osm 0.0.26 → 0.1.0

data/lib/osm/api_access.rb

@@ -1,8 +1,6 @@
 module Osm
 
-  class ApiAccess
-    include ::ActiveAttr::MassAssignmentSecurity
-    include ::ActiveAttr::Model
+  class ApiAccess < Osm::Model
 
     # @!attribute [rw] id
     #   @return [Fixnum] the id for the API
@@ -20,52 +18,91 @@ module Osm
     validates_numericality_of :id, :only_integer=>true, :greater_than=>0
     validates_presence_of :name
 
-    validates :permissions, :hash => {:key_type => Symbol, :value_in => [10, 20]}
+    validates :permissions, :hash => {:key_type => Symbol, :value_type => Array}
 
 
-    # @!method initialize
-    #   Initialize a new Term
-    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+    # Get API access details for a given section
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the details for
+    # @!macro options_get
+    # @return [Array<Osm::ApiAccess>]
+    def self.get_all(api, section, options={})
+      section_id = section.to_i
+      cache_key = ['api_access', api.user_id, section_id]
 
+      if !options[:no_cache] && cache_exist?(api, cache_key)
+        return cache_read(api, cache_key)
+      end
 
-    # Initialize a new ApiAccess from api data
-    # @param [Hash] data the hash of data provided by the API
-    def self.from_api(data)
-      attributes = {}
-      attributes[:id] = data['apiid'].to_i
-      attributes[:name] = data['name']
-      attributes[:permissions] = data['permissions'].is_a?(Hash) ? data['permissions'] : {}
-
-      # Rubyfy permissions hash
-      attributes[:permissions].keys.each do |key|
-        attributes[:permissions][key] = attributes[:permissions][key].to_i
-        attributes[:permissions][(key.to_sym rescue key) || key] = attributes[:permissions].delete(key) # Symbolize key
+      data = api.perform_query("users.php?action=getAPIAccess&sectionid=#{section_id}")
+
+      permissions_map = {
+        10  => [:read],
+        20  => [:read, :write],
+      }
+      result = Array.new
+      data['apis'].each do |item|
+        attributes = {}
+        attributes[:id] = item['apiid'].to_i
+        attributes[:name] = item['name']
+        attributes[:permissions] = item['permissions'].is_a?(Hash) ? item['permissions'] : {}
+  
+        # Rubyify permissions hash
+        attributes[:permissions].keys.each do |old_key|
+          new_key = (old_key.to_sym rescue old_key)    # Get symbol of the key
+          attributes[:permissions][new_key] = attributes[:permissions].delete(old_key)  # Change the key
+          attributes[:permissions][new_key] = permissions_map[attributes[:permissions][new_key].to_i] # Translate permissions value
+        end
+        attributes[:permissions].freeze
+
+        this_item = new(attributes)
+        result.push this_item
+        cache_write(api, [*cache_key, this_item.id], this_item)
       end
-      attributes[:permissions].freeze
+      cache_write(api, cache_key, result)
 
-      return new(attributes)
+      return result
     end
 
-    # Determine if this API has read access for the provided permission
-    # @param [Symbol] key the permission being queried
-    # @return [Boolean] if this API can read the passed permission
-    def can_read?(key)
-      return [20, 10].include?(permissions[key])
-    end
 
-    # Determine if this API has write access for the provided permission
-    # @param [Symbol] key the permission being queried
-    # @return [Boolean] if this API can write the passed permission
-    def can_write?(key)
-      return [20].include?(permissions[key])
+    # Get our API access details for a given section
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the details for
+    # @!macro options_get
+    # @return [Osm::ApiAccess]
+    def self.get_ours(api, section, options={})
+      get(api, section, api.api_id, options)
     end
 
-    # Determine if this API is the API being used to make requests
-    # @return [Boolean] if this is the API being used
-    def our_api?
-      return id == Osm::Api.api_id.to_i
+
+    # Get API Access for a given API
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the details for
+    # @param [Osm::Api] for_api The api (or its ID) to get access for
+    # @!macro options_get
+    # @return [Osm::ApiAccess]
+    def self.get(api, section, for_api, options={})
+      section_id = section.to_i
+      for_api_id = for_api.to_i
+      cache_key = ['api_access', api.user_id, section_id, for_api]
+
+      if !options[:no_cache] && cache_exist?(api, cache_key)
+        return cache_read(api, cache_key)
+      end
+
+      data = get_all(api, section_id, options)
+
+      data.each do |item|
+        return item if item.id == for_api_id
+      end
+      return nil
     end
 
+
+    # @!method initialize
+    #   Initialize a new Term
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
   end # Class ApiAccess
 
 end # Module

data/lib/osm/due_badges.rb

@@ -1,8 +1,6 @@
 module Osm
 
-  class DueBadges
-    include ::ActiveAttr::MassAssignmentSecurity
-    include ::ActiveAttr::Model
+  class DueBadges < Osm::Model
 
     # @!attribute [rw] descriptions
     #   @return [Hash] descriptions for each of the badges
@@ -30,15 +28,25 @@ module Osm
     end
 
 
-    # @!method initialize
-    #   Initialize a new Term
-    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+    # Get due badges
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the due badges for
+    # @param [Osm::Term, Fixnum, nil] term the term (or its ID) to get the due badges for, passing nil causes the current term to be used
+    # @!macro options_get
+    # @return [Osm::DueBadges]
+    def self.get(api, section, term=nil, options={})
+      section = Osm::Section.get(api, section, options) if section.is_a?(Fixnum)
+      term_id = term.nil? ? Osm::Term.get_current_term_for_section(api, section, options) : term.to_i
+      cache_key = ['due_badges', section.id, term_id]
 
+      if !options[:no_cache] && cache_exist?(api, cache_key) && get_user_permissions(api, section.id)[:badge].include?(:read)
+        return cache_read(api, cache_key)
+      end
 
-    # Initialize a new DueBadges from api data
-    # @param [Hash] data the hash of data provided by the API
-    def self.from_api(data)
-      data = {} unless data.is_a?(Hash) # OSM returns an empty array to represent no badges
+      data = api.perform_query("challenges.php?action=outstandingBadges&section=#{section.type}&sectionid=#{section.id}&termid=#{term_id}")
+
+
+      data = {} unless data.is_a?(Hash) # OSM/OGM returns an empty array to represent no badges
       pending_raw = data['pending'] || {}
       descriptions_raw = data['description'] || {}
 
@@ -52,16 +60,23 @@ module Osm
           name = "#{member['firstname']} #{member['lastname']}"
           description = descriptions_raw[key]['name'] + (descriptions_raw[key]['section'].eql?('staged') ? " (Level #{member['level']})" : '')
           description_key = key + (descriptions_raw[key]['section'].eql?('staged') ? "_#{member['level']}" : '_1')
-
           attributes[:descriptions][description_key] = description
           attributes[:by_member][name] ||= []
           attributes[:by_member][name].push(description_key)
         end
       end
 
-      new(attributes)
+      due_badges = Osm::DueBadges.new(attributes)
+      cache_write(api, cache_key, due_badges)
+      return due_badges
     end
 
+
+    # @!method initialize
+    #   Initialize a new Term
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
     # Check if there are no badges due
     # @return [Boolean]
     def empty?

data/lib/osm/evening.rb

@@ -1,11 +1,8 @@
 module Osm
 
-  class Evening
+  class Evening < Osm::Model
     class Activity; end # Ensure the constant exists for the validators
 
-    include ::ActiveAttr::MassAssignmentSecurity
-    include ::ActiveAttr::Model
-
     # @!attribute [rw] id
     #   @return [Fixnum] the id of the evening
     # @!attribute [rw] section_id
@@ -60,37 +57,103 @@ module Osm
     #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
-    # Initialize a new Evening from api data
-    # @param [Hash] data the hash of data provided by the API
-    # @param activities an array of hashes to generate the list of ProgrammeActivity objects
-    def self.from_api(data, activities)
-      attributes = {}
-      attributes[:id] = Osm::to_i_or_nil(data['eveningid'])
-      attributes[:section_id] = Osm::to_i_or_nil(data['sectionid'])
-      attributes[:title] = data['title'] || 'Unnamed meeting'
-      attributes[:notes_for_parents] = data['notesforparents'] || ''
-      attributes[:games] = data['games'] || ''
-      attributes[:pre_notes] = data['prenotes'] || ''
-      attributes[:post_notes] = data['postnotes'] || ''
-      attributes[:leaders] = data['leaders'] || ''
-      attributes[:start_time] = data['starttime'].nil? ? nil : data['starttime'][0..4]
-      attributes[:finish_time] = data['endtime'].nil? ? nil : data['endtime'][0..4]
-      attributes[:meeting_date] = Osm::parse_date(data['meetingdate'])
-
-      attributes[:activities] = Array.new
-      unless activities.nil?
-        activities.each do |item|
-          attributes[:activities].push Evening::Activity.from_api(item)
+    # Get the programme for a given term
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the programme for
+    # @param [Osm::term, Fixnum, nil] term the term (or its ID) to get the programme for, passing nil causes the current term to be used
+    # @!macro options_get
+    # @return [Array<Osm::Evening>]
+    def self.get_programme(api, section, term, options={})
+      section_id = section.to_i
+      term_id = term.nil? ? Osm::Term.get_current_term_for_section(api, section).id : term.to_i
+      cache_key = ['programme', section_id, term_id]
+
+      if !options[:no_cache] && cache_exist?(api, cache_key) && get_user_permissions(api, section_id)[:programme].include?(:read)
+        return cache_read(api, cache_key)
+      end
+
+      data = api.perform_query("programme.php?action=getProgramme&sectionid=#{section_id}&termid=#{term_id}")
+
+      result = Array.new
+      data = {'items'=>[],'activities'=>{}} if data.is_a? Array
+      items = data['items'] || []
+      activities = data['activities'] || {}
+
+      items.each do |item|
+        attributes = {}
+        attributes[:id] = Osm::to_i_or_nil(item['eveningid'])
+        attributes[:section_id] = Osm::to_i_or_nil(item['sectionid'])
+        attributes[:title] = item['title'] || 'Unnamed meeting'
+        attributes[:notes_for_parents] = item['notesforparents'] || ''
+        attributes[:games] = item['games'] || ''
+        attributes[:pre_notes] = item['prenotes'] || ''
+        attributes[:post_notes] = item['postnotes'] || ''
+        attributes[:leaders] = item['leaders'] || ''
+        attributes[:start_time] = item['starttime'].nil? ? nil : item['starttime'][0..4]
+        attributes[:finish_time] = item['endtime'].nil? ? nil : item['endtime'][0..4]
+        attributes[:meeting_date] = Osm::parse_date(item['meetingdate'])
+  
+        our_activities = activities[item['eveningid']]
+        attributes[:activities] = Array.new
+        unless our_activities.nil?
+          our_activities.each do |activity_data|
+            attributes[:activities].push Osm::Evening::Activity.new(
+              :activity_id => Osm::to_i_or_nil(activity_data['activityid']),
+              :title => activity_data['title'],
+              :notes => activity_data['notes'],
+            )
+          end
         end
+  
+        result.push new(attributes)
       end
 
-      new(attributes)
+      cache_write(api, cache_key, result)
+      return result
     end
 
-    # Get the evening's data for use with the API
-    # @return [Hash]
-    def to_api
-      {
+
+    # Create an evening in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section or section_id to add the evening to
+    # @param [Date] meeting_date the date of the meeting
+    # @return [Boolean] if the operation suceeded or not
+    def self.create(api, section, meeting_date)
+      section_id = section.to_i
+      api_data = {
+        'meetingdate' => meeting_date.strftime(Osm::OSM_DATE_FORMAT),
+        'sectionid' => section_id,
+        'activityid' => -1
+      }
+
+      data = api.perform_query("programme.php?action=addActivityToProgramme", api_data)
+
+      # The cached programmes for the section will be out of date - remove them
+      Osm::Term.get_for_section(api, section).each do |term|
+        cache_delete(api, ['programme', section_id, term.id])
+      end
+
+      return data.is_a?(Hash) && (data['result'] == 0)
+    end
+
+
+    # Update an evening in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @return [Boolean] if the operation suceeded or not
+    def update(api)
+      raise ObjectIsInvalid, 'evening is invalid' unless valid?
+
+      activities_data = Array.new
+      activities.each do |activity|
+        this_activity = {
+          'activityid' => activity.activity_id,
+          'notes' => activity.notes,
+        }
+        activities_data.push this_activity
+      end
+      activities_data = ActiveSupport::JSON.encode(activities_data)
+
+      api_data = {
         'eveningid' => id,
         'sectionid' => section_id,
         'meetingdate' => meeting_date.strftime(Osm::OSM_DATE_FORMAT),
@@ -102,27 +165,39 @@ module Osm
         'postnotes' => post_notes,
         'games' => games,
         'leaders' => leaders,
-        'activity' => activities_for_to_api,
+        'activity' => activities_data,
       }
+      response = api.perform_query("programme.php?action=editEvening", api_data)
+
+      # The cached programmes for the section will be out of date - remove them
+      Osm::Term.get_for_section(api, section_id).each do |term|
+        self.class.cache_delete(api, ['programme', section_id, term.id]) if term.contains_date?(meeting_date)
+      end
+
+      return response.is_a?(Hash) && (response['result'] == 0)
     end
 
 
-    private
-    # Get the JSON for the activities to pass to the OSM API
-    # @return [String]
-    def activities_for_to_api
-      to_save = Array.new
-      activities.each do |activity|
-        this_activity = {
-          'activityid' => activity.activity_id,
-          'notes' => activity.notes,
-        }
-        to_save.push this_activity
+    # Get the badge requirements met on a specific evening
+    # @param [Osm::Api] api The api to use to make the request
+    # @!macro options_get
+    # @return [Array<Hash>] hashes ready to pass into the update_register method
+    def get_badge_requirements(api, options={})
+      section = Osm::Section.get(api, section_id)
+      cache_key = ['badge_requirements', section.id, id]
+
+      if !options[:no_cache] && self.class.cache_exist?(api, cache_key) && get_user_permissions(api, section_id)[:programme].include?(:read)
+        return self.class.cache_read(api, cache_key)
       end
-      return ActiveSupport::JSON.encode(to_save)
+
+      data = api.perform_query("users.php?action=getActivityRequirements&date=#{meeting_date.strftime(Osm::OSM_DATE_FORMAT)}&sectionid=#{section.id}&section=#{section.type}")
+
+      self.class.cache_write(api, cache_key, data)
+      return data
     end
 
 
+    private
     class Activity
       include ::ActiveAttr::MassAssignmentSecurity
       include ::ActiveAttr::Model
@@ -143,22 +218,10 @@ module Osm
       validates_numericality_of :activity_id, :only_integer=>true, :greater_than=>0
       validates_presence_of :title
 
-
       # @!method initialize
       #   Initialize a new Evening::Activity
       #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-  
-      # Initialize a new Evening::Activity from api data
-      # @param [Hash] data the hash of data provided by the API
-      def self.from_api(data)
-        new({
-          :activity_id => Osm::to_i_or_nil(data['activityid']),
-          :title => data['title'],
-          :notes => data['notes'],
-        })
-      end
-
     end # Class Evening::Activity
 
   end # Class Evening

data/lib/osm/event.rb

@@ -1,8 +1,6 @@
 module Osm
 
-  class Event
-    include ::ActiveAttr::MassAssignmentSecurity
-    include ::ActiveAttr::Model
+  class Event < Osm::Model
 
     # @!attribute [rw] id
     #   @return [Fixnum] the id for the event
@@ -22,6 +20,8 @@ module Osm
     #   @return [String] notes about the event
     # @!attribute [rw] archived
     #   @return [Boolean] if the event has been archived
+    # @!attribute [rw] fields
+    #   @return [Hash] Keys are the field's id, values are the field names
 
     attribute :id, :type => Integer
     attribute :section_id, :type => Integer
@@ -32,34 +32,292 @@ module Osm
     attribute :location, :type => String, :default => ''
     attribute :notes, :type => String, :default => ''
     attribute :archived, :type => Boolean, :default => false
+    attribute :fields, :default => {}
 
-    attr_accessible :id, :section_id, :name, :start, :finish, :cost, :location, :notes, :archived
+    attr_accessible :id, :section_id, :name, :start, :finish, :cost, :location, :notes, :archived, :fields
 
     validates_numericality_of :id, :only_integer=>true, :greater_than=>0, :allow_nil => true
     validates_numericality_of :section_id, :only_integer=>true, :greater_than=>0
     validates_presence_of :name
+    validates :fields, :hash => {:key_type => String, :value_type => String}
 
 
     # @!method initialize
     #   Initialize a new Term
     #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-    # Initialize a new Event from api data
-    # @param [Hash] data the hash of data provided by the API
-    def self.from_api(data)
-      new({
-        :id => Osm::to_i_or_nil(data['eventid']),
-        :section_id => Osm::to_i_or_nil(data['sectionid']),
-        :name => data['name'],
-        :start => Osm::make_datetime(data['startdate'], data['starttime']),
-        :end => Osm::make_datetime(data['enddate'], data['endtime']),
-        :cost => data['cost'],
-        :location => data['location'],
-        :notes => data['notes'],
-        :archived => data['archived'].eql?('1'),
+
+    # Get events for a section
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the events for
+    # @!macro options_get
+    # @option options [Boolean] :include_archived (optional) if true then archived activities will also be returned
+    # @return [Array<Osm::Event>]
+    def self.get_for_section(api, section, options={})
+      section_id = section.to_i
+      cache_key = ['events', section_id]
+      events = nil
+
+      if !options[:no_cache] && cache_exist?(api, cache_key) && get_user_permissions(api, section_id)[:events].include?(:read)
+        return cache_read(api, cache_key)
+      end
+
+      data = api.perform_query("events.php?action=getEvents&sectionid=#{section_id}&showArchived=true")
+
+      events = Array.new
+      unless data['items'].nil?
+        data['items'].each do |item|
+          event_id = Osm::to_i_or_nil(item['eventid'])
+          fields_data = api.perform_query("events.php?action=getEvent&sectionid=#{section_id}&eventid=#{event_id}")
+          fields = {}
+          ActiveSupport::JSON.decode(fields_data['config']).each do |field|
+            fields[field['id']] = field['name']
+          end
+
+          event = Osm::Event.new(
+            :id => event_id,
+            :section_id => Osm::to_i_or_nil(item['sectionid']),
+            :name => item['name'],
+            :start => Osm::make_datetime(item['startdate'], item['starttime']),
+            :finish => Osm::make_datetime(item['enddate'], item['endtime']),
+            :cost => item['cost'],
+            :location => item['location'],
+            :notes => item['notes'],
+            :archived => item['archived'].eql?('1'),
+            :fields => fields,
+          )
+          events.push event
+          cache_write(api, ['event', event.id], event)
+        end
+      end
+      cache_write(api, cache_key, events)
+
+      return events if options[:include_archived]
+      return events.reject do |event|
+        event.archived?
+      end
+    end
+
+    # Get an event
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Section, Fixnum] section the section (or its ID) to get the events for
+    # @param [Fixnum] event_id the id of the event to get
+    # @!macro options_get
+    # @option options [Boolean] :include_archived (optional) if true then archived activities will also be returned
+    # @return [Osm::Event, nil] the event (or nil if it couldn't be found
+    def self.get(api, section, event_id, options={})
+      section_id = section.to_i
+      cache_key = ['event', event_id]
+
+      if !options[:no_cache] && cache_exist?(api, cache_key) && get_user_permissions(api, section_id)[:events].include?(:read)
+        return cache_read(api, cache_key)
+      end
+
+      events = get_for_section(api, section, options)
+      return nil unless events.is_a? Array
+
+      events.each do |event|
+        return event if event.id == event_id
+      end
+
+      return nil
+    end
+
+
+    # Create an event in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @return [Osm::Event, nil] the created event, nil if failed
+    def self.create(api, parameters)
+      event = new(parameters)
+      raise ObjectIsInvalid, 'event is invalid' unless event.valid?
+      raise Forbidden, 'you do not have permission to write to events for this section' unless get_user_permissions(api, event.section_id)[:events].include?(:write)
+
+      data = api.perform_query("events.php?action=addEvent&sectionid=#{event.section_id}", {
+        'name' => event.name,
+        'location' => event.location,
+        'startdate' => event.start.strftime(Osm::OSM_DATE_FORMAT),
+        'enddate' => event.finish.strftime(Osm::OSM_DATE_FORMAT),
+        'cost' => event.cost,
+        'notes' => event.notes,
+        'starttime' => event.start.strftime(Osm::OSM_TIME_FORMAT),
+        'endtime' => event.finish.strftime(Osm::OSM_TIME_FORMAT),
+      })
+
+      # The cached events for the section will be out of date - remove them
+      cache_delete(api, ['events', event.section_id])
+      cache_write(api, ['event', event.id], event)
+
+      if (data.is_a?(Hash) && data.has_key?('id'))
+        event.id = data['id'].to_i
+        return event
+      else
+        return nil
+      end
+    end
+
+    # Update event in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @return [Boolean] wether the update succedded
+    def update(api)
+      raise Forbidden, 'you do not have permission to write to events for this section' unless self.class.get_user_permissions(api, section_id)[:events].include?(:write)
+
+      data = api.perform_query("events.php?action=addEvent&sectionid=#{section_id}", {
+        'eventid' => id,
+        'name' => name,
+        'location' => location,
+        'startdate' => start? ? start.strftime(Osm::OSM_DATE_FORMAT) : '',
+        'enddate' => finish? ? finish.strftime(Osm::OSM_DATE_FORMAT) : '',
+        'cost' => cost,
+        'notes' => notes,
+        'starttime' => start? ? start.strftime(Osm::OSM_TIME_FORMAT) : '',
+        'endtime' => finish? ? finish.strftime(Osm::OSM_TIME_FORMAT) : '',
+      })
+
+      # The cached events for the section will be out of date - remove them
+      self.class.cache_delete(api, ['event', id])
+      self.class.cache_delete(api, ['events', section_id])
+
+      return data.is_a?(Hash) && (data['id'].to_i == id)
+    end
+
+    # Delete event from OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @return [Boolean] wether the delete succedded
+    def delete(api)
+      raise Forbidden, 'you do not have permission to write to events for this section' unless self.class.get_user_permissions(api, section_id)[:events].include?(:write)
+
+      data = api.perform_query("events.php?action=deleteEvent&sectionid=#{section_id}&eventid=#{id}")
+
+      # The cached events for the section will be out of date - remove them
+      self.class.cache_delete(api, ['events', section_id])
+      self.class.cache_delete(api, ['event', id])
+
+      return data.is_a?(Hash) ? data['ok'] : false
+    end
+
+
+    # Get event attendance
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Term, Fixnum, nil] term the term (or its ID) to get the members for, passing nil causes the current term to be used
+    # @!macro options_get
+    # @option options [Boolean] :include_archived (optional) if true then archived activities will also be returned
+    # @return [Array<Osm::Event::Attendance>]
+    def get_attendance(api, term=nil, options={})
+      term_id = term.nil? ? Osm::Term.get_current_term_for_section(api, section).id : term.to_i
+      cache_key = ['event_attendance', id]
+
+      if !options[:no_cache] && self.class.cache_exist?(api, cache_key) && self.class.get_user_permissions(api, section_id)[:events].include?(:read)
+        return self.class.cache_read(api, cache_key)
+      end
+
+      data = api.perform_query("events.php?action=getEventAttendance&eventid=#{id}&sectionid=#{section_id}&termid=#{term_id}")
+      data = data['items']
+
+      attendance = []
+      data.each_with_index do |item, index|
+        item.merge!({
+          'dob' => item['dob'].nil? ? nil : Osm::parse_date(item['dob'], :ignore_epoch => true),
+          'attending' => item['attending'].eql?('Yes'),
+        })
+
+        attendance.push Osm::Event::Attendance.new(
+          :event => self,
+          :member_id => Osm::to_i_or_nil(item['scoutid']),
+          :grouping_id => Osm::to_i_or_nil(item['patrolid'].eql?('') ? nil : item['patrolid']),
+          :fields => item.select { |key, value|
+            ['firstname', 'lastname', 'dob', 'attending'].include?(key) || key.to_s.match(/\Af_\d+\Z/)
+          },
+          :row => index,
+        )
+      end
+
+      self.class.cache_write(api, cache_key, attendance)
+      return attendance
+    end
+
+
+    # Add a field in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [String] field_label the label for the field to add
+    # @return [Boolean] wether the update succedded
+    def add_field(api, label)
+      raise ArgumentIsInvalid, 'label is invalid' if label.blank?
+      raise Forbidden, 'you do not have permission to write to events for this section' unless self.class.get_user_permissions(api, section_id)[:events].include?(:write)
+
+      data = api.perform_query("events.php?action=addColumn&sectionid=#{section_id}&eventid=#{id}", {
+        'columnName' => label
       })
+
+      # The cached events for the section will be out of date - remove them
+      self.class.cache_delete(api, ['events', section_id])
+      self.class.cache_delete(api, ['event', id])
+      self.class.cache_delete(api, ['event_attendance', id])
+
+      return data.is_a?(Hash) && (data['eventid'].to_i == id)
     end
 
+
+
+    class Attendance
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
+  
+      # @!attribute [rw] member_id
+      #   @return [Fixnum] OSM id for the member
+      # @!attribute [rw] grouping__id
+      #   @return [Fixnum] OSM id for the grouping the member is in
+      # @!attribute [rw] fields
+      #   @return [Hash] Keys are the field's id, values are the field values
+      # @!attribute [rw] row
+      #   @return [Fixnum] part of the OSM API
+  
+      attribute :row, :type => Integer
+      attribute :member_id, :type => Integer
+      attribute :grouping_id, :type => Integer
+      attribute :fields, :default => {}
+      attribute :event
+  
+      attr_accessible :member_id, :grouping_id, :fields, :row, :event
+  
+      validates_numericality_of :row, :only_integer=>true, :greater_than_or_equal_to=>0
+      validates_numericality_of :member_id, :only_integer=>true, :greater_than=>0
+      validates_numericality_of :grouping_id, :only_integer=>true, :greater_than_or_equal_to=>-2
+      validates :fields, :hash => {:key_type => String}
+      validates_each :event do |record, attr, value|
+        record.event.valid?
+      end
+
+  
+      # @!method initialize
+      #   Initialize a new FlexiRecordData
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+      # Update event attendance
+      # @param [Osm::Api] api The api to use to make the request
+      # @param [String] field_id the id of the field to update (must be 'attending' or /\Af_\d+\Z/)
+      # @return [Boolean] if the operation suceeded or not
+      def update(api, field_id)
+        raise ArgumentIsInvalid, 'field_id is invalid' unless field_id.match(/\Af_\d+\Z/) || field_id.eql?('attending')
+        raise Forbidden, 'you do not have permission to write to events for this section' unless Osm::Model.get_user_permissions(api, event.section_id)[:events].include?(:write)
+
+        data = api.perform_query("events.php?action=updateScout", {
+          'scoutid' => member_id,
+          'column' => field_id,
+          'value' => !field_id.eql?('attending') ? fields[field_id] : (fields['attending'] ? 'Yes' : 'No'),
+          'sectionid' => event.section_id,
+          'row' => row,
+          'eventid' => event.id,
+        })
+  
+        # The cached event attedance will be out of date
+        Osm::Model.cache_delete(api, ['event_attendance', event.id])
+  
+        return data.is_a?(Hash)
+      end
+
+    end # Class Attendance
+
   end # Class Event
 
 end # Module