real_page 2.3.0

data/lib/real_page/utils/request_fetcher.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+
+require 'real_page/utils'
+require 'real_page/utils/configuration_validator'
+
+module RealPage
+  module Utils
+    # Send a SOAP request to RealPage
+    class RequestFetcher
+      # @param generator [RequestGenerator] an instance of a RequestGenerator,
+      #   which responds to #generate(pmc_id, site_id).
+      def initialize(generator:)
+        @generator = generator
+      end
+
+      # @return [String] the XML response from RealPage
+      def fetch
+        ConfigurationValidator.new.validate!
+        Faraday.new.post(RealPage.config.web_service_url) do |request|
+          request.body = generator.body
+          request.headers = generator.headers
+        end.body
+      end
+
+      private
+
+      attr_reader :generator
+    end
+  end
+end

data/lib/real_page/utils/request_generator.rb

@@ -0,0 +1,52 @@
+require 'nokogiri'
+
+require 'real_page/utils'
+
+module RealPage
+  module Utils
+    # Generate a SOAP request for a specific action and sections
+    class RequestGenerator
+      ENVELOPE = {
+        'xmlns:soapenv' => 'http://schemas.xmlsoap.org/soap/envelope/',
+        'xmlns:tem' => 'http://tempuri.org/'
+      }.freeze
+
+      # @param soap_action [String] the action to request from RealPage.
+      # @param sections [Array<RequestSection>] the section generators that will
+      #   be used to generate the body of the XML request
+      def initialize(soap_action, sections)
+        @soap_action = soap_action
+        @sections = sections
+      end
+
+      # @return [String] the XML request for the specified action and sections
+      def body
+        Nokogiri::XML::Builder.new do |xml_builder|
+          xml_builder.Envelope(ENVELOPE) do
+            namespace = xml_builder.parent.namespace_definitions.first
+            xml_builder.parent.namespace = namespace
+            xml_builder['soapenv'].Header
+            xml_builder['soapenv'].Body do
+              xml_builder['tem'].send(soap_action.downcase) do
+                sections.each do |section|
+                  section.generate(xml_builder['tem'])
+                end
+              end
+            end
+          end
+        end.to_xml
+      end
+
+      def headers
+        {
+          'Content-Type' => 'text/xml; charset=utf-8',
+          'SOAPAction' => "http://tempuri.org/IRPXService/#{soap_action.downcase}"
+        }
+      end
+
+      private
+
+      attr_reader :soap_action, :sections
+    end
+  end
+end

data/lib/real_page/utils/snowflake_event_tracker.rb

@@ -0,0 +1,107 @@
+require 'securerandom'
+require 'event_tracker'
+require 'real_page/utils'
+
+module RealPage
+  module Utils
+    class SnowflakeEventTracker
+      IMPORT_PMS_RESIDENT_EVENT = 'import_pms_resident'
+      IMPORT_PMS_PROSPECT_EVENT = 'import_pms_prospect'
+
+      def self.track_pms_resident_event(
+          remote_lease_id: nil,
+          resident_type:,
+          request_params:,
+          move_in_date: nil,
+          lease_to: nil,
+          lease_from: nil,
+          first_name_present: false,
+          last_name_present: false,
+          email_present: false,
+          phones_count:,
+          error: nil
+        )
+        EventTracker.track_process_events(name: IMPORT_PMS_RESIDENT_EVENT) do |events|
+          events.add_imported_event(
+            EventTracker::ResourceFactory.build_pms_resident(
+              billing_import: EventTracker::BillingImportFactory.build_billing_import(
+                property_id: request_params[:billing_config].property_id,
+                billing_config_id: request_params[:billing_config].id,
+                remote_id: request_params[:site_id],
+                pms_type: 'real_page',
+                import_id: request_params[:import_id],
+                pmc_id: request_params[:pmc_id],
+                service: RealPage.config.app_name
+              ),
+              remote_lease_id: remote_lease_id,
+              import_resident_id: import_resident_id(request_params[:import_id]),
+              resident_type: resident_type,
+              api_name: 'GetLeasesByTrafficSource',
+              request_params: EventTracker::ResourceFactory::PmsResident.build_request_params(
+                start_date: request_params[:start_date],
+                end_date: request_params[:end_date],
+                prospect_id: request_params[:prospect_id],
+                pmc_id: request_params[:pmc_id],
+                remote_id: request_params[:site_id],
+                traffic_source_id: request_params[:traffic_source_id]
+              ),
+              move_in_date: move_in_date,
+              lease_to: lease_to,
+              lease_from: lease_from,
+              first_name_present: first_name_present,
+              last_name_present: last_name_present,
+              email_present: email_present,
+              phones_count: phones_count,
+              error: error
+            )
+          )
+        end
+      end
+
+      def self.track_pms_prospect_event(
+          remote_lease_id: nil,
+          resident_type:,
+          request_params:,
+          contact_date: nil,
+          contact_source: nil,
+          remote_prospect_id: nil,
+          error: nil
+        )
+        EventTracker.track_process_events(name: IMPORT_PMS_PROSPECT_EVENT) do |events|
+          events.add_imported_event(
+            EventTracker::ResourceFactory.build_pms_prospect(
+              billing_import: EventTracker::BillingImportFactory.build_billing_import(
+                property_id: request_params[:billing_config].property_id,
+                billing_config_id: request_params[:billing_config].id,
+                remote_id: request_params[:site_id],
+                pms_type: 'real_page',
+                import_id: request_params[:import_id],
+                pmc_id: request_params[:pmc_id],
+                service: RealPage.config.app_name
+              ),
+              remote_lease_id: remote_lease_id,
+              import_resident_id: import_resident_id(request_params[:import_id]),
+              resident_type: resident_type,
+              api_name: 'ProspectSearch',
+              request_params: EventTracker::ResourceFactory::PmsProspect.build_request_params(
+                pmc_id: request_params[:pmc_id],
+                remote_id: request_params[:site_id],
+                prospect_id: request_params[:guest_card_id]
+              ),
+              contact_date: contact_date,
+              contact_source: contact_source,
+              remote_prospect_id: remote_prospect_id,
+              error: error
+            )
+          )
+        end
+      end
+
+      private
+
+      def self.import_resident_id(import_id)
+        "#{import_id}-#{SecureRandom.alphanumeric(15)}"
+      end
+    end
+  end
+end

data/lib/real_page/validator.rb

@@ -0,0 +1,6 @@
+module RealPage
+  module Validator
+  end
+
+  private_constant :Validator
+end

data/lib/real_page/validator/move_in_report.rb

@@ -0,0 +1,65 @@
+require 'active_support/core_ext/object'
+
+require 'real_page/validator'
+require 'real_page/utils/snowflake_event_tracker'
+
+module RealPage
+  module Validator
+    # Send parased response's move-in report data to Snowflake via event tracker
+
+    class MoveInReport
+      def initialize(response, request_params, request_name)
+        @response = response
+        @request_params = request_params
+      end
+
+      def validate!
+        return if leases.blank?
+        send_successful_response_data_to_snowflake
+      end
+
+      private
+
+      attr_reader :response, :request_params
+
+      def send_successful_response_data_to_snowflake
+        leases.each do |lease|
+          Utils::SnowflakeEventTracker.track_pms_resident_event(
+            remote_lease_id: lease['leaseid'],
+            resident_type: 'PRIMARY',
+            request_params: request_params,
+            move_in_date: DateTime.strptime(lease['moveindate'], '%m/%d/%y').to_time,
+            lease_to: DateTime.strptime(lease['leaseenddate'], '%m/%d/%y').to_time,
+            lease_from: DateTime.strptime(lease['leasebegindate'], '%m/%d/%y').to_time,
+            first_name_present: !lease['firstname'].blank?,
+            last_name_present: !lease['lastname'].blank?,
+            email_present: !lease['email'].blank?,
+            phones_count: phones_count(lease)
+          )
+        end
+      end
+
+      def leases
+        body = response['s:Envelope']['s:Body']
+        response_key = body.keys.detect { |key| key !~ /^xmlns/ }
+        contents_response = body.fetch(response_key)
+        result_key = contents_response.keys.detect { |key| key !~ /^xmlns/ }
+        contents_result = contents_response.fetch(result_key)
+        result = contents_result.values.first
+        leases_hash = result.dig('leases', 'lease')
+        return [] if leases_hash.nil?
+        return [leases_hash] unless leases_hash.is_a?(Array)
+        leases_hash
+      end
+
+      def phones_count(lease)
+        count = 0
+        phone_keys = lease.keys.select { |key| key.include?('phone') && !key.include?('phoneext') }
+        phone_keys.each do |phone_key|
+          count +=1 unless lease[phone_key].blank?
+        end
+        count
+      end
+    end
+  end
+end

data/lib/real_page/validator/prospects_data.rb

@@ -0,0 +1,93 @@
+require 'active_support/core_ext/object'
+
+require 'real_page/validator'
+require 'real_page/utils/snowflake_event_tracker'
+
+module RealPage
+  module Validator
+    # Sends parased response's roommate and prospect data to Snowflake via event tracker
+
+    class ProspectsData
+      def initialize(response, request_params, request_name)
+        @response = response
+        @request_params = request_params
+        @guest_cards = guest_cards
+      end
+
+      def validate!
+        return if guest_cards.blank?
+        send_data_to_snowflake
+      end
+
+      private
+
+      attr_reader :response, :request_params, :guest_cards
+
+      def send_data_to_snowflake
+        guest_cards.each do |guest_card|
+          prospects_of_current_guest_card = prospects(guest_card)
+          send_roommates_data_to_snowflake(prospects_of_current_guest_card)
+          send_prospects_data_to_snowflake(prospects_of_current_guest_card, guest_card)
+        end
+      end
+
+      def send_roommates_data_to_snowflake(prospects)
+        prospects.each do |prospect|
+          Utils::SnowflakeEventTracker.track_pms_resident_event(
+            resident_type: 'ROOMMATE',
+            request_params: request_params,
+            first_name_present: !prospect['FirstName'].blank?,
+            last_name_present: !prospect['LastName'].blank?,
+            email_present: !prospect['Email'].blank?,
+            phones_count: phones_count(prospect)
+          )
+        end
+      end
+
+      def send_prospects_data_to_snowflake(prospects, guest_card)
+        prospects.each do |prospect|
+          Utils::SnowflakeEventTracker.track_pms_prospect_event(
+            resident_type: 'ROOMMATE',
+            request_params: request_params,
+            contact_date: DateTime.parse(guest_card['DateContact']).to_time,
+            contact_source: guest_card['PrimaryLeadSource'],
+            remote_prospect_id: prospect['IdNumber']
+          )
+        end
+      end
+
+      def guest_cards
+        guest_cards_hash = parsed_response.dig('GuestCards', 'GuestCard')
+        return [] if guest_cards_hash.nil?
+        return [guest_cards_hash] unless guest_cards_hash.is_a?(Array)
+        guest_cards_hash
+      end
+
+      def prospects(guest_card)
+        prospects_hash = guest_card.dig('Prospects', 'Prospect')
+        return [] if prospects_hash.nil?
+        return [prospects_hash] unless prospects_hash.is_a?(Array)
+        prospects_hash
+      end
+
+      def parsed_response
+        body = response['s:Envelope']['s:Body']
+        response_key = body.keys.detect { |key| key !~ /^xmlns/ }
+        contents_response = body.fetch(response_key)
+        result_key = contents_response.keys.detect { |key| key !~ /^xmlns/ }
+        contents_result = contents_response.fetch(result_key)
+        result = contents_result.values.first
+      end
+
+      def phones_count(prospect)
+        phone_numbers_hash = prospect.dig('Numbers', 'PhoneNumber')
+        return 0 if phone_numbers_hash.blank?
+        if !phone_numbers_hash.is_a?(Array)
+          return 0 if phone_numbers_hash['Number'].blank?
+          return 1
+        end
+        phone_numbers_hash.select { |phone_number| !phone_number['Number'].blank? }.length
+      end
+    end
+  end
+end

data/lib/real_page/validator/request_errors.rb

@@ -0,0 +1,97 @@
+require 'active_support/core_ext/object'
+
+require 'real_page/utils/array_fetcher'
+require 'real_page/utils/snowflake_event_tracker'
+
+module RealPage
+  module Validator
+    # Ensure there are no errors in the wrapped contents of the body.
+    #
+    # This validator works on responses that have the following format:
+    #
+    # <s:Envelope>
+    #   <s:Body>
+    #     <actionnameResponse>
+    #       <actionnameResult>
+    #         <actionnameresponse>
+    #           <success>false</success>
+    #           <errorcount>1</errorcount>
+    #           <errors>
+    #             <error>
+    #               <severity>Critical</severity>
+    #               <errornumber>1</errornumber>
+    #               <errormessage>something went wrong</errormessage>
+    #               <internalerrormessage/>
+    #             </error>
+    #           </errors>
+    #         </actionnameresponse>
+    #       </actionnameResult>
+    #     </actionnameResponse>
+    #   </s:Body>
+    # </s:Envelope>
+    class RequestErrors
+      # Ensure the concatenated error message does not exceed Snowflake error column max
+      # character length. The error column data type is VARCHAR(16777216)
+      # 16777216 bytes / 4 bytes per character = 4194304 characters
+      MAX_ERROR_LENGTH = 4194304
+      private_constant :MAX_ERROR_LENGTH
+
+      # @param response [Hash<String, Object>] the XML response parsed into a
+      #   Hash
+      def initialize(response, request_params, request_name)
+        @response = response
+        @request_params = request_params
+      end
+
+      # @raise [RealPage::Error::RequestFault] if the response has an error
+      #   node in the contents
+      def validate!
+        return unless error?
+        send_request_error_to_snowflake
+        raise RealPage::Error::BadRequest.new(errors)
+      end
+
+      private
+
+      attr_reader :response, :request_params
+
+      def contents
+        body = response['s:Envelope']['s:Body']
+        response_key = body.keys.detect { |key| key !~ /^xmlns/ }
+        contents_response = body[response_key]
+        result_key = contents_response.keys.detect { |key| key !~ /^xmlns/ }
+        contents_result = contents_response[result_key]
+        contents_result.values.first
+      end
+
+      def error?
+        contents['success'] == 'false'
+      end
+
+      def errors
+        errors = contents['errors']
+        errors_array = Utils::ArrayFetcher.new(hash: errors, key: 'error').fetch
+        errors_array.map do |error|
+          Struct.new(:message, :severity, :internal_message).new(
+            error['errormessage'],
+            error['severity'],
+            error['internalerrormessage']
+          )
+        end
+      end
+
+      def send_request_error_to_snowflake
+        Utils::SnowflakeEventTracker.track_pms_resident_event(
+          resident_type: 'PRIMARY',
+          request_params: request_params,
+          phones_count: 0,
+          error: error_messages
+        )
+      end
+
+      def error_messages
+        errors.map(&:message).join(' ').slice(0, MAX_ERROR_LENGTH)
+      end
+    end
+  end
+end