dm_core 4.2.1.5

data/app/models/activity.rb

@@ -0,0 +1,10 @@
+#------------------------------------------------------------------------------
+class Activity < ActiveRecord::Base
+
+  self.table_name   = 'core_activities'
+
+  default_scope     { where(account_id: Account.current.id).order("created_at ASC") }
+
+  belongs_to :user
+  
+end

data/app/models/address.rb

@@ -0,0 +1,24 @@
+class Address < ActiveRecord::Base
+
+  self.table_name   = 'core_addresses'
+  belongs_to        :addressable, :polymorphic => true
+  
+  attr_accessor     :name
+  
+  biggs :postal_address,
+          :recipient => :name,
+          :country => :country_code,
+          :street => Proc.new {|address| "#{address.line1} #{address.line2}" }
+
+  #------------------------------------------------------------------------------
+  def to_s(name_to_use = '')
+    self.name = name_to_use
+    postal_address.strip
+  end
+
+  #------------------------------------------------------------------------------
+  def to_html(name_to_use = '')
+    # self.to_s(name_to_use).gsub("\n", "<br/>".html_safe)
+    self.to_s(name_to_use).split(/\n/).xss_aware_join('<br>'.html_safe)
+  end
+end

data/app/models/category.rb

@@ -0,0 +1,18 @@
+#------------------------------------------------------------------------------
+class Category < ActiveRecord::Base
+
+  self.table_name       = 'core_categories'
+
+  include RankedModel
+  ranks                 :row_order, :with_same => :account_id
+
+  default_scope         { where(account_id: Account.current.id) }
+  scope                 :ordered, -> { order('row_order ASC') }
+
+  # --- globalize
+  translates            :name, :description, :fallbacks_for_empty_translations => true
+  globalize_accessors   :locales => DmCore::Language.language_array
+
+  validates             :name, presence_default_locale: true
+
+end

data/app/models/comment.rb

@@ -0,0 +1,24 @@
+# Generated from acts_as_commentable
+#------------------------------------------------------------------------------
+class Comment < ActiveRecord::Base
+  include           ActsAsCommentable::Comment
+
+  self.table_name   = 'core_comments'
+
+  belongs_to        :commentable, :polymorphic => true, :counter_cache => true
+  has_ancestry      :cache_depth => true
+
+  #--- don't add ordering to default scope, as it messes with calculating recent_comment
+  default_scope     { where(account_id: Account.current.id) }
+
+  #--- NOTE: install the acts_as_votable plugin to vote on the quality of comments
+  #acts_as_voteable
+
+  #--- don't use a counter cache until you can seperate users per account
+  belongs_to        :user #, :counter_cache => true
+  belongs_to        :account
+  
+  validates_presence_of   :body
+  self.per_page = 10
+
+end

data/app/models/custom_field.rb

@@ -0,0 +1,99 @@
+# TODO The one problem I have with this is that when a field is empty, we still
+#      save the record to the database.  The difficulty is that when the 
+#      form is displayed, you need to have all the records there, ones that
+#      were saved and empty ones for those not saved, all in the proper order.
+#      This presents a challenge I'm not willing to tackle at this moment.
+#      But it should be done so that the database isn't cluttered with needless
+#      records.
+#
+# Note: We serialize the data.  This makes it easy to store checkbox arrays, dates,
+# etc, without having to worry about munging the data first.
+#------------------------------------------------------------------------------
+class CustomField < ActiveRecord::Base
+  self.table_name               = 'core_custom_fields'
+  serialize                     :field_data
+  
+  # acts_as_reportable
+
+  belongs_to                    :custom_field_def
+  belongs_to                    :owner, polymorphic: true
+
+  default_scope                 { where(account_id: Account.current.id) }
+  
+  # before_save                   :prepare_data
+
+  delegate :field_type,         to: :custom_field_def
+  delegate :name,               to: :custom_field_def
+  delegate :label,              to: :custom_field_def
+  delegate :description,        to: :custom_field_def
+  delegate :required?,          to: :custom_field_def
+  delegate :choice_list_array,  to: :custom_field_def
+
+  # delegate :controldef,       to: :custom_field_def
+  # delegate :leadin_text,      to: :custom_field_def
+  # delegate :visible?,         to: :custom_field_def
+  # delegate :divider?,         to: :custom_field_def
+  # delegate :position,         to: :custom_field_def
+  # delegate :show_in_list?,    to: :custom_field_def
+
+  validates_presence_of         :field_data, if: Proc.new {|field| field.required?}
+  validates_numericality_of     :field_data, if: Proc.new {|field| field.field_type == 'number_field' && !field.field_data.blank?}
+  validate                      :checkbox_required, if: Proc.new {|field| field.field_type == 'check_box_collection' && field.required?}
+
+  #------------------------------------------------------------------------------
+  def initialize(*options, &block)
+    super(*options, &block)
+    # prepare_data
+  end
+  
+  # Returns a munged value depending on the field type.  Used when data is exported.
+  #------------------------------------------------------------------------------
+  def value
+    #--- if field is a country field, convert the country_id into real name
+    if custom_field_def.field_type == 'country'
+      Country.find(self.field_data.to_i).english_name
+    elsif self.field_data.is_a? Array
+      # make into a comma delimited string.  remove any blank/nil entries
+      self.field_data.reject {|x| x.blank?}.join(', ')
+    else
+      self.field_data
+    end
+  end
+  
+  #------------------------------------------------------------------------------
+  def checkbox_required
+    errors.add(:field_data, :blank) if self.value.blank?
+  end
+  
+  # # Munge the data so that it's stored correctly
+  # #------------------------------------------------------------------------------
+  # def prepare_data
+  #   #--- an array of values is stores as a comma delimited string
+  #   self.field_data = self.field_data.join(', ') if self.field_data.class == Array
+  # 
+  #   # #--- if field is a date/time field, convert the date into database format
+  #   # unless custom_field_def_id.nil?
+  #   #   field_def = CustomFieldDef.find(custom_field_def_id)
+  #   #   if field_def and !self.data.blank?
+  #   #     if field_def.fieldtype == 'date_time' or field_def.fieldtype == 'date'
+  #   #       self.data = Time.parse(self.data).to_s(:db)
+  #   #     elsif field_def.fieldtype == 'number_field'
+  #   #       p = NumberParser.new
+  #   #       self.data = p.extract(self.data.to_s)[0]
+  #   #     end
+  #   #   end
+  #   # end
+  # end
+  # 
+  # # Treat data as comma delimited, return it as an array of values
+  # #------------------------------------------------------------------------------
+  # def field_data_array
+  #   self.field_data.nil? ? [] : self.field_data.split(',').collect { |item| item.strip }
+  # end  
+  # 
+  # #------------------------------------------------------------------------------
+  # def human_attribute_name(key)
+  #   label.blank? ? 'Field' : "'#{nls(label, namespace: 'site_custom_field')}'"
+  # end
+  
+end

data/app/models/custom_field_def.rb

@@ -0,0 +1,61 @@
+# Reference: "Handle Multiple Models in One Form" from "Advanced Rails Recipes"
+# and http://railscasts.com/episodes/403-dynamic-forms
+# and http://railscasts.com/episodes/196-nested-model-form-revised
+# Note: tried to use coder: JSON for the store, but kept getting a 
+# "A JSON text must at least contain two octets!" exception (from new fields)
+# so store in yaml format instead
+#------------------------------------------------------------------------------
+class CustomFieldDef < ActiveRecord::Base
+  self.table_name         = 'core_custom_field_defs'
+                          
+  belongs_to              :owner, polymorphic: true
+  has_many                :custom_fields, dependent: :destroy
+  store                   :properties, accessors: [:choice_list, :valid_until]
+                          
+  include RankedModel
+  ranks                   :row_order, with_same: [:owner_id, :owner_type]
+  default_scope           { where(account_id: Account.current.id) }
+
+  translates              :label, :description, fallbacks_for_empty_translations: true
+  globalize_accessors     locales: DmCore::Language.language_array
+
+  validates_presence_of   :field_type
+  validates_length_of     :field_type, maximum: 20
+
+  FIELD_TYPES = [ ['Text Field',      'text_field'], 
+                  ['Text Area',       'text_area'],
+                  ['Number Field',    'number_field'],
+                  ['Checkboxes',      'check_box_collection'], 
+                  ['Radio Buttons',   'radio_buttons'], 
+                  ['Drop Down Menu',  'select'], 
+                  ['Divider',         'divider']
+                  # ['Date/Time Selection', 'date_time'],
+                  # ['Date Selection', 'date'],
+                  # ['Country Selection', 'country'],
+                ].freeze
+
+  #------------------------------------------------------------------------------
+  def divider?
+    fieldtype == 'divider'
+  end
+
+  #------------------------------------------------------------------------------
+  def choice_list_array
+    choice_list.split(',').collect { |item| item.strip }
+  end
+  
+  # Text to use for the column during export or in reports.  The label will
+  # be used if the 'name' attribute is blank
+  #------------------------------------------------------------------------------
+  def column_name
+    self.name.blank? ? self.label.to_s_default : self.name
+  end
+
+  #   # custom field is visible if it's not disabled and it's still valid
+  #   #------------------------------------------------------------------------------
+  #   def visible?
+  #     !(disabled? || (!valid_until.nil? && valid_until < Time.now.to_date))
+  #   end
+  #   
+
+end

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

@@ -0,0 +1,17 @@
+# Wrap core level specific CanCan rules.  Should be included in the main app's
+# Ability class.
+#------------------------------------------------------------------------------
+module DmCore
+  module Concerns
+    module Ability
+      def dm_core_abilities(user)
+        if user
+          if user.is_admin? || user.has_role?(:manager)
+            can :manage, :all
+            can :access_admin, :all
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/dm_core/concerns/defines_custom_fields.rb

@@ -0,0 +1,17 @@
+#------------------------------------------------------------------------------
+module DmCore
+  module Concerns
+    module DefinesCustomFields
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :custom_field_defs, as: :owner, dependent: :destroy
+  
+        accepts_nested_attributes_for :custom_field_defs, allow_destroy: true
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end

data/app/models/dm_core/concerns/friendly_id.rb

@@ -0,0 +1,57 @@
+# FriendlyID support methods
+# In general, 
+# - extends FriendlyID
+# - requires slug to be present
+# - normalizes slug using Babosa gem.  Ensures normalized even if user inputed
+# - indicates to generate a new slug if it's blank
+#
+# To use:
+#   extend FriendlyId
+#   include DmCore::Concerns::FriendlyId
+#
+#   def model_slug
+#     send("title_#{Account.current.preferred_default_locale}")
+#   end
+
+#------------------------------------------------------------------------------
+module DmCore
+  module Concerns
+    module FriendlyId
+      extend ActiveSupport::Concern
+
+      included do
+
+        friendly_id               :model_slug, use: :scoped, scope: :account_id
+        validates_presence_of     :slug
+        before_save               :normalize_slug
+
+        # Override this to provide what the slug value should be based on
+        #------------------------------------------------------------------------------
+        def model_slug
+          slug
+        end
+
+        # regenerate slug if it's blank
+        #------------------------------------------------------------------------------
+        def should_generate_new_friendly_id?
+          self.slug.blank?
+        end
+
+        # If user set slug sepcifically, we need to make sure it's been normalized
+        #------------------------------------------------------------------------------
+        def normalize_slug
+          self.slug = normalize_friendly_id(self.slug)
+        end
+  
+        # use babosa gem (to_slug) to allow better handling of multi-language slugs
+        #------------------------------------------------------------------------------
+        def normalize_friendly_id(text)
+          text.to_s.to_slug.normalize.to_s
+        end
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end

data/app/models/dm_core/concerns/has_custom_fields.rb

@@ -0,0 +1,28 @@
+#------------------------------------------------------------------------------
+module DmCore
+  module Concerns
+    module HasCustomFields
+      extend ActiveSupport::Concern
+
+      included do
+
+        has_many  :custom_fields, as: :owner, dependent: :destroy
+        accepts_nested_attributes_for :custom_fields
+
+        # Given an object that defines all the custom fields, builds any missing fields
+        # onto the custom_fields association.
+        #------------------------------------------------------------------------------
+        def build_missing_fields(defining_object)
+          existing_def_ids   = custom_fields.map(&:custom_field_def_id) # can't use pluck
+          missing_field_defs = defining_object.custom_field_defs.reject {|x| existing_def_ids.include? x.id}
+          missing_field_defs.each do |field_def|
+            custom_fields.build(custom_field_def_id: field_def.id)
+          end
+        end
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end

data/app/models/dm_core/concerns/public_private.rb

@@ -0,0 +1,151 @@
+# Implementation for public/protected/private and membership objects.
+# "public"        means it is available for everyone to see, login not required
+# "protected"     means it is available to anyone that is logged in
+# "private"       means it is hidden unless you are an explicit member of the object
+# "subscription"  means a paid subscription is required
+#------------------------------------------------------------------------------
+module DmCore
+  module Concerns
+    module PublicPrivate
+      extend ActiveSupport::Concern
+
+      # 'included do' causes the included code to be evaluated in the
+      # conext where it is included (post.rb), rather than be 
+      # executed in the module's context (blorgh/concerns/models/post).
+      included do
+        
+        scope :all_public,      -> { where(is_public: true) } # includes public and protected
+        scope :by_public,       -> { where(is_public: true, requires_login: false) }
+        scope :by_protected,    -> { where(is_public: true, requires_login: true) }
+        scope :all_private,     -> { where(is_public: false) } # includes private and subscription
+        scope :by_private,      -> { where(is_public: false, requires_subscription: false) }
+        scope :by_subscription, -> { where(requires_subscription: true) }
+        
+        # check if public (does not require login)
+        #------------------------------------------------------------------------------
+        def is_public?
+          is_public == true && requires_login == false
+        end
+  
+        # check if protected (public and requires login)
+        #------------------------------------------------------------------------------
+        def is_protected?
+          is_public == true && requires_login == true
+        end
+  
+        # check if private (not public and does not require login, or requires a subscription)
+        # we consider a requires subscription as private in this context
+        #------------------------------------------------------------------------------
+        def is_private?
+          is_public == false || (is_public == false && requires_subscription == true)
+        end
+        
+        #------------------------------------------------------------------------------
+        def is_subscription_only?
+          requires_subscription == true
+        end
+  
+        #------------------------------------------------------------------------------
+        def visibility_to_s
+          is_public? ? 'public' : is_subscription_only? ? 'subscription' : is_private? ? 'private' : 'protected'
+        end
+
+        # add user as a member. duplicates are not added automatically
+        #------------------------------------------------------------------------------
+        def add_member(user)
+          user.add_role(:member, self)
+        end
+        
+        #------------------------------------------------------------------------------
+        def remove_member(user)
+          user.remove_role(:member, self)
+        end
+        
+        # Is the user a member of this object?
+        #------------------------------------------------------------------------------
+        def member?(user)
+          user.has_role?(:member, self) || self.owner.try('member?', user)
+        end
+
+        #------------------------------------------------------------------------------
+        def member_count(which_ones = :all)
+          case which_ones
+          when :manual
+            ::User.with_role(:member, self).count
+          when :automatic
+            if is_subscription_only?
+              ::User.paid_subscribers.count
+            else
+              self.owner ? self.owner.member_count : 0
+            end
+          when :all
+            member_count(:manual) + member_count(:automatic)
+          end
+        end
+        
+        # Return a list of users that have access
+        #------------------------------------------------------------------------------
+        def member_list(which_ones = :all)
+          case which_ones
+          when :manual
+            ::User.with_role(:member, self).includes(:user_profile).sort_by {|u| u.full_name.downcase}
+          when :automatic
+            if is_subscription_only?
+              ::User.paid_subscribers
+            else
+              self.owner ? self.owner.member_list : []
+            end
+          when :all
+            member_list(:manual) + member_list(:automatic)
+          end
+        end
+
+        # Can this object be read by a user
+        #------------------------------------------------------------------------------
+        def can_be_read_by?(attempting_user)
+          if attempting_user
+            self.published? && (self.is_public? || self.is_protected? || self.member?(attempting_user) || attempting_user.is_admin? ||
+                  (self.is_subscription_only? && attempting_user.is_paid_subscriber?) )
+          else
+            self.published? && self.is_public?
+          end
+        end
+        
+        # Can this object be replied to by user
+        #------------------------------------------------------------------------------
+        def can_be_replied_by?(attempting_user)
+          if attempting_user
+            self.published? && (self.is_public? || self.is_protected? || self.member?(attempting_user) || attempting_user.is_admin? ||
+                  (self.is_subscription_only? && attempting_user.is_paid_subscriber?) )
+          else
+            false  # must be logged in to make a reply
+          end
+        end
+      end
+
+      module ClassMethods
+
+        # Get list of available objects for user
+        #------------------------------------------------------------------------------
+        def available_to_user(user)
+          if user.nil?
+            #--- not logged in, only public
+            objects = self.by_public.published
+          elsif user.is_admin?
+            objects = self.all
+          else
+            #--- all public/protected, as well as private that they are a member and subscriptions
+            objects  = self.all_public.published
+            objects += self.by_private.published.with_role(:member, user)
+            self.by_private.published.where('owner_id IS NOT NULL').each do |item|
+              objects << item if item.owner.member?(user)
+            end
+            objects += self.by_subscription.published if user.is_paid_subscriber?
+            return objects
+          end
+        end
+      end
+    end
+  end
+end
+