dm_cms 4.2.1.5

data/app/models/cms_post.rb

@@ -0,0 +1,76 @@
+class CmsPost < ActiveRecord::Base
+
+  # --- globalize (don't use versioning: true, translations erased when updating regular model data.  Maybe fixed in github version)
+  translates              :title, :summary, :content, :fallbacks_for_empty_translations => true #, :versioning => true
+  globalize_accessors     :locales => DmCore::Language.language_array
+    
+  # --- FriendlyId
+  extend FriendlyId
+  include DmCore::Concerns::FriendlyId
+
+  # --- re-define so it can be scoped to the blog as well
+  friendly_id             :model_slug, use: :scoped, scope: [:account_id, :cms_blog]
+
+  acts_as_commentable
+  
+  belongs_to              :cms_blog
+  belongs_to              :account
+  
+  default_scope           { where(account_id: Account.current.id) }
+  scope                   :published, -> { where("published_on IS NOT NULL AND published_on <= ?", Time.now ) }
+  
+  validates               :title, presence_default_locale: true
+  validates               :summary, liquid: { :locales => true }, presence_default_locale: true
+  validates               :content, liquid: { :locales => true }, presence_default_locale: true
+  validates_uniqueness_of :slug, scope: [:account_id, :cms_blog_id]
+  
+  self.per_page = 10
+  
+  # Base the slug on the default locale
+  #------------------------------------------------------------------------------
+  def model_slug
+    send("title_#{Account.current.preferred_default_locale}")
+  end
+
+  #------------------------------------------------------------------------------
+  def is_published?
+    !published_on.nil? && published_on <= Time.now
+  end
+  
+  # Allow comments if also enabled in the blog
+  #------------------------------------------------------------------------------
+  def comments_allowed?
+    cms_blog.comments_allowed? && comments_allowed
+  end
+  
+  # Send post notification to any members and followers.  Updates the 
+  # :notification_sent_on column after emails sent.
+  # Use 'sets' to only end up with a unique list of users
+  #------------------------------------------------------------------------------
+  def send_notification_emails(test_user = nil)
+    if test_user
+      email     = PostNotifyMailer.post_notify(test_user, self, self.account).deliver_now
+      return (email ? 1 : 0)
+    else
+      user_list = cms_blog.member_list(:all).to_set
+      cms_blog.followers.each {|follower| user_list << follower.user}
+      async_send_notification_emails(user_list)
+      return user_list.size
+    end
+
+  end
+
+  #------------------------------------------------------------------------------
+  def async_send_notification_emails(user_list)
+    success   = failed = 0
+    Rails.logger.info "=== Sending #{user_list.size} emails for blog post '#{title}'"
+    user_list.each do |user|
+      email     = PostNotifyMailer.post_notify(user, self, self.account).deliver_later
+      success  += 1 if email
+      failed   += 1 if email.nil?
+    end
+    update_attribute(:notification_sent_on, Time.now)
+    Rails.logger.info "    Completed sending: successes (#{success}) -- failures (#{failed}) "
+  end
+  
+end

data/app/models/cms_snippet.rb

@@ -0,0 +1,42 @@
+# Note: fragment caching is used during rendering.  The cache key is based
+# on both the model and the current locale (because each model supports
+# multiple translations).  The cache will be busted automatically since
+# the updated_at attribute will be updated on save.
+#------------------------------------------------------------------------------
+class CmsSnippet < ActiveRecord::Base
+  class Translation < ::Globalize::ActiveRecord::Translation
+    has_paper_trail
+  end
+
+  # --- FriendlyId
+  extend FriendlyId
+  include DmCore::Concerns::FriendlyId
+
+  default_scope         { where(account_id: Account.current.id) }
+  
+  # --- globalize (don't use versioning: true, translations erased when updating regular model data.  Maybe fixed in github version)
+  translates            :content, :fallbacks_for_empty_translations => true
+  globalize_accessors   :locales => DmCore::Language.language_array
+
+  # --- versioning - skip anything translated
+  has_paper_trail       :skip => :content
+  
+  # --- validations 
+  validates_presence_of :itemtype, :slug
+  validates_length_of   :itemtype,    :maximum => 30
+  validates             :content, liquid: { :locales => true }, presence_default_locale: true
+
+  # --- content types supported
+  CONTENT_TYPES = [ 'Markdown', 'Textile', 'HTML' ]
+
+  #------------------------------------------------------------------------------
+  def is_published?
+    published
+  end
+  
+  #------------------------------------------------------------------------------
+  def to_liquid
+    {}
+  end
+
+end

data/app/models/contact_form.rb

@@ -0,0 +1,28 @@
+# Generic contact form class.  If changes are needed, then a new version should
+# be created in the theme's models folder
+#------------------------------------------------------------------------------
+class ContactForm < ::MailForm::Base
+  
+  attribute :name,        :validate => true
+  attribute :email,       :validate =>  /\A([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})\z/i
+  attribute :organization                    # Not validated
+  attribute :subject,     :validate => true
+  attribute :message,     :validate => true
+  attribute :reason,      :validate => true
+  attribute :nickname,    :captcha  => true
+  
+  # append    :remote_ip, :user_agent, :session   # append these values to the end of all emails
+
+  # for a contact form, the "from" address should be a valid email address
+  # within the domain that is doing the actual sending, instead of the contacter's
+  # address.  This important for services like Sparkpost or Mandrill, that checks
+  # the validity of the sending domain.
+  #------------------------------------------------------------------------------
+  def headers
+    { subject:  "#{I18n.t('cms.contact_form.subject_prefix')}: #{reason}: #{subject}" , 
+      to:       Account.current.preferred_support_email,
+      from:     Account.current.preferred_support_email,
+      reply_to: %("#{name}" <#{email}>)
+    }
+  end
+end

data/app/models/dm_cms/concerns/ability.rb

@@ -0,0 +1,54 @@
+# Wrap blog/cms specific CanCan rules.  Should be included in the main app's
+# Ability class.
+# NOTE:  When checking abilities, don't check for Class level abilities,
+# unless you don't care about the instance level.  For example, don't
+# use both styles
+#   can? :moderate, Forum
+#   can? :moderate, @forum
+# In this case, if you need to check the class level, then use specific
+#    current_user.has_role? :moderator, Forum
+#------------------------------------------------------------------------------
+
+module DmCms
+  module Concerns
+    module Ability
+      def dm_cms_abilities(user)
+        if user
+          #--- Admin
+          if user.has_role?(:content_manager)
+            can :manage_content, :all
+            can :access_admin, :all
+          end
+
+          #--- Blog
+          can(:read, CmsBlog)   { |blog| blog.can_be_read_by?(user) }
+          can(:reply, CmsBlog)  { |blog| blog.can_be_replied_by?(user) }
+          # can :moderate, CmsBlog, :id => CmsBlog.published.with_role(:moderator, user).map(&:id)
+          
+          can(:read, CmsPost)   { |post| post.is_published? || user.has_role?(:reviewer) || user.has_role?(:content_manager)}
+          
+          #--- Pages
+          can(:read, CmsPage)   { |page| page.is_published? || user.has_role?(:reviewer) || user.has_role?(:content_manager)}
+        else
+          #--- can only read/see public blogs when not logged in
+          can(:read, CmsBlog)   { |blog| blog.can_be_read_by?(user) }
+          can(:read, CmsPost)   { |post| post.is_published? }
+          can(:read, CmsPage)   { |page| page.is_published? }
+        end
+      end
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# The abilities get basically compiled.  So if you use
+#
+#    can :moderate, Forum, :id => Forum.with_role(:moderator, user).map(&:id)
+#
+# this will execute the Forum.with_role query once during Ability.new.  However
+#
+#    can :moderate, Forum do |forum|
+#      user.has_role? :moderator, forum
+#    end
+#
+# this will execute the has_role? block on each call to can?

data/app/models/dm_cms/permitted_params.rb

@@ -0,0 +1,34 @@
+module DmCms
+  module PermittedParams
+
+    #------------------------------------------------------------------------------
+    def cms_snippet_params
+      params.require(:cms_snippet).permit! if can? :manage_content, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def cms_blog_params
+      params.require(:cms_blog).permit! if can? :manage_content, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def cms_post_params
+      params.require(:cms_post).permit! if can? :manage_content, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def cms_page_params
+      params.require(:cms_page).permit! if can? :manage_content, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def cms_contentitem_params
+      params.require(:cms_contentitem).permit! if can? :manage_content, :all
+    end
+
+    #------------------------------------------------------------------------------
+    def media_file_params
+      params.require(:media_file).permit! if can? :manage_content, :all
+    end
+  end
+end

data/app/models/media_file.rb

@@ -0,0 +1,102 @@
+#------------------------------------------------------------------------------
+class MediaFile < ActiveRecord::Base
+
+  self.table_name = 'cms_media_files'
+  
+  translates              :title, :description, fallbacks_for_empty_translations: true
+  globalize_accessors     :locales => DmCore::Language.language_array
+  acts_as_taggable
+
+  belongs_to              :user
+  default_scope           { where(account_id: Account.current.id) }
+  validate                :validate_name_is_unique
+  
+  #--- Using Carrierwave
+  mount_uploader          :media, MediaUploader
+  before_save             :prepare_attributes
+  
+  #------------------------------------------------------------------------------
+  def image?
+    self.media_content_type.start_with? 'image'
+  end
+
+  #------------------------------------------------------------------------------
+  def pdf?
+    self.media_content_type.end_with? 'pdf'
+  end
+  
+  #------------------------------------------------------------------------------
+  def short_location(version = nil)
+    filename = version ? self.media.versions[version].file.filename : self.media.file.filename
+    folder.blank? ? filename : "#{folder}/#{filename}"
+  end
+  
+  # return a list of tags for all media objects
+  #------------------------------------------------------------------------------
+  def self.tag_list_all
+    MediaFile.tag_counts_on(:tags).map(&:name).sort
+  end
+  
+  # Given a name in the form 'folder/filename.ext', grab the url with the correct version
+  # Use 'version: :original' to allow the original version to be pulled
+  #------------------------------------------------------------------------------
+  def self.url_by_name(name, options = {version: :original})
+    asset = MediaFile.find_by_name(name)
+    if asset
+      options[:version] == :original ? asset.media.url : asset.media.url(options[:version])
+    else
+      nil
+    end
+  end
+
+  # Given a name in the form 'folder/filename.ext', check if the version exists.
+  # Use 'version: :original' to allow the original version to be pulled
+  #------------------------------------------------------------------------------
+  def self.version_exists?(name, options = {version: :original})
+    asset = MediaFile.find_by_name(name)
+    if asset
+      options[:version] == :original ? true : asset.media.version_exists?(options[:version])
+    else
+      false
+    end
+  end
+
+  # Given a name in the form 'folder/filename.ext', return the correct media file
+  #------------------------------------------------------------------------------
+  def self.find_by_name(name)
+    components  = name.split('/')
+    filename    = components[-1]
+    folder      = components[-2] || ''
+    asset       = MediaFile.where(folder: folder, media: filename).first
+  end
+  
+private
+
+  #------------------------------------------------------------------------------
+  def validate_name_is_unique
+    if self.new_record?
+      if self.media.file.nil?
+        errors.add :media, "please select a file to upload"
+      elsif MediaFile.where(media: self.media.file.original_filename, folder: self.folder, account_id: self.account_id).count > 0
+        errors.add :media, "'#{self.short_location}' already exists"
+      end
+    end
+  end
+
+  # Save the media metadata, and add the 'folder' as a tag
+  #------------------------------------------------------------------------------
+  def prepare_attributes
+    if media.present? && media_changed?
+      self.media_content_type = media.file.content_type
+      self.media_file_size    = media.file.size
+    end
+
+    if self.new_record?
+      self.folder = self.folder.sanitize_filename
+      self.tag_list.add(self.folder)
+      self.tag_list.add(media.file.extension)
+    end
+  end
+  
+
+end

data/app/presenters/cms_blog_presenter.rb

@@ -0,0 +1,15 @@
+class CmsBlogPresenter < BasePresenter
+
+  presents :cms_blog
+
+  #------------------------------------------------------------------------------
+  def label_published
+    cms_blog.is_published? ? h.colored_label('Published', :success) : h.colored_label('Draft')
+  end
+  
+  #------------------------------------------------------------------------------
+  def visibility
+    cms_blog.visibility_to_s
+  end
+  
+end

data/app/presenters/cms_page_presenter.rb

@@ -0,0 +1,23 @@
+class CmsPagePresenter < BasePresenter
+
+  presents :cms_page
+
+  #------------------------------------------------------------------------------
+  def label_published
+    cms_page.is_published? ? h.colored_label('Published', :success) : h.colored_label('Draft')
+  end
+  
+  # Prepare a title for admin Page views.  page/menu title with slug in <small>
+  #------------------------------------------------------------------------------
+  def admin_edit_title
+    main_title  = (cms_page.title.present? ? cms_page.title : (cms_page.menutitle.present? ? cms_page.menutitle : '(no title)'))
+    sub_title   = cms_page.slug
+
+    #--- make sure it's built safely...
+    html = "".html_safe
+    html << main_title
+    html << "<small>".html_safe
+    html << sub_title
+    html << "</small>".html_safe
+  end
+end

data/app/presenters/cms_post_presenter.rb

@@ -0,0 +1,11 @@
+class CmsPostPresenter < BasePresenter
+
+  presents :cms_post
+
+  #------------------------------------------------------------------------------
+  def label_published
+    date_formatted = cms_post.published_on.nil? ? 'Draft' : format_datetime(cms_post.published_on)
+    cms_post.is_published? ? h.colored_label(date_formatted, :success) : h.colored_label(date_formatted)
+  end
+  
+end

data/app/presenters/cms_snippet_presenter.rb

@@ -0,0 +1,10 @@
+class CmsSnippetPresenter < BasePresenter
+
+  presents :cms_snippet
+
+  #------------------------------------------------------------------------------
+  def label_published
+    cms_snippet.is_published? ? h.colored_label('Published', :success) : h.colored_label('Draft')
+  end
+  
+end

data/app/uploaders/media_uploader.rb

@@ -0,0 +1,169 @@
+# For uploading files into the media library.  Creates versions based on
+# settings in the Account.  Will also create retina versions automatically.
+# Files are stored in the theme's 'media' folder.  User can specify a single
+# subfolder to store the file, giving a little extra flexibility.
+# At the moment, files are in the public folders.  Future version will
+# allow uploading protected files.
+#
+# make sure ghostscript is installed for PDF thumbnailing
+# on OSX, `brew install ghostscript`
+#------------------------------------------------------------------------------
+class MediaUploader < CarrierWave::Uploader::Base
+  include DmCore::AccountHelper
+
+  # Include RMagick or MiniMagick support:
+  include CarrierWave::MimeTypes
+  include CarrierWave::MiniMagick
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  process :set_content_type
+
+  # Everything gets stored in the 'media' folder
+  #------------------------------------------------------------------------------
+  def store_dir
+    partition_dir = model.folder
+    "#{account_site_assets_media(false)}/#{partition_dir}"
+  end
+
+  # We basically want the width to be the max, allowing the height to grow
+  #------------------------------------------------------------------------------
+  def resize_to_width(width)
+    manipulate! do |img|
+      img.resize "#{width}>"
+      img = yield(img) if block_given?
+      img
+    end
+  end
+
+   # If a pdf, convert to jpg and size, maintain aspect ration and pad to square
+   # If an image, resize it to a cropped square
+   #------------------------------------------------------------------------------
+   def thumb_image_pdf(width, height)
+     if pdf?(self)
+       self.convert(:jpg)
+       self.resize_and_pad(width, height)
+     else
+       self.resize_to_fill(width, height)
+     end
+   end
+   
+   # Convert to png if a pdf, then size to a specfic width
+   #------------------------------------------------------------------------------
+   def size_image_pdf(width)
+     self.convert(:jpg) if pdf?(self)
+     self.resize_to_width(width)
+   end
+   
+   # From: https://github.com/jhnvz/retina_rails
+   # Process retina quality of the image.
+   # Works with ImageMagick and MiniMagick
+   # === Parameters
+   #
+   # [percentage (Int)] quality in percentage
+   #
+   def retina_quality(percentage)
+     manipulate! do |img|
+       if defined?(Magick)
+         img.write(current_path) { self.quality = percentage } unless img.quality == percentage
+       elsif defined?(MiniMagick)
+         img.quality(percentage.to_s)
+       end
+       img = yield(img) if block_given?
+       img
+     end
+   end
+
+  # Create different versions of image files
+  #   Retina naming: http://blog.remarkablelabs.com/2013/01/creating-retina-images-with-carrierwave
+  #------------------------------------------------------------------------------
+  version :retina_lg, :if => :thumbnable_retina? do
+    # process :size_image_pdf => [Account.current.preferred_image_large_width * 2]
+    process :size_image_pdf => [900 * 2]
+    process :retina_quality => 60
+    def full_filename(for_file = model.media.file)
+      name = super.tap {|file_name| file_name.gsub!(/\.+[0-9a-zA-Z]{3,4}$/){ "@2x#{$&}" }.gsub!('retina_', '') }
+      model.pdf? ? (name.chomp(File.extname(name)) + '.jpg') : name
+    end
+  end
+  version :lg, :if => :thumbnable? do
+    # process :size_image_pdf => [Account.current.preferred_image_large_width]
+    process :size_image_pdf => [900]
+    def full_filename (for_file = model.file.file)
+      model.pdf? ? (super.chomp(File.extname(super)) + '.jpg') : super
+    end
+  end
+
+  version :retina_md, :if => :thumbnable_retina?, :from_version => :retina_lg do
+    # process :size_image_pdf => [Account.current.preferred_image_medium_width * 2]
+    process :size_image_pdf => [600 * 2]
+    process :retina_quality => 60
+    def full_filename(for_file = model.media.file)
+      name = super.tap {|file_name| file_name.gsub!(/\.+[0-9a-zA-Z]{3,4}$/){ "@2x#{$&}" }.gsub!('retina_', '') }
+      model.pdf? ? (name.chomp(File.extname(name)) + '.jpg') : name
+    end
+  end
+  version :md, :if => :thumbnable?, :from_version => :lg do
+    # process :size_image_pdf => [Account.current.preferred_image_medium_width]
+    process :size_image_pdf => [600]
+    def full_filename (for_file = model.file.file)
+      model.pdf? ? (super.chomp(File.extname(super)) + '.jpg') : super
+    end
+  end
+
+  version :retina_sm, :if => :thumbnable_retina?, :from_version => :retina_md do
+    # process :size_image_pdf => [Account.current.preferred_image_small_width * 2]
+    process :size_image_pdf => [300 * 2]
+    process :retina_quality => 60
+    def full_filename(for_file = model.media.file)
+      name = super.tap {|file_name| file_name.gsub!(/\.+[0-9a-zA-Z]{3,4}$/){ "@2x#{$&}" }.gsub!('retina_', '') }
+      model.pdf? ? (name.chomp(File.extname(name)) + '.jpg') : name
+    end
+  end
+  version :sm, :if => :thumbnable?, :from_version => :retina_md do
+    # process :size_image_pdf => [Account.current.preferred_image_small_width]
+    process :size_image_pdf => [300]
+    def full_filename (for_file = model.file.file)
+      model.pdf? ? (super.chomp(File.extname(super)) + '.jpg') : super
+    end
+  end
+
+  version :thumb, :if => :thumbnable?, :from_version => :retina_md do
+    # process thumb_image_pdf: [Account.current.preferred_image_thumbnail_width, Account.current.preferred_image_thumbnail_width]
+    process thumb_image_pdf: [200, 200]
+    def full_filename (for_file = model.file.file)
+      model.pdf? ? (super.chomp(File.extname(super)) + '.jpg') : super
+    end
+  end
+
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  #------------------------------------------------------------------------------
+  def extension_white_list
+    %w(jpg jpeg gif png mp3 mp4 m4v ogg webm pdf css js)
+  end
+
+protected
+
+  #------------------------------------------------------------------------------
+  def thumbnable?(new_file)
+    image?(new_file) || pdf?(new_file)
+  end
+
+  #------------------------------------------------------------------------------
+  def thumbnable_retina?(new_file)
+    model.generate_retina? ? (image?(new_file) || pdf?(new_file)) : false
+  end
+
+  #------------------------------------------------------------------------------
+  def image?(new_file)
+    new_file.content_type.start_with? 'image'
+  end
+
+  #------------------------------------------------------------------------------
+  def pdf?(new_file)
+    new_file.content_type.end_with? 'pdf'
+  end
+  
+end