lc_alchemy_cms 3.2.0

data/app/models/alchemy/page/page_natures.rb

@@ -0,0 +1,114 @@
+module Alchemy
+  module Page::PageNatures
+
+    extend ActiveSupport::Concern
+
+    def taggable?
+      definition['taggable'] == true
+    end
+
+    def rootpage?
+      !self.new_record? && self.parent_id.blank?
+    end
+
+    def systempage?
+      return true if Page.root.nil?
+      rootpage? || (self.parent_id == Page.root.id && !self.language_root?)
+    end
+
+    def folded?(user_id)
+      return unless Alchemy.user_class < ActiveRecord::Base
+      folded_pages.where(user_id: user_id, folded: true).any?
+    end
+
+    def contains_feed?
+      definition["feed"]
+    end
+
+    # Returns true or false if the pages layout_description for config/alchemy/page_layouts.yml contains redirects_to_external: true
+    def redirects_to_external?
+      !!definition["redirects_to_external"]
+    end
+
+    def has_controller?
+      !PageLayout.get(self.page_layout).nil? && !PageLayout.get(self.page_layout)["controller"].blank?
+    end
+
+    def controller_and_action
+      if self.has_controller?
+        {
+          controller: self.layout_description["controller"].gsub(/(^\b)/, "/#{$1}"),
+          action: self.layout_description["action"]
+        }
+      end
+    end
+
+    # Returns a Hash describing the status of the Page.
+    #
+    def status
+      {
+        public: public?,
+        visible: visible?,
+        locked: locked?,
+        restricted: restricted?
+      }
+    end
+
+    # Returns the translated status for given status type.
+    #
+    # @param [Symbol] status_type
+    #
+    def status_title(status_type)
+      I18n.t(self.status[status_type].to_s, scope: "page_states.#{status_type}")
+    end
+
+    # Returns the self#page_layout definition from config/alchemy/page_layouts.yml file.
+    def definition
+      return {} if self.systempage?
+      description = PageLayout.get(self.page_layout)
+      if description.nil?
+        log_warning "Page layout description for `#{self.page_layout}` not found. Please check `page_layouts.yml` file."
+        return {}
+      end
+      description
+    end
+    alias_method :layout_description, :definition
+
+    # Returns translated name of the pages page_layout value.
+    # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
+    # Translate the name in your config/locales language yml file.
+    def layout_display_name
+      I18n.t(self.page_layout, :scope => :page_layout_names)
+    end
+
+    # Returns the name for the layout partial
+    #
+    def layout_partial_name
+      page_layout.parameterize.underscore
+    end
+
+    # Returns the key that's taken for cache path.
+    #
+    # Uses the +published_at+ value that's updated when the user publishes the page.
+    #
+    # If the page is the current preview it uses the updated_at value as cache key.
+    #
+    def cache_key
+      if Page.current_preview == self
+        "alchemy/pages/#{id}-#{updated_at}"
+      else
+        "alchemy/pages/#{id}-#{published_at}"
+      end
+    end
+
+    # We use the published_at value for the cache_key.
+    #
+    # If no published_at value is set yet, i.e. because it was never published,
+    # we return the updated_at value.
+    #
+    def published_at
+      read_attribute(:published_at) || updated_at
+    end
+
+  end
+end

data/app/models/alchemy/page/page_scopes.rb

@@ -0,0 +1,95 @@
+module Alchemy
+
+  # ActiveRecord scopes for Alchemy::Page
+  #
+  module Page::PageScopes
+    extend ActiveSupport::Concern
+
+    included do
+      # All language root pages
+      #
+      scope :language_roots, -> { where(language_root: true) }
+
+      # All layout pages
+      #
+      scope :layoutpages, -> { where(layoutpage: true) }
+
+      # All locked pages
+      #
+      scope :all_locked, -> { where(locked: true) }
+
+      # All pages locked by given user
+      #
+      scope :all_locked_by, ->(user) {
+        if user.class.respond_to? :primary_key
+          all_locked.where(locked_by: user.send(user.class.primary_key))
+        end
+      }
+
+      # All not locked pages
+      #
+      scope :not_locked, -> { where(locked: false) }
+
+      # All visible pages
+      #
+      scope :visible, -> { where(visible: true) }
+
+      # All public pages
+      #
+      scope :published, -> { where(public: true) }
+
+      # All not restricted pages
+      #
+      scope :not_restricted, -> { where(restricted: false) }
+
+      # All restricted pages
+      #
+      scope :restricted, -> { where(restricted: true) }
+
+      # All pages that are a published language root
+      #
+      scope :public_language_roots, -> {
+        published.language_roots.where(
+          language_code: Language.published.pluck(:code)
+        )
+      }
+
+      # Last 5 pages that where recently edited by given user
+      #
+      scope :all_last_edited_from, ->(user) {
+        where(updater_id: user.id).order('updated_at DESC').limit(5)
+      }
+
+      # Returns all pages that have the given +language_id+
+      #
+      scope :with_language, ->(language_id) {
+        where(language_id: language_id)
+      }
+
+      # Returns all content pages.
+      #
+      scope :contentpages, -> { where(layoutpage: [false, nil]).where(Page.arel_table[:parent_id].not_eq(nil)) }
+
+      # Returns all public contentpages that are not locked.
+      #
+      # Used for flushing all pages caches at once.
+      #
+      scope :flushables, -> { not_locked.published.contentpages }
+
+      # All searchable pages
+      #
+      scope :searchables, -> { not_restricted.published.contentpages }
+
+      # All pages from +Alchemy::Site.current+
+      #
+      scope :from_current_site, -> {
+        where(Language.table_name => {site_id: Site.current || Site.default}).joins(:language)
+      }
+
+      # All pages for xml sitemap
+      #
+      scope :sitemap, -> { from_current_site.published.contentpages.where(sitemap: true) }
+    end
+
+  end
+end

data/app/models/alchemy/page/page_users.rb

@@ -0,0 +1,58 @@
+module Alchemy
+  module Page::PageUsers
+    extend ActiveSupport::Concern
+
+    # Returns the creator of this page.
+    #
+    def creator
+      get_page_user(creator_id)
+    end
+
+    # Returns the last updater of this page.
+    #
+    def updater
+      get_page_user(updater_id)
+    end
+
+    # Returns the user currently editing this page.
+    #
+    def locker
+      get_page_user(locked_by)
+    end
+
+    # Returns the name of the creator of this page.
+    #
+    # If no creator could be found or associated user model
+    # does not respond to +#name+ it returns +'unknown'+
+    #
+    def creator_name
+      (creator && creator.try(:name)) || I18n.t('unknown')
+    end
+
+    # Returns the name of the last updater of this page.
+    #
+    # If no updater could be found or associated user model
+    # does not respond to +#name+ it returns +'unknown'+
+    #
+    def updater_name
+      (updater && updater.try(:name)) || I18n.t('unknown')
+    end
+
+    # Returns the name of the user currently editing this page.
+    #
+    # If no locker could be found or associated user model
+    # does not respond to +#name+ it returns +'unknown'+
+    #
+    def locker_name
+      (locker && locker.try(:name)) || I18n.t('unknown')
+    end
+
+    private
+
+    def get_page_user(id)
+      if Alchemy.user_class.respond_to? :primary_key
+        Alchemy.user_class.try(:find_by, {Alchemy.user_class.primary_key => id})
+      end
+    end
+  end
+end

data/app/models/alchemy/picture.rb

@@ -0,0 +1,220 @@
+# == Schema Information
+#
+# Table name: alchemy_pictures
+#
+#  id                :integer          not null, primary key
+#  name              :string(255)
+#  image_file_name   :string(255)
+#  image_file_width  :integer
+#  image_file_height :integer
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  creator_id        :integer
+#  updater_id        :integer
+#  upload_hash       :string(255)
+#  cached_tag_list   :text
+#  image_file_uid    :string(255)
+#  image_file_size   :integer
+#
+
+module Alchemy
+  class Picture < ActiveRecord::Base
+    include Alchemy::NameConversions
+    include Alchemy::Touching
+    include Alchemy::Picture::Sweeping
+    include Alchemy::Picture::Transformations
+
+    has_many :essence_pictures, class_name: 'Alchemy::EssencePicture', foreign_key: 'picture_id'
+    has_many :contents, through: :essence_pictures
+    has_many :elements, through: :contents
+    has_many :pages, through: :elements
+
+    # Raise error, if picture is in use (aka. assigned to an EssencePicture)
+    #
+    # === CAUTION
+    #
+    # This HAS to be placed for Dragonfly's class methods,
+    # to ensure this runs before Dragonfly's before_destroy callback.
+    #
+    before_destroy unless: :deletable? do
+      raise PictureInUseError, I18n.t(:cannot_delete_picture_notice) % { name: name }
+    end
+
+    # Enables Dragonfly image processing
+    dragonfly_accessor :image_file, app: :alchemy_pictures do
+      # Preprocess after uploading the picture
+      after_assign do |p|
+        if Config.get(:preprocess_image_resize).present?
+          p.thumb!("#{Config.get(:preprocess_image_resize)}>")
+        end
+      end
+    end
+
+    validates_presence_of :image_file
+    validates_size_of :image_file, maximum: Config.get(:uploader)['file_size_limit'].megabytes
+    validates_property :format,
+      of: :image_file,
+      in: Config.get(:uploader)['allowed_filetypes']['pictures'],
+      case_sensitive: false,
+      message: I18n.t("not a valid image")
+
+    acts_as_taggable
+
+    stampable stamper_class_name: Alchemy.user_class_name
+
+    scope :named, ->(name) {
+      where("#{self.table_name}.name LIKE ?", "%#{name}%")
+    }
+
+    scope :recent, -> {
+      where("#{self.table_name}.created_at > ?", Time.now - 24.hours).order(:created_at)
+    }
+
+    scope :deletable, -> {
+      where("#{table_name}.id NOT IN (SELECT picture_id FROM #{EssencePicture.table_name})")
+    }
+
+    scope :without_tag, -> {
+      where("#{self.table_name}.cached_tag_list IS NULL OR #{self.table_name}.cached_tag_list = ''")
+    }
+
+    after_update :touch_contents
+
+    # Class methods
+
+    class << self
+
+      # Returns filtered, paginated and ordered picture collection.
+      def find_paginated(params, per_page)
+        @pictures = Picture.all
+
+        if params[:tagged_with].present?
+          @pictures = @pictures.tagged_with(params[:tagged_with])
+        end
+        if params[:filter].present?
+          @pictures = @pictures.filtered_by(params[:filter])
+        end
+        if params[:query].present?
+          @pictures = @pictures.named(params[:query])
+        end
+
+        @pictures.page(params[:page] || 1).per(per_page).order(:name)
+      end
+
+      def last_upload
+        last_picture = Picture.last
+        return Picture.all unless last_picture
+        Picture.where(upload_hash: last_picture.upload_hash)
+      end
+
+      def filtered_by(filter = '')
+        case filter
+          when 'recent'      then recent
+          when 'last_upload' then last_upload
+          when 'without_tag' then without_tag
+        else
+          all
+        end
+      end
+    end
+
+    # Instance methods
+
+    # Updates name and tag_list attributes.
+    #
+    # Used by +Admin::PicturesController#update_multiple+
+    #
+    # Note: Does not delete name value, if the form field is blank.
+    #
+    def update_name_and_tag_list!(params)
+      if params[:pictures_name].present?
+        self.name = params[:pictures_name]
+      end
+      self.tag_list = params[:pictures_tag_list]
+      self.save!
+    end
+
+    # Returns a Hash suitable for jquery fileupload json.
+    #
+    def to_jq_upload
+      {
+        name: image_file_name,
+        size: image_file_size,
+        error: errors[:image_file].join
+      }
+    end
+
+    # Returns an uri escaped name.
+    #
+    def urlname
+      if self.name.blank?
+        "image_#{self.id}"
+      else
+        ::CGI.escape(self.name.gsub(/\.(gif|png|jpe?g|tiff?)/i, '').gsub(/\./, ' '))
+      end
+    end
+
+    # Returns the suffix of the filename.
+    #
+    def suffix
+      image_file.ext
+    end
+
+    # Returns a humanized, readable name from image filename.
+    #
+    def humanized_name
+      return "" if image_file_name.blank?
+      convert_to_humanized_name(image_file_name, suffix)
+    end
+
+    # Checks if the picture is restricted.
+    #
+    # A picture is only restricted if it's assigned on restricted pages only.
+    #
+    # Once a picture is assigned on a not restricted page,
+    # it is considered public and therefore not restricted any more,
+    # even if it is also assigned on a restricted page.
+    #
+    def restricted?
+      pages.any? && pages.not_restricted.blank?
+    end
+
+    # Returns true if picture is not assigned to any EssencePicture.
+    #
+    def deletable?
+      !essence_pictures.any?
+    end
+
+    # A size String from original image file values.
+    #
+    # == Example
+    #
+    # 200 x 100
+    #
+    def image_file_dimensions
+      "#{image_file_width} x #{image_file_height}"
+    end
+
+    # Returns a security token for signed picture rendering requests.
+    #
+    # Pass a params hash containing:
+    #
+    #   size       [String]  (Optional)
+    #   crop       [Boolean] (Optional)
+    #   crop_from  [String]  (Optional)
+    #   crop_size  [String]  (Optional)
+    #   quality    [Integer] (Optional)
+    #
+    # to sign them.
+    #
+    def security_token(params = {})
+      params = params.dup.stringify_keys
+      params.update({
+        'crop' => params['crop'] ? 'crop' : nil,
+        'id' => self.id
+      })
+      PictureAttributes.secure(params)
+    end
+
+  end
+end