browsercms-artirix 4.0.0.rc1.art4

data/app/models/cms/content_type.rb

@@ -0,0 +1,191 @@
+module Cms
+  class ContentType
+
+    attr_accessor :name
+
+    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
+
+      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
+
+      # Returns only user generated Content Blocks
+      def user_generated_connectables()
+        available.select { |content_type| !content_type.name.starts_with?("Cms::") }
+      end
+
+      # Return content types that can be accessed as pages.
+      def addressable()
+        available.select { |content_type| content_type.model_class.addressable? }
+      end
+    end
+
+
+    # Given a 'key' like 'html_blocks' or 'portlet'. Looks first for a class in the Cms:: namespace, then again without it.
+    # Raises exception if nothing was found.
+    def self.find_by_key(key)
+      class_name = key.tableize.classify
+      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
+      end
+      unless klass
+        raise "Couldn't find ContentType for '#{key}'. Checked for classes Cms::#{class_name} and #{class_name}."
+      end
+      klass.content_type
+    end
+
+    # Returns a list of column names and values for this content type which are allowed be orderable.
+    def orderable_attributes
+      attribute_names = model_class.new.attribute_names
+      attribute_names -= ["id", "version", "lock_version", "created_by_id", "updated_by_id"]
+    end
+
+    # @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
+      model_class.respond_to?(:form) ? model_class.form : "#{name.underscore.pluralize}/form"
+    end
+
+    def display_name
+      model_class.respond_to?(:display_name) ? model_class.display_name : Cms::Behaviors::Connecting.default_naming_for(model_class)
+    end
+
+    def display_name_plural
+      model_class.respond_to?(:display_name_plural) ? model_class.display_name_plural : display_name.pluralize
+    end
+
+    def model_class
+      name.constantize
+    end
+
+    # Determines if the content can be connected to other pages.
+    def connectable?
+      model_class.connectable?
+    end
+
+    # Cms::HtmlBlock -> html_block
+    # ThingBlock -> thing_block
+    def param_key
+      model_class.model_name.param_key
+    end
+
+    # Allows models to show additional columns when being shown in a list.
+    def columns_for_index
+      if model_class.respond_to?(:columns_for_index)
+        model_class.columns_for_index.map do |column|
+          column.respond_to?(:humanize) ? {:label => column.humanize, :method => column} : column
+        end
+      else
+        [{:label => "Name", :method => :name, :order => "name"},
+         {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"}]
+      end
+    end
+
+    # Used in ERB for pathing
+    def content_block_type
+      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
+    # This is true for portlets, where you don't want to list all portlets of a given type,
+    # You want to list all portlets
+    def content_block_type_for_list
+      if model_class.respond_to?(:content_block_type_for_list)
+        model_class.content_block_type_for_list
+      else
+        content_block_type
+      end
+    end
+
+  end
+end

data/app/models/cms/dynamic_view.rb

@@ -0,0 +1,81 @@
+module Cms
+  class DynamicView < ActiveRecord::Base
+    store_templates
+
+    extend DefaultAccessible
+
+    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
+      where(conditions)
+    end
+
+    def self.inherited(subclass)
+      super if defined? super
+    ensure
+      subclass.class_eval do
+        flush_cache_on_change
+        is_publishable
+        uses_soft_delete
+        is_userstamped
+        is_versioned
+
+        before_validation :set_publish_on_save
+        before_validation :set_defaults, :set_path
+
+        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",
+                                conditions: -> { where(deleted: false) }
+
+      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, :locale => I18n.locale}.merge(options))
+    end
+
+    def self.find_by_file_name(file_name)
+      with_file_name(file_name).first
+    end
+
+    def self.base_path
+      File.join(Rails.root, "tmp", "views")
+    end
+
+    def file_name
+      "#{name}.#{format}.#{handler}"
+    end
+
+    def display_name
+      self.class.display_name(file_name)
+    end
+
+    def self.default_body
+      ""
+    end
+
+    def set_publish_on_save
+      self.publish_on_save = true
+    end
+
+    def set_path
+      self.path = self.class.relative_path + '/' + name
+    end
+
+    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

@@ -0,0 +1,63 @@
+module Cms
+  class EmailMessage < ActiveRecord::Base
+
+    extend DefaultAccessible
+    extend Cms::DomainSupport
+
+    scope :undelivered, -> { where("delivered_at is null") }
+    validates_presence_of :recipients
+    after_create :deliver_now
+
+    def delivered?
+      !!delivered_at
+    end
+
+    def self.deliver!
+      # Send all messages, 100 at a time
+      undelivered.all(:limit => 100).each do |m|
+        m.deliver!
+      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!
+    end
+
+    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
+
+  end
+end

data/app/models/cms/email_message_mailer.rb

@@ -0,0 +1,12 @@
+module Cms
+  class EmailMessageMailer < ActionMailer::Base
+
+
+    def email_message(message)
+      email = {:to=>message.recipients, :from=>message.sender, :subject => message.subject, :body =>message.body}
+      email[:content_type]  = message.content_type if message.content_type
+      mail email
+    end
+
+  end
+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

data/app/models/cms/file_block.rb

@@ -0,0 +1,19 @@
+module Cms
+  class FileBlock < Cms::AbstractFileBlock
+
+    acts_as_content_block :taggable => true
+    content_module :core
+
+    has_attachment :file
+    validates_attachment_presence :file, :message => "You must upload a file"
+
+    def self.display_name
+      "File"
+    end
+
+    # Override default behavior to handle STI class when looking up other versions of attachments.
+    def attachable_type
+      Cms::Attachment::FILE_BLOCKS
+    end
+  end
+end

data/app/models/cms/form.rb

@@ -0,0 +1,47 @@
+module Cms
+  class Form < ActiveRecord::Base
+    acts_as_content_block
+    content_module :forms
+    is_addressable path: '/forms', template: 'default'
+
+    has_many :fields,  -> {order(:position)}, class_name: 'Cms::FormField'
+    has_many :entries, class_name: 'Cms::FormEntry'
+
+    validates_format_of :notification_email, :with => /@/, unless: lambda { |form| form.notification_email.blank? }
+
+    # Copy any field related errors into the model :base so they get displayed at the top of the form.
+    after_validation do
+      unless errors[:fields].empty?
+        fields.each do |field|
+          field.errors.each do |attribute, error|
+            errors[:base] << field.errors.full_message(attribute, error)
+          end
+
+        end
+      end
+    end
+
+    def field(name)
+      fields.select {|f| f.name == name}.first
+    end
+
+    def required?(name)
+      field = field(name)
+      field ? field.required? : false
+    end
+
+    def field_names
+      fields.collect { |f| f.name }
+    end
+
+    def show_text?
+      confirmation_behavior.to_sym == :show_text
+    end
+
+    # Provides a sample Entry for the form.
+    # This allows us to use SimpleForm to layout out elements but ignore the input when the form submits.
+    def new_entry
+      Cms::Entry.new(form: self)
+    end
+  end
+end

data/app/models/cms/form_entry.rb

@@ -0,0 +1,75 @@
+module Cms
+  class FormEntry < ActiveRecord::Base
+
+    store :data_columns
+    belongs_to :form, class_name: 'Cms::Form'
+
+    after_initialize :add_field_accessors
+
+    def permitted_params
+      form.field_names
+    end
+
+    # Returns a copy of the persisted object. This is required so that existing records fetched from the db can
+    # have validation during update operations.
+    #
+    # @return [Cms::FormEntry] A copy of this record with validations enabled on it.
+    def enable_validations
+      entry = FormEntry.for(form)
+      entry.attributes = self.attributes
+      entry.instance_variable_set(:@new_record, false)
+      entry
+    end
+
+    class << self
+
+      def search(term)
+        where("data_columns like ?", "%#{term}%")
+      end
+      
+      # Create an Entry for a specific Form. It will have validation and accessors based on the fields of the form.
+      #
+      # @param [Cms::Form] form
+      def for(form)
+        entry = FormEntry.ish(form: form) {
+          form.field_names.each do |field_name|
+            if form.required?(field_name)
+              validates field_name, presence: true
+            end
+          end
+        }
+        entry
+      end
+
+      # Create an instance of a FormEntry with the given methods.
+      def ish(*args, &block)
+        dup(&block).new(*args)
+      end
+
+      # Creates a faux class with singleton methods. Solves this problem:
+      #   https://github.com/rails/rails/issues/5449
+      def dup(&block)
+        super.tap do |dup|
+          def dup.name()
+            FormEntry.name
+          end
+
+          dup.class_eval(&block) if block
+        end
+      end
+    end
+    private
+
+    # Add a single field accessor to the current instance of the object. (I.e. not shared with others)
+    def add_store_accessor(field_name)
+      singleton_class.class_eval { store_accessor :data_columns, field_name }
+    end
+
+    def add_field_accessors
+      return unless form
+      form.field_names.each do |field_name|
+        add_store_accessor(field_name)
+      end
+    end
+  end
+end

data/app/models/cms/form_field.rb

@@ -0,0 +1,78 @@
+module Cms
+  class FormField < ActiveRecord::Base
+    extend DefaultAccessible
+
+    belongs_to :form
+    acts_as_list scope: :form
+
+    attr_accessor :edit_path, :delete_path
+
+    # Name is assigned when the Field is created, and should not be changed afterwords.
+    # Otherwise existing entries will not display their data correctly.
+    #
+    # FormField#name is used for input fields. I.e. <%= f.input field.name %>
+    before_validation(on: :create) do
+      self.name = label.parameterize.underscore.to_sym if label
+    end
+
+    validates :name, :uniqueness => {:scope => :form_id, message: "can only be used once per form."}
+
+    def as_json(options={})
+      super(:methods => [:edit_path, :delete_path])
+    end
+
+
+    # Return the form widget that should be used to render this field.
+    #
+    # @return [Symbol] A SimpleForm input mapping (i.e. :string, :text)
+    def as
+      case field_type
+        when "text_field"
+          :string
+        when "text_area"
+          :text
+        else
+          field_type.to_sym
+      end
+    end
+
+    # Return options to be passed to a SimpleForm input.
+    # @return [Hash]
+    # @param [Hash] config
+    # @option config [Boolean] :disabled If the field should be disabled.
+    # @option config [FormEntry] :entry
+    def options(config={})
+      opts = {label: label}
+      if field_type != "text_field"
+        opts[:as] = self.as
+      end
+      if config[:disabled]
+        opts[:disabled] = true
+        opts[:readonly] = 'readonly'
+      end
+      opts[:required] = !!required
+      opts[:hint] = instructions if instructions
+      unless choices.blank?
+        opts[:collection] = parse_choices
+        opts[:prompt] = !self.required?
+      end
+      unless config[:entry] && config[:entry].send(name)
+        opts[:input_html] =  {value: default_value}
+      end
+      opts
+    end
+
+
+    # Don't allow name to be set via UI.
+    def self.permitted_params
+      super - [:name]
+    end
+
+    private
+
+    # Choices is a single text area where choices are divided by endlines.
+    def parse_choices
+      choices.split( /\r?\n/ )
+    end
+  end
+end

data/app/models/cms/group.rb

@@ -0,0 +1,62 @@
+#
+# A group represents a collection of permissions. Each User can be assigned to one or more groups, and the sum of
+# their permissions from all groups combined represents what they can do.
+#
+class Cms::Group < ActiveRecord::Base
+  GUEST_CODE = "guest"
+
+  has_many :user_group_memberships, :class_name => 'Cms::UserGroupMembership'
+  has_many :users, :through => :user_group_memberships, :class_name => 'Cms::PersistentUser'
+
+  has_many :group_permissions, :class_name => 'Cms::GroupPermission'
+  has_many :permissions, :through => :group_permissions, :class_name => 'Cms::Permission'
+
+  has_many :group_sections, :class_name => 'Cms::GroupSection'
+  has_many :sections, :through => :group_sections, :class_name => 'Cms::Section'
+
+  belongs_to :group_type, :class_name => 'Cms::GroupType'
+
+  extend Cms::DefaultAccessible
+
+  # @override Add extra params
+  def self.permitted_params
+    super + [:group_type_id] +[section_ids: [], permission_ids: []]
+  end
+
+
+  validates_presence_of :name
+
+  class << self
+    def named(n)
+      where name: n
+    end
+
+    def with_code(c)
+      where code: c
+    end
+  end
+
+  scope :public, -> { where(["#{Cms::GroupType.table_name}.cms_access = ?", false]).includes(:group_type).references(:group_type) }
+  scope :cms_access, -> { where(["#{Cms::GroupType.table_name}.cms_access = ?", true]).includes(:group_type).references(:group_type) }
+
+  def guest?
+    group_type && group_type.guest?
+  end
+
+  def cms_access?
+    group_type && group_type.cms_access?
+  end
+
+  # Finds the guest group, which is a special group that represents public non-logged in users.
+  def self.guest
+    with_code(GUEST_CODE).first
+  end
+
+
+  def has_permission?(permission)
+    permissions.any? do |p|
+      return true if permission.to_sym == p.name.to_sym
+    end
+    false
+  end
+end