westarete-skylinecms 3.0.8.20100329

data/app/models/skyline/publication.rb

@@ -0,0 +1,25 @@
+# @private
+class Skyline::Publication < Skyline::ArticleVersion
+  belongs_to :variant, :class_name => "Skyline::Variant"
+  
+  default_scope :order => "created_at DESC"
+  named_scope :with_variant, {:conditions => "variant_id IS NOT NULL"}
+  
+  def published?
+    self.article.published_publication == self
+  end
+  
+  # variant_attributes: an Hash of attributes for a new Variant
+  # required: variant_attributes[:name]
+  #
+  def rollback(variant_attributes)
+    raise ArgumentError, "variant_attributes must be an Hash" unless variant_attributes.kind_of?(Hash)
+    raise ArgumentError, "variant_attributes['name'] expected" unless variant_attributes.include?('name')
+    
+    variant = self.clone_to_class(self.article.variants)
+    variant.attributes = variant_attributes      
+    variant.variant_id = nil
+    variant.save
+    variant
+  end
+end

data/app/models/skyline/ref_object.rb

@@ -0,0 +1,10 @@
+# @private
+class Skyline::RefObject < ActiveRecord::Base
+  belongs_to :referable, :polymorphic => true, :autosave => true
+
+  set_table_name :skyline_ref_objects
+  
+  serialize :options  
+  
+  validates_presence_of :referable_type
+end

data/app/models/skyline/referable_uri.rb

@@ -0,0 +1,18 @@
+# @private
+class Skyline::ReferableUri < ActiveRecord::Base
+  set_table_name :skyline_referable_uris
+  
+  def url
+    self.uri
+  end
+  
+  # used in ref_object_helper
+  def title
+    self.uri
+  end
+
+  def external?
+    # definition of the URL scheme: http://labs.apache.org/webarch/uri/rfc/rfc3986.html#scheme
+    self.uri.present? && self.uri =~ /^[a-z][a-z0-9\+\-\.]*:/i
+  end
+end

data/app/models/skyline/right.rb

@@ -0,0 +1,6 @@
+# @private
+class Skyline::Right < ActiveRecord::Base
+  set_table_name :skyline_rights
+  
+  has_and_belongs_to_many :roles, :class_name => "Skyline::Role", :join_table => "skyline_rights_skyline_roles"
+end

data/app/models/skyline/role.rb

@@ -0,0 +1,9 @@
+# @private
+class Skyline::Role < ActiveRecord::Base
+  set_table_name :skyline_roles
+  
+  has_many :grants, :class_name => "Skyline::Grant"
+  has_many :users, :class_name => "Skyline::User", :through => :grants
+  
+  has_and_belongs_to_many :rights, :class_name => "Skyline::Right", :join_table => "skyline_rights_skyline_roles"
+end

data/app/models/skyline/section.rb

@@ -0,0 +1,34 @@
+# @private
+class Skyline::Section < ActiveRecord::Base
+  set_table_name :skyline_sections
+  
+  belongs_to :variant, :class_name => "Skyline::Variant"
+  belongs_to :article_version, :class_name => "Skyline::ArticleVersion"
+  belongs_to :sectionable, :polymorphic => true, :dependent => :destroy
+
+  accepts_nested_attributes_for :sectionable
+  
+  validates_presence_of :sectionable
+  
+  default_scope :order => "position ASC"
+  
+  def build_sectionable(sectionable_attributes)
+    params = sectionable_attributes.dup
+    raise ArgumentError, "Missing class parameter when building sectionable" unless params["class"]
+    klass = params.delete("class")
+    self.sectionable = klass.constantize.new(params)
+  end
+  
+  def clone
+    returning super do |clone|
+      clone.sectionable = self.sectionable.clone
+    end
+  end  
+  
+  # to_text
+  # ==== returns 
+  # String:: plain text of section
+  def to_text
+    self.sectionable.to_text
+  end 
+end

data/app/models/skyline/sections/content_collection_section.rb

@@ -0,0 +1,39 @@
+# @private
+class Skyline::Sections::ContentCollectionSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include Skyline::Taggable
+  taggable_scope lambda{|ccs| ccs.content_type}
+  
+  validates_presence_of :content_type
+  validates_numericality_of :number, :greater_than => 0
+  
+  def content_class
+    @content_class ||= self.content_type.constantize    
+  end
+  
+  def content_name
+    if self.content_class.name.demodulize == "Data" 
+      self.content_class.parent.name.underscore 
+    else
+      self.content_class.name.underscore 
+    end    
+  end
+  
+  def collection_name
+    self.content_name.pluralize.to_sym
+  end
+  
+  def collection
+    self.full_collection.scoped(:limit => self.number)
+  end
+  
+  def full_collection
+    self.content_class.published.with_tags(self.tags).scoped(:limit => self.number)
+  end
+  
+  def clone
+    returning super do |clone|
+      clone.associated_tags = self.associated_tags.collect{|associated_tag| associated_tag.clone}
+    end
+  end  
+end

data/app/models/skyline/sections/content_item_section.rb

@@ -0,0 +1,28 @@
+# @private
+class Skyline::Sections::ContentItemSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+
+  belongs_to :content_item, :polymorphic => true
+  
+  validates_presence_of :content_item_type, :content_item_id
+
+  cattr_accessor :selectable_models  
+  
+  class << self
+    def selectable_content_models
+      # lazy load all models in /app/models (not recursive) to find all Content models
+      Dir.chdir(File.join(Rails.root, "app", "models")) do 
+        Dir.glob("*.rb").map{|f| f.sub(".rb","").camelcase.constantize}
+      end
+      Rails.logger.info "Selectable models for ContentItemSections: " + Skyline::Sections::ContentItemSection.selectable_models.inspect
+      selectable_models || []
+    end
+    
+    def register_selectable_model(klass)
+      self.selectable_models ||= []
+      self.selectable_models.delete_if{|c| c.to_s == klass.to_s } # Hack to remove stale object
+      self.selectable_models << klass
+    end
+    
+  end  
+end

data/app/models/skyline/sections/heading_section.rb

@@ -0,0 +1,6 @@
+# @private
+class Skyline::Sections::HeadingSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  
+  self.default_interface = false
+end

data/app/models/skyline/sections/iframe_section.rb

@@ -0,0 +1,9 @@
+# @private
+class Skyline::Sections::IframeSection < ActiveRecord::Base
+  extend UrlValidation  
+  include Skyline::Sections::Interface
+  
+  validates_numericality_of :width, :height
+  validates_presence_of :url
+  validates_format_of_url :url, :schemes => %w{http}
+end

data/app/models/skyline/sections/link_section.rb

@@ -0,0 +1,22 @@
+# @private
+class Skyline::Sections::LinkSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include NestedAttributesPositioning  
+  
+  has_many :links, :class_name => "Skyline::LinkSectionLink", :dependent => :destroy
+  
+  validate :has_at_least_one_link
+  
+  accepts_nested_attributes_for :links, :allow_destroy => true
+  
+  def clone
+    returning super do |clone|
+      clone.links = self.links.collect{|link| link.clone}
+    end
+  end  
+  
+  protected
+  def has_at_least_one_link
+    self.errors.add(:links, :no_links) unless self.links.detect{|link| !link.marked_for_destruction?}
+  end
+end

data/app/models/skyline/sections/media_section.rb

@@ -0,0 +1,40 @@
+# @private
+class Skyline::Sections::MediaSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include Skyline::BelongsToReferable
+  
+  ALIGNMENT = %w{left right block_left block_right block_center}
+  
+  # The media linked to this section
+  belongs_to_referable :media
+  
+  # An optional link
+  belongs_to_referable :link
+  
+  validates_numericality_of :width, :height, :allow_nil => true
+  
+  delegate :url, :external?, :to => :media
+  
+  def width
+    self.dimension[0]
+  end
+  
+  def height
+    self.dimension[1]
+  end
+  
+  def dimension
+    width = self[:width].to_i
+    height = self[:height].to_i
+    if self.media.present? 
+      proportional = self.media.proportional_dimension(width,height)
+      if proportional
+        width,height = proportional
+      else
+        width,height = self.media.width,self.media.height
+      end
+    end
+
+    [width,height]
+  end
+end

data/app/models/skyline/sections/page_fragment_section.rb

@@ -0,0 +1,8 @@
+# @private
+class Skyline::Sections::PageFragmentSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+
+  belongs_to :page_fragment, :class_name => "Skyline::PageFragment"
+  
+  validates_presence_of :page_fragment_id
+end

data/app/models/skyline/sections/raw_section.rb

@@ -0,0 +1,8 @@
+# @private
+class Skyline::Sections::RawSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+    
+  def to_text
+    HTML::FullSanitizer.new.sanitize(self.body)
+  end  
+end

data/app/models/skyline/sections/redirect_section.rb

@@ -0,0 +1,17 @@
+# @private
+class Skyline::Sections::RedirectSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include Skyline::BelongsToReferable
+  
+  belongs_to_referable :linked
+  
+  validates_numericality_of :delay
+
+  def url(request)
+    if self.linked.external? || self.linked.url =~ /:\/\//
+      self.linked.url
+    else
+      request.protocol + request.host_with_port + self.linked.url
+    end
+  end
+end

data/app/models/skyline/sections/rss_section.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+
+# @private
+class Skyline::Sections::RssSection < ActiveRecord::Base
+  extend ActiveSupport::Memoizable
+  extend UrlValidation  
+  include Skyline::Sections::Interface
+
+  
+  validates_numericality_of :show_count
+  validates_format_of_url :url, :schemes => %w{http}
+  
+  cattr_accessor :cache_path
+  @@cache_path ||= Skyline::Configuration.rss_section_cache_path  
+
+  cattr_accessor :cache_timeout
+  @@cache_timeout ||= Skyline::Configuration.rss_section_cache_timeout
+  
+  after_update :delete_from_cache
+  after_destroy :delete_from_cache
+
+  def title
+    self.rss_feed ? self.rss_feed[:title] : ""
+  end      
+
+  def items
+    self.rss_feed ? self.rss_feed[:items] : []
+  end
+  
+  protected
+  def cache_file
+    File.join(self.class.cache_path, "#{self.id}.yml")
+  end
+  memoize :cache_file
+    
+  def rss_feed
+    if File.exists?(self.cache_file) && File.mtime(self.cache_file) > Time.now - self.cache_timeout
+      YAML.load(File.read(self.cache_file))
+    else
+      if feed = fetch_feed
+        results = RSS::Parser.parse(feed, false)
+        channel = results.channel
+        feed = {
+          :title => channel.title,
+          :description => channel.description, 
+          :copyright => channel.copyright,
+          :category => channel.category.andand.content,
+          :date => channel.date,
+          :items => []
+        }
+        results.items.each_with_index do |item, i|
+          feed[:items] << {
+            :title => item.title, 
+            :link => item.link, 
+            :author => item.author, 
+            :description => item.description, 
+            :guid => item.guid, 
+            :pubDate => item.pubDate,
+            :source => item.source,                        
+            :category => item.category.andand.content
+          } if i < self.show_count  
+        end        
+        cache(feed)
+        feed
+      elsif File.exists?(self.cache_file)
+        self.reset_mtime
+        YAML.load(File.read(self.cache_file))
+      else
+        false
+      end
+    end
+#  rescue
+#    logger.error "[RssSection] Failed to parse feed!"
+#    false
+  end
+  memoize :rss_feed
+  
+  def fetch_feed
+    logger.debug "[RssSection] Fetching feed #{self.url}"
+    feed = open(self.url).read
+  rescue
+    logger.error "[RssSection] Failed to fetch!"
+    false
+  end
+  
+  def cache(feed)
+    File.open(self.cache_file, "w") do |f|
+      f.write feed.to_yaml
+    end
+  end
+  
+  def reset_mtime
+    FileUtils.touch(self.cache_file)
+  rescue
+  end
+  
+  def delete_from_cache
+    File.delete(self.cache_file)
+  rescue
+  end
+end

data/app/models/skyline/sections/splitter_section.rb

@@ -0,0 +1,6 @@
+# @private
+class Skyline::Sections::SplitterSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  
+  self.default_interface = false
+end

data/app/models/skyline/sections/wysiwyg_section.rb

@@ -0,0 +1,13 @@
+# @private
+class Skyline::Sections::WysiwygSection < ActiveRecord::Base
+  include Skyline::Sections::Interface
+  include Skyline::HasManyReferablesIn
+  
+  self.default_interface = false
+  
+  has_many_referables_in :body
+  
+  def to_text
+    HTML::FullSanitizer.new.sanitize(self.body)
+  end
+end

data/app/models/skyline/site.rb

@@ -0,0 +1,30 @@
+class Skyline::Site
+  include Comparable
+  
+  class << self
+    def find_by_id(id)
+      self.new
+    end
+  end
+  
+  def root
+    Skyline::Page.find_by_parent_id(nil)
+  end
+  
+  def pages
+    Skyline::Page
+  end
+  
+  def renderer(options = {})
+    Skyline::Rendering::Renderer.new(options.merge(:site => self))
+  end
+  
+  def named_scope_with_site_for(article_data_class)
+    {}
+  end
+  
+  def <=>(other)
+    other.class <=> self.class
+  end
+  
+end

data/app/models/skyline/tag.rb

@@ -0,0 +1,34 @@
+class Skyline::Tag < ActiveRecord::Base
+  set_table_name :skyline_tags
+  
+  cattr_accessor :taggable_models
+
+  before_validation :sanitize_tag  
+  
+  class << self
+    def taggable_content_models
+      # lazy load all models in /app/models (not recursive) to find all Content models
+      Dir.chdir(File.join(Rails.root, "app", "models")) do 
+        Dir.glob("*.rb").map{|f| f.sub(".rb","").camelcase.constantize}
+      end
+
+      (taggable_models || []).delete_if{|m| m.parents.include?(Skyline) } 
+    end
+    
+    def register_taggable_model(klass)
+      self.taggable_models ||= []
+      self.taggable_models.delete_if{|c| c.to_s == klass.to_s } # Hack to remove stale object
+      self.taggable_models << klass      
+    end
+    
+    def delete_unused_tags
+      self.connection.execute("DELETE FROM #{self.table_name} WHERE id NOT IN (SELECT DISTINCT tag_id FROM #{Skyline::AssociatedTag.table_name})")
+    end
+  end
+  
+  protected
+  
+  def sanitize_tag
+    self.tag = self.tag.to_s.strip.downcase if self.tag
+  end
+end

data/app/models/skyline/user.rb

@@ -0,0 +1,192 @@
+class Skyline::User < ActiveRecord::Base
+  set_table_name :skyline_users
+  has_many :grants, :class_name => "Skyline::Grant", :dependent => :delete_all
+  has_many :roles, :class_name => "Skyline::Role", :through => :grants
+  has_many :rights, :class_name => "Skyline::Right", 
+    :finder_sql => 'SELECT DISTINCT r.* FROM skyline_rights AS r, skyline_grants AS g JOIN skyline_rights_skyline_roles AS rr ON rr.role_id = g.role_id WHERE g.user_id = #{id} AND r.id = rr.right_id'
+  
+    
+  # This must be set to change the password (by the user himself)
+  attr_accessor :current_password
+  
+  # This can be set by the admin to change the PW
+  attr_reader :force_password
+  attr_protected :force_password
+  
+  # This can be set by the admin to force checking of the current password etc
+  attr_accessor :editing_myself
+    
+  
+  # Validations
+  validate_on_update :valid_current_password, :if => :editing_myself
+
+  validates_presence_of :password, :if => :password_changed?
+  validates_presence_of :password_confirmation, :message => :confirmation, :if => :password_changed?, :on => :update
+  validates_confirmation_of :password, :message => :confirmation, :if => :password_changed?
+
+  validates_confirmation_of :force_password, :message => :confirmation, :if => lambda{|user| user.force_password.present?}
+  
+  validates_presence_of :email
+  validate :valid_email_address
+  validates_uniqueness_of :email, :unless => :is_destroyed
+
+  validate :grants_didnt_change, :if => :editing_myself
+
+  before_validation_on_update :reset_password_on_empty_current_password
+  before_save :set_forced_password,:encrypt_password
+  
+  default_scope :order => "email ASC"
+  
+  accepts_nested_attributes_for :grants
+  
+  
+  class << self
+    
+    # Authenticates a user with email and password
+    #
+    # ==== Returns
+    # User:: The user if authentication passed
+    # --
+    def authenticate(email,password)
+      user = self.first(:conditions => {:email => email.to_s.downcase, :password => encrypt(password.to_s), :is_destroyed => false})
+      user && user || false
+    end
+    
+    def encrypt(pw)
+      Digest::SHA1.hexdigest(pw)
+    end
+    
+    def extract_valid_email_address(email)
+      if email.kind_of? TMail::Address
+        return email.address
+      else
+        begin
+          address = TMail::Address.parse(email.to_s)
+        rescue
+          return false
+        end
+      end
+      if address && address.respond_to?(:domain) && address.domain
+        return address.address 
+      else
+        return false
+      end
+    end  
+    
+    def per_page; 30; end      
+    
+  end
+  
+  # Check if a user has a specific right
+  #
+  # ==== Parameters
+  # right_or_class<String,Symbol,~right_prefix>:: 
+  #   Can be a string or a symbol to check a specific right, or you can pass
+  #   an object that responds to #right_prefix, right_prefix must return a string
+  # suffix<String,Symbol>,::
+  #   A suffix to append to the right, mostly usefull in combination with an object
+  #
+  # ==== Returns
+  #<Boolean>:: true if the right exists in one of the roles fo the user
+  # --
+  def allow?(right_or_class,suffix=nil)
+    if right_or_class.respond_to?(:right_prefix)
+      right_or_class = right_or_class.right_prefix
+    end
+    
+    right = [right_or_class,suffix].compact.map(&:to_s).join("_")
+    
+    @rights ||= self.rights.map{|r| r.name }.uniq
+    @rights.include?(right)
+  end
+
+  # Check if this users password matches.
+  def correct_password?(password)
+    if self.password_changed?
+      self.password == password.to_s
+    else
+      self.password == self.class.encrypt(password.to_s)
+    end
+  end
+
+  def current_password=(v)
+    changed_attributes.delete("password") if v.blank?
+    @current_password = v
+  end
+
+  # Generate a new password, set it and return it.
+  #
+  # ==== Returns
+  # String:: The newly set password
+  # --
+  def generate_new_password!
+    pw = SimplePassword.new(8).to_s
+    self.force_password!(pw)
+  end
+
+  # Forcefully set a password without any validations
+  # Directly saves the object.
+  # --
+  def force_password!(pw)
+    self.update_attribute(:password, pw)
+    pw
+  end
+  
+  def force_password=(pw)
+    @force_password = pw if pw.present?
+  end
+  
+  # Display the name or e-mailaddress of the user for
+  # display purposes.
+  def display_name
+    return self.name
+    self.name.present? ? self.name : self.email
+  end
+  
+  # Don't really destroy the object, just
+  # set the is_destroyed? flag.
+  def destroy_without_callbacks
+    unless new_record?
+      self.update_attributes(:is_destroyed => true)
+    end
+    
+    freeze
+  end
+      
+  def viewable_roles
+    if self.system?
+      Skyline::Role.all
+    else
+      Skyline::Role.all(:conditions => {:system => false})
+    end
+  end
+  
+  protected
+  
+  def set_forced_password
+    self.password = @force_password if @force_password.present?
+  end
+  
+  def encrypt_password
+    return unless self.password_changed?
+    self.password = self.class.encrypt(self.password.to_s)
+  end
+
+  def valid_current_password
+    unless self.current_password && self.password_was == self.class.encrypt(self.current_password)
+      self.errors.add(:current_password, :mismatch)
+    end
+  end
+
+  def reset_password_on_empty_current_password
+    changed_attributes.delete("password") if self.current_password.blank?
+  end
+
+  def valid_email_address
+    return self.errors.add(:email,:invalid) if !Skyline::User.extract_valid_email_address(self.email)
+  end
+  
+  def grants_didnt_change
+    self.errors.add :grants, :changed if self.grants.detect{|g| g.changed?}
+  end
+end