dm_event 4.2.1.5

data/app/models/registration.rb

@@ -0,0 +1,297 @@
+# Important: one reason to link off of the user_profile instead of the user
+# is so that we can support registrations without requiring an account.
+# We can create a "userless" profile, that has all the necessary information.
+# This is instead of duplicating all those fields in the registration table.
+#------------------------------------------------------------------------------
+class Registration < ActiveRecord::Base
+  include DmEvent::Concerns::RegistrationStateMachine
+  include DmEvent::Concerns::RegistrationStateEmail
+  include DmCore::Concerns::HasCustomFields
+  include ActiveMerchant::Billing::Integrations
+
+  self.table_name               = 'ems_registrations'
+
+  belongs_to                    :workshop, counter_cache: true
+  belongs_to                    :workshop_price
+  belongs_to                    :user_profile
+  belongs_to                    :account
+  has_many                      :payment_histories, as: :owner, dependent: :destroy
+  belongs_to                    :payment_comment, class_name: 'Comment'
+  preference                    :payment_reminder_hold_until,  :date
+  serialize                     :payment_reminder_history, Array
+  attr_accessor                 :payment_comment_text
+  acts_as_commentable           :private
+
+  accepts_nested_attributes_for :user_profile
+
+  monetize                      :amount_paid_cents, with_model_currency: :amount_paid_currency, allow_nil: true
+
+  default_scope                 { where(account_id: Account.current.id) }
+  scope                         :attending, -> { where("(aasm_state = 'accepted' OR aasm_state = 'paid') AND archived_on IS NULL") }
+  scope                         :accepted,  -> { where("aasm_state = 'accepted' AND archived_on IS NULL") }
+  scope                         :paid,      -> { where("aasm_state = 'paid' AND archived_on IS NULL") }
+  scope                         :unpaid,    -> { where("aasm_state = 'accepted' AND archived_on IS NULL") } # same as accepted
+  scope                         :discounted,-> { where("discount_value > 0") } # use like registrations.attending.discounted
+
+  after_initialize              :create_uuid
+  before_create                 :set_currency
+  after_create                  :set_receipt_code
+
+  validates_uniqueness_of       :uuid
+  validates_presence_of         :workshop_price_id, if: Proc.new { |reg| reg.workshop.workshop_prices.size > 0}
+  validates_presence_of         :workshop_price_id, if: Proc.new { |reg| reg.workshop.workshop_prices.size > 0}
+  validates_numericality_of     :discount_value, allow_nil: true
+  validates_length_of           :payment_comment, maximum: 255
+  
+  delegate                      :first_name, :last_name, :full_name, :email, :address, :address2, 
+                                :city, :state, :country, :zipcode, :phone, to: :user_profile
+
+private
+
+  # the uuid is used to provide a private url to a customer so that they can access
+  # their registration if not logged in.  This is particularly important when
+  # a customer registers without having a user account.
+  #------------------------------------------------------------------------------
+  def create_uuid
+    self.uuid = SecureRandom.uuid if self.new_record?
+  end
+
+  # The amount_paid currency should match the workshop base currency
+  #------------------------------------------------------------------------------
+  def set_currency
+    self[:amount_paid_currency] = workshop.base_currency
+  end
+  
+  # Receipt code: (workshop.id)-(registration.id).  eg.  003-101
+  #------------------------------------------------------------------------------
+  def set_receipt_code
+    receipt_code = ("%03d" % workshop.id) + '-' + ("%03d" % self[:id])
+    update_attribute(:receipt_code, receipt_code)
+  end
+  
+public
+
+  # receipt code is simply the record id + 1100
+  #------------------------------------------------------------------------------
+  def self.receiptcode_to_id(receiptcode)
+    return receipt_code.split('-')[1].to_i
+  end
+
+  # Price of this registration (without discount)
+  #------------------------------------------------------------------------------
+  def price
+    (workshop_price && workshop_price.price) ? workshop_price.price : Money.new(0, workshop.base_currency)
+  end
+  
+  # Price with discount
+  #------------------------------------------------------------------------------
+  def discounted_price
+    price - discount
+  end
+  
+  #------------------------------------------------------------------------------
+  def discount
+    return Money.new(0, workshop.base_currency) if workshop_price.nil? || workshop_price.price.nil?
+
+    unless discount_value.blank?
+      cents = (discount_use_percent ? (workshop_price.price.cents * discount_value / 100) : (discount_value * 100))
+    else
+      cents = 0
+    end
+    Money.new(cents, workshop_price.price.currency)
+  end
+
+  # Return the amount still owed, based on the current payments made.
+  # balance_owed is positive if payment is still required.  Negative if there
+  # has been an overpayment
+  #------------------------------------------------------------------------------
+  def balance_owed
+    discounted_price - amount_paid
+  end
+  
+  # suggested amount of next payment.
+  # if a payment is within 20 of the balance_owed, then they should pay the balance
+  #------------------------------------------------------------------------------
+  def payment_owed
+    if workshop_price
+      amount_20 = Money.new(2000, workshop_price.price.currency)
+      (workshop_price.payment_price + amount_20) > balance_owed ? balance_owed : workshop_price.payment_price 
+    else
+      balance_owed
+    end
+  end
+  
+  # Return the number of items specified, in particular the number of items in 
+  # a particular state
+  #------------------------------------------------------------------------------
+  def self.number_of(state, options = {})
+    query = (options[:only_confirmed] ? where.not(confirmed_on: nil) : all)
+    case state
+    when :attending
+      attending.count
+    when :unpaid
+      #--- the number of unpaid is the same as the number of accepted
+      number_of(:accepted)
+    when :checkedin
+      query.where.not(checkin_at: 0).where(archived_on: nil).count
+    when :archived
+      query.where.not(archived_on: nil).count
+    when :registrations
+      #--- don't count any canceled
+      query.where(archived_on: nil).where.not(aasm_state: 'canceled').where.not(aasm_state: 'refunded').count
+    when :at_price
+      #--- number of registrations for a particular price
+      query.where(archived_on: nil).where("(aasm_state = 'paid' OR aasm_state = 'accepted')").where(workshop_price_id: options[:price_id]).count
+    when :for_all_prices
+      #--- array of counts per price
+      query.where(archived_on: nil).where("(aasm_state = 'paid' OR aasm_state = 'accepted')").group(:workshop_price_id).count
+    when :discounted
+      attending.discounted.count
+    when :discounted_total
+      total = attending.discounted.to_a.sum(&:discount)
+      (total == 0) ? Money.new(0) : total
+    when :user_updated
+      #--- how many users updated their record
+      query.where(archived_on: nil).where("(aasm_state = 'paid' OR aasm_state = 'accepted')").where.not(user_updated_at: nil).count
+    when :confirmed
+      #--- how many users confirmed their attendance
+      where.not(confirmed_on: nil).where(archived_on: nil).where("(aasm_state = 'paid' OR aasm_state = 'accepted')").count
+    else
+      #--- must be wanting to count the process states
+      query.where(archived_on: nil, aasm_state: state).count
+    end
+  end
+
+  # check if the regsitration is unpaid
+  #------------------------------------------------------------------------------
+  def unpaid?
+    self.accepted? && self.archived_on == nil
+  end
+  
+  # Is it time to send a payment reminder?
+  # Due first 7 days after inital registration.  Then every 14 days after that
+  #------------------------------------------------------------------------------
+  def payment_reminder_due?
+    if preferred_payment_reminder_hold_until.nil? || preferred_payment_reminder_hold_until < Time.now
+      time_period = self.payment_reminder_sent_on.nil? ? (self.created_at + 7.days) : (self.payment_reminder_sent_on + 14.days)
+      self.balance_owed > Money.new(0, workshop.base_currency) && time_period < Time.now
+    end
+
+    # if recurring_period since last paymnet
+    # if 7 days after registration and no payment
+    # if 14 days since last reminder and no payment
+    # if resume_reminders is past
+    # last_payment = payment_histories.order('created_on').last
+    # if workshop_price.recurring?
+    #   if 
+  end
+  
+  # Setup the columns for exporting data as csv.
+  #------------------------------------------------------------------------------
+  def self.csv_columns(workshop)
+    column_definitions = []
+    column_definitions <<     ["Receipt Code",      "'R-' + item.receipt_code", 75] # 'R-' makes sure Numbers treats as a String, not a Date
+    column_definitions <<     ['Process State',     'item.aasm_state', 100]
+    column_definitions <<     ["Full Name",         "item.full_name", 100]
+    column_definitions <<     ["Last Name",         "item.last_name.capitalize", 100]
+    column_definitions <<     ["First Name",        "item.first_name.capitalize", 100]
+    column_definitions <<     ["Email",             "item.email.downcase", 150]
+    column_definitions <<     ["Address",           "item.address", 150]
+    column_definitions <<     ["Address2",          "item.address2"]
+    column_definitions <<     ["City",              "item.city.capitalize", 100]
+    column_definitions <<     ["State",             "item.state.capitalize"]
+    column_definitions <<     ["Zipcode",           "item.zipcode"]
+    column_definitions <<     ["Country",           "item.country.code"]
+
+    column_definitions <<     ['Registered on',     'item.created_at.to_date', 75, {type: 'DateTime', numberformat: 'd mmm, yyyy'}]
+
+    column_definitions <<     ["Price",             "item.workshop_price.price.to_f", nil, {type: 'Number', numberformat: '#,##0.00'}]
+    column_definitions <<     ["Price Description", "item.workshop_price.price_description"]
+    column_definitions <<     ["Price Sub Descr",   "item.workshop_price.sub_description"]
+    column_definitions <<     ["Discount",          "item.discount.to_f", nil, {type: 'Number', numberformat: '#,##0.00'}]
+    column_definitions <<     ["Paid",              "item.amount_paid.to_f", nil, {type: 'Number', numberformat: '#,##0.00'}]
+    column_definitions <<     ["Balance",           "item.balance_owed.to_f", nil, {type: 'Number', numberformat: '#,##0.00'}]
+
+    # ---- add the extra fields defined in the workshop record
+    workshop.custom_field_defs.each_with_index do | x, index |
+      case x.field_type
+      when 'check_box_collection'
+        column_definitions << [ "#{x.column_name}", "(z = item.custom_fields.detect { |y| y.custom_field_def_id == #{x.id} }) ? z.value : ''", nil, {type: 'list', custom_field: true}]
+      when 'divider'
+      else
+        column_definitions << [ "#{x.column_name}", "(z = item.custom_fields.detect { |y| y.custom_field_def_id == #{x.id} }) ? z.value : ''", nil, {custom_field: true}]
+      end
+    end
+    return column_definitions
+  end
+
+  # Payment was entered manually, create the history record.  You can tell it's 
+  # a manual entry if the user_profile is filled in - means a human did it.
+  #------------------------------------------------------------------------------
+  def manual_payment(payment_history, cost, total_currency, user_profile,
+                     options = { item_ref: '', payment_method: 'cash', bill_to_name: '', payment_date: Time.now,
+                                 notify_data: nil, transaction_id: nil, status: '' } )
+    amount            = Monetize.parse(cost, total_currency)
+    
+    if payment_history
+      new_amount_paid = self.amount_paid - self.workshop_price.to_base_currency(payment_history.total) + self.workshop_price.to_base_currency(amount)
+      payment_history.update_attributes(
+        item_ref: options[:item_ref],
+        cost: cost,
+        total_cents: amount.cents,
+        total_currency: amount.currency.iso_code,
+        payment_method: options[:payment_method],
+        bill_to_name: options[:bill_to_name],
+        payment_date: options[:payment_date],
+        user_profile_id: user_profile.id)
+    else
+      new_amount_paid = self.amount_paid + self.workshop_price.to_base_currency(amount)
+      payment_history   = self.payment_histories.create(
+          anchor_id: receipt_code,
+          item_ref: options[:item_ref],
+          cost: cost,
+          quantity: 1,
+          discount: 0,
+          total_cents: amount.cents,
+          total_currency: amount.currency.iso_code,
+          payment_method: options[:payment_method],
+          bill_to_name: options[:bill_to_name],
+          payment_date: options[:payment_date],
+          user_profile_id: (user_profile ? user_profile.id : nil),
+          notify_data: options[:notify_data],
+          transaction_id: options[:transaction_id],
+          status: (user_profile ? "Completed" : options[:status])
+      )
+    end
+        
+    if payment_history.errors.empty?
+      self.update_attribute(:amount_paid_cents, new_amount_paid.cents)
+      self.reload
+      self.send('paid!') if balance_owed.cents <= 0 && self.accepted?
+    else
+      logger.error("===> Error: Registration.manual_payment: #{payment_history.errors.inspect}")
+    end
+    return payment_history
+  end
+
+  # delete a payment and update the registrations total amount paid
+  #------------------------------------------------------------------------------
+  def delete_payment(payment_id)
+    payment = PaymentHistory.find(payment_id)
+    if payment
+      self.update_attribute(:amount_paid_cents, (self.amount_paid - self.workshop_price.to_base_currency(payment.total)).cents)
+      payment.destroy
+      suppress_transition_email
+      self.send('accept!') if balance_owed.positive? && self.paid?
+      return true
+    end
+    return false
+  end
+
+  # Return the payment page url, so that it can be used in emails
+  #------------------------------------------------------------------------------
+  def payment_url
+    DmEvent::Engine.routes.url_helpers.register_choose_payment_url(self.uuid, host: Account.current.url_host, locale: I18n.locale)
+  end
+  
+end

data/app/models/workshop.rb

@@ -0,0 +1,247 @@
+class Workshop < ActiveRecord::Base
+  include DmCore::Concerns::DefinesCustomFields
+
+  self.table_name         = 'ems_workshops'
+
+  belongs_to              :country, class_name: 'DmCore::Country'
+  has_many                :registrations, dependent: :destroy
+  has_many                :workshop_prices, dependent: :destroy
+  has_many                :system_emails,     {as: :emailable, dependent: :destroy}
+  has_one                 :pending_email,     -> { where("email_type LIKE 'pending'") },    class_name: 'SystemEmail', as: :emailable
+  has_one                 :accepted_email,    -> { where("email_type LIKE 'accepted'") },   class_name: 'SystemEmail', as: :emailable
+  has_one                 :rejected_email,    -> { where("email_type LIKE 'rejected'") },   class_name: 'SystemEmail', as: :emailable
+  has_one                 :paid_email,        -> { where("email_type LIKE 'paid'") },       class_name: 'SystemEmail', as: :emailable
+  has_one                 :waitlisted_email,  -> { where("email_type LIKE 'waitlisted'") }, class_name: 'SystemEmail', as: :emailable
+  has_one                 :reviewing_email,   -> { where("email_type LIKE 'reviewing'") },  class_name: 'SystemEmail', as: :emailable
+  has_one                 :canceled_email,    -> { where("email_type LIKE 'canceled'") },   class_name: 'SystemEmail', as: :emailable
+  has_one                 :refunded_email,    -> { where("email_type LIKE 'refunded'") },   class_name: 'SystemEmail', as: :emailable
+  has_one                 :noshow_email,      -> { where("email_type LIKE 'noshow'") },     class_name: 'SystemEmail', as: :emailable
+  has_one                 :cms_blog, as: :owner
+  has_one                 :forum, as: :owner  
+  
+  # --- globalize
+  translates              :title, :description, :summary, :sidebar, fallbacks_for_empty_translations: true
+  globalize_accessors     locales: DmCore::Language.language_array
+
+  # --- FriendlyId
+  extend FriendlyId
+  include DmCore::Concerns::FriendlyId
+
+  resourcify
+
+  preference              :show_social_buttons,  :boolean, default: false
+  preference              :header_accent_color,  :string
+
+  # --- validations
+  validates_presence_of   :country_id
+  validates_presence_of   :base_currency
+  validates_presence_of   :starting_on
+  validates_presence_of   :ending_on
+  validates_presence_of   :contact_email
+  validates_presence_of   :event_style
+  validates               :title, presence_default_locale: true
+  validates               :description, liquid: { locales: true }, presence_default_locale: true
+  validates               :sidebar, liquid: { locales: true }
+  
+  # validates_presence_of   :deadline_on
+
+  default_scope           { where(account_id: Account.current.id) }
+  
+  #--- upcoming and past are used in the admin, so should be published and non-published
+  scope                   :upcoming,  -> { where('ending_on > ? AND archived_on IS NULL', (Date.today - 1).to_s).order('starting_on DESC').includes(:translations) }
+  scope                   :past,      -> { where('ending_on <= ? AND archived_on IS NULL', (Date.today - 1).to_s).order('starting_on DESC').includes(:translations) }
+
+  #--- available is list of published and registration open and not ended
+  scope                   :available, -> { where(published: true).where('ending_on > ? AND deadline_on > ? AND archived_on IS NULL', 
+                                      (Date.today - 1).to_s, (Date.today - 1).to_s).order('starting_on ASC') }
+
+  scope                   :published, -> { where(published: true).where('archived_on IS NULL') }
+  
+  #--- don't use allow_nil, as this will erase the base_currency field if no funding_goal is set
+  monetize                :funding_goal_cents, with_model_currency: :base_currency
+
+  EVENT_STYLES = [['Workshop', 'workshop'], ['Crowdfunding', 'crowdfunding']]
+
+  #------------------------------------------------------------------------------
+  def model_slug
+    send("title_#{Account.current.preferred_default_locale}")
+  end
+
+  # If the total_available is nil, then there are unlimited tickets to be sold.  
+  # Otherwise, check if we have sold out
+  #------------------------------------------------------------------------------
+  def price_sold_out?(workshop_price)
+    # p.sold_out?(@workshop.event_registration.number_of(:registrations_by_paymenttype, payment_id: p.id)
+    false # TODO
+  end
+  
+  # Is this workshop in the past?  
+  #------------------------------------------------------------------------------
+  def past?
+    ending_on < Time.now
+  end
+  
+  #------------------------------------------------------------------------------
+  def show_social_buttons?
+    preferred_show_social_buttons?
+  end
+  
+  # Is the registration closed?  If deadline is null, then registration is open ended
+  #------------------------------------------------------------------------------
+  def registration_closed?
+    !published? || (deadline_on ? (deadline_on < Time.now.to_date) : false)
+  end
+  
+  #------------------------------------------------------------------------------
+  def published?
+    published
+  end
+
+  # toggle the archive state of the workshop
+  #------------------------------------------------------------------------------
+  def toggle_archive
+    archived_on ? update_attribute(:archived_on, nil) : update_attribute(:archived_on, Time.now)
+  end
+  
+  #------------------------------------------------------------------------------
+  def archived?
+    self.archived_on ? true : false
+  end
+
+  #------------------------------------------------------------------------------
+  def crowdfunding?
+    self.event_style == 'crowdfunding'
+  end
+
+  # Return financial summary and details
+  # level => :summary or :detail
+  #------------------------------------------------------------------------------
+  def financial_details(level = :detail)
+    #--- pick currency of first price
+    financials = {summary: { total_possible: Money.new(0, base_currency),          total_possible_worst: Money.new(0, base_currency),
+                                total_paid: Money.new(0, base_currency),              total_outstanding: Money.new(0, base_currency), 
+                                total_outstanding_worst: Money.new(0, base_currency), total_discounts: Money.new(0, base_currency),
+                                total_paid_percent: 0},
+                  collected: {},
+                  collected_monthly: {},
+                  payment_type: {},
+                  projected: {}
+                 }
+
+    registrations.attending.includes(:workshop_price).each do |registration|
+      if registration.workshop_price
+        #--- Calculate the summary values
+        financials[:summary][:total_possible]     += registration.discounted_price
+        financials[:summary][:total_paid]         += registration.amount_paid.nil? ? Money.new(0, base_currency) : registration.amount_paid
+        financials[:summary][:total_outstanding]  += registration.balance_owed
+        financials[:summary][:total_discoutns]    += registration.discount
+      end
+    end
+
+    if level == :detail
+      registrations.attending.includes(:workshop_price, :payment_histories).each do |registration|
+        if registration.workshop_price
+          #--- Calculate what has been collected, by payment method
+          registration.payment_histories.each do |payment_history|
+            payment_method = payment_history.payment_method.titlecase
+            financials[:collected]["#{payment_method}"] = Money.new(0, base_currency) if financials[:collected]["#{payment_method}"].nil?
+            financials[:collected]["#{payment_method}"] += payment_history.total
+      
+            month = payment_history.payment_date.beginning_of_month
+            financials[:collected_monthly][month] = Money.new(0, base_currency) if financials[:collected_monthly][month].nil?
+            financials[:collected_monthly][month] += payment_history.total
+          end
+        end
+      end
+    end
+
+    #--- give a worst case value - reduce by 20%
+    financials[:summary][:total_possible_worst]               = financials[:summary][:total_possible] * 0.80
+    financials[:summary][:total_outstanding_worst]            = financials[:summary][:total_outstanding] * 0.80
+    financials[:summary][:total_paid_percent]                 = (100 * financials[:summary][:total_paid] / financials[:summary][:total_possible]).round if financials[:summary][:total_possible].positive?
+    return financials
+  end
+
+  #------------------------------------------------------------------------------
+  def total_paid
+    total_paid = Money.new(0, base_currency)
+    registrations.attending.each do |registration|
+      if registration.workshop_price
+        total_paid += registration.amount_paid.nil? ? Money.new(0, base_currency) : registration.amount_paid
+      end
+    end
+    return total_paid
+  end
+  
+  # Send out payment reminder emails to unpaid attendees, or to a specific one.
+  # if a specific registration, then always send out the email
+  #------------------------------------------------------------------------------
+  def send_payment_reminder_emails(registration_id = 'all')
+    success     = failed = 0
+    unpaid_list = ( registration_id == 'all' ? registrations.unpaid : registrations.unpaid.where(id: registration_id) )
+    unpaid_list.each do |registration|
+      if registration.payment_reminder_due? || registration_id != 'all'
+        email = PaymentReminderMailer.payment_reminder(registration).deliver_now
+        if email
+          registration.update_attribute(:payment_reminder_sent_on, Time.now)
+          registration.update_attribute(:payment_reminder_history,  [Time.now] + registration.payment_reminder_history)
+          success += 1
+        else
+          failed += 1
+        end
+      end
+    end
+    return {success: success, failed: failed}
+  end
+
+
+  # is the passed in user attending?  Used in some deep level authorization checks,
+  # which rely on the "member?" method.
+  # This does not consider a userless registration as a "member", since there is 
+  # no way they can login
+  #------------------------------------------------------------------------------
+  def member?(user)
+    self.registrations.attending.where(user_profile_id: user.user_profile.id).count > 0
+  end
+
+  # Provide a list of users that are members (does not include userless registrations)
+  #------------------------------------------------------------------------------
+  def member_count
+    self.registrations.attending.joins(user_profile: [:user]).references(:user_profile).where('user_profiles.user_id IS NOT NULL').count
+  end
+
+  # Return list of Users that are attending (does not include userless registrations)
+  #------------------------------------------------------------------------------
+  def member_list
+    User.includes(:user_profile).references(:user_profile).where(user_profiles: { id: self.registrations.attending.map(&:user_profile_id) } )
+  end
+
+  #------------------------------------------------------------------------------
+  def header_image(default = nil)
+    self.image || default
+  end
+
+  #------------------------------------------------------------------------------
+  def header_accent_color(default = '')
+    self.preferred_header_accent_color || default
+  end
+  
+  # Find list of newly createdusers that have not registered for any events, between 
+  # the end of the workshop and up to 60 day before the start of the workshop.
+  # Not perfect, since people can register just to access special
+  # content.  But gives rough idea of people creating an account but not realizing
+  # they need to register for the event they want to participate in.
+  #------------------------------------------------------------------------------
+  def lost_users(days_ago = 10)
+    lost = []
+    new_users = User.where(created_at: (self.starting_on - days_ago.day)..self.ending_on, account_id: Account.current.id)
+    new_users.each do |user|
+      if user.user_site_profiles.where(account_id: Account.current.id)
+        if user.user_profile.registrations.count == 0
+          lost << user
+        end
+      end
+    end
+    lost
+  end
+end

data/app/models/workshop_price.rb

@@ -0,0 +1,118 @@
+# [todo] re-evaluate whether alternate currencies are really needed.  I can't
+# think of a real use case at the moment, and it adds unnecessary complexity.
+#
+# Note: The currency of a WorkshopPrice is the base currency of it's workshop.
+# If they were different, we would need to always have an exchange rate available
+# to convert to/from the workshop and the price currency.
+# With the alternate price/currencies, the exchange rate is directly based on
+# the prices in the two currencies.
+#------------------------------------------------------------------------------
+class WorkshopPrice < ActiveRecord::Base
+
+  self.table_name         = 'ems_workshop_prices'
+  
+  belongs_to              :workshop
+  has_many                :registrations
+  
+  default_scope           { where(account_id: Account.current.id).order('row_order ASC') }
+
+  # --- globalize
+  translates              :price_description, :sub_description, :payment_details, fallbacks_for_empty_translations: true
+  globalize_accessors     locales: DmCore::Language.language_array
+
+  monetize                :price_cents, with_model_currency: :price_currency, allow_nil: true
+  monetize                :alt1_price_cents, with_model_currency: :alt1_price_currency, allow_nil: true
+  monetize                :alt2_price_cents, with_model_currency: :alt2_price_currency, allow_nil: true
+
+  include RankedModel
+  ranks                   :row_order, with_same: :workshop_id
+
+  validates               :price_description, presence_default_locale: true
+  validates               :payment_details, liquid: { locales: true }
+  validates_presence_of   :price_currency,      if: Proc.new { |w| w.price_cents }
+  validates_presence_of   :alt1_price_currency, if: Proc.new { |w| w.alt1_price_cents }
+  validates_presence_of   :alt2_price_currency, if: Proc.new { |w| w.alt2_price_cents }
+  validates_presence_of   :recurring_period,    if: Proc.new { |w| w.recurring_number }
+  validates_presence_of   :recurring_number,    if: Proc.new { |w| w.recurring_period }
+
+  PAYMENT_METHODS = ['Cash', 'Check', 'Credit Card', 'Money Order', 'PayPal', 'Wire Transfer']
+
+  # For some reason, the initial monetized price gets created with the default
+  # Money currency.  Need to use the current currency, as the internal fractional
+  # value depends on it.  For example, 
+  #  "15000".to_money('JPY').cents == 15000
+  #  "15000".to_money('EUR').cents == 1500000
+  # Call this method on the attributes before passing into new() or update_attributes()
+  #------------------------------------------------------------------------------
+  def self.prepare_prices(attributes = {})
+    attributes['price']       = attributes['price'].to_money(attributes['price_currency']) if attributes['price'].present? && attributes['price_currency'].present?
+    attributes['alt1_price']  = attributes['alt1_price'].to_money(attributes['alt1_price_currency']) if attributes['alt1_price'].present? && attributes['alt1_price_currency'].present?
+    attributes['alt2_price']  = attributes['alt2_price'].to_money(attributes['alt2_price_currency']) if attributes['alt2_price'].present? && attributes['alt2_price_currency'].present?
+    return attributes
+  end
+  
+  #------------------------------------------------------------------------------
+  def visible?
+    !(disabled? || (!valid_starting_on.nil? && valid_starting_on > Time.now.to_date) || (!valid_until.nil? && valid_until < Time.now.to_date))
+  end
+ 
+  # If the total_available is nil, then there are unlimited tickets to be sold.  
+  # Otherwise, check if we have sold out
+  #------------------------------------------------------------------------------
+  def sold_out?(num_sold)
+    (total_available.blank? or total_available == 0) ? false : (num_sold >= total_available)
+  end
+  
+  #------------------------------------------------------------------------------
+  def price_formatted
+    price.nil? ? '' : price.format(no_cents_if_whole: true, symbol: true)
+  end
+  
+  # returns the amount of a payment
+  #------------------------------------------------------------------------------
+  def payment_price
+    recurring_payments? ? (price / recurring_number) : price
+  end
+  
+  #------------------------------------------------------------------------------
+  def recurring_payments?
+    recurring_number.to_i > 1
+  end
+  
+  #------------------------------------------------------------------------------
+  def currency_list
+    list = [[price_currency, price_currency]]
+    list << [alt1_price_currency, alt1_price_currency] unless alt1_price_currency.blank?
+    list << [alt2_price_currency, alt1_price_currency] unless alt1_price_currency.blank?
+    return list
+  end
+  
+  # Convert an amount in an alternate currency into the base currency
+  #------------------------------------------------------------------------------
+  def to_base_currency(money)
+    bank.exchange_with(money, price_currency)
+  end
+  
+  # return a bank object filled with the exchange rates, based on the prices.
+  # then you can do:  bank.exchange_with(price, 'USD')
+  #------------------------------------------------------------------------------
+  def bank
+    unless @bank
+      @bank = Money::Bank::VariableExchange.new
+      unless alt1_price_currency.blank?
+        @bank.add_rate(price_currency, alt1_price_currency, alt1_price_cents.to_f / price_cents.to_f)
+        @bank.add_rate(alt1_price_currency, price_currency, price_cents.to_f / alt1_price_cents.to_f)
+      end
+      unless alt2_price_currency.blank?
+        @bank.add_rate(price_currency, alt2_price_currency, alt2_price_cents.to_f / price_cents.to_f)
+        @bank.add_rate(alt2_price_currency, price_currency, price_cents.to_f / alt2_price_cents.to_f)
+      end
+      unless alt1_price_currency.blank? && alt2_price_currency.blank?
+        @bank.add_rate(alt1_price_currency, alt2_price_currency, alt2_price_cents.to_f / alt1_price_cents.to_f)
+        @bank.add_rate(alt2_price_currency, alt1_price_currency, alt1_price_cents.to_f / alt2_price_cents.to_f)
+      end
+    end
+    return @bank
+  end
+  
+end