osm 1.2.25 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ef940d8e32de06f687dcb5632b3a2b98389927b
-  data.tar.gz: 637568e6e8cb0c2cfdee813869a8b949b308f42a
+  metadata.gz: 651a0cdcdd3d694935cd01e1500494bf8cd4c7cf
+  data.tar.gz: 3e28fa840b8b180292c469f068f6667c01f9bbc9
 SHA512:
-  metadata.gz: a9ccff69771e68971f65b5c9251c19bf6269d9fd14724e1421d417eba447a28ec3b8c5a609bb9a3793c9e0b6c4300b0579a9456a5fb468d32231584344dbdbe5
-  data.tar.gz: b4a25bc8837f41b43d54586318f79eb6cd32792954db3a70fcc81a0c998929cc8b0103705400ba92494896f97c961b9d0b92f6fc43341d7742545ff1c4e9092b
+  metadata.gz: 6a31dd0a2da75b15f7c53fb2346e238d0044c3ecca6f04ad14c49bd06818f856987d185474f88a016b76f5df76e889e10464012ace57829bad3d6e049cf8c617
+  data.tar.gz: 0bf8a3ac116819ddda8b030c5caad9b6e77896be6b0e9d075ff92905bc82fda39c536d9ca215d58e221a1e40e9e5bbbba830feaff57abda82488c8e84d4f934b

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## Version 1.3.0
+
+  * Add fetching of file names for events (unable to download)
+  * Add fetching of payment schedules - Osm::OnlinePayment::Schedule
+  * Add fetching of member's payments for a schedule
+  * Add updating a member's payment status
+
 ## Version 1.2.25
 
   * Add fetching My.SCOUT parent login history - Osm::Myscout::ParentLoginHistory.get_for_section

data/README.md

@@ -113,8 +113,13 @@ however it should be noted that when the OSM API adds a feature it can be diffic
   * Groupings (e.g. Sixes, Patrols)
   * Invoices (Gold required)
   * Members
+  * My.SCOUT Templates
   * Notepad
   * Notepads
+  * Online Payments:
+    * Schedules
+    * Payment Statuses
+    * Payment Status History
   * Programme
   * Register Data
   * Register Structure
@@ -140,6 +145,8 @@ however it should be noted that when the OSM API adds a feature it can be diffic
   * Grouping
   * Invoices (Gold required)
   * Member
+  * My.SCOUT Templates
+  * Online payments - payment status
   * Register Attendance
 
 ### Create

data/lib/osm.rb

@@ -174,7 +174,7 @@ module Osm
     replace_with = options[:replace_with] || {}
 
     values = instance.attributes.sort.map{ |(k,v)|
-      (replace_with.keys.include?(k) && !v.nil?) ? "#{k}.#{replace_with[k]}: #{v.try(replace_with[k])}" : "#{k}: #{v.inspect}"
+      (replace_with.keys.include?(k) && !v.nil?) ? "#{k}.#{replace_with[k]}: #{v.try(replace_with[k]).inspect}" : "#{k}: #{v.inspect}"
     }
 
     return "#<#{instance.class.name} #{values.join(', ')} >"

data/lib/osm/event.rb

@@ -28,6 +28,8 @@ module Osm
     #   @return [Boolean] if the event has been archived
     # @!attribute [rw] badges
     #   @return [Array<Osm::Event::BadgeLink>] the badge links for the event
+    # @!attribute [rw] files
+    #   @return [Array<String>] the files attached to this event
     # @!attribute [rw] columns
     #   @return [Array<Osm::Event::Column>] the custom columns for the event
     # @!attribute [rw] notepad
@@ -59,6 +61,7 @@ module Osm
     attribute :notes, :type => String, :default => ''
     attribute :archived, :type => Boolean, :default => false
     attribute :badges, :default => []
+    attribute :files, :default => []
     attribute :columns, :default => []
     attribute :notepad, :type => String, :default => ''
     attribute :public_notepad, :type => String, :default => ''
@@ -72,8 +75,8 @@ module Osm
 
     if ActiveModel::VERSION::MAJOR < 4
       attr_accessible :id, :section_id, :name, :start, :finish, :cost, :location, :notes, :archived,
-                      :fields, :badges, :columns, :notepad, :public_notepad, :confirm_by_date, :allow_changes,
-                      :reminders, :attendance_limit, :attendance_limit_includes_leaders,
+                      :fields, :badges, :files, :columns, :notepad, :public_notepad, :confirm_by_date,
+                      :allow_changes, :reminders, :attendance_limit, :attendance_limit_includes_leaders,
                       :attendance_reminder, :allow_booking
     end
 
@@ -83,6 +86,7 @@ module Osm
     validates_presence_of :name
     validates :badges, :array_of => {:item_type => Osm::Event::BadgeLink, :item_valid => true}
     validates :columns, :array_of => {:item_type => Osm::Event::Column, :item_valid => true}
+    validates :files, :array_of => {:item_type => String}
     validates_inclusion_of :allow_changes, :in => [true, false]
     validates_inclusion_of :reminders, :in => [true, false]
     validates_inclusion_of :attendance_limit_includes_leaders, :in => [true, false]
@@ -120,7 +124,12 @@ module Osm
         unless data['items'].nil?
           data['items'].map { |i| i['eventid'].to_i }.each do |event_id|
             event_data = api.perform_query("events.php?action=getEvent&sectionid=#{section_id}&eventid=#{event_id}")
+            files_data = api.perform_query("ext/uploads/events/?action=listAttachments&sectionid=#{section_id}&eventid=#{event_id}")
+            files = files_data.is_a?(Hash) ? files_data['files'] : files_data
+            files = [] unless files.is_a?(Array)
+
             event = self.new_event_from_data(event_data)
+            event.files = files
             events.push event
             ids.push event.id
             cache_write(api, ['event', event.id], event)

data/lib/osm/online_payment.rb

@@ -0,0 +1,521 @@
+module Osm
+
+  class OnlinePayment
+
+    class Schedule < Osm::Model
+      class Payment < Osm::Model; end # Ensure the constant exists for the validators
+      class PaymentStatus < Osm::Model; end # Ensure the constant exists for validators
+
+      SORT_BY = [:section_id, :name, :id]
+      PAY_NOW_OPTIONS = {
+        -1 => 'Allowed at all times',
+        0  => 'Permanently disabled',
+        7  => 'Allowed within 1 week of due day',
+        14 => 'Allowed within 2 weeks of due day',
+        21 => 'Allowed within 3 weeks of due day',
+        28 => 'Allowed within 4 weeks of due day',
+        42 => 'Allowed within 6 weeks of due day',
+        56 => 'Allowed within 8 weeks of due day',
+      }
+
+      # @!attribute [rw] id
+      #   @return [FixNum] the schedule's ID
+      # @!attribute [rw] section_id
+      #   @return [FixNum] the ID of the section the schedule belongs to
+      # @!attribute [rw] account_id
+      #   @return [FixNum] the ID of the bank account this schedule is tied to
+      # @!attribute [rw] name
+      #   @return [String] the name of the schedule
+      # @!attribute [rw] description
+      #   @return [String] the description of what the schedule is for
+      # @!attribute [rw] archived
+      #   @return [Boolean] whether the schedule has been archived
+      # @!attribute [rw] gift_aid
+      #   @return [Boolean] whether payments made using this schedule are eligable for gift aid
+      # @!attribute [rw] require_all
+      #   @return [Boolean] whether to require all payments within the schedule by default
+      # @!attribute [rw] pay_now
+      #   @return [FixNum] controls the use of the pay now feature in OSM, see the PAY_NOW_OPTIONS hash
+      # @!attribute [rw] annual_limit
+      #   @return [String] the maximum amount you'll be able to collect in a rolling 12 month period using this schedule
+      # @!attribute [rw] payments
+      #   @return [Array<Payment>] the payments which make up this schedule
+
+
+      attribute :id, type: Integer
+      attribute :section_id, type: Integer
+      attribute :account_id, type: Integer
+      attribute :name, type: String
+      attribute :description, type: String, default: ''
+      attribute :archived, type: Boolean
+      attribute :gift_aid, type: Boolean
+      attribute :require_all, type: Boolean
+      attribute :pay_now, type: Integer
+      attribute :annual_limit, type: String
+      attribute :payments, type: Object, default: []
+
+      if ActiveModel::VERSION::MAJOR < 4
+        attr_accessible :id, :section_id, :account_id, :name, :description, :archived, :gift_aid,
+                        :require_all, :pay_now, :annual_limit, :payments
+      end
+
+      validates_numericality_of :id, only_integer: true, greater_than: 0
+      validates_numericality_of :section_id, only_integer: true, greater_than: 0
+      validates_numericality_of :account_id, only_integer: true, greater_than: 0
+      validates_presence_of :annual_limit
+      validates_presence_of :name
+      validates_inclusion_of :pay_now, in: PAY_NOW_OPTIONS.keys
+      validates_inclusion_of :archived, in: [true, false]
+      validates_inclusion_of :gift_aid, in: [true, false]
+      validates_inclusion_of :require_all, in: [true, false]
+      validates :payments, array_of: {item_type: Osm::OnlinePayment::Schedule::Payment, item_valid: true}
+
+
+      # @!method initialize
+      #   Initialize a new Schedule
+      #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+      # Get a simple list of schedules for a section
+      # @param [Osm::Api] api The api to use to make the request
+      # @param [Osm::Section, Fixnum, #to_i] section The section (or its ID) to get the due badges for
+      # @!macro options_get
+      # @return [Array<Hash>]
+      def self.get_list_for_section(api, section, options={})
+        require_ability_to(api, :read, :finance, section, options)
+        section_id = section.to_i
+        cache_key = ['online_payments', 'schedule_list', section_id]
+
+        if !options[:no_cache] && Osm::Model.cache_exist?(api, cache_key)
+          return cache_read(api, cache_key)
+        end
+
+        data = api.perform_query("ext/finances/onlinepayments/?action=getSchemes&sectionid=#{section_id}")
+        data = data.is_a?(Hash) ? data['items'] : nil
+        data ||= []
+        data.map!{ |i| {id: Osm::to_i_or_nil(i['schemeid']), name: i['name'].to_s } }
+
+        cache_write(api, cache_key, data)
+        return data
+      end
+
+
+      # Get all payment schedules for a section
+      # @param [Osm::Api] api The api to use to make the request
+      # @param [Osm::Section, Fixnum, #to_i] section The section (or its ID) to get the due badges for
+      # @!macro options_get
+      # @return [Array<Osm::OnlinePayment::Schedule>]
+      def self.get_for_section(api, section, options={})
+        require_ability_to(api, :read, :finance, section, options)
+
+        get_list_for_section(api, section, options).map do |schedule|
+          get(api, section, schedule[:id], options)
+        end
+      end
+
+
+      # Get a payment schedules for a section
+      # @param [Osm::Api] api The api to use to make the request
+      # @param [Osm::Section, Fixnum, #to_i] section The section (or its ID) to get the due badges for
+      # @param [Fixnum, #to_i] schedule The ID of the payment schedule to get
+      # @!macro options_get
+      # @return [Array<Osm::OnlinePayment::Schedule>]
+      def self.get(api, section, schedule, options={})
+        require_ability_to(api, :read, :finance, section, options)
+        section_id = section.to_i
+        schedule_id = schedule.to_i
+        cache_key = ['online_payments', 'schedule', schedule_id]
+
+        if !options[:no_cache] && cache_exist?(api, cache_key)
+          data = cache_read(api, cache_key)
+          return data if data.section_id.eql?(section_id)
+        end
+
+        data = api.perform_query("ext/finances/onlinepayments/?action=getPaymentSchedule&sectionid=#{section_id}&schemeid=#{schedule_id}&allpayments=true")
+        schedule = new(
+          id:            Osm::to_i_or_nil(data['schemeid']),
+          section_id:    section_id,
+          account_id:    Osm::to_i_or_nil(data['accountid']),
+          name:          data['name'],
+          description:   data['description'],
+          archived:      data['archived'].eql?('1'),
+          gift_aid:      data['giftaid'].eql?('1'),
+          require_all:   data['defaulton'].eql?('1'),
+          pay_now:       data['paynow'],
+          annual_limit:  data['preauth_amount'],
+        )
+
+        (data['payments'] || []).each do |payment_data|
+          payment = Payment.new(
+            amount:   payment_data['amount'],
+            archived: payment_data['archived'].eql?('1'),
+            due_date: Osm::parse_date(payment_data['date']),
+            name:     payment_data['name'].to_s,
+            id:       Osm::to_i_or_nil(payment_data['paymentid']),
+            schedule: schedule,
+          )
+          schedule.payments.push payment
+        end 
+
+        cache_write(api, cache_key, schedule)
+        return schedule
+      end
+
+
+      # Get payments made by members for the schedule
+      # @param [Osm::Api] api The api to use to make the request
+      # @param [Osm::Term, Fixnum, #to_i] term The term (or it's id) to get details for (defaults to current term)
+      # @!macro options_get
+      # @return [Array<Osm::OnlinePayment::Schedule::PaymentsForMember>]
+      def get_payments_for_members(api, term=nil, options={})
+        require_ability_to(api, :read, :finance, section_id, options)
+
+        if term.nil?
+          section = Osm::Section.get(api, section_id, options)
+          term = section.waiting? ? -1 : Osm::Term.get_current_term_for_section(api, section)
+        end
+
+        cache_key = ['online_payments', 'for_members', id, term.to_i]
+        if !options[:no_cache] && cache_exist?(api, cache_key)
+          return cache_read(api, cache_key)
+        end
+
+        data = api.perform_query("ext/finances/onlinepayments/?action=getPaymentStatus&sectionid=#{section_id}&schemeid=#{id}&termid=#{term.to_i}")
+        data = data['items'] || []
+        data.map! do |item|
+          payments_data = {}
+          payments.each do |payment|
+            unless item[payment.id.to_s].nil?
+              payments_data[payment.id] = PaymentStatus.build_from_json(item[payment.id.to_s], payment)
+            end
+          end
+
+          PaymentsForMember.new(
+            member_id:      Osm::to_i_or_nil(item['scoutid']),
+            section_id:     section_id,
+            grouping_id:    Osm::to_i_or_nil(item['patrolid']),
+            first_name:     item['firstname'],
+            last_name:      item['lastname'],
+            start_date:     require_all ? Osm::parse_date(item['startdate']) : nil,
+            direct_debit:   item['directdebit'].downcase.to_sym,
+            payments:       payments_data,
+            schedule:       self,
+          )
+        end
+
+        cache_write(api, cache_key, data)
+        return data
+      end
+
+
+
+      # Get unarchived payments for the schedule
+      # @return [Array<Osm::OnlinePayment::Schedule::Payment>]
+      def current_payments
+        payments.select{ |p| !p.archived? }
+      end
+      # Check if there are any unarchived payments for the schedule
+      # @return [Boolean]
+      def current_payments?
+        payments.any?{ |p| !p.archived? }
+      end
+
+      # Get archived payments for the schedule
+      # @return [Array<Osm::OnlinePayment::Schedule::Payment>]
+      def archived_payments
+        payments.select{ |p| p.archived? }
+      end
+      # Check if there are any archived payments for the schedule
+      # @return [Boolean]
+      def archived_payments?
+        payments.any?{ |p| p.archived? }
+      end
+
+      def to_s
+        "#{id} -> #{name}"
+      end
+
+
+      class Payment < Osm::Model
+        # @!attribute [rw] id
+        #   @return [FixNum] the payment's ID
+        # @!attribute [rw] amount
+        #   @return [Sreing] the amount of the payment
+        # @!attribute [rw] name
+        #   @return [String] the name given to the payment
+        # @!attribute [rw] archived
+        #   @return [Boolean] whether the payment has been archived
+        # @!attribute [rw] date
+        #   @return [Date] the payment's due date
+        # @!attribute [rw] schedule
+        #   @return [Osm::OnlnePayment::Schedule] the schedule the payment belongs to
+
+        attribute :id, type: Integer
+        attribute :amount, type: String
+        attribute :name, type: String
+        attribute :archived, type: Boolean
+        attribute :due_date, type: Object
+        attribute :schedule, type: Object
+
+        if ActiveModel::VERSION::MAJOR < 4
+          attr_accessible :id, :amount, :name, :archived, :due_date, :schedule
+        end
+
+        validates_numericality_of :id, only_integer: true, greater_than: 0
+        validates_presence_of :amount
+        validates_presence_of :name
+        validates_presence_of :due_date
+        validates_presence_of :schedule
+        validates_inclusion_of :archived, in: [true, false]
+
+
+        # @!method initialize
+        #   Initialize a new Payment
+        #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+        # Check if the payment is past due (or will be past due on the passed date)
+        # @param [Date] date The date to check for (defaults to today)
+        # @return [Boolean]
+        def past_due?(date=Date.today)
+          date > due_date
+        end
+
+        def inspect
+          Osm.inspect_instance(self, {:replace_with => {'schedule' => :to_s}})
+        end
+
+      end # Schedule::Payment class
+
+
+      class PaymentsForMember < Osm::Model
+        attribute :first_name, type: String
+        attribute :last_name, type: String
+        attribute :member_id, type: Integer
+        attribute :direct_debit, type: Object
+        attribute :start_date, type: Object
+        attribute :payments, type: Object, default: {}      # payment_id -> Array of statuses
+        attribute :schedule, type: Object
+
+        if ActiveModel::VERSION::MAJOR < 4
+          attr_accessible :first_name, :last_name, :member_id, :direct_debit, :start_date, :payments, :schedule
+        end
+
+        validates_numericality_of :member_id, only_integer: true, greater_than: 0
+        validates_presence_of :first_name
+        validates_presence_of :last_name
+        validates_presence_of :schedule
+        validates_inclusion_of :direct_debit, in: [:active, :inactive, :cancelled]
+        validates :payments, hash: {key_type: Fixnum, value_type: Array}
+
+
+        # @!method initialize
+        #   Initialize a new Schedule
+        #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+        # Get the most recent status for a member's payment
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to check
+        # @return [Boolean]
+        def latest_status_for(payment)
+          @latest_status ||= Hash[ payments.map{ |k,v| [k, v.sort[0]] } ]
+          @latest_status[payment.to_i]
+        end
+
+        # Check if the status of a member's payment is considered paid
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to check
+        # @return [Boolean, nil]
+        def paid?(payment)
+          status = latest_status_for(payment.to_i)
+          return nil if status.nil?
+          [:paid, :paid_manually, :received, :initiated].include?(status.status)
+        end
+
+        # Check if the status of a member's payment is considered unpaid
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to check
+        # @return [Boolean, nil]
+        def unpaid?(payment)
+          status = latest_status_for(payment.to_i)
+          return nil if status.nil?
+          [:required].include?(status.status)
+        end
+
+        # Check if a payment is over due (or will be over due on the passed date)
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to check
+        # @param [Date] date The date to check for (defaults to today)
+        # @return [Boolean] whether the member's payment is unpaid and the payment's due date has passed
+        def over_due?(payment, date=nil)
+          unpaid?(payment) && payment.past_due?(date)
+        end
+
+        # Check if the member has an active direct debit for this schedule
+        # @return [Boolean]
+        def active_direct_debit?
+          direct_debit.eql?(:active)
+        end
+
+        # Update the status of a payment for the member in OSM
+        # @param [Osm::Api] api The api to use to make the request
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to update
+        # @param [Symbol] status What to update the status to (:required, :not_required or :paid_manually)
+        # @param [Boolean] gift_aid Whether to update the gift aid record too (only relevant when setting to :paid_manually)
+        # @return [Boolean] whether the update was made in OSM
+        def update_payment_status(api, payment, status, gift_aid=false)
+          payment_id = payment.to_i
+          fail ArgumentError, "#{payment_id} is not a valid payment for the schedule." unless schedule.payments.map(&:id).include?(payment_id)
+          fail ArgumentError, "status must be either :required, :not_required or :paid_manually. You passed in #{status.inspect}" unless [:required, :not_required, :paid_manually].include?(status)
+
+          gift_aid = false unless payment.schedule.gift_aid?
+          api_status = {
+            required:       'Payment required',
+            not_required:   'Payment not required',
+            paid_manually:  'Paid manually',
+          }[status]
+
+          data = api.perform_query("ext/finances/onlinepayments/?action=updatePaymentStatus", {
+            'sectionid' => schedule.section_id,
+            'schemeid' => schedule.id,
+            'scoutid' => member_id,
+            'paymentid' => payment_id,
+            'giftaid' => gift_aid,
+            'value' => api_status,
+          })
+
+          data = data[payment_id.to_s]
+          return false if data.nil?                     # No data (at all) for this payment
+          data = PaymentStatus.build_from_json(data)
+          return false if data.nil?                     # No history for payment so it didn't get updated
+          data = data.sort[0]
+          return false if data.nil?                     # No history for payment so it didn't get updated
+          return false unless data.status.eql?(status)  # Latest status is not what we set
+          return true
+        end
+
+        # Mark a payment as required by the member
+        # @param [Osm::Api] api The api to use to make the request
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to update
+        # @return [Boolean] whether the update was made in OSM
+        def mark_payment_required(api, payment)
+          update_payment_status(api, payment, :required)
+        end
+
+        # Mark a payment as not required by the member
+        # @param [Osm::Api] api The api to use to make the request
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to update
+        # @return [Boolean] whether the update was made in OSM
+        def mark_payment_not_required(api, payment)
+          update_payment_status(api, payment, :not_required)
+        end
+
+        # Mark a payment as paid by the member
+        # @param [Osm::Api] api The api to use to make the request
+        # @param [Osm::OnlinePayment::Schedule::Payment, Fixnum, #to_i] payment The payment (or it's ID) to update
+        # @param [Boolean] gift_aid Whether to update the gift aid record too
+        # @return [Boolean] whether the update was made in OSM
+        def mark_payment_paid_manually(api, payment, gift_aid=false)
+          update_payment_status(api, payment, :paid_manually, gift_aid)
+        end
+
+      end # Schedule::PaymentsForMember class
+
+
+      class PaymentStatus < Osm::Model
+        VALID_STATUSES = [:required, :not_required, :initiated, :paid, :received, :paid_manually]
+
+        attribute :id, type: Integer
+        attribute :payment, type: Object
+        attribute :timestamp, type: Object
+        attribute :status, type: Object
+        attribute :details, type: String
+        attribute :updated_by, type: String
+        attribute :updated_by_id, type: Integer
+
+        if ActiveModel::VERSION::MAJOR < 4
+          attr_accessible :id, :payment, :timestamp, :status, :details, :updated_by, :updated_by_id
+        end
+
+        validates_numericality_of :id, only_integer: true, greater_than: 0
+        validates_numericality_of :updated_by_id, only_integer: true, greater_than_or_equal_to: -2
+        validates_presence_of :payment
+        validates_presence_of :timestamp
+        validates_presence_of :updated_by
+        validates_inclusion_of :status, in: VALID_STATUSES
+
+
+        # @!method initialize
+        #   Initialize a new PaymentStatus
+        #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+        # @!method required?
+        #   Whether the status is :required
+        #   @return (Boolean)
+        # @!method not_required?
+        #   Whether the status is :not_required
+        #   @return (Boolean)
+        # @!method initiated?
+        #   Whether the status is :initiated
+        #   @return (Boolean)
+        # @!method paid?
+        #   Whether the status is :paid
+        #   @return (Boolean)
+        # @!method received?
+        #   Whether the status is :received
+        #   @return (Boolean)
+        # @!method paid_manually?
+        #   Whether the status is :paid_manually
+        #   @return (Boolean)
+        VALID_STATUSES.each do |attribute|
+          define_method "#{attribute}?" do
+            status.eql?(attribute)
+          end
+        end
+
+
+        def <=>(another)
+          result = -(self.timestamp <=> another.try(:timestamp))
+          result = self.payment <=> another.try(:payment) if result.eql?(0)
+          result = self.id <=> another.try(:id) if result.eql?(0)
+          return result
+        end
+
+        def inspect
+          Osm.inspect_instance(self, {:replace_with => {'payment' => :id}})
+        end
+
+        protected
+        def self.build_from_json(json, payment=nil)
+          data = ActiveSupport::JSON.decode(json)
+          return [] unless data.is_a?(Hash)
+          data = data['status']
+          return [] unless data.is_a?(Array)
+
+          status_map = {
+            'Payment required' => :required,
+            'Payment not required' => :not_required,
+            'Initiated' => :initiated,
+            'Paid' => :paid,
+            'Received' => :received,
+            'Paid manually' => :paid_manually,
+          }
+
+          data.map! do |item|
+            new(
+              id:             Osm::to_i_or_nil(item['statusid']),
+              payment:        payment,
+              timestamp:      Time.strptime(item['statustimestamp'], '%d/%m/%Y %H:%M'),
+              status:         status_map[item['status']],
+              details:        item['details'],
+              updated_by:     item['firstname'],
+              updated_by_id:  item['who'].to_i,
+            )
+          end
+        end
+
+      end # Schedule::PaymentStatus class
+
+    end # Schedule class
+
+  end
+   
+end

data/osm.gemspec

@@ -32,5 +32,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rb-inotify', '~> 0.9'
   s.add_development_dependency 'coveralls', '~> 0.7'
   s.add_development_dependency 'simplecov', '~> 0.7'
+  s.add_development_dependency 'listen', '< 3.1' # Actually required by another dependency but >= 3.1 causing issues
 
 end

data/spec/osm/event_spec.rb

@@ -16,6 +16,7 @@ describe "Event" do
       :notes => 'None',
       :archived => '0',
       :badges => [],
+      :files => [],
       :columns => [],
       :notepad => 'notepad',
       :public_notepad => 'public notepad',
@@ -39,6 +40,7 @@ describe "Event" do
     event.notes.should == 'None'
     event.archived.should == false
     event.badges.should == []
+    event.files.should == []
     event.columns.should == []
     event.notepad.should == 'notepad'
     event.public_notepad.should == 'public notepad'
@@ -208,6 +210,7 @@ describe "Event" do
 
       FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvents&sectionid=1&showArchived=true", :body => @events_body.to_json, :content_type => 'application/json')
       FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvent&sectionid=1&eventid=2", :body => @event_body.to_json, :content_type => 'application/json')
+      FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/ext/uploads/events/?action=listAttachments&sectionid=1&eventid=2", :body => '{"files":["file1.txt", "file2.txt"]}', :content_type => 'application/json')
 
       Osm::Model.stub(:get_user_permissions) { {:events => [:read, :write]} }
     end
@@ -252,9 +255,16 @@ describe "Event" do
         event.badges[1].badge_type.should == :staged
         event.badges[1].requirement_id.should == 4
         event.badges[1].data.should == '1'
+        event.files.should == ['file1.txt', 'file2.txt']
         event.valid?.should == true
       end
 
+      it "Handles no files being an empty array not a hash" do
+        FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/ext/uploads/events/?action=listAttachments&sectionid=1&eventid=2", :body => '[]', :content_type => 'application/json')
+        expect{ @event = Osm::Event.get(@api, 1, 2) }.to_not raise_error
+        @event.files.should == []
+      end
+
       it "Handles a blank config" do
         @event_body['config'] = ''
         FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvent&sectionid=1&eventid=2", :body => @event_body.to_json,:content_type => 'application/json')
@@ -313,6 +323,8 @@ describe "Event" do
         FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvents&sectionid=1&showArchived=true", :body => body.to_json, :content_type => 'application/json')
         FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvent&sectionid=1&eventid=1", :body => {'config' => '[]', 'archived' => '0', 'eventid' => '1'}.to_json, :content_type => 'application/json')
         FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/events.php?action=getEvent&sectionid=1&eventid=2", :body => {'config' => '[]', 'archived' => '1', 'eventid' => '2'}.to_json, :content_type => 'application/json')
+        FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/ext/uploads/events/?action=listAttachments&sectionid=1&eventid=1", :body => '[]', :content_type => 'application/json')
+        FakeWeb.register_uri(:post, "https://www.onlinescoutmanager.co.uk/ext/uploads/events/?action=listAttachments&sectionid=1&eventid=2", :body => '[]', :content_type => 'application/json')
 
         events = Osm::Event.get_for_section(@api, 1)
         OsmTest::Cache.clear

data/spec/osm/online_payment_spec.rb

@@ -0,0 +1,490 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Online payments" do
+
+  describe "Schedule" do
+
+    it "Create" do
+      schedule = Osm::OnlinePayment::Schedule.new(
+        id:             1,
+        section_id:     2,
+        account_id:     3,
+        name:           'A payment schedule',
+        description:    'What this payment schedule is used for',
+        archived:       true,
+        gift_aid:       true,
+        require_all:    true,
+        pay_now:        14,
+        annual_limit:   '100',
+        payments:       [],
+      )
+      schedule.id.should == 1
+      schedule.section_id.should == 2
+      schedule.account_id.should == 3
+      schedule.name.should == 'A payment schedule'
+      schedule.description.should == 'What this payment schedule is used for'
+      schedule.archived.should == true
+      schedule.gift_aid.should == true
+      schedule.require_all.should == true
+      schedule.pay_now.should == 14
+      schedule.annual_limit.should == '100'
+      schedule.payments.should == []
+      schedule.valid?.should == true
+    end
+
+    it "Provides current payments" do
+      payment1 = Osm::OnlinePayment::Schedule::Payment.new(id: 1, archived: false)
+      payment2 = Osm::OnlinePayment::Schedule::Payment.new(id: 2, archived: true)
+      schedule = Osm::OnlinePayment::Schedule.new(payments: [payment1, payment2])
+      schedule.current_payments.should == [payment1]
+    end
+
+    it "Checks for current payments" do
+      payment1 = Osm::OnlinePayment::Schedule::Payment.new(id: 1, archived: false)
+      payment2 = Osm::OnlinePayment::Schedule::Payment.new(id: 2, archived: true)
+      schedule = Osm::OnlinePayment::Schedule.new()
+
+      schedule.payments = [payment1]
+      schedule.current_payments?.should == true
+
+      schedule.payments = [payment2]
+      schedule.current_payments?.should == false
+    end
+
+    it "Provides archived payments" do
+      payment1 = Osm::OnlinePayment::Schedule::Payment.new(id: 1, archived: false)
+      payment2 = Osm::OnlinePayment::Schedule::Payment.new(id: 2, archived: true)
+      schedule = Osm::OnlinePayment::Schedule.new(payments: [payment1, payment2])
+      schedule.archived_payments.should == [payment2]
+    end
+
+    it "Checks for archived payments" do
+      payment1 = Osm::OnlinePayment::Schedule::Payment.new(id: 1, archived: false)
+      payment2 = Osm::OnlinePayment::Schedule::Payment.new(id: 2, archived: true)
+      schedule = Osm::OnlinePayment::Schedule.new()
+
+      schedule.payments = [payment2]
+      schedule.archived_payments?.should == true
+
+      schedule.payments = [payment1]
+      schedule.archived_payments?.should == false
+    end
+
+    it "Sorts by section_id, name then id" do
+      schedule1 = Osm::OnlinePayment::Schedule.new(section_id: 1, name: 'A', id: 1)
+      schedule2 = Osm::OnlinePayment::Schedule.new(section_id: 2, name: 'A', id: 1)
+      schedule3 = Osm::OnlinePayment::Schedule.new(section_id: 2, name: 'B', id: 1)
+      schedule4 = Osm::OnlinePayment::Schedule.new(section_id: 2, name: 'B', id: 2)
+      schedules = [schedule3, schedule2, schedule4, schedule1]
+      schedules.sort.should == [schedule1, schedule2, schedule3, schedule4]
+    end
+
+    it "Converts to a string" do
+      schedule = Osm::OnlinePayment::Schedule.new(id: 1, name: 'Name')
+      schedule.to_s.should == '1 -> Name'
+    end
+
+
+    describe "Uses OSM's API" do
+
+      it "Gets summary list" do
+        @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=getSchemes&sectionid=1'){ {'items'=>[{"schemeid"=>"539","name"=>"Events"}]} }
+        result = Osm::OnlinePayment::Schedule.get_list_for_section(@api, 1)
+        result.should == [{id: 539, name: 'Events'}]
+      end
+
+      it "Gets an individual schedule" do
+        data = {"schemeid"=>"2","sectionid"=>"1","accountid"=>"3","name"=>"Schedule name","preauth_amount"=>"12.34","description"=>"Schedule description","giftaid"=>"1","defaulton"=>"1","paynow"=>"-1","archived"=>"1","payments"=>[{"paymentid"=>"4","schemeid"=>"2","date"=>"2013-03-21","amount"=>"1.23","name"=>"Payment name","archived"=>"1"}]}
+        @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=getPaymentSchedule&sectionid=1&schemeid=2&allpayments=true'){ data }
+        schedule = Osm::OnlinePayment::Schedule.get(@api, 1, 2)
+        schedule.id.should == 2
+        schedule.section_id.should == 1
+        schedule.account_id.should == 3
+        schedule.name.should == 'Schedule name'
+        schedule.description.should == 'Schedule description'
+        schedule.archived.should == true
+        schedule.gift_aid.should == true
+        schedule.require_all.should == true
+        schedule.pay_now.should == -1
+        schedule.annual_limit.should == '12.34'
+        schedule.payments.count.should == 1
+        schedule.valid?.should == true
+        payment = schedule.payments[0]
+        payment.id.should == 4
+        payment.amount.should == '1.23'
+        payment.name.should == 'Payment name'
+        payment.archived.should == true
+        payment.due_date.should == Date.new(2013, 3, 21)
+        payment.schedule.should == schedule
+        payment.valid?.should == true
+      end
+
+      it "Gets all schedules for a section" do
+        Osm::OnlinePayment::Schedule.should_receive(:get_list_for_section).with(@api, 5, {}){ [{id: 6, name: 'A'}, {id: 7, name: 'B'}] }
+        Osm::OnlinePayment::Schedule.should_receive(:get).with(@api, 5, 6, {}){ 'A' }
+        Osm::OnlinePayment::Schedule.should_receive(:get).with(@api, 5, 7, {}){ 'B' }
+        Osm::OnlinePayment::Schedule.get_for_section(@api, 5).should == ['A', 'B']
+      end
+
+      describe "Gets member's payments" do
+
+        before :each do
+          @payment = Osm::OnlinePayment::Schedule::Payment.new(id: 4)
+          @schedule = Osm::OnlinePayment::Schedule.new(
+            id:         1,
+            section_id: 2,
+            payments:   [@payment]
+          )
+          body = {'items'=>[ {
+            'directdebit'=>'Active', 'firstname'=>'John', 'lastname'=>'Snow', 'patrolid'=>'5', 'scoutid'=>'6',
+            'startdate'=>'2015-02-03',
+            '4'=>'{"status":[{"statusid":"7","scoutid":"6","schemeid":"1","paymentid":"8","statustimestamp":"03/02/2016 20:51","status":"Paid manually","details":"","editable":"1","latest":"1","who":"0","firstname":"System"}]}',
+          } ]}
+          @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=getPaymentStatus&sectionid=2&schemeid=1&termid=3').once{ body }
+        end
+
+        it 'For a "collect all" schedule' do
+          @schedule.require_all = true
+          p4m = @schedule.get_payments_for_members(@api, 3)
+          p4m.is_a?(Array).should == true
+          p4m.size.should == 1
+          p4m = p4m[0]
+          p4m.member_id.should == 6
+          p4m.first_name.should == 'John'
+          p4m.last_name.should == 'Snow'
+          p4m.start_date.should == Date.new(2015, 2, 3)
+          p4m.direct_debit.should == :active
+          p4m.payments.size.should == 1
+          payment = p4m.payments[4][0]
+          payment.id.should == 7
+          payment.payment.should == @payment
+          payment.timestamp.should == Time.new(2016, 2, 3, 20, 51)
+          payment.status.should == :paid_manually
+          payment.details.should == ''
+          payment.updated_by.should == 'System'
+          payment.updated_by_id.should == 0
+          payment.valid?.should == true
+          p4m.valid?.should == true
+        end
+
+        it 'For a "not collect all" schedule' do
+          @schedule.require_all = false
+          p4m = @schedule.get_payments_for_members(@api, 3)[0]
+          p4m.start_date.should == nil    # Only difference to a "collect all" type
+          p4m.valid?.should == true
+        end
+
+        it "When it needs to fetch a term" do
+          section = Osm::Section.new(id: 2)
+          Osm::Term.stub(:get_current_term_for_section).and_return(Osm::Term.new(id: 3))
+          Osm::Section.stub(:get).and_return(section)
+          p4m = @schedule.get_payments_for_members(@api)[0]
+          p4m.member_id.should == 6
+          p4m.valid?.should == true
+        end
+
+      end # describe Schedule : Uses OSM's API : Get member's payments
+
+    end # describe Schedule : Uses OSM's API
+
+
+    describe "Payment" do
+
+      it "Create" do
+        schedule = Osm::OnlinePayment::Schedule.new()
+        schedule.stub('valid?'){ true }
+        payment = Osm::OnlinePayment::Schedule::Payment.new(
+          id:       1,
+          amount:   '12.34',
+          name:     'A payment',
+          archived: true,
+          due_date: Date.new(2016, 5, 1),
+          schedule: schedule,
+        )
+        payment.id.should == 1
+        payment.amount.should == '12.34'
+        payment.name.should == 'A payment'
+        payment.archived.should == true
+        payment.due_date.should == Date.new(2016, 5, 1)
+        payment.schedule.should == schedule
+        payment.valid?.should == true
+      end
+
+      it "Checks if a payment is past due" do
+        payment = Osm::OnlinePayment::Schedule::Payment.new(due_date: Date.new(2016, 5, 2))
+        payment.past_due?(Date.new(2016, 5, 1)).should == false
+        payment.past_due?(Date.new(2016, 5, 2)).should == false
+        payment.past_due?(Date.new(2016, 5, 3)).should == true
+      end
+
+    end # describe Schedule -> Payment
+
+
+    describe "PaymentsForMember" do
+
+      it "Create" do
+        schedule = Osm::OnlinePayment::Schedule.new
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(
+          first_name:     'John',
+          last_name:      'Smith',
+          member_id:      1,
+          direct_debit:   :active,
+          start_date:     Date.new(2016, 6, 7),
+          payments:       {},
+          schedule:       schedule,
+        )
+        p4m.first_name.should == 'John'
+        p4m.last_name.should == 'Smith'
+        p4m.member_id.should == 1
+        p4m.direct_debit.should == :active
+        p4m.start_date.should == Date.new(2016, 6, 7)
+        p4m.payments.should == {}
+        p4m.schedule.should == schedule
+        p4m.valid?.should == true
+      end
+
+      it "Gets most recent status for a payment" do
+        payments = {
+          1 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(id: 1, timestamp: Time.new(2016, 1, 2, 3, 4))],
+          2 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(id: 2, timestamp: Time.new(2016, 1, 2, 3, 4))],
+          3 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(id: 3, timestamp: Time.new(2016, 1, 2, 3, 4)), Osm::OnlinePayment::Schedule::PaymentStatus.new(id: 4, timestamp: Time.new(2016, 1, 2, 3, 5))],
+        }
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(payments: payments)
+
+        p4m.latest_status_for(1).id.should == 1
+        p4m.latest_status_for(Osm::OnlinePayment::Schedule::Payment.new(id: 2)).id.should == 2
+        p4m.latest_status_for(3).id.should == 4
+      end
+
+      it "Works out if a payment is paid" do
+        payments = {
+          1 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :required)],
+          2 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :not_required)],
+          3 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :initiated)],
+          4 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :paid)],
+          5 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :received)],
+          6 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :paid_manually)],
+        }
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(payments: payments)
+
+        p4m.paid?(1).should == false
+        p4m.paid?(2).should == false
+        p4m.paid?(3).should == true
+        p4m.paid?(4).should == true
+        p4m.paid?(5).should == true
+        p4m.paid?(6).should == true
+        p4m.paid?(7).should == nil
+      end
+
+      it "Works out if a payment is unpaid" do
+        payments = {
+          1 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :required)],
+          2 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :not_required)],
+          3 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :initiated)],
+          4 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :paid)],
+          5 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :received)],
+          6 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :paid_manually)],
+        }
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(payments: payments)
+
+        p4m.unpaid?(1).should == true
+        p4m.unpaid?(2).should == false
+        p4m.unpaid?(3).should == false
+        p4m.unpaid?(4).should == false
+        p4m.unpaid?(5).should == false
+        p4m.unpaid?(6).should == false
+        p4m.unpaid?(7).should == nil
+      end
+
+      it "Tells if the user has an active direct debit" do
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(direct_debit: :active)
+        p4m.active_direct_debit?.should == true
+
+        p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(direct_debit: :inactive)
+        p4m.active_direct_debit?.should == false
+      end
+
+      describe "Works out if a payment is over due" do
+
+        before :each do
+          @payment = Osm::OnlinePayment::Schedule::Payment.new(id: 1, due_date: Date.new(2016, 1, 2))
+          paid_payments = { 1 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :paid, payment: @payment)] }
+          @paid = Osm::OnlinePayment::Schedule::PaymentsForMember.new(payments: paid_payments)
+          unpaid_payments = { 1 => [Osm::OnlinePayment::Schedule::PaymentStatus.new(status: :required, payment: @payment)] }
+          @unpaid = Osm::OnlinePayment::Schedule::PaymentsForMember.new(payments: unpaid_payments)
+        end
+
+        it "Due date in over" do
+          date = Date.new(2016, 1, 3)
+          @paid.over_due?(@payment, date).should == false
+          @unpaid.over_due?(@payment, date).should == true
+        end
+
+        it "Due date in present" do
+          # Due today means that it is not over being due
+          date = Date.new(2016, 1, 2)
+          @paid.over_due?(@payment, date).should == false
+          @unpaid.over_due?(@payment, date).should == false
+        end
+
+        it "Due date in future" do
+          date = Date.new(2016, 1, 1)
+          @paid.over_due?(@payment, date).should == false
+          @unpaid.over_due?(@payment, date).should == false
+        end
+
+      end # describe Schedule -> PaymentsForMember : is payment past due?
+
+      describe "Update a payment in OSM" do
+
+        before :each do
+          @schedule = Osm::OnlinePayment::Schedule.new(id: 10, section_id: 4, gift_aid: true)
+          @payment = Osm::OnlinePayment::Schedule::Payment.new(id: 1, schedule: @schedule)
+          @schedule.payments = [@payment]
+          @status = Osm::OnlinePayment::Schedule::PaymentStatus.new(id: 2, payment: @payment)
+          @p4m = Osm::OnlinePayment::Schedule::PaymentsForMember.new(member_id: 3, payments: {1=>[@status]}, schedule: @schedule)
+        end
+
+        describe "Using update_payment_status method" do
+          it "Success" do
+            @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>false,'value'=>'Payment not required'})
+              .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled', '1'=>'{"status":[{"statusid":"6","scoutid":"3","schemeid":"4","paymentid":"1","statustimestamp":"01/02/2003 04:05","status":"Payment not required","details":"","editable":"0","latest":"1","who":"0","firstname":"System generated"}]}'} }
+            @p4m.update_payment_status(@api, @payment, :not_required).should == true
+          end
+
+          describe "Failure" do
+            it "No history for payment" do
+              @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>true,'value'=>'Paid manually'})
+                .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled', '1'=>'{"status":[]}'} }
+              @p4m.update_payment_status(@api, @payment, :paid_manually, true).should == false
+            end
+
+            it "No payment data" do
+              @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>true,'value'=>'Paid manually'})
+                .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled'} }
+              @p4m.update_payment_status(@api, @payment, :paid_manually, true).should == false
+            end
+
+            it "Latest status is not what we set" do
+              @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>true,'value'=>'Paid manually'})
+                .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled', '1'=>'{"status":[{"statusid":"6","scoutid":"3","schemeid":"4","paymentid":"1","statustimestamp":"01/02/2003 04:05","status":"Payment not required","details":"","editable":"0","latest":"1","who":"0","firstname":"System generated"}]}'} }
+              @p4m.update_payment_status(@api, @payment, :paid_manually, true).should == false
+            end
+          end
+
+          it "Fails if payment is not in the schedule" do
+            expect{ @p4m.update_payment_status(@api, 2, :paid_manually) }.to raise_error ArgumentError, '2 is not a valid payment for the schedule.'
+          end
+
+          it "Fails if given a bad status" do
+            expect{ @p4m.update_payment_status(@api, 1, :invalid) }.to raise_error ArgumentError, 'status must be either :required, :not_required or :paid_manually. You passed in :invalid'
+          end
+
+          describe "Ignores gift aid parameter if appropriate" do # pass in true and check if calls out with false
+            it "Schedule is a gift aid one" do
+              @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>true,'value'=>'Paid manually'})
+                .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled', '1'=>'{"status":[{"statusid":"6","scoutid":"3","schemeid":"4","paymentid":"1","statustimestamp":"01/02/2003 04:05","status":"Paid manually","details":"","editable":"0","latest":"1","who":"0","firstname":"System generated"}]}'} }
+              @p4m.update_payment_status(@api, @payment, :paid_manually, true).should == true
+            end
+
+            it "Schedule is NOT a gift aid one" do
+              @schedule.gift_aid = false
+              @api.should_receive(:perform_query).with('ext/finances/onlinepayments/?action=updatePaymentStatus', {'sectionid'=>4,'schemeid'=>10,'scoutid'=>3,'paymentid'=>1,'giftaid'=>false,'value'=>'Paid manually'})
+                .once{ {'scoutid'=>'3', 'firstname'=>'John', 'lastname'=>'Smith', 'patrolid'=>'5', 'startdate'=>'1970-01-01', 'directdebit'=>'cancelled', '1'=>'{"status":[{"statusid":"6","scoutid":"3","schemeid":"4","paymentid":"1","statustimestamp":"01/02/2003 04:05","status":"Paid manually","details":"","editable":"0","latest":"1","who":"0","firstname":"System generated"}]}'} }
+              @p4m.update_payment_status(@api, @payment, :paid_manually, true).should == true
+            end
+          end
+
+        end # Using update_payment_status method
+
+        describe "Using" do
+          it "mark_payment_required" do
+            @p4m.should_receive(:update_payment_status).with(@api, @payment, :required).once{ true }
+            @p4m.mark_payment_required(@api, @payment).should == true
+          end
+
+          it "mark_payment_not_required" do
+            @p4m.should_receive(:update_payment_status).with(@api, @payment, :not_required).once{ true }
+            @p4m.mark_payment_not_required(@api, @payment).should == true
+          end
+
+          describe "mark_payment_paid_manually" do
+            it "Updating gift aid" do
+              @p4m.should_receive(:update_payment_status).with(@api, @payment, :paid_manually, true).once{ true }
+              @p4m.mark_payment_paid_manually(@api, @payment, true).should == true
+            end
+
+            it "Not updating gift aid" do
+              @p4m.should_receive(:update_payment_status).with(@api, @payment, :paid_manually, false).once{ true }
+              @p4m.mark_payment_paid_manually(@api, @payment, false).should == true
+            end
+          end
+
+        end
+
+      end # describe Schedule -> PaymentsForMember : Update a payment in OSM
+
+    end # describe Schedule -> PaymentsForMember
+
+
+    describe "Payment status" do
+
+      it "Create" do
+        payment = Osm::OnlinePayment::Schedule::Payment.new
+        payment.stub('valid?'){ true }
+        status = Osm::OnlinePayment::Schedule::PaymentStatus.new(
+          id:             1,
+          payment:        payment,
+          details:        'Details',
+          timestamp:      Time.new(2016, 4, 5, 6, 7),
+          status:         :paid,
+          updated_by:     'My.SCOUT',
+          updated_by_id:  -2,
+        )
+        status.id.should == 1
+        status.payment.should == payment
+        status.details.should == 'Details'
+        status.timestamp.should == Time.new(2016, 4, 5, 6, 7)
+        status.status.should == :paid
+        status.updated_by.should == 'My.SCOUT'
+        status.updated_by_id.should == -2
+        status.valid?.should == true
+      end
+
+      it "Sorts by timestamp (desc), payment then id" do
+        status1 = Osm::OnlinePayment::Schedule::PaymentStatus.new(timestamp: Time.new(2016, 1, 2, 3, 6), payment: 1, id: 1)
+        status2 = Osm::OnlinePayment::Schedule::PaymentStatus.new(timestamp: Time.new(2016, 1, 2, 3, 5), payment: 1, id: 1)
+        status3 = Osm::OnlinePayment::Schedule::PaymentStatus.new(timestamp: Time.new(2016, 1, 2, 3, 5), payment: 2, id: 1)
+        status4 = Osm::OnlinePayment::Schedule::PaymentStatus.new(timestamp: Time.new(2016, 1, 2, 3, 5), payment: 2, id: 2)
+        statuses = [status3, status1, status4, status2]
+        statuses.sort.should == [status1, status2, status3, status4]
+      end
+
+      describe "Has status checking method for" do
+        before :each do
+          @payments = []
+          Osm::OnlinePayment::Schedule::PaymentStatus::VALID_STATUSES.each do |status|
+            payment = Osm::OnlinePayment::Schedule::PaymentStatus.new(status: status)
+            @payments.push payment
+            instance_variable_set("@#{status}_payment", payment)
+          end
+        end
+
+        Osm::OnlinePayment::Schedule::PaymentStatus::VALID_STATUSES.each do |status|
+          it status.to_s do
+            payment = instance_variable_get("@#{status}_payment")
+            payment.send("#{status}?").should == true
+            (Osm::OnlinePayment::Schedule::PaymentStatus::VALID_STATUSES - [status]).each do |i|
+              payment.send("#{i}?").should == false
+            end
+          end
+        end
+      end
+
+    end # describe Schedule -> PaymentStatus
+
+
+  end # describe Schedule
+
+end

data/version.rb

@@ -1,3 +1,3 @@
 module Osm
-  VERSION = "1.2.25"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: osm
 version: !ruby/object:Gem::Version
-  version: 1.2.25
+  version: 1.3.0
 platform: ruby
 authors:
 - Robert Gauld
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-30 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -202,6 +202,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: Use the Online Scout Manager API (https://www.onlinescoutmanager.co.uk)
   to retrieve and save data.
 email:
@@ -239,6 +253,7 @@ files:
 - lib/osm/member.rb
 - lib/osm/model.rb
 - lib/osm/myscout.rb
+- lib/osm/online_payment.rb
 - lib/osm/register.rb
 - lib/osm/section.rb
 - lib/osm/sms.rb
@@ -263,6 +278,7 @@ files:
 - spec/osm/member_spec.rb
 - spec/osm/model_spec.rb
 - spec/osm/myscout_spec.rb
+- spec/osm/online_payment_spec.rb
 - spec/osm/osm_spec.rb
 - spec/osm/register_spec.rb
 - spec/osm/section_spec.rb