aemo 0.1.27 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1fd45c318e16565e909a6d11a72da6269d66378
-  data.tar.gz: 6fd484904e983d654a81a3432fe2c98b2f9f4b4e
+  metadata.gz: a7cfd209892c3e31b002bd98258c0f45c86a703d
+  data.tar.gz: 89da4a8819f3e2f23bb0df135012b021d9e7104e
 SHA512:
-  metadata.gz: 2574715d16d64abc06e9cf641685f8fd72f7b70bf4e38ff405d2611bf12fb3daa8d7cff57fdd9d504ea04e181115e4ef8ecfa02ffadc0fb1415267180aceeff6
-  data.tar.gz: e355c2c6a20ceb7f310f230c4dd8304aa54d7fd993b2e2095bd896c9fceaa0f012ea17f38be41cf29e62dc2705811bf43c3cb1cf7eb1ff85f4ea4bb4990ae9fe
+  metadata.gz: ae9be88e2ce60f53d7742b4f6b93b154b043c5ccc0e43808e597fa9d6ddc2e1d44dac951662ba1d0c87f207d982b6443c68ce19e2f873517ae97b3e08b2b697c
+  data.tar.gz: c8723d45670118e9fc7b6e94de0c43cef8b66a3d5795de6a9bb29cbf164f4d9fe3d2261ae6c9557ba8b9b7f53c898c404b49d05a6efb51d6589a90a0c679a5dc

data/lib/aemo/dispatchable.rb

@@ -1,7 +1,7 @@
 module AEMO
   class Region
-    DISPATCH_TYPE   = ['Generator','Load Norm Off','Network Service Provider']
-    CATEGORY        = ['Market','Non-Market']
-    CLASSIFICATION  = ['Scheduled','Semi-Scheduled','Non-Scheduled']
+    DISPATCH_TYPE   = ['Generator', 'Load Norm Off', 'Network Service Provider'].freeze
+    CATEGORY        = ['Market', 'Non-Market'].freeze
+    CLASSIFICATION  = ['Scheduled', 'Semi-Scheduled', 'Non-Scheduled'].freeze
   end
-end
+end

data/lib/aemo/market.rb

@@ -1,42 +1,45 @@
 module AEMO
+  # AEMO::Market
+  #
+  # @author Joel Courtney
+  # @abstract
+  # @since 0.1.0
   module Market
     include HTTParty
     base_uri 'www.nemweb.com.au'
 
-    def self.current_dispatch(region)
-      response = AEMO::Market.get "/mms.GRAPHS/GRAPHS/GRAPH_5#{region}1.csv"
-      values = AEMO::Market.parse_response(response)
-      values
-    end
+    # Class Methods
+    class << self
+      def current_dispatch(region)
+        response = get "/mms.GRAPHS/GRAPHS/GRAPH_5#{region}1.csv"
+        values = parse_response(response)
+        values
+      end
 
-    def self.current_trading(region)
-      response = AEMO::Market.get "/mms.GRAPHS/GRAPHS/GRAPH_30#{region}1.csv"
-      values = AEMO::Market.parse_response(response)
-      values
-    end
+      def current_trading(region)
+        response = get "/mms.GRAPHS/GRAPHS/GRAPH_30#{region}1.csv"
+        values = parse_response(response)
+        values
+      end
 
-    # ######### #
       protected
-    # ######### #
 
-    def self.parse_response(response)
-      values = []
-      if response.response.code == '200'
-        CSV.parse(response.body, :headers => true, :converters => :numeric) do |row|
-          puts "row(#{row.class})(respond_to?:#{row.respond_to?(:to_hash)}): #{row.inspect}"
-          if row.respond_to?(:to_h)
-            row = row.to_h
-          elsif row.respond_to?(:to_hash)
-            row = row.to_hash
-          else
-            raise NoMethodError, "cannot convert #{row.class} to Hash"
+      def parse_response(response)
+        values = []
+        if response.response.code == '200'
+          CSV.parse(response.body, headers: true, converters: :numeric) do |row|
+            if row.respond_to?(:to_h)
+              row = row.to_h
+            elsif row.respond_to?(:to_hash)
+              row = row.to_hash
+            else
+              raise NoMethodError, "cannot convert #{row.class} to Hash"
+            end
+            values.push ::AEMO::Market::Interval.new(row['SETTLEMENTDATE'], row)
           end
-          values.push AEMO::Market::Interval.new(row['SETTLEMENTDATE'],row)
         end
+        values
       end
-      values
     end
-
   end
-
 end

data/lib/aemo/market/interval.rb

@@ -1,26 +1,31 @@
 module AEMO
   module Market
+    # AEMO::Market::Interval
+    #
+    # @author Joel Courtney
+    # @abstract
+    # @since 0.1.0
     class Interval
       INTERVALS = {
-        :trading => 'Trading',
-        :dispatch => 'Dispatch'
-      }
-      
+        trading: 'Trading',
+        dispatch: 'Dispatch'
+      }.freeze
+
       attr_accessor :datetime, :region, :total_demand, :rrp, :period_type
-      
-      # @param datetime [Time] 
+
+      # @param datetime [Time]
       # @param options [Hash] Hash of optional data values
       # @return [AEMO::Market::Interval]
-      def initialize(datetime,options={})
+      def initialize(datetime, options = {})
         @datetime     = Time.parse("#{datetime} +1000")
         @region       = options['REGION']
         @total_demand = options['TOTALDEMAND']
         @rrp          = options['RRP']
         @period_type  = options['PERIODTYPE']
       end
-      
+
       # Instance Variable Getters
-      
+
       # All AEMO Data operates in Australian Eastern Standard Time
       # All AEMO Data aggregates to the trailing edge of the period (this makes it difficult to do daily aggregations :( )
       # @param trailing_edge [Boolean] selection of either the trailing edge of the period or the rising edge of the period for the date time
@@ -30,35 +35,35 @@ module AEMO
         # If the datetime requested is the trailing edge, offset as per interval requirement
         unless trailing_edge
           # This is for dispatch intervals of five minutes
-          if self.is_dispatch?
+          if dispatch?
             t -= 5 * 60
-          elsif self.is_trading?
+          elsif trading?
             t -= 30 * 60
           end
         end
         t
       end
-      
-      # @return [Time] the time of the 
+
+      # @return [Time] the time of the
       def interval_length
         Time.at(300)
       end
-      
+
       # @return [Symbol] :dispatch or :trading
       def interval_type
-        self.is_dispatch? ? :dispatch : :trading
+        dispatch? ? :dispatch : :trading
       end
-      
+
       # @return [Boolean] returns true if the interval type is dispatch
-      def is_dispatch?
+      def dispatch?
         @period_type.nil? || @period_type.empty?
       end
-      
+
       # @return [Boolean] returns true if the interval type is trading
-      def is_trading?
-        !(self.is_dispatch?)
+      def trading?
+        !dispatch?
       end
-      
+
       # @return [Float] the value of the interval in Australian Dollars
       def value
         @value ||= Float::NAN
@@ -67,7 +72,6 @@ module AEMO
         end
         @value
       end
-
     end
   end
-end
+end

data/lib/aemo/msats.rb

@@ -5,14 +5,18 @@ require 'nokogiri'
 require 'digest/sha1'
 
 module AEMO
-
+  # AEMO::MSATS
+  #
+  # @author Joel Courtney
+  # @abstract
+  # @since 0.1.0
   class MSATS
     # Globally set request headers
     HEADERS = {
-      'User-Agent'    => "Ruby.AEMO.MSATS.Api",
+      'User-Agent'    => 'Ruby.AEMO.MSATS.Api',
       'Accept'        => 'text/xml',
       'Content-Type'  => 'text/xml'
-    }
+    }.freeze
 
     # We like to party
     include HTTParty
@@ -25,233 +29,237 @@ module AEMO
     # Where we like to party
     base_uri 'https://msats.prod.nemnet.net.au/msats/ws/'
 
-    def initialize(options = {})
-      @@auth = {username: nil, password: nil}
-
-      @@auth[:username]  = options[:username]        if options[:username].is_a?(String)
-      @@auth[:password]  = options[:password]        if options[:password].is_a?(String)
-      @@participant_id   = options[:participant_id]  if options[:participant_id].is_a?(String)
-    end
-
-    # Single NMI Master (C4) Report
-    # /C4/PARTICIPANT_IDENTIFIER?transactionId=XXX&nmi=XXX&checksum=X&type=XXX&reason=XXX
-    #
-    # @param [String,AEMO::NMI] nmi   the NMI to run the master report against
-    # @param [Date,String] from_date  the from date for the master report
-    # @param [Date,String] to_date  the from date for the master report
-    # @return [Hash] A hashed view of the NMI Standing Data for a given NMI
-    def self.c4(nmi, from_date,to_date,as_at_date, options = {})
-
-      nmi         = AEMO::NMI.new(nmi) if nmi.is_a?(String)
-      from_date   = Date.parse(from_date) if from_date.is_a?(String)
-      to_date     = Date.parse(to_date) if to_date.is_a?(String)
-      as_at_date  = Date.parse(as_at_date) if as_at_date.is_a?(String)
-
-      options[:participantId]   ||= nil
-      options[:roleId]          ||= nil
-      options[:inittransId]     ||= nil
-
-      query = {
-        transactionId:  transaction_id,
-        NMI:            nmi.nmi,      # Note: AEMO has case sensitivity but no consistency across requests.
-        fromDate:       from_date,
-        toDate:         to_date,
-        asatDate:       as_at_date,
-        participantId:  @@participant_id,
-        roleId:         options[:role_id],
-        inittransId:    options[:init_trans_id],
-      }
-
-      response =  self.get( "/C4/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+    # Class Methods
+    class << self
+      attr_accessor :auth
+      attr_accessor :participant_id
+
+      # Single NMI Master (C4) Report
+      # /C4/PARTICIPANT_IDENTIFIER?transactionId=XXX&nmi=XXX&checksum=X&type=XXX&reason=XXX
+      #
+      # @param [String, AEMO::NMI] nmi   the NMI to run the master report against
+      # @param [Date, String] from_date  the from date for the master report
+      # @param [Date, String] to_date  the from date for the master report
+      # @return [Hash] A hashed view of the NMI Standing Data for a given NMI
+      def c4(nmi, from_date, to_date, as_at_date, options = {})
+        nmi         = AEMO::NMI.new(nmi) if nmi.is_a?(String)
+        from_date   = Date.parse(from_date) if from_date.is_a?(String)
+        to_date     = Date.parse(to_date) if to_date.is_a?(String)
+        as_at_date  = Date.parse(as_at_date) if as_at_date.is_a?(String)
+
+        options[:participantId]   ||= nil
+        options[:roleId]          ||= nil
+        options[:inittransId]     ||= nil
+
+        query = {
+          transactionId:  transaction_id,
+          # Note: AEMO has case sensitivity but no consistency across requests.
+          NMI:            nmi.nmi,
+          fromDate:       from_date,
+          toDate:         to_date,
+          asatDate:       as_at_date,
+          participantId:  @participant_id,
+          roleId:         options[:role_id],
+          inittransId:    options[:init_trans_id]
+        }
+
+        response = get("/C4/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+        end
       end
-    end
 
-    # MSATS Limits
-    # /MSATSLimits/PARTICIPANT_IDENTIFIER?transactionId=XXX
-    #
-    # @return [Hash] The report results from the MSATS Limits web service query
-    def self.msats_limits(options={})
-      query = {
-        transactionId:  transaction_id,
-      }
-      response = self.get( "/MSATSLimits/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+      # MSATS Limits
+      # /MSATSLimits/PARTICIPANT_IDENTIFIER?transactionId=XXX
+      #
+      # @return [Hash] The report results from the MSATS Limits web service query
+      def msats_limits(options = {})
+        query = {
+          transactionId:  transaction_id
+        }
+        response = get("/MSATSLimits/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+        end
       end
-    end
-
-    # NMI Discovery - By Delivery Point Identifier
-    #
-    # @param [String] jurisdiction_code The Jurisdiction Code
-    # @param [Integer] delivery_point_identifier Delivery Point Identifier
-    # @return [Hash] The response
-    def self.nmi_discovery_by_delivery_point_identifier(jurisdiction_code,delivery_point_identifier,options={})
-      raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
-      raise ArgumentError, 'delivery_point_identifier is not valid' unless delivery_point_identifier.respond_to?("to_i")
-      raise ArgumentError, 'delivery_point_identifier is not valid' if( delivery_point_identifier.to_i < 10000000 || delivery_point_identifier.to_i > 99999999)
 
-      query = {
-        transactionId:  transaction_id,
-        jurisdictionCode: jurisdiction_code,
-        deliveryPointIdentifier: delivery_point_identifier.to_i
-      }
-
-      response =  self.get( "/NMIDiscovery/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
+      # NMI Discovery - By Delivery Point Identifier
+      #
+      # @param [String] jurisdiction_code The Jurisdiction Code
+      # @param [Integer] delivery_point_identifier Delivery Point Identifier
+      # @return [Hash] The response
+      def nmi_discovery_by_delivery_point_identifier(jurisdiction_code, delivery_point_identifier, options = {})
+        raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
+        raise ArgumentError, 'delivery_point_identifier is not valid' unless delivery_point_identifier.respond_to?('to_i')
+        raise ArgumentError, 'delivery_point_identifier is not valid' if delivery_point_identifier.to_i < 10_000_000 || delivery_point_identifier.to_i > 99_999_999
+
+        query = {
+          transactionId:  transaction_id,
+          jurisdictionCode: jurisdiction_code,
+          deliveryPointIdentifier: delivery_point_identifier.to_i
+        }
+
+        response = get("/NMIDiscovery/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
+        end
       end
-    end
-
-    # NMI Discovery - By Meter Serial Numner
-    #
-    # @param [String] jurisdiction_code The Jurisdiction Code
-    # @param [Integer] meter_serial_number The meter's serial number
-    # @return [Hash] The response
-    def self.nmi_discovery_by_meter_serial_number(jurisdiction_code,meter_serial_number,options={})
-      raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
 
-      query = {
-        transactionId:  transaction_id,
-        jurisdictionCode: jurisdiction_code,
-        meterSerialNumber: meter_serial_number.to_i
-      }
-
-      response = self.get( "/NMIDiscovery/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
+      # NMI Discovery - By Meter Serial Numner
+      #
+      # @param [String] jurisdiction_code The Jurisdiction Code
+      # @param [Integer] meter_serial_number The meter's serial number
+      # @return [Hash] The response
+      def nmi_discovery_by_meter_serial_number(jurisdiction_code, meter_serial_number, options = {})
+        raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
+
+        query = {
+          transactionId:  transaction_id,
+          jurisdictionCode: jurisdiction_code,
+          meterSerialNumber: meter_serial_number.to_i
+        }
+
+        response = get("/NMIDiscovery/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
+        end
       end
-    end
-
-    # NMI Discovery - By Address
-    #
-    # @param [String] jurisdiction_code The Jurisdiction Code
-    # @param [Integer] meter_serial_number The meter's serial number
-    # @return [Hash] The response
-    def self.nmi_discovery_by_address(jurisdiction_code,options = {})
-      raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
-
-      options[:building_or_property_name] ||= nil
-      options[:location_descriptor] ||= nil
-      options[:lot_number] ||= nil
-      options[:flat_or_unit_number] ||= nil
-      options[:flat_or_unit_type] ||= nil
-      options[:floor_or_level_number] ||= nil
-      options[:floor_or_level_type] ||= nil
-      options[:house_number] ||= nil
-      options[:house_number_suffix] ||= nil
-      options[:street_name] ||= nil
-      options[:street_suffix] ||= nil
-      options[:street_type] ||= nil
-      options[:suburb_or_place_or_locality] ||= nil
-      options[:postcode] ||= nil
-      options[:state_or_territory] ||= jurisdiction_code
 
-      query = {
-        transactionId:  transaction_id,
-        jurisdictionCode: jurisdiction_code,
-        buildingOrPropertyName: options[:building_or_property_name],
-        locationDescriptor: options[:location_descriptor],
-        lotNumber: options[:lot_number],
-        flatOrUnitNumber: options[:flat_or_unit_number],
-        flatOrUnitType: options[:flat_or_unit_type],
-        floorOrLevelNumber: options[:floor_or_level_number],
-        floorOrLevelType: options[:floor_or_level_type],
-        houseNumber: options[:house_number],
-        houseNumberSuffix: options[:house_number_suffix],
-        streetName: options[:street_name],
-        streetSuffix: options[:street_suffix],
-        streetType: options[:street_type],
-        suburbOrPlaceOrLocality: options[:suburb_or_place_or_locality],
-        postcode: options[:postcode],
-        stateOrTerritory: options[:state_or_territory]
-      }
-
-      response = self.get( "/NMIDiscovery/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        myresponse = response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
-        myresponse.is_a?(Hash)? [ myresponse ] : myresponse
+      # NMI Discovery - By Address
+      #
+      # @param [String] jurisdiction_code The Jurisdiction Code
+      # @param [Integer] meter_serial_number The meter's serial number
+      # @return [Hash] The response
+      def nmi_discovery_by_address(jurisdiction_code, options = {})
+        raise ArgumentError, 'jurisdiction_code is not valid' unless %w(ACT NEM NSW QLD SA VIC TAS).include?(jurisdiction_code)
+
+        options[:building_or_property_name] ||= nil
+        options[:location_descriptor] ||= nil
+        options[:lot_number] ||= nil
+        options[:flat_or_unit_number] ||= nil
+        options[:flat_or_unit_type] ||= nil
+        options[:floor_or_level_number] ||= nil
+        options[:floor_or_level_type] ||= nil
+        options[:house_number] ||= nil
+        options[:house_number_suffix] ||= nil
+        options[:street_name] ||= nil
+        options[:street_suffix] ||= nil
+        options[:street_type] ||= nil
+        options[:suburb_or_place_or_locality] ||= nil
+        options[:postcode] ||= nil
+        options[:state_or_territory] ||= jurisdiction_code
+
+        query = {
+          transactionId:  transaction_id,
+          jurisdictionCode: jurisdiction_code,
+          buildingOrPropertyName: options[:building_or_property_name],
+          locationDescriptor: options[:location_descriptor],
+          lotNumber: options[:lot_number],
+          flatOrUnitNumber: options[:flat_or_unit_number],
+          flatOrUnitType: options[:flat_or_unit_type],
+          floorOrLevelNumber: options[:floor_or_level_number],
+          floorOrLevelType: options[:floor_or_level_type],
+          houseNumber: options[:house_number],
+          houseNumberSuffix: options[:house_number_suffix],
+          streetName: options[:street_name],
+          streetSuffix: options[:street_suffix],
+          streetType: options[:street_type],
+          suburbOrPlaceOrLocality: options[:suburb_or_place_or_locality],
+          postcode: options[:postcode],
+          stateOrTerritory: options[:state_or_territory]
+        }
+
+        response = get("/NMIDiscovery/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          myresponse = response.parsed_response['aseXML']['Transactions']['Transaction']['NMIDiscoveryResponse']['NMIStandingData']
+          myresponse.is_a?(Hash) ? [myresponse] : myresponse
+        end
       end
-    end
 
-    # NMI Detail
-    # /NMIDetail/PARTICIPANT_IDENTIFIER?transactionId=XXX&nmi=XXX&checksum=X&type=XXX&reason=XXX
-    #
-    # @return [Hash] A hashed view of the NMI Standing Data for a given NMI
-    def self.nmi_detail(nmi, options = {})
-      if nmi.is_a?(String)
-        nmi = AEMO::NMI.new(nmi)
+      # NMI Detail
+      # /NMIDetail/PARTICIPANT_IDENTIFIER?transactionId=XXX&nmi=XXX&checksum=X&type=XXX&reason=XXX
+      #
+      # @return [Hash] A hashed view of the NMI Standing Data for a given NMI
+      def nmi_detail(nmi, options = {})
+        nmi = AEMO::NMI.new(nmi) if nmi.is_a?(String)
+
+        options[:type]    ||= nil
+        options[:reason]  ||= nil
+
+        query = {
+          transactionId: transaction_id,
+          nmi: nmi.nmi,
+          checksum: nmi.checksum,
+          type: options[:type],
+          reason: options[:reason]
+        }
+
+        response = get("/NMIDetail/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['NMIStandingDataResponse']['NMIStandingData']
+        end
       end
-      options[:type]    ||= nil
-      options[:reason]  ||= nil
-
-      query = {
-        transactionId: transaction_id,
-        nmi: nmi.nmi,
-        checksum: nmi.checksum,
-        type: options[:type],
-        reason: options[:reason]
-      }
 
-      response = self.get( "/NMIDetail/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['NMIStandingDataResponse']['NMIStandingData']
+      # Participant System Status
+      # /ParticipantSystemStatus/PARTICIPANT_IDENTIFIER?transactionId=XXX
+      #
+      # @return [Hash] The report results from the Participant System Status web service query
+      def system_status(options = {})
+        query = {
+          transactionId:  transaction_id
+        }
+        response = get("/ParticipantSystemStatus/#{@participant_id}", basic_auth: @auth, headers: HEADERS, query: query, verify: (options[:verify_ssl] != false))
+        if response.response.code != '200'
+          response
+        else
+          response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+        end
       end
-    end
 
-    # Participant System Status
-    # /ParticipantSystemStatus/PARTICIPANT_IDENTIFIER?transactionId=XXX
-    #
-    # @return [Hash] The report results from the Participant System Status web service query
-    def self.system_status(options={})
-      query = {
-        transactionId:  transaction_id,
-      }
-      response = self.get( "/ParticipantSystemStatus/#{@@participant_id}", basic_auth: @@auth, headers: { 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'}, query: query, verify: (options[:verify_ssl] != false) )
-      if response.response.code != '200'
-        response
-      else
-        response.parsed_response['aseXML']['Transactions']['Transaction']['ReportResponse']['ReportResults']
+      # Sets the authentication credentials in a class variable.
+      #
+      # @param [String] email cl.ly email
+      # @param [String] password cl.ly password
+      # @return [Hash] authentication credentials
+      def authorize(participant_id, username, password)
+        @participant_id  = participant_id
+        @auth            = { username: username, password: password }
       end
-    end
 
+      # Check if credentials are available to use
+      #
+      # @return [Boolean] true/false if credentials are available
+      def can_authenticate?
+        !(@participant_id.nil? || @auth[:username].nil? || @auth[:password].nil?)
+      end
 
-    # Sets the authentication credentials in a class variable.
-    #
-    # @param [String] email cl.ly email
-    # @param [String] password cl.ly password
-    # @return [Hash] authentication credentials
-    def self.authorize(participant_id,username,password)
-      @@participant_id  = participant_id
-      @@auth            = {username: username, password: password}
+      # Method for creating a unique transaction id
+      #
+      # @return [String] the transaction id
+      def transaction_id
+        Digest::SHA1.hexdigest(Time.now.to_s)[0..35]
+      end
     end
 
-    # Check if credentials are available to use
-    #
-    # @return [Boolean] true/false if credentials are available
-    def self.can_authenticate?
-      !(@@participant_id.nil? || @@auth[:username].nil? || @@auth[:password].nil?)
-    end
+    # Instance Methods
+    def initialize(options = {})
+      @auth = { username: nil, password: nil }
 
-    # Method for creating a unique transaction id
-    #
-    # @return [String] the transaction id
-    def self.transaction_id
-      Digest::SHA1.hexdigest(Time.now.to_s)[0..35]
+      @auth[:username]  = options[:username]        if options[:username].is_a?(String)
+      @auth[:password]  = options[:password]        if options[:password].is_a?(String)
+      @participant_id   = options[:participant_id]  if options[:participant_id].is_a?(String)
     end
-
   end
 end