browsercms 3.5.7 → 4.0.0.alpha

data/app/models/cms/content.rb

@@ -0,0 +1,31 @@
+module Cms
+  # An API for interacting with the Content API of BrowserCMS.
+  module Content
+
+    # Find a single content item.
+    # example:
+    #   Cms::Content.find("html_block", 12) # Finds a Cms::HtmlBlock with an id of 12.
+    #
+    # @param [String] content_name The name of the content type to find.
+    # @param [Integer] id The id of the content.
+    # @return [ContentBlock] A single content block or page
+    def self.find(content_type, id)
+      if content_type == "page"
+        return Cms::Page.find(id)
+      end
+      type = ContentType.find_by_key(content_type)
+      type.model_class.find(id)
+    end
+
+    # Find the latest draft for a single content item.
+    # example:
+    #   Cms::Content.find("html_block", 12) # Finds a Cms::HtmlBlock with an id of 12.
+    #
+    # @param [String] content_name The name of the content type to find.
+    # @param [Integer] id The id of the content.
+    # @return [ContentBlock] A single content block or page
+    def self.find_draft(content_type, id)
+      find(content_type, id).as_of_draft_version
+    end
+  end
+end

data/app/models/cms/content_type.rb

@@ -1,22 +1,87 @@
 module Cms
-  class ContentType < ActiveRecord::Base
+  class ContentType
 
-    attr_accessible :name, :group_name, :content_type_group
+    attr_accessor :name
 
-    attr_accessor :group_name
-    belongs_to :content_type_group, :class_name => 'Cms::ContentTypeGroup'
-    validates_presence_of :content_type_group
-    before_validation :set_content_type_group
+    def initialize(options)
+      self.name = options[:name]
+      @path_builder = EngineAwarePathBuilder.new(model_class)
+    end
+
+    attr_accessor :path_builder
+    delegate :main_app_model?, :engine_name, :engine_class, to: :path_builder
+
+    DEFAULT_CONTENT_TYPE_NAME = 'Cms::HtmlBlock'
+
+    class << self
+      def named(name)
+        [Cms::ContentType.new(name: name)]
+      end
 
-    scope :named, lambda { |name| {:conditions => ["#{ContentType.table_name}.name = ?", name]} }
+      def connectable
+        available.select { |content_type| content_type.connectable? }
+      end
+
+      # Return all content types, grouped by module.
+      #
+      # @return [Hash<Symbol, Cms::ContentType]
+      def available_by_module
+        modules = {}
+        available.each do |content_type|
+
+          modules[content_type.module_name] = [] unless modules[content_type.module_name]
+          modules[content_type.module_name] << content_type
+        end
+        modules
+      end
+
+      # Returns a list of all ContentTypes in the system. Content Types can opt out of this list by specifying:
+      #
+      #   class MyWidget < ActiveRecord::Base
+      #     acts_as_content content_module: false
+      #   end
+      #
+      # Ignores the database to just look at classes, then returns a 'new' ContentType to match.
+      #
+      # @return [Array<Cms::ContentType] An alphabetical list of content types.
+      def available
+        subclasses = ObjectSpace.each_object(::Class).select do |klass|
+          klass < Cms::Concerns::HasContentType::InstanceMethods
+        end
+        subclasses << Cms::Portlet
+        subclasses.uniq! { |k| k.name } # filter duplicate classes
+        subclasses.map do |klass|
+          unless klass < Cms::Portlet
+            Cms::ContentType.new(name: klass.name)
+          end
+        end.compact.sort { |a, b| a.name <=> b.name }
+      end
+
+      def list
+        available
+      end
+
+      # Returns all content types besides the default.
+      #
+      # @return [Array<Cms::ContentType]
+      def other_connectables()
+        available.select { |content_type| content_type.name != DEFAULT_CONTENT_TYPE_NAME }
+      end
+
+      # Returns the default content type that is most frequently added to pages.
+      def default()
+        Cms::ContentType.new(name: DEFAULT_CONTENT_TYPE_NAME)
+      end
 
-    scope :connectable,
-          :include => :content_type_group,
-          :conditions => ["#{ContentTypeGroup.table_name}.name != ?", 'Categorization'],
-          :order => "#{ContentType.table_name}.priority, #{ContentType.table_name}.name"
+      # Returns only user generated Content Blocks
+      def user_generated_connectables()
+        available.select { |content_type| !content_type.name.starts_with?("Cms::") }
+      end
 
-    def self.list
-      all.map { |f| f.name.underscore.to_sym }
+      # Return content types that can be accessed as pages.
+      def addressable()
+        available.select { |content_type| content_type.model_class.addressable? }
+      end
     end
 
 
@@ -24,38 +89,44 @@ module Cms
     # Raises exception if nothing was found.
     def self.find_by_key(key)
       class_name = key.tableize.classify
-      content_type = find(:first, :conditions => ["name like ?", "%#{class_name}"])
-      if content_type.nil?
-        if class_name.constantize.ancestors.include?(Cms::Portlet)
-          content_type = Cms::ContentType.new(:name => class_name)
-          content_type.content_type_group = Cms::ContentTypeGroup.find_by_name('Core')
-          content_type.freeze
-          content_type
-        else
-          raise "Not a Portlet"
+      klass = nil
+      prefix = "Cms::"
+      if !class_name.starts_with? prefix
+        klass = "Cms::#{class_name}".safe_constantize
+      end
+      unless klass
+        klass = class_name.safe_constantize
+      end
+      unless klass
+        if class_name.starts_with?(prefix)
+          klass = class_name[prefix.length, class_name.length].safe_constantize
         end
-      else
-        content_type
       end
-    rescue Exception
-      if class_name.starts_with? "Cms::"
-        return self.find_by_key(class_name.gsub(/Cms::/, ""))
+      unless klass
+        raise "Couldn't find ContentType for '#{key}'. Checked for classes Cms::#{class_name} and #{class_name}."
       end
-      raise "Couldn't find ContentType of class '#{class_name}'"
+      klass.content_type
     end
 
-    # Returns URL friendly 'key' which is used to identify this
-    def key
-      model_class_form_name
+    # @deprecated
+    def save!
+      ActiveSupport::Deprecation.warn "Cms::ContentType#save! should no longer be called. Content Types do not need to be registered in the database."
+    end
+
+    def self.create!
+      ActiveSupport::Deprecation.warn "Cms::ContentType.create! should no longer be called. Content Types do not need to be registered in the database."
+    end
+
+    # Return the name of the module this content type should be grouped in. In most cases, content blocks will be
+    # configured to specify this.
+    # @return [Symbol]
+    def module_name
+      model_class.content_module
     end
 
     # Returns the partial used to render the form fields for a given block.
     def form
-      f = model_class.respond_to?(:form) ? model_class.form : "#{name.underscore.pluralize}/form"
-      if main_app_model?
-        f = "cms/#{f}"
-      end
-      f
+      model_class.respond_to?(:form) ? model_class.form : "#{name.underscore.pluralize}/form"
     end
 
     def display_name
@@ -70,28 +141,15 @@ module Cms
       name.constantize
     end
 
-    # @deprecated Should be removed eventually
-    def route_name
-      if model_class.name.starts_with?("Cms")
-        model_class_form_name
-      else
-        "main_app.cms_#{model_class_form_name}"
-      end
-    end
-
-    include EngineHelper
-    def target_class
-      model_class
-    end
-
-    def path_subject
-      model_class
+    # Determines if the content can be connected to other pages.
+    def connectable?
+      model_class.connectable?
     end
 
     # Cms::HtmlBlock -> html_block
     # ThingBlock -> thing_block
-    def model_class_form_name
-      model_class.model_name.element
+    def param_key
+      model_class.model_name.param_key
     end
 
     # Allows models to show additional columns when being shown in a list.
@@ -108,7 +166,8 @@ module Cms
 
     # Used in ERB for pathing
     def content_block_type
-      name.demodulize.pluralize.underscore
+      n = name.starts_with?("Cms::") ? name.demodulize : name
+      n.pluralize.underscore
     end
 
     # This is used for situations where you want different to use a type for the list page
@@ -122,12 +181,5 @@ module Cms
       end
     end
 
-    def set_content_type_group
-      if group_name
-        group = Cms::ContentTypeGroup.first(:conditions => {:name => group_name})
-        self.content_type_group = group || build_content_type_group(:name => group_name)
-      end
-    end
-
   end
 end

data/app/models/cms/dynamic_view.rb

@@ -1,22 +1,18 @@
 module Cms
   class DynamicView < ActiveRecord::Base
+    store_templates
 
-    after_save :write_file_to_disk
-    after_destroy :remove_file_from_disk
+    extend DefaultAccessible
 
-    include DefaultAccessible
-    # Need to explicitly define these, since during new project creation, these files aren't discoverable.
-    attr_accessible :name, :body, :format, :handler
-
-    scope :with_file_name, lambda { |file_name|
+    def self.with_file_name(file_name)
       conditions = {:name => nil, :format => nil, :handler => nil}
       if file_name && (parts = file_name.split(".")).size == 3
         conditions[:name] = parts[0]
         conditions[:format] = parts[1]
         conditions[:handler] = parts[2]
       end
-      {:conditions => conditions}
-    }
+      where(conditions)
+    end
 
     def self.inherited(subclass)
       super if defined? super
@@ -29,16 +25,22 @@ module Cms
         is_versioned
 
         before_validation :set_publish_on_save
+        before_validation :set_defaults, :set_path
 
-        validates_presence_of :name, :format, :handler
+        validates_presence_of :name, :format, :handler, :path, :locale
         validates_uniqueness_of :name, :scope => [:format, :handler],
                                 :message => "Must have a unique combination of name, format and handler"
 
       end
     end
 
+    # Returns the title of this class
+    def self.title
+      self.name.demodulize.titleize
+    end
+
     def self.new_with_defaults(options={})
-      new({:format => "html", :handler => "erb", :body => default_body}.merge(options))
+      new({:format => "html", :handler => "erb", :body => default_body, :locale => I18n.locale}.merge(options))
     end
 
     def self.find_by_file_name(file_name)
@@ -49,10 +51,6 @@ module Cms
       File.join(Rails.root, "tmp", "views")
     end
 
-    def self.form_name
-      ActiveModel::Naming.singular(self)
-    end
-
     def file_name
       "#{name}.#{format}.#{handler}"
     end
@@ -61,23 +59,6 @@ module Cms
       self.class.display_name(file_name)
     end
 
-    def write_file_to_disk
-      if respond_to?(:file_path) && !file_path.blank?
-        FileUtils.mkpath(File.dirname(file_path))
-        open(file_path, 'w') { |f| f << body }
-      end
-    end
-
-    def self.write_all_to_disk!
-      all(:conditions => {:deleted => false}).each { |v| v.write_file_to_disk }
-    end
-
-    def remove_file_from_disk
-      if respond_to?(:file_path) && File.exists?(file_path)
-        File.delete(file_path)
-      end
-    end
-
     def self.default_body
       ""
     end
@@ -86,21 +67,14 @@ module Cms
       self.publish_on_save = true
     end
 
-    # Get the plural symbol for a particular resource.
-    # i.e. Cms::PageTemplate -> :page_templates
-    def self.resource_name
-      resource_collection_name.pluralize
-    end
-
-    # Default implementation
-    def self.resource_collection_name
-      model_name.underscore
+    def set_path
+      self.path = self.class.relative_path + '/' + name
     end
 
-    # So that route lookup works for these resources.
-    # See PathHelper#cms_index_path_for
-    def self.engine
-      "cms"
+    def set_defaults
+      self.locale = I18n.locale.to_s unless locale
+      self.partial = partial?
+      true
     end
   end
 end

data/app/models/cms/email_message.rb

@@ -1,9 +1,10 @@
 module Cms
   class EmailMessage < ActiveRecord::Base
 
-    include DefaultAccessible
+    extend DefaultAccessible
+    extend Cms::DomainSupport
 
-    scope :undelivered, :conditions => "delivered_at is null"
+    scope :undelivered, -> { where("delivered_at is null") }
     validates_presence_of :recipients
     after_create :deliver_now
 
@@ -18,6 +19,34 @@ module Cms
       end
     end
 
+    # Returns a clean (non-www prefixed) domain name
+    def self.normalize_domain(domain)
+      normalized = domain =~ /^www/ ? domain.sub(/^www\./, "") : domain
+      # Strip the port
+      URI.parse("http://#{normalized}").host
+    end
+
+    # Converts a relative path to a path in the CMS. Used for creating a links to internal pages in the body of emails.
+    #
+    # @param [String] path A relative path (i.e. /cms/your-page)
+    # @return [String] (i.e http://cms.example.com/cms/your-page)
+    def self.absolute_cms_url(path)
+      host = normalize_domain(Rails.configuration.cms.site_domain)
+      "http://#{cms_domain_prefix}.#{host}#{path}"
+    end
+
+    # Returns a default address that mail will be sent from. (i.e. mailbot@example.com)
+    def self.mailbot_address
+      address = Rails.configuration.cms.mailbot
+      if address == :default
+        host = normalize_domain(Rails.configuration.cms.site_domain)
+        "mailbot@#{host}"
+      else
+        address
+      end
+
+    end
+
     #TODO: Take this out when we have an email queue processor
     def deliver_now
       deliver!
@@ -25,6 +54,7 @@ module Cms
 
     def deliver!
       return false if delivered?
+      self.sender = self.class.mailbot_address if self.sender.blank?
       Cms::EmailMessageMailer.email_message(self).deliver
       update_attributes(:delivered_at => Time.now)
     end

data/app/models/cms/external_user.rb

@@ -0,0 +1,60 @@
+module Cms
+
+  # Represents a user that has been authenticated from an external data source. Typical use case might be:
+  #
+  # ```
+  #  # Assumes there is an external Crm tool that we look up username/passwords from.
+  #  if(SouthparkCrm::Client.authenticate(params[:login], params[:password]))
+  #   user = Cms::ExternalUser.authenticate('stan.marsh', 'southpark-crm')
+  #   user.authorize('cms-admin')
+  # end
+  # ```
+  class ExternalUser < Cms::PersistentUser
+
+    # Allows extra data to be cached from external sources without needing to alter table columns of the :cms_users table.
+    # This could be anything from security group information to shoe size.
+    store :external_data, coder: JSON
+
+    class << self
+
+      # Returns an authenticated external user. If this is the first time this account has been logged in, this will create
+      # a new User row as a side effect. Otherwise, it returns the existing user account.
+      #
+      # @param [String] login
+      # @param [String] source Used for documentation purposes to determine where User accounts were granted permission from.
+      # @param [Hash] info (Optional) Additional user attributes to assign to user. Can be core user fields (:first_name) or :external_data.
+      # @return [Cms::ExternalUser] An ExternalUser record which has been persisted in the database.
+      def authenticate(login, source, info={})
+        info = work_around_rails_4_serialization_bug(info)
+        criteria = {login: login, source: source}
+        existing = Cms::ExternalUser.where(criteria).first
+        if existing
+          existing.update(info)
+          return existing
+        end
+        criteria.merge!(info)
+        new_user = Cms::ExternalUser.create!(criteria)
+        new_user.groups << Cms::Group.guest if Cms::Group.guest
+        new_user
+      end
+
+      # Rails 4.0.2 bug: If some value (even {}) for external_data is not specified, then a serialization error occurs.
+      def work_around_rails_4_serialization_bug(info)
+        {external_data: {}}.merge(info)
+      end
+    end
+
+    # Determines if this User can have their password changed.
+    def password_changeable?
+      false
+    end
+
+    # Authorize this particular user to be part of one or more groups.
+    # This will overwrite any previous group membership. Typically this would be called after authenticating a user.
+    # @param [Array<String>] group_codes One or more group codes
+    def authorize(*group_codes)
+      new_groups = group_codes.collect { |code| Cms::Group.with_code(code).first }
+      self.groups = new_groups
+    end
+  end
+end