roconnector 0.0.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Adam Focht and Brian Roberg
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/regonlineconnector.rb

@@ -0,0 +1,263 @@
+require 'regonlineconnector/client'
+require 'regonlineconnector/parser'
+require 'regonlineconnector/error'
+
+# = regonlineconnector.rb - Regonline API Interface Library
+# 
+# Copyright (c) 2011 Adam Focht and Brian Roberg
+#
+# RegonlineConnector provides a ruby interface to the RegOnline Web
+# API[http://forums.regonline.com/forums/thread/1383.aspx].
+#
+# This class provides ruby-friendly method names that return 
+# parsed RegOnline provided via hashes of hashes.
+#
+# == Example
+#
+# === Authentication
+#
+#  require 'regonlineconnector'
+#  
+#  roc = RegonlineConnector.new(123456, 'joeuser', 'password')
+#  
+#  if !roc.authenticate
+#    puts "Invalid Credentials"
+#  end
+#
+# === Getting All Events
+# 
+#  require 'regonlineconnector'
+#  require 'pp'
+#  
+#  roc = RegonlineConnector.new(123456, 'joeuser', 'password')
+#  
+#  events = roc.events(654321)
+#  pp events
+#
+class RegonlineConnector
+  def initialize(account_id, username, password)
+    @client  = RegonlineConnector::Client.new(account_id, username, password)
+    @parser  = RegonlineConnector::Parser.new
+  end
+  
+  # Returns boolean indicating whether valid login credentials have
+  # been supplied.
+  def authenticate
+    @authenticate = @client.authenticate
+  end
+  
+  # Returns hashed data from RegOnline's getEvents.byAccountID method.
+  def events
+    events = @client.getEvents.ByAccountID
+    if events.include?("The credentials you supplied are not valid.")
+          raise RegonlineConnector::AuthenticationError
+    end
+    @parser.parse_events(events)
+  end
+  
+  # Returns hashed data from RegOnline's getEvents.byAccountIDEventID method.
+  def event(event_id)
+    event = @client.getEvents.ByAccountIDEventID(event_id)
+    if event.include?('The credentials you supplied are not valid.')
+          raise RegonlineConnector::AuthenticationError
+    end
+    @parser.parse_events(event)
+  end
+  
+  # Returns hashed data from RegOnline's getEvents.byAccountIDWithFilters
+  # method.
+  def filtered_events(filter_hash, filter_operator, filter_like_matching)
+    unless filter_like_matching == 'true' || filter_like_matching == 'false'
+      raise ArgumentError, "filter_like_matching argument must be either 'true' or 'false'"
+    end 
+    unless filter_operator == 'and' || filter_operator == 'or'
+      raise ArgumentError, "filter_operator argument must be either 'and' or 'or'"
+    end
+    unless filter_hash.instance_of?(Hash)
+      raise ArgumentError, "filter hash must be hash"
+    end
+    if filter_hash.empty?
+      raise ArgumentError, "filter hash must not be empty"
+    end
+    
+    filter_xml = "<filters>"
+    filter_hash.sort.each {|filter, value| filter_xml << "<#{filter}>#{value}</#{filter}>"}
+    filter_xml << "</filters>"
+
+    begin
+      events = @client.getEvents.ByAccountIDWithFilters(filter_xml, filter_operator, filter_like_matching)
+    rescue SOAP::FaultError
+      raise   RegonlineConnector::RegonlineServerError
+    end
+
+    if events.include?('The credentials you supplied are not valid.')
+          raise RegonlineConnector::AuthenticationError
+    end
+    @parser.parse_events(events)
+  end
+  
+  # Returns hashed data from RegOnline's geteventfields.RetrieveEventFields2
+  # method.
+  def event_fields(event_id, exclude_amounts="false")
+    begin
+      @parser.parse_event_fields(@client.getEventFields(event_id, exclude_amounts).RetrieveEventFields2)
+    rescue SOAP::FaultError => exception
+      if exception.to_s.include?("Authentication failure")
+        raise RegonlineConnector::AuthenticationError
+      else
+        raise RegonlineConnector::RegonlineServerError
+      end
+    end
+  end
+  
+  # Returns hashed data from RegOnline's getEventRegistrations method.
+  def simple_event_registrations(event_id)
+    begin
+      @parser.parse_registrations(@client.getEventRegistrations(event_id).RetrieveRegistrationInfo)
+    rescue SOAP::FaultError => exception
+      if exception.to_s.include?("Authentication failure")
+        raise RegonlineConnector::AuthenticationError
+      else
+        raise RegonlineConnector::RegonlineServerError
+      end
+    end
+  end
+  
+  # Returns hashed data from RegOnline's retrieveAllRegistrations method.
+  def event_registrations(event_id)
+    begin
+      @parser.parse_registrations(@client.retrieveAllRegistrations(event_id).RetrieveAllRegistrations)
+    rescue SOAP::FaultError => exception
+      if exception.to_s.include?("Authentication failure")
+        raise RegonlineConnector::AuthenticationError
+      else
+        raise RegonlineConnector::RegonlineServerError
+      end
+    end
+  end
+    
+  # Returns hashed data from RegOnline's retrieveSingleRegistration
+  # method.
+  def registration(event_id, registration_id)
+    begin
+      @parser.parse_registrations(@client.retrieveSingleRegistration(event_id, registration_id).RetrieveSingleRegistration)
+    rescue SOAP::FaultError => exception
+      if exception.to_s.include?("Authentication failure")
+        raise RegonlineConnector::AuthenticationError
+      else
+        raise RegonlineConnector::RegonlineServerError
+      end
+    end
+  end
+  
+  # Returns hashed data from RegOnline's RegOnline.getReport
+  # method.
+  def report(report_id, event_id, start_date, end_date, add_date)
+    unless add_date == 'true' || add_date == 'false'
+      raise ArgumentError, "add_date argument must be either 'true' or 'false'"
+    end
+    start_t = Date.parse(start_date)
+    end_t = Date.parse(end_date)
+    unless start_t < DateTime.now
+      raise ArgumentError, "start_time argument cannot be in future"
+    end
+    unless end_t < DateTime.now
+      raise ArgumentError, "end_time argument cannot be in future"
+    end
+    unless start_t < end_t
+      raise ArgumentError, "start time must be before end time cannot be in future"
+    end
+    
+    registrations = @client.regOnline(report_id, event_id, start_date, end_date, add_date).getReport
+    if registrations.include?("Error 4458") && @client.authenticate == false
+      raise RegonlineConnector::AuthenticationError
+    end
+    @parser.parse_report(registrations)
+  end
+  
+  # Updates regonline registrations from an XML file using the
+  # RegistrationUpdateService.UpdateRegistrations method.
+  def update_registrations(event_id, update_data_hash)
+    unless event_id.kind_of?(Integer)
+      raise ArgumentError, "event_id must be integer"
+    end
+    unless event_id > 0
+      raise ArgumentError, "event_id must be positive integer"
+    end
+    unless update_data_hash.instance_of?(Hash)
+      raise ArgumentError, "update data hash must be hash"
+    end
+    if update_data_hash.empty?
+      raise ArgumentError, "update data hash must not be empty"
+    end
+    
+    registrations_to_be_updated = update_data_hash.keys.sort
+    registration_updater = @client.registrationUpdateService
+    request_xml = registration_updater.generate_request_xml(event_id, update_data_hash)
+    
+    begin
+      response_xml = registration_updater.UpdateRegistrations(request_xml)
+    rescue SOAP::FaultError => exception
+      if exception.to_s.include?("Authentication failure")
+        raise RegonlineConnector::AuthenticationError
+      else
+        raise RegonlineConnector::RegonlineServerError
+      end
+    end
+    
+    updated_registrations = @parser.parse_updated_registrations(response_xml)
+    updated_registrations.sort!
+    
+    if registrations_to_be_updated != updated_registrations
+      raise RegonlineConnector::ResponseError
+    end
+    
+    updated_registrations
+  end
+  
+  
+  #--
+  ############################################################################
+  #  The following methods are not expected to be implemented at this time.  #
+  #  Feel free to implement them as desired and contribute them.  :)         #
+  ############################################################################
+  #++
+  
+  # Uses the checkinreg.CheckIn method to check an attendee in.
+  # <b><em>Not implemented.</em></b> 
+  def check_in(registration_id, event_id)
+    raise NotImplementedError
+  end
+  
+  # Uses the customfieldresponse.modify method to assign a dna code to an 
+  # attendee. <b><em>Not implemented.</em></b>
+  def assign_dna(registration_id, event_id, custom_field_id, dna_code)
+    raise NotImplementedError
+  end
+  
+  # Uses the customfieldresponse.AssignSeat method to assign a seat for an
+  # attendee. <b><em>Not implemented.</em></b>
+  def assign_seat(registration_id, event_id, custom_field_id, level_id,
+                  section_id, row_id, seat_id, block_code)
+    raise NotImplementedError
+  end
+  
+  # Uses the registrationWS.Modify method to assign a resource group to an 
+  # attendee. <b><em>Not implemented.</em></b>
+  def assign_resource_group(registration_id, resource_group_id)
+    raise NotImplementedError
+  end
+  
+  # Uses the registrationWS.assignRoomSharerID method to assign a room sharer
+  # to an attendee.  <b><em>Not implemented.</em></b>
+  def assign_room_sharer(registration_id, room_sharer_id)
+    raise NotImplementedError
+  end
+  
+  # Uses the SetCustomFieldResponseStatus.setStatus method to set an attendee's
+  # custom field response status. <b><em>Not implemented.</em></b>
+  def set_custom_field_response_status(registration_id, custom_field_id,
+                                       status_id)
+    raise NotImplementedError
+  end
+end

data/lib/regonlineconnector/client.rb

@@ -0,0 +1,122 @@
+require 'regonlineconnector/client/geteventfields'
+require 'regonlineconnector/client/geteventregistrations'
+require 'regonlineconnector/client/getevents'
+require 'regonlineconnector/client/registrationupdateservice'
+require 'regonlineconnector/client/regonline'
+require 'regonlineconnector/client/retrieveallregistrations'
+require 'regonlineconnector/client/retrievesingleregistration'
+require 'regonlineconnector/client/registrationupdateservice'
+require 'base64'
+require 'md5'
+require 'rubygems'
+require 'zip/zip'
+
+
+class RegonlineConnector
+  
+  # The client class handles the communication objects, containing
+  # the account_id, username, and password, once authenticated.
+  class Client
+    def initialize(account_id, username, password)
+      @account_id         = account_id
+      @username           = username
+      @password           = password
+    end
+    
+    # Provides interface to authentication method.
+    def authenticate
+      authenticate = RegonlineConnector::Client::GetEvents.new(@account_id,
+                                                               @username,
+                                                               @password)
+      authenticate.Authenticate
+    end
+    
+    # Provides interface to GetEvents method, returning GetEvents object.
+    def getEvents
+      get_events = RegonlineConnector::Client::GetEvents.new(@account_id, 
+                                                             @username,
+                                                             @password)
+    end
+    
+    # Provides interface to GetEventFields method, returning 
+    # GetEventFields object.
+    def getEventFields(event_id, exclude_amounts = "false")
+      get_event_fields = 
+          RegonlineConnector::Client::GetEventFields.new(event_id,
+                                                         @username,
+                                                         @password,
+                                                         exclude_amounts)
+    end
+    
+    # Provides interface to GetEventRegistrations method, returning 
+    # GetEventRegistrations object.
+    def getEventRegistrations(event_id)
+      get_event_registrations = 
+          RegonlineConnector::Client::GetEventRegistrations.new(event_id,
+                                                                @username,
+                                                                @password)
+    end
+    
+    # Provides interface to RetrieveAllRegistrations method, returning 
+    # RetrieveAllRegistrations object.
+    def retrieveAllRegistrations(event_id)
+      retrieve_all_registrations = 
+          RegonlineConnector::Client::RetrieveAllRegistrations.new(event_id,
+                                                                   @username,
+                                                                   @password)
+    end
+    
+    # Provides interface to RetrieveSingleRegistration method, returning
+    # RetrieveSingleRegistration object.
+    def retrieveSingleRegistration(event_id, registration_id)
+      retrieve_single_registration = 
+          RegonlineConnector::Client::RetrieveSingleRegistration.new(event_id,
+                                                                     registration_id,
+                                                                     @username,
+                                                                     @password)
+    end
+    
+    # Provides interface to RegOnline method, returning RegOnline object.
+    def regOnline(report_id, event_id, start_date, end_date, add_date)
+      report_service = 
+          RegonlineConnector::Client::RegOnline.new(@account_id, @username, @password,
+                                                    report_id, event_id, start_date,
+                                                    end_date, add_date)
+    end
+    
+    # Provides interface to RegistrationUpdateService method, returning 
+    # RegistrationUpdateService object.
+    def registrationUpdateService
+      registration_update_service =
+          RegonlineConnector::Client::RegistrationUpdateService.new(@username, @password)
+    end
+    
+    private
+    
+    # Takes base64 encoded string of zipped info and returns decoded
+    # and unzipped response.
+    def self.zip_to_xml(response)
+        response_decoded = Base64.decode64(response)
+        
+        tmp_dir = Dir::tmpdir
+        zip_tmp = tmp_dir + '/' + MD5.md5(rand(1234567).to_s).to_s
+        
+        File.open(zip_tmp, 'wb') do |f|
+          f.puts response_decoded
+        end
+        
+        xml_response = '<?xml version="1.0" encoding="utf-8"?>'
+        xml_response << '<string xmlns="http://www.regonline.com/webservices/">'
+        Zip::ZipInputStream::open(zip_tmp) do |io|
+          io.get_next_entry
+          ic = Iconv.new("UTF-8", "UTF-16")
+          xml_response << ic.iconv(io.read)
+        end
+        xml_response << '</string>'
+        
+        File.delete(zip_tmp)
+         
+        xml_response
+    end
+  end 
+end

data/lib/regonlineconnector/client/geteventfields.rb

@@ -0,0 +1,32 @@
+require 'soap/wsdlDriver' 
+
+class RegonlineConnector
+
+  class Client  
+
+    # This class provides RegOnline's 
+    # getEventFields.asmx[http://www.regonline.com/webservices/geteventFields.asmx]
+    # service.
+    class GetEventFields
+
+      def initialize(event_id, username, password, exclude_amounts)
+        @event_id = event_id
+        @username = username
+        @password = password
+        @exclude_amounts = exclude_amounts
+        @wsdl = 'http://www.regonline.com/webservices/getEventFields.asmx?WSDL'
+        @field_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+      
+      # Provides access to the RetrieveEventFields2 SOAP operation.
+      def RetrieveEventFields2
+          response = @field_getter.RetrieveEventFields2(
+                                                {"login"    => @username,
+                                                 "password" => @password,
+                                                 "eventID"  => @event_id,
+                                                 "excludeAmounts" => @exclude_amounts})
+          response.retrieveEventFields2Result
+      end
+    end
+  end
+end

data/lib/regonlineconnector/client/geteventregistrations.rb

@@ -0,0 +1,30 @@
+require 'soap/wsdlDriver' 
+
+class RegonlineConnector
+  
+  class Client
+  
+    # This class provides RegOnline's 
+    # getEventRegistrations.asmx[http://www.regonline.com/webservices/geteventregistrations.asmx]
+    # service.
+    class GetEventRegistrations
+
+      def initialize(event_id, username, password )
+        @event_id = event_id
+        @username = username
+        @password = password
+        @wsdl = 'http://www.regonline.com/webservices/getEventRegistrations.asmx?WSDL'
+        @registrant_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+      
+      # Provides access to the RetrieveRegistrationInfo SOAP operation.
+      def RetrieveRegistrationInfo
+        response = @registrant_getter.RetrieveRegistrationInfo(
+                                              {"login"    => @username,
+                                               "password" => @password,
+                                               "eventID"  => @event_id})
+        response.retrieveRegistrationInfoResult
+      end                                      
+    end
+  end
+end

data/lib/regonlineconnector/client/getevents.rb

@@ -0,0 +1,62 @@
+require 'soap/wsdlDriver' 
+
+class RegonlineConnector
+  
+  # The Client class handles communication with RegOnline.
+  class Client
+  
+    # This class provides RegOnline's 
+    # getEvents.asmx[https://www.regonline.com/webservices/getEvents.asmx]
+    # service.
+    class GetEvents
+      def initialize( account_id, username, password )
+        @account_id         = account_id
+        @username           = username
+        @password           = password
+        @wsdl = 'http://www.regonline.com/webservices/getEvents.asmx?WSDL'
+        @event_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+
+      # Test whether valid authentication credentials have been provided (by
+      # attempting to get a list of events).
+      def Authenticate
+        response = @event_getter.ByAccountID({"AccountID" => @account_id,
+                                               "Username"  => @username,
+                                               "Password"  => @password})
+        if response.byAccountIDResult == 'The credentials you supplied are not valid.'
+          return false
+        else
+          return true
+        end
+      end
+      
+      # Provides access to the ByAccountID SOAP operation.
+      def ByAccountID
+        response = @event_getter.ByAccountID({"AccountID" => @account_id,
+                                               "Username"  => @username,
+                                               "Password"  => @password})
+        response.byAccountIDResult
+      end
+      
+      # Provides access to the ByAccountIDEventID SOAP operation.
+      def ByAccountIDEventID(event_id)
+        response = @event_getter.ByAccountIDEventID({"AccountID" => @account_id,
+                                                      "Username"  => @username,
+                                                      "Password"  => @password,
+                                                      "EventId"   => event_id})                                                    
+        response.byAccountIDEventIDResult
+      end
+      
+      # Provides access to the ByAccountIDWithFilters SOAP operation.
+      def ByAccountIDWithFilters(filter_xml, filter_operator, filter_like_matching)
+        response = @event_getter.ByAccountIDWithFilters({"AccountID"      => @account_id,
+                                                         "Username"       => @username,
+                                                         "Password"       => @password,
+                                                         "xmlFilterData"  => filter_xml,
+                                                         "FilterOperator" => filter_operator,
+                                                         "LikeMatching"   => filter_like_matching})                                                    
+        response.byAccountIDWithFiltersResult
+      end                                   
+    end
+  end
+end  

data/lib/regonlineconnector/client/registrationupdateservice.rb

@@ -0,0 +1,91 @@
+require 'soap/wsdlDriver'
+
+class RegonlineConnector
+  
+  # The Client class handles communication with RegOnline.
+  class Client
+  
+    # This class provides RegOnline's 
+    # RegistrationUpdateService.asmx[https://www.regonline.com/webservices/RegistrationUpdateService.asmx]
+    # service.
+    class RegistrationUpdateService
+      def initialize( username, password )
+        @username           = username
+        @password           = password
+      end
+      
+      # Provides access to the UpdateRegistrations SOAP operation.
+      def UpdateRegistrations(request_xml)
+        request = SOAP::StreamHandler::ConnectionData.new(request_xml)
+        stream = SOAP::HTTPStreamHandler.new(SOAP::Property.new)
+        resp_data = stream.send('http://www.regonline.com/webservices/RegistrationUpdateService.asmx',
+                                request,
+                                "http://www.regonline.com/webservices/2007/08/RegistrationUpdateService/UpdateRegistrations"
+                               )
+        resp_data.receive_string
+      end
+      
+      # Takes event id and hash of update data and returns regonline-friendly xml request xml.
+      #
+      # Example update_data_hash structure:
+      # 
+      #  update_data_hash = {registration_id => {
+      #                                           "agenda_items"  => {"Field Name" => "Field Value"}
+      #                                           "custom_fields" => {"Field Name" => "Field Value"}
+      #                                           "fees"          => {"Field Name" => "Field Value"}
+      #                                         }
+      #                     }
+      # 
+      # where all three sub hashes are optional, as long as at least one exists.
+      def generate_request_xml(event_id, update_data_hash)
+        envelope = SOAP::SOAPEnvelope.new(update_registrations_request_header,
+                                          update_registrations_request(event_id, update_data_hash))
+        request_string = SOAP::Processor.marshal(envelope)
+      end
+      
+      private
+      
+      # Generates request header for updating registrations from stored username and password.
+      def update_registrations_request_header
+        header = SOAP::SOAPHeader.new
+        request_header = SOAP::SOAPElement.new('updateRegistrationsRequestHeader', '')
+        request_header.extraattr['xmlns'] = 'http://www.regonline.com/webservices/2007/08/RegistrationUpdateService'
+        request_header.add(SOAP::SOAPElement.new('login', @username))
+        request_header.add(SOAP::SOAPElement.new('password', @password))
+        header.add(nil, request_header)
+        header
+      end
+      
+      # Generates request body from passed event id and update data hash.
+      def update_registrations_request(event_id, update_data_hash)
+        body_item = SOAP::SOAPElement.new('UpdateRegistrationsRequest', nil)
+        body_item.extraattr['xmlns'] = 'http://www.regonline.com/webservices/2007/08/RegistrationUpdateService'
+        event_id_xml = SOAP::SOAPElement.new('eventID', event_id.to_s)
+        event_id_xml.extraattr['xmlns'] = 'http://www.regonline.com/webservices/2007/08/RegistrationUpdateServiceTypes'
+        body_item.add(event_id_xml)
+        registrations = SOAP::SOAPElement.new('registrations', nil)
+        registrations.extraattr['xmlns'] = 'http://www.regonline.com/webservices/2007/08/RegistrationUpdateServiceTypes'
+        
+        update_data_hash.each do |registration_id, registration_data|
+          registration = SOAP::SOAPElement.new('registration', nil)
+          registration.add(SOAP::SOAPElement.new('registrationId', registration_id.to_s))
+          
+          custom_fields = SOAP::SOAPElement.new('customFields', nil)
+          registration_data['custom_fields'].each do |field_name, field_value|
+            custom_field = SOAP::SOAPElement.new('customField', nil)
+            custom_field.add(SOAP::SOAPElement.new('fieldName', field_name))
+            custom_field.add(SOAP::SOAPElement.new('value', field_value))
+            custom_field.add(SOAP::SOAPElement.new('quantity', '1'))
+            custom_fields.add(custom_field)
+          end
+          registration.add(custom_fields)
+          registrations.add(registration)
+        end
+
+        body_item.add(registrations)
+        body = SOAP::SOAPBody.new(body_item)        
+      end
+    end
+  end
+end
+

data/lib/regonlineconnector/client/regonline.rb

@@ -0,0 +1,46 @@
+require 'soap/wsdlDriver'
+
+class RegonlineConnector
+  
+  class Client
+  
+    # This class provides RegOnline's 
+    # RegOnline.asmx[http://www.regonline.com/activereports/RegOnline.asmx]
+    # service.
+    class RegOnline
+
+      def initialize(account_id, username, password, report_id, event_id, start_date, end_date, add_date)
+        @account_id = account_id
+        @username   = username
+        @password   = password
+        @report_id  = report_id
+        @event_id   = event_id
+        @start_date = start_date
+        @end_date   = end_date
+        @add_date   = add_date
+        @wsdl       = 'http://www.regonline.com/activereports/RegOnline.asmx?WSDL'
+        @report_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+      
+      # Provides access to the getReport SOAP operation.
+      def getReport
+        response = @report_getter.getReport({"login"      => @username,
+                                             "pass"       => @password,
+                                             "customerID" => @account_id,
+                                             "reportID"   => @report_id,
+                                             "eventID"    => @event_id,
+                                             "startDate"  => @start_date,
+                                             "endDate"    => @end_date,
+                                             "bAddDate"   => @add_date})
+
+        if response.getReportResult == 'Error 4458: unable to process request.'
+          return response.getReportResult
+        else
+          return registrations = RegonlineConnector::Client::zip_to_xml(
+                                    response.getReportResult)
+        end
+        
+      end
+    end
+  end
+end

data/lib/regonlineconnector/client/retrieveallregistrations.rb

@@ -0,0 +1,32 @@
+require 'soap/wsdlDriver'
+
+class RegonlineConnector
+  
+  class Client
+  
+    # This class provides RegOnline's 
+    # RetrieveAllRegistrations.asmx[http://www.regonline.com/webservices/RetrieveAllRegistrations.asmx]
+    # service.
+    class RetrieveAllRegistrations
+
+      def initialize(event_id, username, password )
+        @event_id = event_id
+        @username = username
+        @password = password
+        @wsdl = 'http://www.regonline.com/webservices/RetrieveAllRegistrations.asmx?WSDL'
+        @registration_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+      
+      # Provides access to the RetrieveAllRegistrations SOAP operation.
+      def RetrieveAllRegistrations
+        response = @registration_getter.RetrieveAllRegistrations(
+                                              {"customerUserName" => @username,
+                                               "customerPassword" => @password,
+                                               "eventID"          => @event_id})
+                                               
+        registrations = RegonlineConnector::Client::zip_to_xml(
+            response.retrieveAllRegistrationsResult)
+      end
+    end
+  end
+end

data/lib/regonlineconnector/client/retrievesingleregistration.rb

@@ -0,0 +1,34 @@
+require 'soap/wsdlDriver'
+
+class RegonlineConnector
+  
+  class Client
+  
+    # This class provides RegOnline's 
+    # RetrieveSingleRegistration.asmx[http://www.regonline.com/webservices/RetrieveSingleRegistration.asmx]
+    # service.
+    class RetrieveSingleRegistration
+
+      def initialize(event_id, registration_id, username, password)
+        @event_id = event_id
+        @registration_id = registration_id
+        @username = username
+        @password = password
+        @wsdl = 'http://www.regonline.com/webservices/RetrieveSingleRegistration.asmx?WSDL'
+        @registration_getter = SOAP::WSDLDriverFactory.new(@wsdl).create_rpc_driver
+      end
+      
+      # Provides access to the RetrieveSingleRegistration SOAP operation.
+      def RetrieveSingleRegistration
+        response = @registration_getter.RetrieveSingleRegistration(
+                                              {"customerUserName" => @username,
+                                               "customerPassword" => @password,
+                                               "eventID"          => @event_id,
+                                               "registrationID"   => @registration_id})
+                                               
+        registration = RegonlineConnector::Client::zip_to_xml(
+            response.retrieveSingleRegistrationResult)
+      end                                      
+    end
+  end
+end

data/lib/regonlineconnector/error.rb

@@ -0,0 +1,14 @@
+class RegonlineConnector
+  
+  # Custom error class for rescuing from all RegonlineConnector errors    
+  class Error < StandardError; end
+  
+  # Raised when Regonline reports invalid credentials
+  class AuthenticationError < Error; end
+  
+  # Raised when Regonline server raises other SOAP fault error
+  class RegonlineServerError < Error; end
+  
+  # Raised when Regonline server does not respond as expected
+  class ResponseError < Error; end
+end

data/lib/regonlineconnector/parser.rb

@@ -0,0 +1,113 @@
+require 'rexml/document'
+include REXML
+
+class RegonlineConnector
+    
+  class Parser
+     def initialize
+     
+     end
+     
+     # Returns hash of event hashes from events xml.
+     def parse_events(response)
+       events = elements_to_hash(response, "//Table", "ID")
+     end
+     
+     # Returns hash of event fields from event fields xml.
+     def parse_event_fields(response)
+       event_fields = attributes_to_hash(response, "//customField", "id", "//listItem", "name")
+     end
+     
+     # Returns hash of registration hashes from registrations xml.
+     def parse_registrations(response)
+       registration = elements_to_hash(response, "//Registration", "registrationID")
+     end
+     
+     # Returns hash of registration hashes from simple registrations xml.
+     def parse_simple_registrations(response)
+       registrations = attributes_to_hash(response, "//registration", "id")
+     end
+
+     # Returns hash of registration hashes from a report from report xml.
+     def parse_report(response)
+       response_no_escape = response.to_s.gsub!(/_x0020_/,'')
+       events = elements_to_hash(response, "//Table1", "ConfirmationNumber")
+     end
+     
+     # Returns array of updated registration ids from response xml.
+     def parse_updated_registrations(response)
+       unless response
+         return nil
+       end
+       doc = REXML::Document.new response
+       updated_registrations = []
+       #if element = doc.elements.to_a("//updateRegistrationsResult")
+       #  updated_registrations_string = element.text if element = doc.elements.to_a("//updateRegistrationsResult")
+       #end
+       updated_registrations_string = XPath.first( doc, "//updateRegistrationsResult").text
+       if updated_registrations_string
+         updated_registrations_string_array = updated_registrations_string.split(',')
+         updated_registrations_string_array.each {|registration_id| updated_registrations << registration_id.to_i}
+       end
+       updated_registrations
+     end
+     
+     private
+     
+     # Returns hash from xml elements
+     def elements_to_hash(xml_response, xpath, hash_id)
+       unless xml_response
+         return nil
+       end
+       doc = REXML::Document.new xml_response
+       entries = Hash.new
+       doc.elements.to_a(xpath).each do |xml_element|
+         entry = Hash.new
+         xml_element.elements.to_a.each do |el|
+           if el.text =~ %r{^[0-9]*$} then # Integer value
+             entry[el.name] = el.text.to_i
+           elsif el.text =~ %r{^[0-9]+\.[0-9]+$} then # Float value
+             entry[el.name] = el.text.to_f
+           else # String value
+             entry[el.name] = el.text
+           end
+         end
+         if entry[hash_id]
+           entries[entry[hash_id]] = entry
+         end
+       end
+       entries
+     end
+     
+     # Returns hash from xml attributes
+     def attributes_to_hash(xml_response, xpath, hash_id, children_xpath = nil, child_attribute = nil)
+       unless xml_response
+         return nil
+       end
+       doc = REXML::Document.new xml_response
+       entries = Hash.new
+       doc.elements.to_a(xpath).each do |xml_element|
+         entry = Hash.new
+         xml_element.attributes.each do |name, value|
+           if value =~ %r{^[0-9]*$} then # Integer value
+             entry[name] = value.to_i
+           elsif value =~ %r{^[0-9]+\.[0-9]+$} then # Float value
+             entry[name] = value.to_f
+           else # String value
+             entry[name] = value
+           end
+         end
+         if entry[hash_id]
+           entries[entry[hash_id]] = entry
+         end
+         if children_xpath and xml_element.has_elements?
+           entry['list_items'] = []
+           xml_element.elements.to_a(children_xpath).each do |child_element|
+             entry['list_items'] << child_element.attribute(child_attribute).value if child_attribute
+           end
+         end
+       end
+       entries
+     end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: roconnector
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adam Focht
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-16 00:00:00 Z
+dependencies: []
+
+description: A Ruby interface an online registration service's API version 1.
+email: fochta@dm.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/regonlineconnector/error.rb
+- lib/regonlineconnector/client.rb
+- lib/regonlineconnector/parser.rb
+- lib/regonlineconnector/client/geteventfields.rb
+- lib/regonlineconnector/client/retrieveallregistrations.rb
+- lib/regonlineconnector/client/retrievesingleregistration.rb
+- lib/regonlineconnector/client/regonline.rb
+- lib/regonlineconnector/client/registrationupdateservice.rb
+- lib/regonlineconnector/client/geteventregistrations.rb
+- lib/regonlineconnector/client/getevents.rb
+- lib/regonlineconnector.rb
+- LICENSE.txt
+homepage: https://github.com/disciplemakers/RO-Connector
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Interface to an online registration service's API version 1 (deprecated).
+test_files: []
+