goldencobra 1.4.27 → 2.3.3

data/app/models/goldencobra/role.rb

@@ -14,6 +14,7 @@
 
 module Goldencobra
   class Role < ActiveRecord::Base
+      attr_accessible :name, :description, :redirect_after_login
 
       validates_presence_of :name
 

data/app/models/goldencobra/role_user.rb

@@ -14,7 +14,9 @@
 module Goldencobra
   class RoleUser < ActiveRecord::Base
     self.table_name = 'goldencobra_roles_users'
-    belongs_to :operator, :polymorphic => true
-    belongs_to :role, :class_name => Goldencobra::Role
+    attr_accessible :operator_id, :role_id, :operator_type
+
+    belongs_to :operator, polymorphic: true
+    belongs_to :role, class_name: Goldencobra::Role
   end
 end

data/app/models/goldencobra/setting.rb

@@ -15,14 +15,14 @@
 
 module Goldencobra
   class Setting < ActiveRecord::Base
-
+    require 'fileutils'
     # TODO cache invalidate über touch /temp/settings_updated.txt
 
 
     @@key_value = {}
     attr_accessible :title, :value, :ancestry, :parent_id, :data_type
     SettingsDataTypes = ["string","date","datetime","boolean","array"]
-    has_ancestry :orphan_strategy => :restrict
+    has_ancestry orphan_strategy: :restrict
     if ActiveRecord::Base.connection.table_exists?("versions")
       has_paper_trail
     end
@@ -30,20 +30,12 @@ module Goldencobra
     after_update :update_cache
 
     scope :parent_ids_in_eq, lambda { |art_id| subtree_of(art_id) }
-    search_methods :parent_ids_in_eq
-
     scope :parent_ids_in, lambda { |art_id| subtree_of(art_id) } if ActiveRecord::Base.connection.table_exists?("goldencobra_settings") && Goldencobra::Setting.all.any?
-    search_methods :parent_ids_in
-
-    scope :with_values, where("value IS NOT NULL")
+    scope :with_values, -> { where("value IS NOT NULL") }
 
 
     def self.absolute_base_url
-      if Goldencobra::Setting.for_key("goldencobra.use_ssl") == "true"
-        "https://#{Goldencobra::Setting.for_key('goldencobra.url')}"
-      else
-        "http://#{Goldencobra::Setting.for_key('goldencobra.url')}"
-      end
+      Goldencobra::Url.to_s
     end
 
     def self.regenerate_active_admin
@@ -72,7 +64,7 @@ module Goldencobra
     def self.for_key_helper(name)
     if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
       setting_title = name.split(".").last
-      settings = Goldencobra::Setting.where(:title => setting_title)
+      settings = Goldencobra::Setting.where(title: setting_title)
       if settings.count == 1
         return settings.first.value
       elsif settings.count > 1
@@ -91,7 +83,7 @@ module Goldencobra
       @@key_value = nil
       if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
         setting_title = name.split(".").last
-        settings = Goldencobra::Setting.where(:title => setting_title)
+        settings = Goldencobra::Setting.where(title: setting_title)
         if settings.count == 1
           settings.first.update_attributes(value: value, data_type: data_type_name)
           true
@@ -112,7 +104,7 @@ module Goldencobra
       if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
         require 'yaml'
         raise "Settings File '#{path_file_name}' does not exist" if !File.exists?(path_file_name)
-        imports = open(path_file_name) {|f| YAML.load(f) }
+        imports = open(path_file_name) { |f| YAML.load(f) }
         imports.each_key do |key|
           generate_default_setting(key, imports)
         end
@@ -127,40 +119,41 @@ module Goldencobra
       self.path.map(&:title).join(".")
     end
 
+    def has_children
+      self.has_children?
+    end
 
     private
-    def self.generate_default_setting(key, yml_data, parent_id=nil)
+
+    def self.generate_default_setting(key, yml_data, parent_id = nil)
       if yml_data[key].class == Hash
-        #check if childen keys are value and type or not
-        if yml_data[key].keys.count == 2 && yml_data[key].keys.sort == ["type","value"]
-          #new way of defining settings by additional value and type params
-          create_setting_by_key_and_parent_and_type_and_value(key,parent_id, yml_data[key]["type"], yml_data[key]["value"])
+        # check if childen keys are value and type or not
+        if yml_data[key].keys.count == 2 && yml_data[key].keys.sort == ["type", "value"]
+          # new way of defining settings by additional value and type params
+          create_setting_by_key_and_parent_and_type_and_value(key, parent_id, yml_data[key]["type"], yml_data[key]["value"])
         else
-          #old way of defining Settings
+          # old way of defining Settings
           parent = Setting.find_by_ancestry_and_title(parent_id, key)
-          unless parent
-            parent = Setting.create(:ancestry => parent_id, :title => key)
-          end
+          parent = Setting.create(ancestry: parent_id, title: key) unless parent
           yml_data[key].each_key do |name|
-            generate_default_setting(name, yml_data[key], [parent.ancestry,parent.id].compact.join('/'))
+            generate_default_setting(name, yml_data[key], [parent.ancestry, parent.id].compact.join('/'))
           end
         end
       elsif yml_data[key].class == String
-        create_setting_by_key_and_parent_and_type_and_value(key,parent_id, "string", yml_data[key])
+        create_setting_by_key_and_parent_and_type_and_value(key, parent_id, "string", yml_data[key])
       else
         raise "invalid yml File at: #{key}  -  #{yml_data}"
       end
     end
 
-
     def self.create_setting_by_key_and_parent_and_type_and_value(key,parent, data_type_name, value_name)
       set = Goldencobra::Setting.find_by_title_and_ancestry(key, parent)
       unless set
         if Goldencobra::Setting.new.respond_to?(:data_type)
-          Goldencobra::Setting.create(:title => key , :value => value_name, :ancestry => parent, :data_type => data_type_name )
+          Goldencobra::Setting.create(title: key , value: value_name, ancestry: parent, data_type: data_type_name )
         else
           if data_type_name == "string"
-            Goldencobra::Setting.create(:title => key , :value => value_name, :ancestry => parent)
+            Goldencobra::Setting.create(title: key , value: value_name, ancestry: parent)
           end
         end
       end
@@ -177,18 +170,44 @@ module Goldencobra
     def update_cache
       @@key_value ||= {}
       @@key_value[self.path_name] = nil
-      FileUtils.mkdir_p("tmp/settings")
-      FileUtils.touch("tmp/settings/updated_#{self.path_name}.txt")
+      FileUtils.mkdir_p(Goldencobra::Setting.absolute_tmp_path)
+      FileUtils.touch(Goldencobra::Setting.absolute_tmp_path("updated_#{self.path_name}.txt"))
     end
 
     def self.get_cache_modification_time(name)
-      if File.exists?("tmp/settings/updated_#{name}.txt")
-        File.mtime("tmp/settings/updated_#{name}.txt")
+      if File.exists?(absolute_tmp_path("updated_#{name}.txt"))
+        File.mtime(absolute_tmp_path("updated_#{name}.txt"))
       else
-        FileUtils.mkdir_p("tmp/settings")
-        FileUtils.touch("tmp/settings/updated_#{name}.txt")
+        FileUtils.mkdir_p(absolute_tmp_path)
+        FileUtils.touch(absolute_tmp_path("updated_#{name}.txt"))
         return Time.now
       end
+    rescue
+      Airbrake.notify(error_message: "Rescued Error 'FileUtils mkdir_p' with '#{Goldencobra::Setting.absolute_tmp_path}' ")
+      return Time.now
+    end
+
+    def self.absolute_tmp_path(file_name = nil)
+      File.join([Rails.root, "tmp", "settings", file_name].compact)
+    end
+
+
+    # **************************
+    # **************************
+    # Private Methods
+    # **************************
+    # **************************
+
+    private
+
+    # Allow Scopes and Methods to search for in ransack (n.a. metasearch)
+    # @param auth_object = nil [self] "if auth_object.try(:admin?)"
+    #
+    # @return [Array] Array of Symbols representing scopes and class methods
+    def self.ransackable_scopes(auth_object = nil)
+      [
+       :parent_ids_in
+      ]
     end
 
   end

data/app/models/goldencobra/tracking.rb

@@ -29,11 +29,14 @@
 
 module Goldencobra
   class Tracking < ActiveRecord::Base
-    attr_accessible :ip, :referer, :request, :session_id, :url, :user_agent, :language, :url_paremeters, :path, :page_duration, :view_duration, :db_duration
-    attr_accessible :utm_source, :utm_medium, :utm_term, :utm_content, :utm_campaign, :location
+    attr_accessible :ip, :referer, :request, :session_id, :url, :user_agent,
+                    :language, :url_paremeters, :path, :page_duration,
+                    :view_duration, :db_duration, :utm_source, :utm_medium,
+                    :utm_term, :utm_content, :utm_campaign, :location
+
     serialize :url_paremeters
 
-    default_scope order("created_at DESC")
+    default_scope { order("created_at DESC") }
 
     def self.analytics(request, location=nil)
       if Goldencobra::Setting.for_key("goldencobra.analytics.active") == "true"

data/app/models/goldencobra/upload.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 # == Schema Information
 #
 # Table name: goldencobra_uploads
@@ -21,32 +19,60 @@
 
 module Goldencobra
   class Upload < ActiveRecord::Base
+    attr_accessible :id, :source, :rights, :description, :image_file_name,
+                    :crop_x, :crop_y, :crop_w, :crop_h, :crop_image, :image_url,
+                    :image_content_type, :image_file_size, :created_at,
+                    :updated_at, :attachable_id, :attachable_type, :alt_text,
+                    :sorter_number, :image, :tag_list
 
     attr_accessor :crop_x, :crop_y, :crop_w, :crop_h, :crop_image, :image_url
 
     if ActiveRecord::Base.connection.table_exists?("goldencobra_uploads") &&
-      ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
+       ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
       has_attached_file :image,
-                        :styles => { :large => ["900x900>", :jpg], :big => ["600x600>",:jpg], :medium => ["300x300>",:jpg], :px250 => ["250x250>",:jpg], :px200 => ["200x200>",:jpg], :px150 => ["150x150>",:jpg], :thumb => ["100x100>", :jpg], :mini => ["50x50>",:jpg] },
-                        :path => ":rails_root/public/system/:attachment/:id/:style/:filename",
-                        :url => "/system/:attachment/:id/:style/:filename",
-                        :convert_options => { :all => "#{Goldencobra::Setting.for_key('goldencobra.upload.convert_options')}" },
-                        :default_url => "missing_:style.png"
+                        styles: {
+                          large: ["900x900>", :jpg],
+                          big: ["600x600>", :jpg],
+                          medium: ["300x300>", :jpg],
+                          px250: ["250x250>", :jpg],
+                          px200: ["200x200>", :jpg],
+                          px150: ["150x150>", :jpg],
+                          thumb: ["100x100>", :jpg],
+                          mini: ["50x50>", :jpg]
+                        },
+                        path: ":rails_root/public/system/:attachment/:id/:style/:filename",
+                        url: "/system/:attachment/:id/:style/:filename",
+                        convert_options: -> {
+                          {
+                            all: Goldencobra::Setting.for_key("goldencobra.upload.convert_options")
+                                                     .to_s
+                          }
+                        }.call,
+                        default_url: "missing_:style.png"
+      do_not_validate_attachment_file_type :image
       before_post_process :image_file?
+
     end
 
-    has_many :article_images, :class_name => Goldencobra::ArticleImage
-    has_many :articles, :through => :article_images
-    has_many :imports, :class_name => Goldencobra::Import
+    has_many :article_images,
+             class_name: "Goldencobra::ArticleImage",
+             foreign_key: "image_id",
+             dependent: :destroy
+    has_many :articles, through: :article_images
+    has_many :imports, class_name: "Goldencobra::Import"
     belongs_to :attachable, polymorphic: true
 
-    before_save :download_remote_image, :if => :image_url_provided?
-
+    before_save :download_remote_image, if: :image_url_provided?
     before_save :crop_image_with_coords
+
+    acts_as_taggable_on :tags
+
     def crop_image_with_coords
-      require 'RMagick'
+      require "RMagick"
       # Should we crop?
-      if self.crop_image.present? && self.crop_image == "1" && self.crop_x.present? && self.crop_y.present? && self.crop_w.present? && self.crop_h.present?
+      if self.crop_image.present? && self.crop_image == "1" && self.crop_x.present? &&
+        self.crop_y.present? && self.crop_w.present? && self.crop_h.present?
+
         scaled_img = Magick::ImageList.new(self.image.path(:large))
         orig_img = Magick::ImageList.new(self.image.path(:original))
         scale = orig_img.columns.to_f / scaled_img.columns
@@ -61,47 +87,36 @@ module Goldencobra
       end
     end
 
-    #
-
-    # def crop_image_with_coords
-    #   if self.crop_image.present? && self.crop_image == "1" && self.crop_x.present? && self.crop_y.present? && self.crop_w.present? && self.crop_h.present? && self.crop_image.present?
-    #     orig_img = Magick::ImageList.new(self.image.path(:original))
-    #     orig_img.crop(self.crop_x.to_i, self.crop_y.to_i, self.crop_w.to_i, self.crop_h.to_i)
-    #     orig_img.write(self.image.path(:original))
-    #     #self.image = File.open("tmp/cropped_image")
-    #     #self.image.reprocess!
-    #   end
-    # end
-
     def title
       "#{self.image_file_name} (#{self.image_content_type})"
     end
 
-    acts_as_taggable_on :tags
-
     def complete_list_name
       result = ""
-      result << "#{self.image_file_name} " if self.image_file_name.present?
-      result << "(#{self.source}, #{self.rights}) " if self.source.present? || self.rights.present?
-      result << "- #{self.updated_at.strftime("%d.%m.%Y - %H:%M Uhr")}"
-      return result
+      result += "#{self.image_file_name} " if self.image_file_name.present?
+      result += "(#{self.source}, #{self.rights}) " if self.source.present? || self.rights.present?
+      result + "- #{self.updated_at.strftime("%d.%m.%Y - %H:%M Uhr")}"
     end
 
     def unzip_files
       if self.image_file_name.include?(".zip") && File.exists?(self.image.path)
-        require 'zip'
+        require "zip"
         zipped_files = Zip::File.open(self.image.path)
-        int = 0
         zipped_files.each do |zipped_file|
-          int = int + 1
+          filename = zipped_file.name.split("/").last.gsub(" ", "_").gsub(/[^0-9A-z.\-]/, "")
+          file_path = "tmp/#{self.id}_#{filename}"
+          next if filename[0] == "."
           if zipped_file.file?
-            zipped_file.extract("tmp/#{self.id}_unzipped_#{int}.jpg")
-            Goldencobra::Upload.create(:image => File.open("tmp/#{self.id}_unzipped_#{int}.jpg"),
-                        :source => self.source,
-                        :rights => self.rights,
-                        :description => self.description,
-                        :tag_list => self.tag_list.join(", ") )
-            File.delete("tmp/#{self.id}_unzipped_#{int}.jpg")
+            zipped_file.extract(file_path)
+            Goldencobra::Upload.create(
+              image: File.open(file_path),
+              image_file_name: filename,
+              source: self.source,
+              rights: self.rights,
+              description: self.description,
+              tag_list: self.tag_list.join(", ")
+            )
+            File.delete(file_path)
           end
         end
       end
@@ -114,16 +129,17 @@ module Goldencobra
     #
     # Returns true for image or pdf files and false for everything else
     def image_file?
-      #debugger
-      if !(self.image_content_type =~ /^image.*/).nil?
-        return true
-      elsif !(self.image_content_type =~ /pdf/).nil?
-        return true
+      if !(self.image_content_type =~ /^image.*/).nil? || !(self.image_content_type =~ /pdf/).nil?
+        true
       else
-        return false
+        false
       end
     end
 
+    def self.default_position
+      Goldencobra::Setting.for_key("goldencobra.article.image_positions").
+      to_s.split(",").map(&:strip).first
+    end
 
     private
 
@@ -132,14 +148,16 @@ module Goldencobra
     end
 
     def download_remote_image
-      require 'open-uri'
-      io = open(URI.parse(self.image_url))
+      require "open-uri"
+      require "addressable/uri"
+      io = open(Addressable::URI.parse(self.image_url))
       self.image = io
       self.image_file_name = io.base_uri.path.split('/').last
       self.image_remote_url = self.image_url
-    rescue # catch url errors with validations instead of exceptions (Errno::ENOENT, OpenURI::HTTPError, etc...)
+    rescue
+    # catch url errors with validations instead of exceptions
+    # (Errno::ENOENT, OpenURI::HTTPError, etc...)
     end
-
   end
 end
 

data/app/models/goldencobra/vita.rb

@@ -12,13 +12,13 @@
 #  description   :text
 #  created_at    :datetime         not null
 #  updated_at    :datetime         not null
-#  status_cd     :integer          default 0 
+#  status_cd     :integer          default 0
 #
 
 module Goldencobra
   class Vita < ActiveRecord::Base
-    belongs_to :loggable, :polymorphic => true
-    attr_accessible :description, :title, :user_id
+    belongs_to :loggable, polymorphic: true
+    attr_accessible :description, :title, :user_id, :status_cd
     acts_as_taggable_on :tags
 
     as_enum :status,  success: 0, warning: 1, error: 2

data/app/models/goldencobra/widget.rb

@@ -28,14 +28,18 @@
 
 module Goldencobra
   class Widget < ActiveRecord::Base
+    attr_accessible :title, :content, :css_name, :active, :id_name, :sorter, :teaser, :default,
+                    :description, :alternative_content, :mobile_content, :offline_days,
+                    :offline_time_active, :offline_date_start, :offline_date_end,
+                    :offline_time_week_start_end, :tag_list, :tags, :article_ids
 
     serialize :offline_time_week_start_end
 
     has_many  :article_widgets
-    has_many  :articles, :through => :article_widgets
-    has_many  :permissions, :class_name => Goldencobra::Permission, :foreign_key => "subject_id", :conditions => {:subject_class => "Goldencobra::Widget"}
+    has_many  :articles, through: :article_widgets
+    has_many  :permissions, -> { where subject_class: "Goldencobra::Widget" }, class_name: Goldencobra::Permission, foreign_key: "subject_id"
 
-    accepts_nested_attributes_for :permissions, :allow_destroy => true
+    accepts_nested_attributes_for :permissions, allow_destroy: true
 
     attr_accessor :offline_time_start_mo, :offline_time_end_mo, :offline_time_start_tu, :offline_time_end_tu, :offline_time_start_we, :offline_time_end_we
     attr_accessor :offline_time_start_th, :offline_time_end_th, :offline_time_start_fr, :offline_time_end_fr, :offline_time_start_sa, :offline_time_end_sa
@@ -43,28 +47,29 @@ module Goldencobra
 
     before_save :set_week_start_end_times
     before_save :validate_start_end_time
+    before_save :set_default_tag
+    if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
+      if Goldencobra::Setting.for_key("goldencobra.widgets.recreate_cache") == "true"
+        after_save "Goldencobra::Article.recreate_cache"
+      end
+    end
 
-    OfflineDays   = ["Mo", 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']
-    OfflineDaysEN = ['mo', 'tu', 'we', 'th', 'fr', 'sa', 'su']
+    OfflineDays   = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
+    OfflineDaysEN = ["mo", "tu", "we", "th", "fr", "sa", "su"]
 
     ImportDataFunctions = []
 
-    scope :active, where(:active => true).order(:sorter)
-    scope :inactive, where(:active => false).order(:sorter)
-    scope :default, where(:default => true).order(:sorter)
-    scope :not_default, where(:default => false).order(:sorter)
+    scope :active, -> { where(active: true).order(:sorter) }
+    scope :inactive, -> { where(active: false).order(:sorter) }
+    scope :default, -> { where(default: true).order(:sorter) }
+    scope :not_default, -> { where(default: false).order(:sorter) }
+
 
-    if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
-      if Goldencobra::Setting.for_key("goldencobra.widgets.recreate_cache") == "true"
-        after_save 'Goldencobra::Article.recreate_cache'
-      end
-    end
     if ActiveRecord::Base.connection.table_exists?("versions")
       has_paper_trail
     end
     acts_as_taggable_on :tags
 
-    before_save :set_default_tag
 
     def set_default_tag
       self.tag_list = "sidebar" if self.tag_list.blank?
@@ -79,7 +84,7 @@ module Goldencobra
     end
 
     def self.recent(count)
-      Goldencobra::Widget.where('title IS NOT NULL').order('created_at DESC').limit(count)
+      Goldencobra::Widget.where("title IS NOT NULL").order("created_at DESC").limit(count)
     end
 
     # def offline_time_start_display
@@ -183,6 +188,7 @@ module Goldencobra
       attrs["title"] = "#{attrs["title"]} (Kopie)"
       attrs["id_name"] = attrs["id_name"].present? ? "#{attrs["id_name"]}-kopie" : nil
       attrs["active"] = false
+      attrs["tag_list"] = tag_list
       new_widget = Goldencobra::Widget.create!(attrs)
       new_widget ? new_widget.id : nil
     end