osm 0.0.1.alpha

data/lib/osm/api_access.rb

@@ -0,0 +1,43 @@
+module Osm
+
+  class ApiAccess
+
+    attr_reader :id, :name, :permissions
+
+    # Initialize a new API Access using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @id = data['apiid'].to_i
+      @name = data['name']
+      @permissions = data['permissions'] || {}
+
+      # Rubyfy permissions hash
+      @permissions.keys.each do |key|
+        @permissions[key] = @permissions[key].to_i
+        @permissions[(key.to_sym rescue key) || key] = @permissions.delete(key) # Symbolize key
+      end
+    end
+
+    # Determine if this API has read access for the provided permission
+    # @param key - the key for the permission being queried
+    # @returns - true if this API can read the passed permission, false otherwise
+    def can_read?(key)
+      return [20, 10].include?(@permissions[key])
+    end
+
+    # Determine if this API has write access for the provided permission
+    # @param key - the key for the permission being queried
+    # @returns - true if this API can write the passed permission, false otherwise
+    def can_write?(key)
+      return [20].include?(@permissions[key])
+    end
+
+    # Determine if this API is the API being used to make requests
+    # @returns - true if this is the API being used, false otherwise
+    def our_api?
+      return @id == Osm::Api.api_id.to_i
+    end
+
+  end
+
+end

data/lib/osm/due_badges.rb

@@ -0,0 +1,53 @@
+module Osm
+
+  class DueBadges
+
+    attr_reader :descriptions, :by_member, :totals
+
+    # Initialize a new Event using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      data = {} unless data.is_a?(Hash)
+
+      @pending = (data['pending'] || {}).symbolize_keys
+      @descriptions = (data['description'] || {}).symbolize_keys
+
+      @pending.each_key do |key|
+        @pending[key].each do |item|
+          item.symbolize_keys!
+          item[:sid] = item[:sid].to_i
+          item[:completed] = item[:completed].to_i
+        end
+      end
+      @descriptions.each_key do |key|
+        @descriptions[key].symbolize_keys!
+        @descriptions[key][:section] = @descriptions[key][:section].to_sym
+        @descriptions[key][:type] = @descriptions[key][:type].to_sym
+      end
+
+
+      @by_member = {}
+      @totals = {}
+      @pending.each_key do |key|
+        @pending[key].each do |item|
+          name = "#{item[:firstname]} #{item[:lastname]}"
+          by_member[name] = [] if by_member[name].nil?
+
+          badge = {
+            :badge => key,
+            :extra_information => item[:extra]
+          }
+          by_member[name].push badge
+          @totals[key] = {} if @totals[key].nil?
+          @totals[key][item[:extra]] = @totals[key][item[:extra]].to_i + 1
+        end
+      end
+    end
+
+    def empty?
+      return @by_member.empty?
+    end
+
+  end
+
+end

data/lib/osm/event.rb

@@ -0,0 +1,22 @@
+module Osm
+
+  class Event
+
+    attr_reader :id, :section_id, :name, :start, :end, :cost, :location, :notes
+
+    # Initialize a new Event using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @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']
+    end
+
+  end
+
+end

data/lib/osm/grouping.rb

@@ -0,0 +1,17 @@
+module Osm
+
+  class Grouping
+
+    attr_reader :id, :name, :active
+
+    # Initialize a new Grouping using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @id = Osm::to_i_or_nil(data['patrolid'])
+      @name = data['name']
+      @active = (data['active'] == 1)
+    end
+
+  end
+
+end

data/lib/osm/member.rb

@@ -0,0 +1,64 @@
+module Osm
+
+  class Member
+
+    attr_reader :id, :section_id, :type, :first_name, :last_name, :email1, :email2, :email3, :email4, :phone1, :phone2, :phone3, :phone4, :address, :address2, :date_of_birth, :started, :joined_in_years, :parents, :notes, :medical, :religion, :school, :ethnicity, :subs, :grouping_id, :grouping_leader, :joined, :age, :joined_years, :patrol
+
+    # Initialize a new Member using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @id = Osm::to_i_or_nil(data['scoutid'])
+      @section_id = Osm::to_i_or_nil(data['sectionid'])
+      @type = data['type']
+      @first_name = data['firstname']
+      @last_name = data['lastname']
+      @email1 = data['email1']
+      @email2 = data['email2']
+      @email3 = data['email3']
+      @email4 = data['email4']
+      @phone1 = data['phone1']
+      @phone2 = data['phone2']
+      @phone3 = data['phone3']
+      @phone4 = data['phone4']
+      @address = data['address']
+      @address2 = data['address2']
+      @date_of_birth = Osm::parse_date(data['dob'])
+      @started = Osm::parse_date(data['started'])
+      @joined_in_years = data['joining_in_yrs'].to_i
+      @parents = data['parents']
+      @notes = data['notes']
+      @medical = data['medical']
+      @religion = data['religion']
+      @school = data['school']
+      @ethnicity = data['ethnicity']
+      @subs = data['subs']
+      @grouping_id = Osm::to_i_or_nil(data['patrolid'])
+      @grouping_leader = data['patrolleader'] # 0 - No, 1 = seconder, 2 = sixer
+      @joined = Osm::parse_date(data['joined'])
+      @age = data['age'] # 'yy / mm'
+      @joined_years = data['yrs'].to_i
+      @patrol = data['patrol']
+    end
+
+    # Get the years element of this scout's age
+    # @returns the number of years this scout has been alive
+    def age_years
+      return @age[0..1].to_i
+    end
+
+    # Get the months element of this scout's age
+    # @returns the number of months since this scout's last birthday
+    def age_months
+      return @age[-2..-1].to_i
+    end
+
+    # Get the full name
+    # @param seperator (optional) what to split the scout's first name and last name with, defaults to a space
+    # @returns this scout's full name seperate by the optional seperator
+    def name(seperator=' ')
+      return "#{@first_name}#{seperator.to_s}#{@last_name}"
+    end
+
+  end
+
+end

data/lib/osm/programme_activity.rb

@@ -0,0 +1,18 @@
+module Osm
+
+  class ProgrammeActivity
+
+    attr_reader :evening_id, :activity_id, :title, :notes
+
+    # Initialize a new EveningActivity using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @evening_id = Osm::to_i_or_nil(data['eveningid'])
+      @activity_id = Osm::to_i_or_nil(data['activityid'])
+      @title = data['title']
+      @notes = data['notes']
+    end
+
+  end
+
+end

data/lib/osm/programme_item.rb

@@ -0,0 +1,58 @@
+module Osm
+
+  class ProgrammeItem
+
+    attr_accessor :evening_id, :section_id, :title, :notes_for_parents, :games, :pre_notes, :post_notes, :leaders, :meeting_date, :activities, :google_calendar
+    attr_reader :start_time, :end_time
+
+    # Initialize a new ProgrammeItem using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    # @param activities an array of hashes to generate the list of ProgrammeActivity objects
+    def initialize(data, activities)
+      @evening_id = Osm::to_i_or_nil(data['eveningid'])
+      @section_id = Osm::to_i_or_nil(data['sectionid'])
+      @title = data['title'] || 'Unnamed meeting'
+      @notes_for_parents = data['notesforparents'] || ''
+      @games = data['games'] || ''
+      @pre_notes = data['prenotes'] || ''
+      @post_notes = data['postnotes'] || ''
+      @leaders = data['leaders'] || ''
+      @start_time = data['starttime'].nil? ? nil : data['starttime'][0..4]
+      @end_time = data['endtime'].nil? ? nil : data['endtime'][0..4]
+      @meeting_date = Osm::parse_date(data['meetingdate'])
+      @google_calendar = data['googlecalendar']
+
+      @activities = Array.new
+      unless activities.nil?
+        activities.each do |item|
+          @activities.push Osm::ProgrammeActivity.new(item)
+        end
+      end
+    end
+
+    # Custom setters for times
+    [:start, :end].each do |attribute|
+      define_method "#{attribute}_time=" do |value|
+        unless value.nil?
+          value = value.strftime('%H:%M') unless value.is_a?(String)
+          raise ArgumentError, 'invalid time' unless /\A(?:[0-1][0-9]|2[0-3]):[0-5][0-9]\Z/.match(value)
+        end
+        instance_variable_set("@#{attribute}_time", value)
+      end
+    end
+
+    def activities_for_saving
+      to_save = Array.new
+      @activities.each do |activity|
+        this_activity = {
+          'activityid' => activity.activity_id,
+          'notes' => activity.notes,
+        }
+        to_save.push this_activity
+      end
+      return ActiveSupport::JSON.encode(to_save)
+    end
+
+  end
+
+end

data/lib/osm/role.rb

@@ -0,0 +1,66 @@
+module Osm
+
+  class Role
+
+    attr_reader :section, :group_name, :group_id, :group_normalized, :default, :permissions
+
+    # Initialize a new UserRole using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @section = Osm::Section.new(data['sectionid'], data['sectionname'], ActiveSupport::JSON.decode(data['sectionConfig']), self)
+      @group_name = data['groupname']
+      @group_id = Osm::to_i_or_nil(data['groupid'])
+      @group_normalized = Osm::to_i_or_nil(data['groupNormalised'])
+      @default = data['isDefault'].eql?('1') ? true : false
+      @permissions = (data['permissions'] || {}).symbolize_keys
+
+      # Convert permission values to a number
+      @permissions.each_key do |key|
+        @permissions[key] = @permissions[key].to_i
+      end
+    end
+
+    # Determine if this role has read access for the provided permission
+    # @param key - the key for the permission being queried
+    # @returns - true if this role can read the passed permission, false otherwise
+    def can_read?(key)
+      return [10, 20, 100].include?(@permissions[key])
+    end
+
+    # Determine if this role has write access for the provided permission
+    # @param key - the key for the permission being queried
+    # @returns - true if this role can write the passed permission, false otherwise
+    def can_write?(key)
+      return [20, 100].include?(@permissions[key])
+    end
+
+    # Get section's full name in a consistent format
+    # @returns a string e.g. "Scouts (1st Somewhere)"
+    def long_name
+      @group_name.blank? ? @section.name : "#{@section.name} (#{@group_name})"
+    end
+
+    # Get section's full name in a consistent format
+    # @returns a string e.g. "1st Somewhere Beavers"
+    def full_name
+      @group_name.blank? ? @section.name : "#{@group_name} #{@section.name}"
+    end
+
+    def <=>(another_role)
+      compare_group_name = self.group_name <=> another_role.group_name
+      return compare_group_name unless compare_group_name == 0
+
+      return 0 if self.section.type == another_role.section.type
+      [:beavers, :cubs, :scouts, :explorers, :waiting, :adults].each do |type|
+        return -1 if self.section.type == type
+        return 1 if another_role.section.type == type
+      end
+    end
+
+    def ==(another_role)
+      self.section == another_role.try(:section)
+    end
+
+  end
+
+end

data/lib/osm/section.rb

@@ -0,0 +1,63 @@
+module Osm
+
+  class Section
+
+    attr_reader :id, :name, :subscription_level, :subscription_expires, :type, :num_scouts, :has_badge_records, :has_programme, :wizard, :column_names, :fields, :intouch_fields, :mobile_fields, :extra_records, :role
+
+    # Initialize a new SectionConfig using the hash returned by the API call
+    # @param id the section ID used by the API to refer to this section
+    # @param data the hash of data for the object returned by the API
+    def initialize(id, name, data, role)
+      subscription_levels = [:bronze, :silver, :gold]
+      subscription_level = data['subscription_level'].to_i - 1
+
+      @id = Osm::to_i_or_nil(id)
+      @name = name
+      @subscription_level = (subscription_levels[subscription_level] unless subscription_level < 0) || :unknown
+      @subscription_expires = data['subscription_expires'] ? Date.parse(data['subscription_expires'], 'yyyy-mm-dd') : nil
+      @type = !data['sectionType'].nil? ? data['sectionType'].to_sym : :unknown
+      @num_scouts = data['numscouts']
+      @has_badge_records = data['hasUsedBadgeRecords'].eql?('1') ? true : false
+      @has_programme = data['hasProgramme']
+      @wizard = (data['wizard'] || '').downcase.eql?('true') ? true : false
+      @column_names = (data['columnNames'] || {}).symbolize_keys
+      @fields = (data['fields'] || {}).symbolize_keys
+      @intouch_fields = (data['intouch'] || {}).symbolize_keys
+      @mobile_fields = (data['mobFields'] || {}).symbolize_keys
+      @extra_records = data['extraRecords'] || []
+      @role = role
+
+      # Symbolise the keys in each hash of the extra_records array
+      @extra_records.each do |item|
+        # Expect item to be: {:name=>String, :extraid=>FixNum}
+        # Sometimes get item as: [String, {"name"=>String, "extraid"=>FixNum}]
+        if item.is_a?(Array)
+          item = item[1].symbolize_keys
+        else
+          item.symbolize_keys!
+        end
+      end
+    end
+
+    def youth_section?
+      [:beavers, :cubs, :scouts, :explorers].include?(@type)
+    end
+
+    # Custom section type checkers
+    [:beavers, :cubs, :scouts, :explorers, :adults, :waiting].each do |attribute|
+      define_method "#{attribute}?" do
+        @type == attribute
+      end
+    end
+
+    def <=>(another_section)
+      self.role <=> another_section.try(:role)
+    end
+
+    def ==(another_section)
+      self.id == another_section.try(:id)
+    end
+
+  end
+
+end

data/lib/osm/term.rb

@@ -0,0 +1,72 @@
+module Osm
+
+  class Term
+
+    attr_reader :id, :section_id, :name, :start, :end
+
+    # Initialize a new Term using the hash returned by the API call
+    # @param data the hash of data for the object returned by the API
+    def initialize(data)
+      @id = Osm::to_i_or_nil(data['termid'])
+      @section_id = Osm::to_i_or_nil(data['sectionid'])
+      @name = data['name']
+      @start = Osm::parse_date(data['startdate'])
+      @end = Osm::parse_date(data['enddate'])
+    end
+
+    # Determine if the term is completly before the passed date
+    # @param date
+    # @returns true if the term is completly before the passed date
+    def before?(date)
+      return @end < date.to_date
+    end
+
+    # Determine if the term is completly after the passed date
+    # @param date
+    # @returns true if the term is completly after the passed date
+    def after?(date)
+      return @start > date.to_date
+    end
+
+    # Determine if the term is in the future
+    # @returns true if the term starts after today
+    def future?
+      return @start > Date.today
+    end
+
+    # Determine if the term is in the past
+    # @returns true if the term finished before today
+    def past?
+      return @end < Date.today
+    end
+
+    # Determine if the term is current
+    # @returns true if the term started before today and finishes after today
+    def current?
+      return (@start <= Date.today) && (@end >= Date.today)
+    end
+
+    # Determine if the provided date is within the term
+    # @param date the date to test
+    # @returns true if the term started before the date and finishes after the date
+    def contains_date?(date)
+      return (@start <= date) && (@end >= date)
+    end
+
+    def <=>(another_term)
+      compare = self.section_id <=> another_term.try(:section_id)
+      return compare unless compare == 0
+
+      compare = self.start <=> another_term.try(:start)
+      return compare unless compare == 0
+
+      self.id <=> another_term.try(:id)
+    end
+
+    def ==(another_term)
+      self.id == another_term.try(:id)
+    end
+
+  end
+
+end