goldencobra 1.4.27 → 2.3.3

data/app/controllers/goldencobra/articles_controller.rb

@@ -1,17 +1,15 @@
-# encoding: utf-8
-
 module Goldencobra
   class ArticlesController < Goldencobra::ApplicationController
+
     layout "application"
-    before_filter :check_format
-    before_filter :get_redirectors, :only => [:show]
-    before_filter :get_article, :only => [:show, :convert_to_pdf]
-    before_filter :verify_token, :only => [:show]
+    before_filter :get_redirectors, only: [:show]
+    before_filter :get_article, only: [:show, :convert_to_pdf]
+    before_filter :verify_token, only: [:show]
     before_filter :geocode_ip_address, only: [:show]
-    after_filter :analytics, :only => [:show]
+    after_filter :analytics, only: [:show]
 
     if Goldencobra::Setting.for_key("goldencobra.article.cache_articles") == "true"
-      caches_action :show, :cache_path => :show_cache_path.to_proc, :if => proc {@article && @article.present? && is_cachable?  }
+      caches_action :show, cache_path: :show_cache_path.to_proc, if: proc {@article && @article.present? && is_cachable?  }
     end
 
     def show_cache_path
@@ -28,51 +26,56 @@ module Goldencobra
       return Zlib.crc32(generated_cache_key).to_s
     end
 
-
     def show
-      ActiveSupport::Notifications.instrument("goldencobra.article.show", :params => params)  #Possible Callbacks on start
-      before_init() #Possible Callbacks on start
-      params[:session] = session.except(:user_location)
-      Goldencobra::Article::LiquidParser["url_params"] = params
+      ActiveSupport::Notifications.instrument("goldencobra.article.show", params: params)
+      before_init # possible callbacks on start
+      params[:session] = session.clone
+      params[:session].delete(:user_location)
       if serve_iframe?
         respond_to do |format|
           format.html { render layout: "/goldencobra/bare_layout" }
         end
+      elsif request.format == "image/jpeg"  || request.format == "image/png"
+        respond_to do |format|
+          format.png { render text: "404", status: 404 }
+          format.jpeg { render text: "404", status: 404 }
+          format.html { render text: "404", status: 404 }
+        end
       elsif serve_basic_article?
         initialize_article(@article)
-        # TODO fix session_params like url_params mit liquid method
-        Goldencobra::Article.load_liquid_methods(location: session[:user_location], article: @article, params: params)
-        load_associated_model_into_liquid() if can_load_associated_model?
-        after_init()
+        load_associated_model_into_liquid if can_load_associated_model?
+        after_init
 
         if generate_index_list?
           current_operator = current_user || current_visitor
           @list_of_articles = @article.index_articles(current_operator,params[:frontend_tags])
-          after_index()
+          after_index
         end
 
         if serve_fresh_page?
-         set_expires_in()
-         ActiveSupport::Notifications.instrument("goldencobra.article.render", :params => params)
-          before_render()
+          set_expires_in
+          ActiveSupport::Notifications.instrument("goldencobra.article.render", params: params)
+          before_render
           respond_to do |format|
-            format.html { render layout: choose_layout() }
+            format.html { render layout: choose_layout }
             format.rss
             format.json do
-              @article["list_of_articles"] = @list_of_articles
-              render json: @article.to_json
+              render json: {
+                article: @article.to_json,
+                list_of_articles: @list_of_articles.as_json
+              }
             end
           end
         end
       elsif should_statically_redirect?
         redirect_to @article.external_url_redirect
       elsif should_dynamically_redirect?
-        redirect_dynamically()
+        redirect_dynamically
       else
         if @unauthorized
-          redirect_to_401()
+          redirect_to_401
         else
-          redirect_to_404()
+          redirect_to_404
         end
       end
     end
@@ -92,12 +95,8 @@ module Goldencobra
     end
 
     def sitemap
-      if Goldencobra::Setting.for_key("goldencobra.use_ssl") == "true"
-        @use_ssl = "s"
-      else
-        @use_ssl = ""
-      end
-      @domain_name = Goldencobra::Setting.for_key("goldencobra.url")
+      @use_ssl = Goldencobra::Url.use_ssl? ? "s" : ""
+      @domain_name = Goldencobra::Url.host
       @articles = Goldencobra::Article.for_sitemap
       #TODO: authorize! :read, @article
       respond_to do |format|
@@ -110,7 +109,7 @@ module Goldencobra
     def verify_token
       if params[:auth_token].present?
         unless current_visitor || current_user
-          render :text => "Nicht authorisiert", :status => 401
+          render text: "Nicht authorisiert", status: 401
         end
       end
     end
@@ -130,16 +129,14 @@ module Goldencobra
       end
     end
 
-
-
     # ------------------ Redirection ------------------------------------------
     def get_redirectors
-      #check if Goldencobra::Redirector has any redirections, with match before rendering this article
-      #request.original_url
-      #base_request_url = request.original_url.to_s.split("?")[0]  # nimmt nur den teil ohne urlparameter
+      # check if Goldencobra::Redirector has any redirections, with match before rendering this article
+      # request.original_url
+      # base_request_url = request.original_url.to_s.split("?")[0]  # nimmt nur den teil ohne urlparameter
       redirect_url, redirect_code = Goldencobra::Redirector.get_by_request(request.original_url)
       if redirect_url.present? && redirect_code.present?
-        redirect_to redirect_url, :status => redirect_code
+        redirect_to redirect_url, status: redirect_code
       end
     end
 
@@ -161,26 +158,28 @@ module Goldencobra
     end
 
     def redirect_to_404
-      ActiveSupport::Notifications.instrument("goldencobra.article.not_found", :params => params)
+      ActiveSupport::Notifications.instrument("goldencobra.article.not_found", params: params)
       @article = Goldencobra::Article.find_by_url_name("404")
+
       if @article
         respond_to do |format|
-          format.html { render :layout => @article.selected_layout, :status => 404 }
+          format.html { render layout: @article.selected_layout, status: 200 }
+          format.any { head(status: 404) }
         end
       else
-        render :text => "404", :status => 404
+        head(status: 404)
       end
     end
 
     def redirect_to_401
-      ActiveSupport::Notifications.instrument("goldencobra.article.not_authorized", :params => params)
+      ActiveSupport::Notifications.instrument("goldencobra.article.not_authorized", params: params)
       @article = Goldencobra::Article.find_by_url_name("401")
       if @article
         respond_to do |format|
-          format.html { render :layout => @article.selected_layout, :status => 401 }
+          format.html { render layout: @article.selected_layout, status: 401 }
         end
       else
-        render :text => "401: Nicht authorisiert", :status => 401
+        render text: "401: Nicht authorisiert", status: 401
       end
     end
     # ------------------ /Redirection -----------------------------------------
@@ -239,10 +238,10 @@ module Goldencobra
 
     def set_expires_in
       if is_cachable?
-        expires_in 30.seconds, :public => true
+        expires_in 30.seconds, public: true
         response.last_modified = @article.date_of_last_modified_child
       else
-        expires_in 1.seconds, :public => true
+        expires_in 1.seconds, public: true
         response.last_modified = Time.now
       end
     end
@@ -267,7 +266,6 @@ module Goldencobra
       end
     end
 
-
     def article_by_role
       # Admin should get preview of article even if it's offline
       if current_user && current_user.has_role?(Goldencobra::Setting.for_key("goldencobra.article.preview.roles").split(",").map{|a| a.strip})
@@ -277,25 +275,22 @@ module Goldencobra
         if article.present?
           operator = current_user || current_visitor
           a = Ability.new(operator,@current_client)
-          logger.warn("###"*40)
-          logger.warn(a.can?(:read, article))
           if a.can?(:read, article)
             @article = article
           else
             @unauthorized = true
           end
-        # elsif current_visitor.present?
-        #   ap = Goldencobra::Permission.where(:subject_class => "Goldencobra::Article", :operator_id => current_visitor.id, :action => "read").pluck(:subject_id)
-        #   if ap.any?
-        #     @article = Goldencobra::Article.where("id in (?)", ap).search_by_url(params[:article_id])
-        #   else
-        #     @unauthorized = true
-        #   end
+          # elsif current_visitor.present?
+          #   ap = Goldencobra::Permission.where(subject_class: "Goldencobra::Article", operator_id: current_visitor.id, action: "read").pluck(:subject_id)
+          #   if ap.any?
+          #     @article = Goldencobra::Article.where("id in (?)", ap).search_by_url(params[:article_id])
+          #   else
+          #     @unauthorized = true
+          #   end
         end
       end
     end
 
-
     def is_startpage?
       startpage = params[:startpage]
       startpage && (startpage == true || startpage == "true")
@@ -304,8 +299,12 @@ module Goldencobra
 
     def check_format
       if request.format == "image/jpeg"  || request.format == "image/png"
-        render :text => "404", :status => 404
+        render text: "404", status: 404
+      end
+      if request.format == "php" || params[:format].to_s == "php"
+        render nothing: true, status: 406
       end
+      return true
     end
 
     def geocode_ip_address
@@ -316,7 +315,7 @@ module Goldencobra
             begin
               @ip_result = Geokit::Geocoders::MultiGeocoder.geocode(request.remote_ip)
               session[:user_location] = @ip_result
-            rescue Exception => e
+            rescue Exception
               @ip_result = nil
             end
             if @ip_result.present? && @ip_result.city.present?
@@ -351,6 +350,5 @@ module Goldencobra
     def analytics
       Goldencobra::Tracking.analytics(request, session[:user_location])
     end
-
   end
 end

data/app/controllers/goldencobra/manage_controller.rb

@@ -14,7 +14,6 @@ module Goldencobra
       end
     end
 
-
     def article_visibility
       @article_saved = false
       @operator = current_user || current_visitor
@@ -33,11 +32,11 @@ module Goldencobra
     def call_for_support
       if current_user || current_visitor
         Goldencobra::ConfirmationMailer.send_support_mail(params[:link]).deliver
-        render :text => "200"
+        render text: "200"
       else
-        render :text => "401"
+        render text: "401"
       end
     end
 
   end
-end
+end

data/app/controllers/goldencobra/sessions_controller.rb

@@ -1,27 +1,30 @@
-# encoding: utf-8
+require "bcrypt"
 
 module Goldencobra
   class SessionsController < Goldencobra::ApplicationController
     layout "application"
 
-
     def login
       @errors = []
-      if params[:usermodel] && params[:usermodel].constantize && params[:usermodel].constantize.present? && params[:usermodel].constantize.attribute_method?(:email)
-        @usermodel = params[:usermodel].constantize.find_by_email(params[:loginmodel][:email])
-        unless @usermodel && params[:usermodel].constantize.attribute_method?(:username)
-          @usermodel = params[:usermodel].constantize.find_by_username(params[:loginmodel][:email])
+      if usermodel
+        # search for user/visitor per email address
+        @usermodel = usermodel.where(email: params[:loginmodel][:email]).first
+        if @usermodel.blank? && usermodel.attribute_method?(:username)
+          # if not found, search for visitor per email address
+          # only visitor has attribute_method "username"
+          @usermodel = usermodel.where(username: params[:loginmodel][:email]).first
         end
       end
 
       if @usermodel.present?
-        if ::BCrypt::Password.new(@usermodel.encrypted_password) == "#{params[:loginmodel][:password]}#{Devise.pepper}"
+        if ::BCrypt::Password.new(@usermodel.encrypted_password) ==
+           "#{params[:loginmodel][:password]}#{Devise.pepper}"
           sign_in @usermodel
           @usermodel.failed_attempts = 0
           @usermodel.sign_in_count = @usermodel.sign_in_count.to_i + 1
           @usermodel.last_sign_in_at = Time.now
           @usermodel.save
-          flash[:notice] = I18n.translate("signed_in", :scope => ["devise", "sessions"])
+          flash[:notice] = I18n.translate("signed_in", scope: ["devise", "sessions"])
           @redirect_to = @usermodel.roles.try(:first).try(:redirect_after_login)
         else
           @usermodel.failed_attempts = @usermodel.failed_attempts.to_i + 1
@@ -33,25 +36,29 @@ module Goldencobra
       end
     end
 
-
     def logout
-      if params[:usermodel] && params[:usermodel].constantize && params[:usermodel].constantize.present? && params[:usermodel].constantize.attribute_method?(:email)
-        sign_out
+      if usermodel
+        sign_out usermodel.to_s.downcase.to_sym
         reset_session
-        flash[:notice] = I18n.translate("signed_out", :scope => ["devise", "sessions"])
+        flash[:notice] = I18n.translate("signed_out", scope: ["devise", "sessions"])
       end
       if request.format == "html"
         redirect_to "/"
       else
-        render :js => "window.location.href = '/';"
+        render js: "window.location.href = '/';"
       end
     end
 
-
     def register
-
     end
 
+    private
+
+    def usermodel
+      return false if params[:usermodel].blank?
+      return false unless DEVISE_MODELS_WHITELIST.include?(params[:usermodel].to_s.downcase)
 
+      params[:usermodel].safe_constantize
+    end
   end
 end

data/app/helpers/goldencobra/application_helper.rb

@@ -17,16 +17,28 @@ module Goldencobra
       role_mod = Goldencobra::Setting.for_key("goldencobra.bugherd.role")
       bugherd_api = Goldencobra::Setting.for_key("goldencobra.bugherd.api")
       if bugherd_api.present? && user_mod.present? && role_mod.present? && eval("!defined?(#{user_mod}).nil? && #{user_mod} && #{user_mod}.present? && #{user_mod}.has_role?('#{role_mod}')")
-        render :partial => "goldencobra/articles/bugherd", :locals => {:bugherd_api => bugherd_api}
+        render partial: "goldencobra/articles/bugherd", locals: {bugherd_api: bugherd_api}
       end
     end
 
     def edit_article_link
-      render :partial => "goldencobra/articles/edit_article_link"
+      render partial: "goldencobra/articles/edit_article_link"
     end
 
     def basic_goldencobra_headers(options={})
-      render :partial => "/goldencobra/articles/headers", :locals => {:options => options}
+      render partial: "/goldencobra/articles/headers", locals: {options: options}
+    end
+
+
+    # Named routes outside mounted rails engine
+    # You can call any named route defined in your railsapp
+    # inside a goldencobra_view by calling:
+    #
+    # <%= link_to "CustomRoute", application_routes.custom_page_path() %>
+    #
+    # @return [UrlHelpers]
+    def application_routes
+      Rails.application.routes.url_helpers
     end
   end
 end

data/app/helpers/goldencobra/articles_helper.rb

@@ -6,18 +6,19 @@ module Goldencobra
     # 'Read on' link to article for index-pages
     # If external_url_redirect is set and a link_title is given,
     # display this link title. Otherwise display a generic link title.
-    def read_on(article)
+    def read_on(article, options={})
       target_window = article.redirection_target_in_new_window ? "_blank" : "_top"
+      html_class = "more #{options[:class]}".strip
       if article.redirect_link_title.present?
-        link_to article.redirect_link_title, article.external_url_redirect, :class => "more", :target => target_window
+        link_to article.redirect_link_title, article.external_url_redirect, class: html_class, target: target_window
       else
-        link_to t(:read_on, scope: [:articles]), article.public_url, :class => "more", :target => target_window, :title => article.title
+        link_to t(:read_on, scope: [:articles]), article.public_url, class: html_class, target: target_window, title: article.title
       end
     end
 
     #Ausgabe aller Hauptbestandteile eines Artikels über "content_for :xy"
     def render_article_content_parts(article)
-      render :partial => "/goldencobra/articles/show", :locals => {:article => article}
+      render partial: "/goldencobra/articles/show", locals: {article: article}
     end
 
 
@@ -26,12 +27,12 @@ module Goldencobra
       glossar_parent = nil
       if parent_article_id
         glossar_parent = Goldencobra::Article.find_by_id(parent_article_id)
-        glossar_article = glossar_parent.children.where(:breadcrumb => tag_name).first
+        glossar_article = glossar_parent.children.where(breadcrumb: tag_name).first
       else
-        glossar_article = Goldencobra::Article.where(:breadcrumb => tag_name).first
+        glossar_article = Goldencobra::Article.where(breadcrumb: tag_name).first
       end
       unless glossar_article
-        glossar_article = Goldencobra::Article.create(:title => tag_name, :breadcrumb => tag_name, :article_type => "Default Show", :parent => glossar_parent)
+        glossar_article = Goldencobra::Article.create(title: tag_name, breadcrumb: tag_name, article_type: "Default Show", parent: glossar_parent)
       end
 
       if glossar_article.present?
@@ -41,21 +42,31 @@ module Goldencobra
     end
 
 
-    def render_article_image_gallery
-      if @article
-        result = ""
-        uploads = Goldencobra::Upload.tagged_with(@article.image_gallery_tags.present? ? @article.image_gallery_tags.split(",") : "" )
-        if uploads && uploads.count > 0
-          uploads.order(:sorter_number).each do |upload|
-            result << content_tag("li", link_to(image_tag(upload.image.url(:thumb), {alt: upload.alt_text}), upload.image.url(:large), title: raw(upload.description)))
+    # [render_article_image_gallery description]
+    # @param options={} [Hash] {link_image_size: :thumb, target_image_size: :large}
+    #
+    # @return [HTML] ImageGallery
+    def render_article_image_gallery(options = {})
+      if @article && @article.image_gallery_tags.present?
+        tags = @article.image_gallery_tags.split(",")
+        uploads = Goldencobra::Upload.tagged_with(tags)
+        list_items = ""
+        uploads.order(:sorter_number).each do |upload|
+          list_items << content_tag("li") do
+            link_to upload.image.url(options[:target_image_size] || :large), title: raw(upload.description) do
+              image_tag(upload.image.url(options[:link_image_size] || :thumb), alt: upload.alt_text)
+            end
           end
         end
-        return content_tag("ul", raw(result), :class => "goldencobra_article_image_gallery")
+        content_tag("ul", raw(list_items), class: "goldencobra_article_image_gallery")
+      elsif @article
+        content_tag("ul", raw(""), class: "goldencobra_article_image_gallery")
       end
     end
 
-
+    # Deprecated Helper Method, will be removed in GC 2.1
     def index_of_articles(options={})
+      warn "Deprecated helper method 'index_of_articles'. Will be removed in GC 2.1"
       if @article && @article.article_for_index_id.present? && master_index_article = Goldencobra::Article.find_by_id(@article.article_for_index_id)
         result_list = ""
         result_list += content_tag(:h2, raw("&nbsp;"), class: "boxheader")
@@ -64,28 +75,37 @@ module Goldencobra
         master_index_article.descendants.order(:created_at).limit(@article.article_for_index_limit).each do |art|
           if @article.article_for_index_levels.to_i == 0 || (@article.depth + @article.article_for_index_levels.to_i > art.depth)
             rendered_article_list_item = render_article_list_item(art)
-            result_list += content_tag(dom_element, rendered_article_list_item, :id => "article_index_list_item_#{art.id}", :class => "article_index_list_item")
+            result_list += content_tag(dom_element, rendered_article_list_item, id: "article_index_list_item_#{art.id}", class: "article_index_list_item")
           end
         end
-        return content_tag(:article, raw(result_list), :id => "article_index_list")
+        return content_tag(:article, raw(result_list), id: "article_index_list")
       end
     end
 
     def render_article_type_content(options={})
       if @article
         if @article.article_type.present? && @article.kind_of_article_type.present?
-         render :partial => "articletypes/#{@article.article_type_form_file.underscore.parameterize.downcase}/#{@article.kind_of_article_type.downcase}"
+         render partial: "articletypes/#{@article.article_type_form_file.underscore.parameterize.downcase}/#{@article.kind_of_article_type.downcase}"
         else
-          render :partial => "articletypes/default/show"
+          render partial: "articletypes/default/show"
         end
       end
     end
 
     def render_article_widgets(options={})
-      @timecontrol = Goldencobra::Setting.for_key("goldencobra.widgets.time_control") == "true"
       custom_css = options[:class] || ""
       tags = options[:tagged_with] || ""
-      default = options[:default] || "false"
+
+      #include default widgets?
+      include_defaults = options[:default].to_s == "true" || false
+
+      #include article widgets?
+      if options[:article].present?
+        include_articles = options[:article].to_s == "true"
+      else
+        include_articles = true
+      end
+
       widget_wrapper = options[:wrapper] || "section"
       result = ""
       if params[:frontend_tags] && params[:frontend_tags].class != String && params[:frontend_tags][:format] && params[:frontend_tags][:format] == "email"
@@ -99,38 +119,46 @@ module Goldencobra
           ability = Ability.new()
         end
       end
-      if @article
-        widgets = @article.widgets.active
-        if tags.present? && default == "false"
-          widgets = widgets.tagged_with(tags.split(","))
-        elsif default == true && tags.present?
-          widgets = Goldencobra::Widget.active.where(:default => true).tagged_with(tags.split(","))
-        else
-          widgets = widgets.where(:tag_list => "")
-        end
-        widgets = widgets.order(:sorter)
-
-        widgets.each do |widget|
-          #check if current user has permissions to see this widget
-          if ability.can?(:read, widget)
-            template = Liquid::Template.parse(widget.content)
-            alt_template = Liquid::Template.parse(widget.alternative_content)
-            html_data_options = {"class" => "#{widget.css_name} #{custom_css} goldencobra_widget",
-                                  "id" => widget.id_name.present? ? widget.id_name : "widget_id_#{widget.id}",
-                                  'data-date-start' => widget.offline_date_start_display,
-                                  'data-date-end' => widget.offline_date_end_display,
-                                  'data-offline-active' => widget.offline_time_active,
-                                  'data-id' => widget.id
-                                }
-            html_data_options = html_data_options.merge(widget.offline_time_week)
+
+      # Get article Widgets
+      if @article && include_articles
+        article_widgets = @article.widgets.active.tagged_with(tags.split(","))
+      else
+        article_widgets = []
+      end
+
+      #Get default widgets
+      if include_defaults == true
+        default_widgets = Goldencobra::Widget.active.where(default: true)
+        default_widgets = default_widgets.tagged_with(tags.split(",")) if tags.present?
+      else
+        default_widgets = []
+      end
+
+      # merge article and default widgets
+      widgets = [default_widgets] + [article_widgets]
+      widgets = widgets.flatten.uniq.compact
+
+      #Sort widgets bei global sorter id
+      widgets = widgets.sort_by(&:sorter)
+
+      #render Widgets
+      widgets.each do |widget|
+        #check if current user has permissions to see this widget
+        if ability.can?(:read, widget)
+          template = Liquid::Template.parse(widget.content)
+          html_data_options = {"class" => "#{widget.css_name} #{custom_css} goldencobra_widget",
+                                "id" => widget.id_name.present? ? widget.id_name : "widget_id_#{widget.id}",
+                                'data-id' => widget.id
+                              }
+          if widget_wrapper == ""
+            result << raw(template.render(Goldencobra::Article::LiquidParser))
+          else
             result << content_tag(widget_wrapper, raw(template.render(Goldencobra::Article::LiquidParser)), html_data_options)
-            if @timecontrol
-              result << content_tag(widget_wrapper, raw(alt_template.render(Goldencobra::Article::LiquidParser)),
-                          class: "#{widget.css_name} #{custom_css} hidden goldencobra_widget", 'data-id' => widget.id)
-            end
           end
         end
       end
+
       return raw(result)
     end
 
@@ -141,9 +169,9 @@ module Goldencobra
       result += content_tag(:div, link_to(article_item.title, article_item.public_url), :class=> "title")
       result += content_tag(:div, article_item.created_at.strftime("%d.%m.%Y %H:%M"), :class=>"created_at")
       if @article.article_for_index_images == true && article_item.images.count > 0
-        result += content_tag(:div, image_tag(article_item.images.first.image(:thumb)), :class => "article_image")
+        result += content_tag(:div, image_tag(article_item.images.first.image(:thumb)), class: "article_image")
       end
-      result += content_tag(:div, raw(article_item.public_teaser), :class => "teaser")
+      result += content_tag(:div, raw(article_item.public_teaser), class: "teaser")
       result += content_tag(:div, link_to(s("goldencobra.article.article_index.link_to_article"), article_item.public_url), :class=> "link_to_article")
       return raw(result)
     end