dm_core 4.2.1.5

data/app/models/follow.rb

@@ -0,0 +1,13 @@
+class Follow < ActiveRecord::Base
+  extend ActsAsFollower::FollowerLib
+  extend ActsAsFollower::FollowScopes
+
+  # NOTE: Follows belong to the "followable" interface, and also to followers
+  belongs_to :followable, :polymorphic => true
+  belongs_to :follower,   :polymorphic => true
+
+  def block!
+    self.update_attribute(:blocked, true)
+  end
+
+end

data/app/models/liquid_validator.rb

@@ -0,0 +1,26 @@
+# Validate whether an attribute has a parsable liquid template.
+# if { locales: true } is passed in, will assume it's a localized
+# field and check all locales
+#   validates    :content, :liquid => { :locales => true }
+#------------------------------------------------------------------------------
+class LiquidValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if options[:locales]
+      Account.current.site_locales.each do |locale|
+        attribute_locale = "#{attribute.to_s}_#{locale}"
+        begin
+          Liquid::Template.parse(record.send(attribute_locale))
+        rescue Liquid::SyntaxError => e
+          record.errors.add attribute_locale, e.message
+        end
+      end
+    else
+      begin
+        Liquid::Template.parse(value)
+      rescue Liquid::SyntaxError => e
+        record.errors.add attribute, e.message
+      end
+    end
+  end
+end
+ 

data/app/models/payment_history.rb

@@ -0,0 +1,57 @@
+# anchor_id        =>  unique number tying paid item to our item
+# order_ref        =>  order number
+# item_ref         =>  specfic item number
+# item_name        =>  item's name
+# quantity         =>  number of items
+# cost             =>  cost of item, as a number string (to_f.to_s)
+# discount         =>  any coupon/dicsount
+# total_cents      =>  total amount in cents
+# total_currency   =>  currency 3 char code
+# payment_method   =>  how payment was made: cash, credit card, etc
+# payment_date     =>  date of payment
+# bill_to_name     =>  who actually paid / was billed to
+# item_details     =>  any specific item details sent by payment processor
+# order_details    =>  any specific order details sent by payment processor
+# status           =>  status of payment
+# user_profile_id  =>  user_profile if payment was enetered manually
+# notify_data      =>  data from the notification object, in case it's needed
+#------------------------------------------------------------------------------
+class PaymentHistory < ActiveRecord::Base
+
+  self.table_name         = 'core_payment_histories'
+
+  belongs_to                :owner, :polymorphic => true
+  belongs_to                :user_profile
+  serialize                 :order_details
+  serialize                 :item_details
+  serialize                 :notify_data
+  monetize                  :total_cents, :with_model_currency => :total_currency, :allow_nil => true
+
+  default_scope             { where(account_id: Account.current.id) }
+
+  validates_numericality_of :cost
+
+  # Generate the anchor code that gets placed in a shopping cart item.  This is
+  # used to gain access to some agreed upon item in the database.
+  # Default algorithm: Use the current time as a unique code and append
+  # the passed in id
+  # Ex: ANC-1158569928-517
+  # -> override this function to provide a different algorithm if needed
+  #------------------------------------------------------------------------------
+  def self.generate_anchor_id(id)
+    "ANC-#{Time.now.utc.to_i}-#{id}"
+  end
+
+  # Extract the anchor code that gets placed in a shopping cart item.  This is
+  # used to gain access to some agreed upon item in the database.
+  # Default algorithm: Use the current time as a unique code and append
+  # the passed in id
+  # -> override this function to provide a different algorithm if needed
+  #------------------------------------------------------------------------------
+  def self.extract_anchor_id(anchor_id)
+    #--- pull off first two pieces, and put rest back together if there were any 
+    #    embedded dashes
+    values = anchor_id.split('-')
+    return values.slice(2, 10).join('-')
+  end
+end

data/app/models/presence_default_locale_validator.rb

@@ -0,0 +1,12 @@
+# Validate whether the default locale of a translated attribute is present
+#   validates    :content, presence_default_locale: true
+#------------------------------------------------------------------------------
+class PresenceDefaultLocaleValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    attribute_locale = "#{attribute.to_s}_#{Account.current.preferred_default_locale}"
+    if record.send(attribute_locale).blank?
+      record.errors.add attribute_locale, I18n.t("errors.messages.blank")
+    end
+  end
+end
+ 

data/app/models/role.rb

@@ -0,0 +1,12 @@
+# Dynamic shortcuts should NOT be enabled for this application, as it conflicts with
+# default account scoping
+#------------------------------------------------------------------------------
+class Role < ActiveRecord::Base
+
+  has_and_belongs_to_many :users, :join_table => :users_roles
+  belongs_to              :resource, :polymorphic => true
+  
+  scopify
+
+  default_scope           { where(account_id: Account.current.id) }
+end

data/app/models/system_email.rb

@@ -0,0 +1,15 @@
+# Generated from acts_as_commentable
+#------------------------------------------------------------------------------
+class SystemEmail < ActiveRecord::Base
+
+  self.table_name       = 'core_system_emails'
+
+  belongs_to            :emailable, :polymorphic => true
+
+  default_scope         { where(account_id: Account.current.id) }
+
+  # --- globalize
+  translates            :subject, :body, :fallbacks_for_empty_translations => true
+  globalize_accessors   :locales => DmCore::Language.language_array
+
+end

data/app/models/ultracart/notification.rb

@@ -0,0 +1,107 @@
+#------------------------------------------------------------------------------
+class Ultracart::Notification
+  attr_accessor :order_details, :items, :anchor_ids
+
+  CURRENT_STAGE_MAPPING = { 'PO' => :pre_order, 'AR' => :account_receivable, 
+                            'SD' => :shipping, 'REJ' => :rejected, 
+                            'CO' => :completed_order}
+  
+  #------------------------------------------------------------------------------
+  def initialize(notify_params)
+
+    #--- extract the order details and the items
+    @order_details  = (notify_params['export']['order'])
+    @items          = @order_details['item']
+    @items = Array.[](@items) if @items.class == HashWithIndifferentAccess or @items.class == Hash
+    
+    #--- remove the items hash from the order, so we can save the order details seperate
+    @order_details.delete('item')
+    
+    #--- build up the anchor_ids array
+    @anchor_ids = Array.new
+    @items.each do |item|
+      @anchor_ids << extract_anchor_id(item)        
+    end
+  end
+  
+  # Stage that the order is in
+  #------------------------------------------------------------------------------
+  def current_stage
+    return CURRENT_STAGE_MAPPING[@order_details['current_stage']]
+  end
+
+
+protected
+  
+  #------------------------------------------------------------------------------
+  def extract_anchor_id(item)
+    anchor = nil
+    option_items = item['option']
+    option_items = Array.[](option_items) if option_items.class == Hash or option_items.class == HashWithIndifferentAccess
+    unless option_items.nil? 
+      option_items.each do |the_option| 
+        #if the_option['option_name'] == 'anchor_id'
+          anchor = the_option['option_value'] unless the_option['option_value'].blank?
+        #end
+      end
+    end
+    return anchor
+  end
+end
+
+# # This function is called by UltraCart when an item is purchased from the online
+# # store.  The entire order is sent.  Initially, we will look for the 
+# # registration code we place in a ticket order, and mark the appropriate record
+# # as payed in the database.  But this also sets up the possibility of keeping
+# # our own purchase records and doing our own reporting.
+# #------------------------------------------------------------------------------
+# def self.verify_payment(current_account, params)
+#   #--- the specifics for order have already been parsed into the params block
+#   notify  = Ultracart::Notification.new(params)
+#   @@uclogger.info(Time.now.utc.to_s + ": Order ID => #{notify.order_details['order_id']}  " +
+#                   "Stage => #{notify.order_details['current_stage']} " +
+#                   "Name => #{notify.order_details['bill_to_first_name']} #{notify.order_details['bill_to_last_name']}"
+#                   )
+# 
+#   receipts      = Array.new
+# 
+#   #--- validate the merchant id
+#   if notify.order_details['merchant_id'] != current_account.preferred(:ultracart_merchant_id)
+#     @@uclogger.info("  ==> Error: merchant_id incorrect: #{notify.order_details['merchant_id']} != #{current_account.preferred(:ultracart_merchant_id)}")
+#     @@uclogger.info(params.inspect)
+#   else
+#     case notify.current_stage
+#     when :pre_order, :account_receivable, :shipping, :rejected
+#       @@uclogger.info("  Ignored")
+#       #--- these are just notifications - do nothing
+#     when :completed_order
+#       #--- iterate over each item in order
+#       notify.items.each_with_index do |item, i|
+#         #--- only record notifications that have a registration code
+#         unless notify.anchor_ids[i].blank?
+#           history = PaymentHistory.create(:notify => notify, :item => item, :anchor_id => notify.anchor_ids[i])
+#           history.update_attribute(:total_cents, EventPayment.payment_total_cents(history.cost, history.quantity, history.discount))
+#           history.update_attribute(:owner_type, 'EventRegistration')
+#           history.update_attribute(:owner_id, EventRegistration.receiptcode_to_id(history.anchor_id))
+#           @@uclogger.info("  item_id => #{history.item_id}  anchor_id => #{history.anchor_id}")
+# 
+#           if history.anchor_id
+#             #--- check if there is a valid user
+#             event = EventRegistration.find_by_receiptcode(history.anchor_id)
+#             if event.nil?
+#               @@uclogger.info("  ==> Error: invalid registration id => #{history.anchor_id}")
+#               @@uclogger.info(params.inspect)
+#             else
+#               history.update_attribute(:currency_country_id, event.event_payment.country_id) 
+#               event.mark_paid(history.total_cents)
+#               event.add_comment(Comment.new(:comment => "[coupon_code: #{history.coupon_code}] ")) unless history.coupon_code.blank?
+#               receipts << {:receiptcode => history.anchor_id, :cost_cents => history.total_cents, :description => history.item_name}
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# 
+#   return receipts
+# end

data/app/models/ultracart/payment_history.rb

@@ -0,0 +1,55 @@
+# Integration with the Ultracart shopping cart (ultracart.com)
+#------------------------------------------------------------------------------
+class Ultracart::PaymentHistory < PaymentHistory
+
+  # Params: :notify, :item, :anchor_id
+  #------------------------------------------------------------------------------
+  def initialize(params, options)
+    init_params = Hash.new
+    notify      = params[:notify]
+    item        = params[:item]
+    anchor_id   = params[:anchor_id]
+
+    #--- extract the relevant data
+    init_params[:order_ref]       = notify.order_details['order_id']
+    init_params[:payment_method]  = notify.order_details['payment_method']
+    init_params[:payment_date]    = Time.parse(notify.order_details['payment_date_time']).utc unless notify.order_details['payment_date_time'].nil?
+    init_params[:bill_to_name]    = notify.order_details['bill_to_first_name'] + ' ' + notify.order_details['bill_to_last_name']
+    init_params[:current_stage]   = notify.current_stage.to_s
+    init_params[:order_details]   = notify.order_details
+    init_params[:item_details]    = item
+    if item
+      init_params[:item_ref]      = item['item_id']
+      init_params[:cost]          = item['cost']
+      init_params[:discount]      = item['discount']
+      init_params[:quantity]      = item['quantity'].to_i
+      init_params[:item_name]     = item['description']
+      init_params[:anchor_id]     = PaymentHistory.extract_anchor_id(anchor_id) unless anchor_id.blank?
+    end
+    super(init_params, options)
+  end
+
+  #------------------------------------------------------------------------------
+  def get_option_value(name)
+    value         = nil
+    option_items  = item_details['option']
+    option_items  = Array.[](option_items) if option_items.class == Hash or option_items.class == HashWithIndifferentAccess
+    unless option_items.nil? 
+      option_items.each do |the_option| 
+        if the_option['option_name'] == name
+          value = the_option['option_value'] unless the_option['option_value'].blank?
+        end
+      end
+    end
+    return value
+  end
+
+  #------------------------------------------------------------------------------
+  def coupon_code
+    if order_details.nil? or order_details['coupon'].nil?
+      ''
+    else
+      order_details['coupon']['coupon_code']
+    end
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,22 @@
+# users, user_profiles, and user_site_profiles...
+#
+# User:
+# There is one User per person/email address.  Email address is the primary key.
+# A User is created for a specific account. However, that user can login to any
+# of the hosted sites on this system, with the same user/pass.  In this way
+# we can have a set of related sites, with single sign-on
+#
+# UserProfile:
+# Only one per User, this contains all the profile information - name, address,
+# public/private avatars.  This information is used across all sites.
+#
+# UserSiteProfile:
+# A User has one of these for each site they have logged into.  Keeps track of 
+# any site specific information, like the last_access_at field, etc.  Also 
+# allows us to know if someone has ever logged into a specific site.
+#------------------------------------------------------------------------------
+class User < ActiveRecord::Base
+
+  include DmCore::Concerns::User
+  
+end

data/app/models/user_profile.rb

@@ -0,0 +1,9 @@
+# This holds the profile data for a user.  There is only one instance per user,
+# so even when we're using users across sites, there is only one profile record
+# per user record.
+#------------------------------------------------------------------------------
+class UserProfile < ActiveRecord::Base
+
+  include DmCore::Concerns::UserProfile
+
+end

data/app/models/user_site_profile.rb

@@ -0,0 +1,11 @@
+# This holds a site profile for a user.  This is any data that is needed for
+# a user, on a per site/account basis, such as site specific preferences, login times,
+# etc.
+#   Note: don't use a default account scope as it makes some of the User 
+#   associations a little more difficult
+#------------------------------------------------------------------------------
+class UserSiteProfile < ActiveRecord::Base
+
+  include DmCore::Concerns::UserSiteProfile
+
+end

data/app/presenters/base_presenter.rb

@@ -0,0 +1,30 @@
+# Based on the Railscast: http://railscasts.com/episodes/287-presenters-from-scratch
+#------------------------------------------------------------------------------
+class BasePresenter
+  include DmCore::LiquidHelper
+  
+  #------------------------------------------------------------------------------
+  def initialize(object, template)
+    @object   = object
+    @template = template
+  end
+
+private
+
+  #------------------------------------------------------------------------------
+  def self.presents(name)
+    define_method(name) do
+      @object
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  def h
+    @template
+  end
+
+  #------------------------------------------------------------------------------
+  def method_missing(*args, &block)
+    @template.send(*args, &block)
+  end
+end

data/app/presenters/comment_presenter.rb

@@ -0,0 +1,20 @@
+class CommentPresenter < BasePresenter
+
+  presents :comment
+
+  #------------------------------------------------------------------------------
+  def formatted_comment
+      markdown(comment.body, :safe => true)
+  end
+  
+  #------------------------------------------------------------------------------
+  def date_posted
+    format_datetime comment.created_at
+  end
+  
+  #------------------------------------------------------------------------------
+  def author
+    comment.user.nil? ? 'Anonymous' : comment.user.display_name
+  end
+  
+end

data/app/presenters/user_presenter.rb

@@ -0,0 +1,48 @@
+class UserPresenter < BasePresenter
+
+  presents :user
+  #delegate :username, to: :user
+
+  #------------------------------------------------------------------------------
+  def role_label
+    if user.is_admin?
+      colored_label('Admin', :success)
+    elsif user.has_role?(:manager)
+      colored_label('Manager', :info)
+    elsif user.has_role?(:content_manager) || user.has_role?(:event_manager) || user.has_role?(:forum_manager)
+      colored_label('Submanager', :warning)
+    elsif user.has_role?(:reviewer)
+      colored_label('Reviewer', :default)
+    elsif user.has_role?(:beta)
+      colored_label('Beta', :danger)
+    else
+      'User'
+    end
+  end
+  
+  #------------------------------------------------------------------------------
+  def last_access
+    user.last_access_at.nil? ? colored_label('n/a', :warning) : "#{time_ago_in_words(user.last_access_at)} ago"
+  end
+
+  # gives the public avatar for a user
+  #------------------------------------------------------------------------------
+  def avatar_for(size = 32)
+    case
+    when size.class == String && size.end_with?('%')
+      avatar = user.user_profile.public_avatar_url(:sq200)
+    when size <= 35
+      avatar = user.user_profile.public_avatar_url(:sq35)
+    when size <= 100
+      avatar = user.user_profile.public_avatar_url(:sq100)
+    when size <= 200
+      avatar = user.user_profile.public_avatar_url(:sq200)
+    else
+      avatar = user.user_profile.public_avatar_url
+    end
+    # image_tag('dm_core/user.gif', width: size, height: size, class: 'image')
+    image_tag(avatar, width: size, class: 'image')
+  end
+
+  
+end