osm 1.2.14 → 1.2.15.dev

data/lib/osm/badges.rb

@@ -17,9 +17,10 @@ module Osm
         return Osm::Model.cache_read(api, cache_key)
       end
 
-      data = api.perform_query("challenges.php?action=getInitialBadges&type=core&sectionid=#{section.id}&section=#{section.type}&termid=#{term_id}")
-      data = (data['stock'] || {}).select{ |k,v| !k.eql?('sectionid') }.
-                                   inject({}){ |new_hash,(badge, level)| new_hash[badge] = level.to_i; new_hash }
+      data = api.perform_query("ext/badges/stock/?action=getBadgeStock&section=#{section.type}&section_id=#{section.id}&term_id=#{term_id}")
+      data = (data['items'] || [])
+      data.map!{ |i| [i['shortname'], i['stock']] }
+      data = Hash[data]
 
       Osm::Model.cache_write(api, cache_key, data)
       return data
@@ -28,22 +29,25 @@ module Osm
     # Update badge stock levels
     # @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 update ther badge stock for
-    # @param [Sring, #to_s] badge_key The badge to set the stock level for
+    # @param [Fixnum, #to_i] badge_id The badge to set the stock level for
+    # @param [Fixnum, #to_i] badge_level The level of a staged badge to set the stock for (default 1)
     # @param [Fixnum, #to_i] stock_level How many of the provided badge there are
     # @return [Boolan] whether the update was successfull or not
-    def self.update_stock(api, section, badge_key, stock_level)
+    def self.update_stock(api, section, badge_id, badge_level=1, stock_level)
       Osm::Model.require_ability_to(api, :write, :badge, section)
       section = Osm::Section.get(api, section) unless section.is_a?(Osm::Section)
 
       Osm::Model.cache_delete(api, ['badge_stock', section.id])
 
-      data = api.perform_query("challenges.php?action=updateStock", {
+      data = api.perform_query("ext/badges.php?action=updateStock", {
         'stock' => stock_level,
-        'table' => badge_key,
         'sectionid' => section.id,
         'section' => section.type,
+        'type' => 'current',
+        'level' => badge_level.to_i,
+        'badge_id' => badge_id.to_i,
       })
-      return data.is_a?(Hash) && (data['sectionid'].to_i == section.id) && (data[badge_key.to_s].to_i == stock_level)
+      return data.is_a?(Hash) && data['ok']
     end
 
 
@@ -63,24 +67,25 @@ module Osm
         return Osm::Model.cache_read(api, cache_key)
       end
 
-      data = api.perform_query("challenges.php?action=outstandingBadges&section=#{section.type}&sectionid=#{section.id}&termid=#{term_id}")
+      data = api.perform_query("ext/badges/due/?action=get&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'] || {}
+      pending = data['pending'] || {}
 
       by_member = {}
       member_names = {}
       badge_names = {}
-      pending_raw.each do |key, members|
+      badge_stock = {}
+
+      pending.each do |badge_identifier, members|
         members.each do |member|
-          id = Osm.to_i_or_nil(member['scoutid'])
-          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')
-          badge_names[description_key] = description
-          by_member[id] ||= []
-          by_member[id].push(description_key)
-          member_names[id] = "#{member['firstname']} #{member['lastname']}"
+          badge_level_identifier = badge_identifier + "_#{member['completed']}"
+          member_id = Osm.to_i_or_nil(member['scout_id'])
+          badge_names[badge_level_identifier] = "#{member['label']} - #{member['name']}" + (!member['extra'].nil? ? " (#{member['extra']})" : '')
+          badge_stock[badge_level_identifier] = member['current_stock'].to_i
+          by_member[member_id] ||= []
+          by_member[member_id].push(badge_level_identifier)
+          member_names[member_id] = "#{member['firstname']} #{member['lastname']}"
         end
       end
 
@@ -88,6 +93,7 @@ module Osm
         :by_member => by_member,
         :member_names => member_names,
         :badge_names => badge_names,
+        :badge_stock => badge_stock,
       )
       Osm::Model.cache_write(api, cache_key, due_badges)
       return due_badges
@@ -105,13 +111,15 @@ module Osm
       attribute :badge_names, :default => {}
       attribute :by_member, :default => {}
       attribute :member_names, :default => {}
+      attribute :badge_stock, :default => {}
 
       if ActiveModel::VERSION::MAJOR < 4
-        attr_accessible :badge_names, :by_member, :member_names
+        attr_accessible :badge_names, :by_member, :member_names, :badge_stock
       end
 
       validates :badge_names, :hash => {:key_type => String, :value_type => String}
       validates :member_names, :hash => {:key_type => Fixnum, :value_type => String}
+      validates :badge_stock, :hash => {:key_type => String, :value_type => Fixnum}
 
       validates_each :by_member do |record, attr, value|
         badge_names_keys = record.badge_names.keys

data/lib/osm/event.rb

@@ -234,23 +234,15 @@ module Osm
 
         # 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)
 
         # Add badge links to OSM
         badges_created = true
         event.badges.each do |badge|
-          badge_data = data = api.perform_query("ext/events/event/index.php?action=badgeAddToEvent&sectionid=#{event.section_id}&eventid=#{event.id}", {
-            'section' => badge.badge_section,
-            'badgetype' => badge.badge_type,
-            'badge' => badge.badge_key,
-            'columnname' => badge.requirement_key,
-            'data' => badge.data,
-            'newcolumnname' => badge.requirement_label,
-          })
-          badges_created = false unless badge_data.is_a?(Hash) && badge_data['ok']
+          badges_created &= event.add_badge_link(api, badge)
         end
 
         if badges_created
+          cache_write(api, ['event', event.id], event)
           return event
         else
           # Someting went wrong adding badges so return what OSM has
@@ -324,43 +316,28 @@ module Osm
         badges_to_delete = []
         original_badges.each do |badge|
           unless badges.include?(badge)
-            badges_to_delete.push({
-              'section' => badge.badge_section,
-              'badge' => badge.badge_key,
-              'columnname' => badge.requirement_key,
-              'data' => badge.data,
-              'newcolumnname' => badge.requirement_label,
-              'badgetype' => badge.badge_type,
-            })
+            badges_to_delete.push badge
           end
         end
-        unless badges_to_delete.empty?
-          data = api.perform_query("ext/events/event/index.php?action=badgeDeleteFromEvent&sectionid=#{section_id}&eventid=#{id}", {
-            'badgelinks' => badges_to_delete,
+        badges_to_delete.each do |badge|
+          data = api.perform_query("ext/badges/records/index.php?action=deleteBadgeLink&sectionid=#{section_id}", {
+            'section' => badge.badge_section,
+            'sectionid' => section_id,
+            'type' => 'event',
+            'id' => id,
+            'badge_id' => badge.badge_id,
+            'badge_version' => badge.badge_version,
+            'column_id' => badge.requirement_id,
           })
-          updated &= data.is_a?(Hash) && data['ok']
+          updated &= data.is_a?(Hash) && data['status']
         end
 
         # Added badges
-        badges_to_add = []
         badges.each do |badge|
           unless original_badges.include?(badge)
-            badges_to_add.push({
-              'section' => badge.badge_section,
-              'badge' => badge.badge_key,
-              'columnname' => badge.requirement_key,
-              'data' => badge.data,
-              'newcolumnname' => badge.requirement_label,
-              'badgetype' => badge.badge_type,
-            })
+            updated &= add_badge_link(api, badge)
           end
         end
-        unless badges_to_add.empty?
-          data = api.perform_query("ext/events/event/index.php?action=badgeAddToEvent&sectionid=#{section_id}&eventid=#{id}", {
-            'badgelinks' => badges_to_add,
-          })
-          updated &= data.is_a?(Hash) && data['ok']
-        end
       end # includes badges
 
       if updated
@@ -442,6 +419,26 @@ module Osm
       return attendance
     end
 
+    # Add a badge link to the event in OSM
+    # @param [Osm::Api] api The api to use to make the request
+    # @param [Osm::Event::BadgeLink] link The badge link to add, if column_id is nil then a new column is created with requirement_label as the name
+    # @return [Boolean] whether the update succedded
+    def add_badge_link(api, link)
+      raise Osm::ObjectIsInvalid, 'link is invalid' unless link.valid?
+
+      data = api.perform_query("ext/badges/records/index.php?action=linkBadgeToItem&sectionid=#{section_id}", {
+        'section' => link.badge_section,
+        'sectionid' => section_id,
+        'type' => 'event',
+        'id' => id,
+        'badge_id' => link.badge_id,
+        'badge_version' => link.badge_version,
+        'column_id' => link.requirement_id.to_i.eql?(0) ? -2 : link.requirement_id,
+        'column_data' => link.data,
+        'new_column_name' => link.requirement_id.to_i.eql?(0) ? link.requirement_label : '',
+      })
+      return (data.is_a?(Hash) && data['status'])
+    end
 
     # Add a column to the event in OSM
     # @param [Osm::Api] api The api to use to make the request
@@ -563,7 +560,16 @@ module Osm
       badges_data = event_data['badgelinks']
       badges_data = [] unless badges_data.is_a?(Array)
       badges_data.each do |field|
-        badges.push BadgeLink.new(badge_key: field['badge'], badge_type: field['badgetype'].to_sym, badge_section: field['section'].to_sym, requirement_key: field['columnname'], badge_label: field['badgeLongName'], requirement_label: field['columnnameLongName'], data: field['data'])
+        badges.push BadgeLink.new(
+          badge_type: field['badgetype'].to_sym,
+          badge_section: field['section'].to_sym,
+          requirement_id: field['column_id'],
+          badge_name: field['badgeLongName'],
+          requirement_label: field['columnnameLongName'],
+          data: field['data'],
+          badge_id: field['badge_id'],
+          badge_version: field['badge_version'],
+        )
       end
       event.badges = badges
 
@@ -571,52 +577,54 @@ module Osm
     end
 
 
-    # When creating a BadgeLink for an existing column in a hikes/nights badge the requirement_label is optional
-    # When creating a BadgeLink for a new column in a hikes/nights badge the requirement_key MUST be blank
-# TODO : Add validation for above statements
     class BadgeLink
       include ActiveModel::MassAssignmentSecurity if ActiveModel::VERSION::MAJOR < 4
       include ActiveAttr::Model
 
-      # @!attribute [rw] badge_key
-      #   @return [String] the badge being done
       # @!attribute [rw] badge_type
       #   @return [Symbol] the type of badge
-      # @!attribute [rw] badge_label
-      #   @return [String] human friendly badge name
-      # @!attribute [rw] requirement_key
-      #   @return [String] the requirement being done
       # @!attribute [rw] badge_section
       #   @return [Symbol] the section type that the badge belongs to
       # @!attribute [rw] requirement_label
       #   @return [String] human firendly requirement label
       # @!attribute [rw] data
       #   @return [String] what to put in the column when the badge records are updated
+      # @!attribute [rw] badge_name
+      #   @return [String] the badge's name
+      # @!attribute [rw] badge_id
+      #   @return [Fixnum] the badge's ID in OSM
+      # @!attribute [rw] badge_version
+      #   @return [Fixnum] the version of the badge
+      # @!attribute [rw] requirement_id
+      #   @return [Fixnum] the requirement's ID in OSM
 
-      attribute :badge_key, :type => String
       attribute :badge_type, :type => Object
-      attribute :requirement_key, :type => String
       attribute :badge_section, :type => Object
-      attribute :badge_label, :type => String
       attribute :requirement_label, :type => String
       attribute :data, :type => String
+      attribute :badge_name, :type => String
+      attribute :badge_id, :type => Integer
+      attribute :badge_version, :type => Integer
+      attribute :requirement_id, :type => Integer
 
       if ActiveModel::VERSION::MAJOR < 4
-        attr_accessible :badge_key, :badge_type, :requirement_key, :badge_section, :badge_label, :requirement_label, :data
+        attr_accessible :badge_type, :badge_section, :requirement_label, :data, :badge_name, :badge_id, :badge_version, :requirement_id
       end
 
-      validates_presence_of :badge_key
-      validates_format_of :requirement_key, :with => /\A(?:[a-z]_\d{2})|(?:custom_\d+)\Z/, :allow_blank => true, :message => 'is not in the correct format (e.g. "a_01")'
+      validates_presence_of :badge_name
       validates_inclusion_of :badge_section, :in => [:beavers, :cubs, :scouts, :explorers, :staged]
       validates_inclusion_of :badge_type, :in => [:core, :staged, :activity, :challenge]
+      validates_numericality_of :badge_id, :only_integer=>true, :greater_than=>0
+      validates_numericality_of :badge_version, :only_integer=>true, :greater_than_or_equal_to=>0
+      validates_numericality_of :requirement_id, :only_integer=>true, :greater_than=>0, :allow_nil=>true
 
       # @!method initialize
       #   Initialize a new Meeting::Activity
       #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-      # Compare BadgeLink based on section, type, key, requirement, data
+      # Compare BadgeLink based on section, type, badge_name, requirement_label, data
       def <=>(another)
-        [:badge_section, :badge_type, :badge_key, :requirement_key].each do |attribute|
+        [:badge_section, :badge_type, :badge_name, :requirement_label].each do |attribute|
           result = self.try(:data) <=> another.try(:data)
           return result unless result == 0
         end

data/lib/osm/meeting.rb

@@ -116,13 +116,16 @@ module Osm
         our_badge_links = badge_links[item['eveningid']]
         attributes[:badge_links] = Array.new
         unless our_badge_links.nil?
-          our_badge_links.each do |badge_link_data|
+          our_badge_links.each do |badge_data|
             attributes[:badge_links].push Osm::Meeting::BadgeLink.new(
-              :badge_key => badge_link_data['badge'],
-              :badge_type => badge_link_data['badgetype'].downcase.to_sym,
-              :requirement_key => badge_link_data['columnname'],
-              :badge_section => badge_link_data['section'].downcase.to_sym,
-              :label => badge_link_data['label'],
+              :badge_type => badge_data['badgetype'].to_sym,
+              :badge_section => badge_data['section'].to_sym,
+              :badge_name => badge_data['badgeLongName'],
+              :badge_id => Osm::to_i_or_nil(badge_data['badge_id']),
+              :badge_version => Osm::to_i_or_nil(badge_data['badge_version']),
+              :requirement_id => Osm::to_i_or_nil(badge_data['column_id']),
+              :requirement_label => badge_data['columnnameLongName'],
+              :data => badge_data['data'],
             )
           end
         end
@@ -178,17 +181,6 @@ module Osm
         activities_data.push this_activity
       end
 
-      badge_links_data = Array.new
-      badge_links.each do |badge_link|
-        this_badge_link = {
-          'section' => badge_link.badge_section,
-          'badge' => badge_link.badge_key,
-          'columnname' => badge_link.requirement_key,
-          'badgetype' => badge_link.badge_type,
-        }
-        badge_links_data.push this_badge_link
-      end
-
       api_data = {
         'eveningid' => id,
         'sectionid' => section_id,
@@ -202,7 +194,22 @@ module Osm
         'games' => games,
         'leaders' => leaders,
         'activity' => ActiveSupport::JSON.encode(activities_data),
-        'badgelinks' => ActiveSupport::JSON.encode(badge_links_data),
+        'badgelinks' => ActiveSupport::JSON.encode(badge_links.map{ |b|
+          {
+            'badge_id' => b.badge_id.to_s,
+            'badge_version' => b.badge_version.to_s,
+            'column_id' => b.requirement_id.to_s,
+            'badge' => nil,
+            'badgeLongName' => b.badge_name,
+            'columnname' => nil,
+            'columnnameLongName' => b.requirement_label,
+            'data' => b.data,
+            'section' => b.badge_section,
+            'sectionLongName' => nil,
+            'badgetype' => b.badge_type.to_s,
+            'badgetypeLongName' => nil,
+          }
+        })
       }
       response = api.perform_query("programme.php?action=editEvening", api_data)
 
@@ -276,20 +283,11 @@ module Osm
       else
         # We'll have to iterate through the activities
         require_ability_to(api, :read, :programme, section_id, options)
-        badges = []
+        badges = badge_links
         activities.each do |activity|
           activity = Osm::Activity.get(api, activity.activity_id, nil, options)
           activity.badges.each do |badge|
-            badges.push ({
-              'name' => badge.label,
-              'badgeName' => badge.badge,
-              'sectionid' => section_id.to_s,
-              'eveningid' => id.to_s,
-              'section' => badge.section_type,
-              'badgetype' => badge.type,
-              'badge' => badge.badge,
-              'columnname' => badge.requirement,
-            })
+            badges.push badge
           end
         end
       end
@@ -354,39 +352,54 @@ module Osm
       include ActiveModel::MassAssignmentSecurity if ActiveModel::VERSION::MAJOR < 4
       include ActiveAttr::Model
 
-      # @!attribute [rw] badge_key
-      #   @return [String] the badge being done
       # @!attribute [rw] badge_type
       #   @return [Symbol] the type of badge
-      # @!attribute [rw] requirement_key
-      #   @return [String] the requirement being done
       # @!attribute [rw] badge_section
       #   @return [Symbol] the section type that the badge belongs to
-      # @!attribute [rw] label
-      #   @return [String] human firendly label for the badge and requirement
+      # @!attribute [rw] requirement_label
+      #   @return [String] human firendly requirement label
+      # @!attribute [rw] data
+      #   @return [String] what to put in the column when the badge records are updated
+      # @!attribute [rw] badge_name
+      #   @return [String] the badge's name
+      # @!attribute [rw] badge_id
+      #   @return [Fixnum] the badge's ID in OSM
+      # @!attribute [rw] badge_version
+      #   @return [Fixnum] the version of the badge
+      # @!attribute [rw] requirement_id
+      #   @return [Fixnum] the requirement's ID in OSM
 
-      attribute :badge_key, :type => String
       attribute :badge_type, :type => Object
-      attribute :requirement_key, :type => String
       attribute :badge_section, :type => Object
-      attribute :label, :type => String
+      attribute :requirement_label, :type => String
+      attribute :data, :type => String
+      attribute :badge_name, :type => String
+      attribute :badge_id, :type => Integer
+      attribute :badge_version, :type => Integer
+      attribute :requirement_id, :type => Integer
 
       if ActiveModel::VERSION::MAJOR < 4
-        attr_accessible :badge_key, :badge_type, :requirement_key, :badge_section, :label
+        attr_accessible :badge_type, :badge_section, :requirement_label, :data, :badge_name, :badge_id, :badge_version, :requirement_id
       end
 
-      validates_presence_of :badge_key
-      validates_format_of :requirement_key, :with => /\A[a-z]_\d{2}\Z/, :message => 'is not in the correct format (e.g. "a_01")'
+      validates_presence_of :badge_name
       validates_inclusion_of :badge_section, :in => [:beavers, :cubs, :scouts, :explorers, :staged]
       validates_inclusion_of :badge_type, :in => [:core, :staged, :activity, :challenge]
+      validates_numericality_of :badge_id, :only_integer=>true, :greater_than=>0
+      validates_numericality_of :badge_version, :only_integer=>true, :greater_than_or_equal_to=>0
+      validates_numericality_of :requirement_id, :only_integer=>true, :greater_than=>0, :allow_nil=>true
 
       # @!method initialize
       #   Initialize a new Meeting::Activity
       #   @param [Hash] attributes The hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-      # Compare BadgeLink based on title then activity_id
+      # Compare BadgeLink based on section, type, badge_name, requirement_label, data
       def <=>(another)
-        return self.label <=> another.try(:label)
+        [:badge_section, :badge_type, :badge_name, :requirement_label].each do |attribute|
+          result = self.try(:data) <=> another.try(:data)
+          return result unless result == 0
+        end
+        return self.try(:data) <=> another.try(:data)
       end
 
     end # Class Meeting::BadgeLink