RubyGems - hln_ice - Versions diffs - 0.3.0 → 0.5.0 - Mend

hln_ice 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

checksums.yaml +4 -4
data/.rubocop.yml +15 -0
data/.rubocop_todo.yml +43 -0
data/CHANGELOG.md +11 -0
data/README.md +43 -2
data/hln_ice.gemspec +43 -0
data/lib/hln_ice/client.rb +15 -355
data/lib/hln_ice/evaluations_parser.rb +59 -0
data/lib/hln_ice/request_builder.rb +146 -0
data/lib/hln_ice/response_parser.rb +157 -0
data/lib/hln_ice/series_parser.rb +106 -0
data/lib/hln_ice/simplified_status.rb +66 -0
data/lib/hln_ice/support.rb +72 -0
data/lib/hln_ice/version.rb +1 -1
data/lib/hln_ice.rb +6 -0
metadata +11 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad2a04435e36bc2e843e01c674c067f8d552f7b528e95e5540b19cbb11a06ff4
-  data.tar.gz: c5a5769cbf8c2d41e7074812a1ff83e0caf489a9a31d3bf4f2486a2160674118
+  metadata.gz: 963f6531ca9e78e0f66d8ede2c7b7e34cc57676726ff7fe8069ceeec03a5b304
+  data.tar.gz: b164c7a89a955be98cca09d1f4d685166702549bcfec82e1c8e0e6502c359206
 SHA512:
-  metadata.gz: 0ea75c7a3a922fb8fb76388f3d5d3ae568f324afe744861cc79b74c2eb0d83fbcdbed60ff2839391dd0823ba36cb197101494c147cd690036013ad46ea9ffc54
-  data.tar.gz: e66a9cd04e3b62d2e47731311dbc1ddc1f57f5a52259f81cc5d3a334fd8f82826ac53ba6e75c3f76630b92b8d54761ae5236127162b2893ec177c7c1469c9f00
+  metadata.gz: 87e3e121398de525f6649c3852694f6a64dbc7a6e49c5cc16e3f88ec7e060686b29b68b8e1bd8083fa05cb35874be8412531dd06411b5620522ca3b40b5aafff
+  data.tar.gz: c9b81008070ad31a93db22e27805db8d355e8f066fb7a45d25e5d778f75385cbe54f78dd6c2baed8f0623ad35a91a8c95dc8c52ddd838e38b69071c6a99c691b

data/.rubocop.yml CHANGED Viewed

@@ -1,5 +1,8 @@
+inherit_from: .rubocop_todo.yml
 AllCops:
   TargetRubyVersion: 3.1
+  SuggestExtensions: false
 Style/StringLiterals:
   Enabled: true
@@ -11,3 +14,15 @@ Style/StringLiteralsInInterpolation:
 Layout/LineLength:
   Max: 120
+# Methods after `private` are indented one level, Rails style.
+Layout/IndentationConsistency:
+  EnforcedStyle: indented_internal_methods
+# With indented private methods, `private` is followed directly by them.
+Layout/EmptyLinesAroundAccessModifier:
+  Enabled: false
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"

data/.rubocop_todo.yml ADDED Viewed

@@ -0,0 +1,43 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config --no-auto-gen-timestamp`
+# using RuboCop version 1.91.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+# Offense count: 5
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 70
+# Offense count: 2
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+# AllowedMethods: refine
+Metrics/BlockLength:
+  Max: 50
+# Offense count: 1
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 113
+# Offense count: 3
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/CyclomaticComplexity:
+  Max: 15
+# Offense count: 8
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 72
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
+Metrics/ParameterLists:
+  Max: 6
+# Offense count: 2
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 15

data/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,16 @@
 ## [Unreleased]
+## [0.5.0] - 2026-10-13
+- **Fix recommendations getting the wrong status when the ICE server outputs series information** (`ICE_OUTPUTSERIESINFORMATION`). The parser took the first coded observation anywhere in a proposal, which could be the selected series instead of the status. When it was, the recommendation's `status` was a series code (e.g. `HEP_B_ADULT_3_DOSE_SERIES`) and its `reasons` were empty, so `simplified_status` reported that vaccine group as `"overdue"` whatever ICE recommended. ICE orders these blocks differently from one request to the next, so which vaccine groups were affected varied. Upgrade before turning series output on.
+- Read every value from the observation it belongs to, by its `observationFocus` code system and code, instead of by position or with descendant searches. This applies to recommendation status and reasons, schedule authorities, dose evaluation status, and the patient and proposal elements. Responses from servers without series output parse exactly as before.
+- Expose the series ICE selected for each recommendation under `series` (`code`, `name`, and `selection`: `"unambiguous"`, `"best_guess"`, or `"alternative"`), its `season` for seasonal vaccines (`code`, `name`, `starts_on`, and `ends_on`), and `doses_remaining` when the server has `ICE_OUTPUTNUMBEROFDOSESREMAINING` enabled. `doses_remaining` is an Integer for a plain count and ICE's text otherwise (e.g. `"Recurring"`). Each evaluation gets the `series` the dose was evaluated against. All new keys are left out when ICE does not send them.
+- Season `starts_on` and `ends_on` are ISO dates read from the trailing `(MM/DD/YYYY - MM/DD/YYYY)` of ICE's season display name, because ICE sends no structured season dates. Both are `nil` if the name does not end in a valid range, e.g. if ICE changes that format. They are passed through as ICE sends them: an `ends_on` of `2100-01-01` is ICE's open-ended end date, and for influenza ICE may return a default season code and label (e.g. `20152016_INFLUENZA_SEASON`) with the current season's dates. Rely on the dates, not the code.
+## [0.4.0] - 2026-10-06
+- Expose ICE's per-dose evaluations under `evaluations` in the result, with one entry per administered dose and vaccine group it counts toward (so a combination vaccine has several). Each entry has the caller's event id, CVX, administration date, vaccine group, dose number, validity, evaluation status, and reasons. Codes are passed through as ICE returns them. `recommendations` and `simplified_status` are unchanged.
 ## [0.3.0] - 2026-09-24
 - Expose schedule authorities (e.g. `ACIP_CDC`, `AAP`, `AAFP`) on each recommendation under `schedule_authorities` when the ICE server has `outputScheduleAuthorities` enabled. The key is omitted when the server does not return them.

data/README.md CHANGED Viewed

@@ -6,7 +6,8 @@ Given a patient's demographics and immunization history, `HlnIce` builds the
 VMR (Virtual Medical Record) request, calls the ICE evaluation endpoint, and
 parses the response into:
-- a full list of **recommendations** (one per vaccine group, with status, reasons, and administration intervals), and
+- a full list of **recommendations** (one per vaccine group, with status, reasons, administration intervals, and, when the ICE server outputs them, schedule authorities, series, season, and doses remaining),
+- the **evaluations** of each administered dose (per vaccine group, with dose number, validity, and reasons), and
 - a **simplified status** map keyed by vaccine group — e.g. `{ ipv_opv: "overdue", mmr: "compliant" }`.
 The gem has no Rails or ActiveSupport dependency; it takes an injected logger
@@ -79,6 +80,7 @@ patient_data = {
       clinicalStatements: {
         substanceAdministrationEvents: [
           {
+            id: "1", # echoed back as event_id on evaluations; a UUID is generated if omitted
             substance: {
               substanceCode: { code: "10", displayName: "Polio" }
             },
@@ -113,7 +115,42 @@ On success:
         schedule_authorities: [
           { code: "ACIP_CDC", name: "Advisory Committee on Immunization Practices / Centers for Disease Control and Prevention" },
           { code: "AAP", name: "American Academy of Pediatrics" }
-        ]
+        ],
+        # Only present when the ICE server has ICE_OUTPUTSERIESINFORMATION enabled.
+        # selection is "unambiguous", "best_guess", or "alternative".
+        series: { code: "...", name: "...", selection: "best_guess" }, # e.g. HEP_B_ADULT_3_DOSE_SERIES
+        # Only present for seasonal vaccines (e.g. influenza, COVID-19) with series output on
+        # starts_on/ends_on are read from the end of ICE's season name, e.g.
+        # "2026-2027 COVID-19 Season (08/28/2026 - 01/01/2100)", because ICE sends
+        # no structured season dates. They are nil if the name is not in that format.
+        # ICE uses an end of 2100-01-01 for an open-ended season. For influenza, ICE
+        # may send a default code and label (e.g. 20152016_INFLUENZA_SEASON) with the
+        # current season's dates; the dates are the ones to rely on.
+        season: {
+          code: "COVID_19_AUG_2026_SEASON",
+          name: "2026-2027 COVID-19 Season (08/28/2026 - 01/01/2100)",
+          starts_on: "2026-08-28",
+          ends_on: "2100-01-01"
+        },
+        # Only present when ICE_OUTPUTNUMBEROFDOSESREMAINING is also enabled. An Integer
+        # for a plain count, otherwise ICE's text, e.g. "Recurring".
+        doses_remaining: 3
+      }
+    ],
+    # One entry per administered dose and vaccine group it counts toward, so a
+    # combination vaccine has several. Codes are passed through from ICE.
+    evaluations: [
+      {
+        event_id: "1",
+        cvx: "10",
+        administered_on: "2020-03-01",
+        vaccine_group: { code: "400", name: "Polio Vaccine Group" },
+        dose_number: 1, # nil if ICE omits it
+        valid: true,
+        status: { code: "VALID", name: "Valid Dose" }, # e.g. VALID, INVALID, ACCEPTED
+        reasons: [], # e.g. [{ code: "BELOW_MINIMUM_INTERVAL", name: "Below Minimum Interval" }]
+        # The series the dose was evaluated against. Only present with series output on.
+        series: { code: "...", name: "...", selection: "unambiguous" } # e.g. MMR_2_DOSE_SERIES
       }
     ],
     simplified_status: { ipv_opv: "overdue" }
@@ -129,6 +166,10 @@ On failure (service error, timeout after retries, or unparseable response):
 Always branch on `result[:success]` before reading `result[:data]`.
+Optional keys (`intervals`, `schedule_authorities`, `series`, `season`,
+`doses_remaining`) are left out when ICE does not send them, so reading one
+returns `nil`.
 ### Simplified status values
 `simplified_status` maps each recognized vaccine group to one of:

data/hln_ice.gemspec ADDED Viewed

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "lib/hln_ice/version"
+Gem::Specification.new do |spec|
+  spec.name = "hln_ice"
+  spec.version = HlnIce::VERSION
+  spec.authors = ["Sam Sohn"]
+  spec.email = ["sam@primary.health"]
+  spec.summary = "Ruby client for the HLN ICE (Immunization Calculation Engine) OpenCDS service."
+  spec.description = "Evaluates a patient's immunization history against the HLN ICE forecasting " \
+                     "rules and returns both the raw recommendations and a simplified status mapping."
+  spec.homepage = "https://github.com/PrimaryDotHealth/hln_ice"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "base64", "~> 0.2"
+  spec.add_dependency "httparty", "~> 0.21"
+  spec.add_dependency "nokogiri", "~> 1.15"
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/hln_ice/client.rb CHANGED Viewed

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
-require "date"
 require "json"
-require "base64"
 require "logger"
-require "securerandom"
 require "httparty"
-require "nokogiri"
 module HlnIce
   # Client for the HLN ICE (Immunization Calculation Engine) OpenCDS service.
@@ -14,28 +10,12 @@ module HlnIce
   # Evaluates a patient's immunization history against the ICE forecasting
   # rules and returns both the raw recommendations and a simplified status
   # mapping keyed by vaccine group.
+  #
+  # All logging happens here: RequestBuilder and ResponseParser never log, so
+  # this class is the only place that can write patient data to the logs.
   class Client
-    # Mapping from ICE status codes to our status keys
-    STATUS_MAPPING = {
-      "CONDITIONAL" => "conditional",
-      "FUTURE_RECOMMENDED" => "compliant",
-      "NOT_RECOMMENDED" => "compliant",
-      "RECOMMENDED" => "overdue",
-    }.freeze
-    # Mapping from ICE vaccine groups to our immunization keys
-    VACCINE_MAPPING = {
-      "DTP Vaccine Group" => :dtap_tdap,
-      "Hep A Vaccine Group" => :hep_a,
-      "Hep B Vaccine Group" => :hep_b,
-      "Hib Vaccine Group" => :hib,
-      "HPV Vaccine Group" => :hpv,
-      "Meningococcal Vaccine Group" => :mcv4,
-      "MMR Vaccine Group" => :mmr,
-      "Pneumococcal Vaccine Group" => :pcv,
-      "Polio Vaccine Group" => :ipv_opv,
-      "Varicella Vaccine Group" => :var,
-    }.freeze
+    STATUS_MAPPING = SimplifiedStatus::STATUS_MAPPING
+    VACCINE_MAPPING = SimplifiedStatus::VACCINE_MAPPING
     attr_reader :base_url, :timeout, :max_retries, :retry_delay, :logger, :log_payloads
@@ -62,7 +42,7 @@ module HlnIce
         )
         response.success?
-      rescue => e
+      rescue StandardError => e
         logger.error("ICE service unavailable: #{e.message}")
         false
       end
@@ -95,7 +75,7 @@ module HlnIce
         else
           handle_error_response(response)
         end
-      rescue => e
+      rescue StandardError => e
         retries += 1
         if retries <= max_retries
           logger.warn("Retrying ICE request (#{retries}/#{max_retries}): #{e.message}")
@@ -109,157 +89,24 @@ module HlnIce
     end
     private
-      # Plain-Ruby equivalent of ActiveSupport's `blank?`.
-      def blank?(value)
-        return true if value.nil?
-        return value.strip.empty? if value.is_a?(String)
-        return value.empty? if value.respond_to?(:empty?)
-        false
-      end
-      # Plain-Ruby equivalent of ActiveSupport's `present?`.
-      def present?(value)
-        !blank?(value)
-      end
       def build_ice_payload(patient_data)
-        # Extract patient information
-        patient_id = patient_data[:patient][:id]
-        date_of_birth = patient_data[:patient][:date_of_birth]
-        gender = patient_data[:patient][:gender]
-        gender = "U" if blank?(gender) # Set default to 'U' if blank
+        builder = RequestBuilder.new(patient_data)
         # Log input data for debugging
         logger.debug("ICE Input Data: #{JSON.pretty_generate(patient_data)}") if log_payloads
-        # Build the VMR XML
-        xml_payload = <<~XML
-          <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-          <ns4:cdsInput xmlns:ns2="org.opencds"
-                        xmlns:ns3="org.opencds.vmr.v1_0.schema.vmr"
-                        xmlns:ns4="org.opencds.vmr.v1_0.schema.cdsinput"
-                        xmlns:ns5="org.opencds.vmr.v1_0.schema.cdsoutput">
-            <templateId root="2.16.840.1.113883.3.795.11.1.1"/>
-            <cdsContext>
-              <cdsSystemUserPreferredLanguage code="en" codeSystem="2.16.840.1.113883.6.99" displayName="English"/>
-            </cdsContext>
-            <vmrInput>
-              <templateId root="2.16.840.1.113883.3.795.11.1.1"/>
-              <patient>
-                <templateId root="2.16.840.1.113883.3.795.11.2.1.1"/>
-                <id root="2.16.840.1.113883.3.795.12.100.11" extension="#{patient_id}"/>
-                <demographics>
-                  <birthTime value="#{format_date_for_ice(date_of_birth)}"/>
-                  <gender code="#{gender}" codeSystem="2.16.840.1.113883.5.1"/>
-                </demographics>
-                <clinicalStatements>
-                  <substanceAdministrationEvents>
-        XML
-        # Add immunization records if available
-        if present?(patient_data[:immunizations])
-          patient_data[:immunizations].each do |imm|
-            next unless present?(imm.dig(:clinicalStatements, :substanceAdministrationEvents))
-            imm[:clinicalStatements][:substanceAdministrationEvents].each do |event|
-              next unless present?(event.dig(:substance, :substanceCode))
-              substance_code = event[:substance][:substanceCode]
-              # Format dates to ICE format (YYYYMMDD)
-              low_date = format_date_for_ice(event[:administrationTimeInterval][:low])
-              high_date = format_date_for_ice(event[:administrationTimeInterval][:high])
-              xml_payload += <<~XML
-                    <substanceAdministrationEvent>
-                      <templateId root="2.16.840.1.113883.3.795.11.9.1.1"/>
-                      <id root="#{event[:id] || SecureRandom.uuid}"/>
-                      <substanceAdministrationGeneralPurpose code="384810002" codeSystem="2.16.840.1.113883.6.5"/>
-                      <substance>
-                        <id root="#{event[:substance][:id] || SecureRandom.uuid}"/>
-                        <substanceCode code="#{substance_code[:code]}"
-                                    codeSystem="2.16.840.1.113883.12.292"
-                                    displayName="#{substance_code[:displayName]}"
-                                    originalText="#{substance_code[:displayName]}"/>
-                      </substance>
-                      <administrationTimeInterval low="#{low_date}" high="#{high_date}"/>
-                    </substanceAdministrationEvent>
-              XML
-            end
-          end
-        end
-        # Close the XML
-        xml_payload += <<~XML
-                  </substanceAdministrationEvents>
-                </clinicalStatements>
-              </patient>
-            </vmrInput>
-          </ns4:cdsInput>
-        XML
         # Log the generated XML for debugging
-        logger.debug("Generated ICE XML: #{xml_payload}") if log_payloads
+        logger.debug("Generated ICE XML: #{builder.xml}") if log_payloads
-        # Base64 encode the XML
-        base64_encoded_payload = Base64.strict_encode64(xml_payload)
-        # Build the full payload
-        {
-          "interactionId" => {
-            "scopingEntityId" => "org.nyc.cir",
-            "interactionId" => "#{patient_id}-#{Time.now.to_i}",
-            "submissionTime" => (Time.now.to_f * 1000).to_i
-          },
-          "evaluationRequest" => {
-            "clientLanguage" => "en",
-            "clientTimeZoneOffset" => "+0000",
-            "kmEvaluationRequest" => [
-              {
-                "kmId" => {
-                  "scopingEntityId" => "org.nyc.cir",
-                  "businessId" => "ICE",
-                  "version" => "1.0.0"
-                }
-              }
-            ],
-            "dataRequirementItemData" => [
-              {
-                "driId" => {
-                  "containingEntityId" => {
-                    "scopingEntityId" => "org.nyc.cir",
-                    "businessId" => "ICEData",
-                    "version" => "1.0.0"
-                  },
-                  "itemId" => "cdsPayload"
-                },
-                "data" => {
-                  "informationModelSSId" => {
-                    "scopingEntityId" => "org.opencds.vmr",
-                    "businessId" => "VMR",
-                    "version" => "1.0"
-                  },
-                  "base64EncodedPayload" => [base64_encoded_payload]
-                }
-              }
-            ]
-          }
-        }
+        builder.payload
       end
       def parse_ice_response(response_body)
         logger.debug("ICE service response: #{response_body}") if log_payloads
-        result = JSON.parse(response_body)
-        if result.dig("finalKMEvaluationResponse", 0, "kmEvaluationResultData", 0, "data", "base64EncodedPayload", 0)
-          base64_result = result["finalKMEvaluationResponse"][0]["kmEvaluationResultData"][0]["data"]["base64EncodedPayload"][0]
-          decoded_result = Base64.decode64(base64_result)
-          # Parse the XML response
-          parsed_result = parse_xml_response(decoded_result)
+        parsed_result = ResponseParser.new(response_body).data
+        if parsed_result
           {
             success: true,
             data: parsed_result
@@ -271,210 +118,23 @@ module HlnIce
             error: "No valid response found in ICE output."
           }
         end
-      rescue => e
+      rescue StandardError => e
         logger.error("Error parsing ICE response: #{e.message}")
         { success: false, error: "Error parsing ICE response: #{e.message}" }
       end
-      def parse_xml_response(xml_string)
-        # Parse the XML
-        doc = Nokogiri::XML(xml_string)
-        # Remove namespaces to simplify parsing
-        doc.remove_namespaces!
-        # Extract patient information
-        patient = doc.xpath("//patient").first
-        return { raw_xml: xml_string } unless patient
-        patient_id = patient.xpath("./id").first["extension"] rescue nil
-        birth_time = patient.xpath("./demographics/birthTime").first["value"] rescue nil
-        gender = patient.xpath("./demographics/gender").first["code"] rescue nil
-        # Format birth date if present
-        birth_date = format_ice_date(birth_time)
-        # Extract vaccine recommendations
-        all_recommendations = []
-        doc.xpath("//substanceAdministrationProposal").each do |proposal|
-          # Get the substance code and name
-          substance_element = proposal.xpath("./substance/substanceCode").first
-          next unless substance_element
-          vaccine_code        = substance_element["code"]
-          vaccine_name        = substance_element["displayName"]
-          vaccine_code_system = substance_element["codeSystem"]
-          # Get the clinical observation result carrying the recommendation status.
-          # A proposal may contain other observation results (e.g. schedule
-          # authorities), in any order, so select the one with a status concept.
-          observation = proposal.xpath(".//observationResult[observationValue/concept]").first
-          next unless observation
-          # Get recommendation status
-          status_element = observation.xpath(".//observationValue/concept").first
-          status_code = status_element["code"]
-          status_name = status_element["displayName"]
-          # Get interpretation reasons
-          reasons = []
-          observation.xpath(".//interpretation").each do |interpretation|
-            reason = {
-              code: interpretation["code"],
-              name: interpretation["displayName"]
-            }
-            # Add supplemental text if available
-            if interpretation["originalText"]
-              reason[:supplemental_text] = interpretation["originalText"]
-            end
-            reasons << reason
-          end
-          # Get administration time intervals if available
-          proposed_interval = proposal.xpath("./proposedAdministrationTimeInterval").first
-          valid_interval = proposal.xpath("./validAdministrationTimeInterval").first
-          intervals = {}
-          if proposed_interval
-            intervals[:proposed] = {
-              low: format_ice_date(proposed_interval["low"]),
-              high: format_ice_date(proposed_interval["high"])
-            }.compact
-          end
-          if valid_interval
-            intervals[:valid] = {
-              low: format_ice_date(valid_interval["low"]),
-              high: format_ice_date(valid_interval["high"])
-            }.compact
-          end
-          # Build the recommendation object
-          recommendation = {
-            vaccine: {
-              code: vaccine_code,
-              code_system: vaccine_code_system,
-              name: vaccine_name
-            },
-            status: {
-              code: status_code,
-              name: status_name
-            },
-            reasons:
-          }
-          # Only add intervals if they exist
-          recommendation[:intervals] = intervals if present?(intervals)
-          # Only add schedule authorities if the service returned them
-          # (requires the ICE outputScheduleAuthorities property)
-          schedule_authorities = parse_schedule_authorities(proposal)
-          recommendation[:schedule_authorities] = schedule_authorities if present?(schedule_authorities)
-          all_recommendations << recommendation
-        end
-        # Create simplified immunization status mapping
-        simplified_status = {}
-        # Process all recommendations to create the simplified mapping
-        all_recommendations.each do |recommendation|
-          vaccine_name = recommendation[:vaccine][:name]
-          status_code = recommendation[:status][:code]
-          # Map the vaccine name to our key
-          vaccine_key = VACCINE_MAPPING[vaccine_name]
-          next unless vaccine_key # Skip if we don't have a mapping
-          # Map the status code to our status
-          status = STATUS_MAPPING[status_code] || "overdue" # Default to overdue if unknown
-          # Special handling for conditional status based on reasons
-          if status == "conditional"
-            # Check if any reason indicates medical exemption
-            has_medical_exemption = recommendation[:reasons].any? { |r| r[:code] == "MEDICAL_EXEMPTION" }
-            if has_medical_exemption
-              status = "medically_exempt"
-            end
-          end
-          # Store in our simplified mapping
-          simplified_status[vaccine_key] = status
-        end
-        # Build the final result structure
-        {
-          raw_xml: xml_string,
-          patient: {
-            id: patient_id,
-            birth_date: birth_date || birth_time,
-            gender:
-          }.compact,
-          recommendations: all_recommendations, # Keep the original flat list for backward compatibility
-          simplified_status: # Add the simplified mapping
-        }
-      end
-      # Extract the schedule authorities (e.g. ACIP_CDC, AAP) for a proposal.
-      # Returns an empty array when the service did not include them.
-      def parse_schedule_authorities(proposal)
-        authorities = proposal.xpath(
-          ".//observationResult[observationFocus/@code='ICE_VACCINE_GROUP_SCHEDULE_AUTHORITIES']/interpretation"
-        )
-        authorities.map do |interpretation|
-          {
-            code: interpretation["code"],
-            name: interpretation["displayName"]
-          }
-        end
-      end
       def handle_error_response(response)
         error_message = "ICE service error: #{response.code}"
         begin
           error_details = JSON.parse(response.body)
-          error_message += " - #{error_details['message'] || error_details['error'] || response.body}"
-        rescue
+          error_message += " - #{error_details["message"] || error_details["error"] || response.body}"
+        rescue StandardError
           error_message += " - #{response.body}"
         end
         logger.error(error_message)
         { success: false, error: error_message }
       end
-      # Helper method to format ICE dates to standard format
-      def format_ice_date(ice_date)
-        return nil unless ice_date
-        # ICE dates are in format: YYYYMMDDHHMMSS.000+0000
-        if ice_date.match(/^(\d{4})(\d{2})(\d{2})/)
-          year = $1
-          month = $2
-          day = $3
-          "#{year}-#{month}-#{day}"
-        else
-          ice_date
-        end
-      end
-      # Helper method to format dates for ICE (YYYYMMDD)
-      def format_date_for_ice(date_string)
-        return nil unless date_string
-        begin
-          date = Date.parse(date_string)
-          # Format as YYYYMMDD
-          date.strftime("%Y%m%d")
-        rescue
-          # If parsing fails, try to use the original string
-          date_string
-        end
-      end
   end
 end

data/lib/hln_ice/evaluations_parser.rb ADDED Viewed

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module HlnIce
+  # Extracts ICE's evaluation of each administered dose from the vMR patient
+  # element. ICE nests one substanceAdministrationEvent per vaccine group under
+  # each input event, so a combination vaccine yields one evaluation per group
+  # it counts toward.
+  class EvaluationsParser
+    include Support
+    def initialize(patient)
+      @patient = patient
+    end
+    def evaluations
+      events = patient.xpath("./clinicalStatements/substanceAdministrationEvents/substanceAdministrationEvent")
+      events.flat_map do |event|
+        event_id = event.at_xpath("./id")&.[]("root")
+        cvx = event.at_xpath("./substance/substanceCode")&.[]("code")
+        event.xpath("./relatedClinicalStatement/substanceAdministrationEvent").filter_map do |component|
+          parse_evaluation(component, event_id:, cvx:)
+        end
+      end
+    end
+    private
+      attr_reader :patient
+      # Build the evaluation for one vaccine group from a nested event.
+      # Returns nil when the event has no evaluation status observation.
+      def parse_evaluation(component, event_id:, cvx:)
+        observation = vaccine_group_observation(component)
+        status = observation&.at_xpath("./observationValue/concept")
+        return unless status
+        focus = observation.at_xpath("./observationFocus")
+        dose_number = component.at_xpath("./doseNumber")&.[]("value")
+        valid = component.at_xpath("./isValid")&.[]("value")
+        series = SeriesParser.new(component).series
+        evaluation = {
+          event_id:,
+          cvx:,
+          administered_on: format_ice_date(component.at_xpath("./administrationTimeInterval")&.[]("low")),
+          vaccine_group: { code: focus["code"], name: focus["displayName"] },
+          dose_number: dose_number&.to_i,
+          valid: valid.nil? ? nil : valid == "true",
+          status: { code: status["code"], name: status["displayName"] },
+          reasons: observation.xpath("./interpretation").map do |interpretation|
+            { code: interpretation["code"], name: interpretation["displayName"] }
+          end
+        }
+        evaluation[:series] = series if series
+        evaluation
+      end
+  end
+end

data/lib/hln_ice/request_builder.rb ADDED Viewed

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require "base64"
+require "securerandom"
+module HlnIce
+  # Builds the ICE evaluate request for a patient: the vMR XML, and the JSON
+  # payload that carries it base64 encoded.
+  #
+  # Does no logging; the Client decides what may be logged.
+  class RequestBuilder
+    include Support
+    def initialize(patient_data)
+      @patient_data = patient_data
+      # Extract patient information
+      @patient_id = patient_data[:patient][:id]
+      @date_of_birth = patient_data[:patient][:date_of_birth]
+      @gender = patient_data[:patient][:gender]
+      @gender = "U" if blank?(@gender) # Set default to 'U' if blank
+    end
+    def xml
+      @xml ||= build_xml
+    end
+    def payload
+      # Base64 encode the XML
+      base64_encoded_payload = Base64.strict_encode64(xml)
+      # Build the full payload
+      {
+        "interactionId" => {
+          "scopingEntityId" => "org.nyc.cir",
+          "interactionId" => "#{patient_id}-#{Time.now.to_i}",
+          "submissionTime" => (Time.now.to_f * 1000).to_i
+        },
+        "evaluationRequest" => {
+          "clientLanguage" => "en",
+          "clientTimeZoneOffset" => "+0000",
+          "kmEvaluationRequest" => [
+            {
+              "kmId" => {
+                "scopingEntityId" => "org.nyc.cir",
+                "businessId" => "ICE",
+                "version" => "1.0.0"
+              }
+            }
+          ],
+          "dataRequirementItemData" => [
+            {
+              "driId" => {
+                "containingEntityId" => {
+                  "scopingEntityId" => "org.nyc.cir",
+                  "businessId" => "ICEData",
+                  "version" => "1.0.0"
+                },
+                "itemId" => "cdsPayload"
+              },
+              "data" => {
+                "informationModelSSId" => {
+                  "scopingEntityId" => "org.opencds.vmr",
+                  "businessId" => "VMR",
+                  "version" => "1.0"
+                },
+                "base64EncodedPayload" => [base64_encoded_payload]
+              }
+            }
+          ]
+        }
+      }
+    end
+    private
+      attr_reader :patient_data, :patient_id, :date_of_birth, :gender
+      def build_xml
+        # Build the VMR XML
+        xml_payload = <<~XML
+          <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+          <ns4:cdsInput xmlns:ns2="org.opencds"
+                        xmlns:ns3="org.opencds.vmr.v1_0.schema.vmr"
+                        xmlns:ns4="org.opencds.vmr.v1_0.schema.cdsinput"
+                        xmlns:ns5="org.opencds.vmr.v1_0.schema.cdsoutput">
+            <templateId root="2.16.840.1.113883.3.795.11.1.1"/>
+            <cdsContext>
+              <cdsSystemUserPreferredLanguage code="en" codeSystem="2.16.840.1.113883.6.99" displayName="English"/>
+            </cdsContext>
+            <vmrInput>
+              <templateId root="2.16.840.1.113883.3.795.11.1.1"/>
+              <patient>
+                <templateId root="2.16.840.1.113883.3.795.11.2.1.1"/>
+                <id root="2.16.840.1.113883.3.795.12.100.11" extension="#{patient_id}"/>
+                <demographics>
+                  <birthTime value="#{format_date_for_ice(date_of_birth)}"/>
+                  <gender code="#{gender}" codeSystem="2.16.840.1.113883.5.1"/>
+                </demographics>
+                <clinicalStatements>
+                  <substanceAdministrationEvents>
+        XML
+        # Add immunization records if available
+        if present?(patient_data[:immunizations])
+          patient_data[:immunizations].each do |imm|
+            next unless present?(imm.dig(:clinicalStatements, :substanceAdministrationEvents))
+            imm[:clinicalStatements][:substanceAdministrationEvents].each do |event|
+              next unless present?(event.dig(:substance, :substanceCode))
+              substance_code = event[:substance][:substanceCode]
+              # Format dates to ICE format (YYYYMMDD)
+              low_date = format_date_for_ice(event[:administrationTimeInterval][:low])
+              high_date = format_date_for_ice(event[:administrationTimeInterval][:high])
+              xml_payload += <<~XML
+                <substanceAdministrationEvent>
+                  <templateId root="2.16.840.1.113883.3.795.11.9.1.1"/>
+                  <id root="#{event[:id] || SecureRandom.uuid}"/>
+                  <substanceAdministrationGeneralPurpose code="384810002" codeSystem="2.16.840.1.113883.6.5"/>
+                  <substance>
+                    <id root="#{event[:substance][:id] || SecureRandom.uuid}"/>
+                    <substanceCode code="#{substance_code[:code]}"
+                                codeSystem="2.16.840.1.113883.12.292"
+                                displayName="#{substance_code[:displayName]}"
+                                originalText="#{substance_code[:displayName]}"/>
+                  </substance>
+                  <administrationTimeInterval low="#{low_date}" high="#{high_date}"/>
+                </substanceAdministrationEvent>
+              XML
+            end
+          end
+        end
+        # Close the XML
+        xml_payload + <<~XML
+                  </substanceAdministrationEvents>
+                </clinicalStatements>
+              </patient>
+            </vmrInput>
+          </ns4:cdsInput>
+        XML
+      end
+  end
+end

data/lib/hln_ice/response_parser.rb ADDED Viewed

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require "base64"
+require "json"
+require "nokogiri"
+module HlnIce
+  # Parses the body of an ICE evaluate response into the result data:
+  # patient, recommendations, evaluations, and simplified status.
+  #
+  # Does no logging; the Client decides what may be logged.
+  class ResponseParser
+    include Support
+    def initialize(response_body)
+      @response_body = response_body
+    end
+    # Returns nil when the response carries no vMR payload. Raises if the
+    # body cannot be parsed.
+    def data
+      result = JSON.parse(response_body)
+      base64_result = result.dig("finalKMEvaluationResponse", 0, "kmEvaluationResultData", 0, "data",
+                                 "base64EncodedPayload", 0)
+      return unless base64_result
+      # Parse the XML response
+      parse_xml_response(Base64.decode64(base64_result))
+    end
+    private
+      attr_reader :response_body
+      def parse_xml_response(xml_string)
+        doc = Nokogiri::XML(xml_string)
+        # Remove namespaces to simplify parsing
+        doc.remove_namespaces!
+        patient = doc.at_xpath("/cdsOutput/vmrOutput/patient")
+        return { raw_xml: xml_string } unless patient
+        recommendations = parse_recommendations(patient)
+        {
+          raw_xml: xml_string,
+          patient: parse_patient(patient),
+          recommendations:,
+          evaluations: EvaluationsParser.new(patient).evaluations,
+          simplified_status: SimplifiedStatus.new(recommendations).to_h
+        }
+      end
+      def parse_patient(patient)
+        birth_time = patient.at_xpath("./demographics/birthTime")&.[]("value")
+        {
+          id: patient.at_xpath("./id")&.[]("extension"),
+          birth_date: format_ice_date(birth_time) || birth_time,
+          gender: patient.at_xpath("./demographics/gender")&.[]("code")
+        }.compact
+      end
+      def parse_recommendations(patient)
+        proposals = patient.xpath(
+          "./clinicalStatements/substanceAdministrationProposals/substanceAdministrationProposal"
+        )
+        proposals.filter_map { |proposal| parse_recommendation(proposal) }
+      end
+      # Returns nil when the proposal has no vaccine group status observation.
+      def parse_recommendation(proposal)
+        substance = proposal.at_xpath("./substance/substanceCode")
+        observation = vaccine_group_observation(proposal)
+        status = observation&.at_xpath("./observationValue/concept")
+        return unless substance && status
+        recommendation = {
+          vaccine: {
+            code: substance["code"],
+            code_system: substance["codeSystem"],
+            name: substance["displayName"]
+          },
+          status: {
+            code: status["code"],
+            name: status["displayName"]
+          },
+          reasons: parse_reasons(observation)
+        }
+        intervals = parse_intervals(proposal)
+        recommendation[:intervals] = intervals if present?(intervals)
+        # Only add schedule authorities if the service returned them
+        # (requires the ICE outputScheduleAuthorities property)
+        schedule_authorities = parse_schedule_authorities(proposal)
+        recommendation[:schedule_authorities] = schedule_authorities if present?(schedule_authorities)
+        recommendation.merge(parse_series(proposal))
+      end
+      def parse_reasons(observation)
+        observation.xpath("./interpretation").map do |interpretation|
+          reason = {
+            code: interpretation["code"],
+            name: interpretation["displayName"]
+          }
+          reason[:supplemental_text] = interpretation["originalText"] if interpretation["originalText"]
+          reason
+        end
+      end
+      def parse_intervals(proposal)
+        {
+          proposed: parse_interval(proposal.at_xpath("./proposedAdministrationTimeInterval")),
+          valid: parse_interval(proposal.at_xpath("./validAdministrationTimeInterval"))
+        }.compact
+      end
+      def parse_interval(interval)
+        return unless interval
+        {
+          low: format_ice_date(interval["low"]),
+          high: format_ice_date(interval["high"])
+        }.compact
+      end
+      # Extract the schedule authorities (e.g. ACIP_CDC, AAP) for a proposal.
+      # Returns an empty array when the service did not include them.
+      def parse_schedule_authorities(proposal)
+        observations = related_observations(proposal, focus_code_system: ICE_OUTPUT_FOCUS_CODE_SYSTEM,
+                                                      focus_code: "ICE_VACCINE_GROUP_SCHEDULE_AUTHORITIES")
+        observations.xpath("./interpretation").map do |interpretation|
+          {
+            code: interpretation["code"],
+            name: interpretation["displayName"]
+          }
+        end
+      end
+      # Only the fields ICE sent, so responses without series output parse as
+      # before.
+      def parse_series(proposal)
+        series = SeriesParser.new(proposal)
+        {
+          series: series.series,
+          season: series.season,
+          doses_remaining: series.doses_remaining
+        }.compact
+      end
+  end
+end

data/lib/hln_ice/series_parser.rb ADDED Viewed

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+module HlnIce
+  # Extracts the series ICE selected for display from a recommendation or dose
+  # evaluation, along with its season and doses remaining. ICE only sends these
+  # when the ICE_OUTPUTSERIESINFORMATION and ICE_OUTPUTNUMBEROFDOSESREMAINING
+  # service settings are on; each value is nil when ICE did not send it.
+  class SeriesParser
+    include Support
+    SERIES_DISPLAY_TYPE_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.501"
+    SERIES_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.10"
+    SEASON_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.11"
+    SEASON_DATE_RANGE = %r{\((\d{2}/\d{2}/\d{4}) - (\d{2}/\d{2}/\d{4})\)\z}
+    # In order of preference, so a selected series wins over an alternative.
+    SELECTIONS = {
+      "SERIES_DISPLAY_UNAMBIGUOUS" => "unambiguous",
+      "SERIES_DISPLAY_BEST_GUESS" => "best_guess",
+      "SERIES_DISPLAY_ALTERNATIVE" => "alternative"
+    }.freeze
+    def initialize(statement)
+      @statement = statement
+    end
+    def series
+      concept = selected_observation&.at_xpath("./observationValue/concept[@codeSystem='#{SERIES_CODE_SYSTEM}']")
+      return unless concept
+      {
+        code: concept["code"],
+        name: concept["displayName"],
+        selection: SELECTIONS.fetch(selection_code(selected_observation))
+      }
+    end
+    def season
+      concept = selected_observation_detail("SEASON", SEASON_CODE_SYSTEM)
+                &.at_xpath("./observationValue/concept[@codeSystem='#{SEASON_CODE_SYSTEM}']")
+      return unless concept
+      starts_on, ends_on = season_dates(concept["displayName"])
+      {
+        code: concept["code"],
+        name: concept["displayName"],
+        starts_on:,
+        ends_on:
+      }
+    end
+    # An Integer when ICE sends a plain count, otherwise ICE's text as is
+    # (e.g. "Recurring").
+    def doses_remaining
+      value = selected_observation_detail("NUMBER_OF_DOSES_REMAINING", SERIES_CODE_SYSTEM)
+              &.at_xpath("./observationValue/text")&.[]("value")
+      value&.match?(/\A\d+\z/) ? value.to_i : value
+    end
+    private
+      attr_reader :statement
+      # ICE sends no structured season dates, only a trailing
+      # "(MM/DD/YYYY - MM/DD/YYYY)" in the season's display name. Returns ISO
+      # dates, or nils when the name does not end in a valid range.
+      def season_dates(name)
+        range = SEASON_DATE_RANGE.match(name.to_s)
+        return [nil, nil] unless range
+        range.captures.map { |date| Date.strptime(date, "%m/%d/%Y").iso8601 }
+      rescue Date::Error
+        [nil, nil]
+      end
+      def selected_observation
+        return @selected_observation if defined?(@selected_observation)
+        @selected_observation = series_selections.min_by do |observation|
+          SELECTIONS.keys.index(selection_code(observation))
+        end
+      end
+      def series_selections
+        options = related_observations(statement, focus_code_system: ICE_OUTPUT_FOCUS_CODE_SYSTEM,
+                                                  focus_code: "SERIES_DISPLAY_OPTIONS")
+        selections = options.flat_map do |option|
+          related_observations(option, focus_code_system: SERIES_DISPLAY_TYPE_CODE_SYSTEM).to_a
+        end
+        selections.select { |observation| SELECTIONS.key?(selection_code(observation)) }
+      end
+      def selection_code(observation)
+        observation.at_xpath("./observationFocus")["code"]
+      end
+      def selected_observation_detail(focus_code, focus_code_system)
+        return unless selected_observation
+        related_observations(selected_observation, focus_code_system:, focus_code:).first
+      end
+  end
+end

data/lib/hln_ice/simplified_status.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module HlnIce
+  # Maps parsed recommendations to a simplified status keyed by our
+  # immunization keys, e.g. { ipv_opv: "overdue", mmr: "compliant" }.
+  class SimplifiedStatus
+    # Mapping from ICE status codes to our status keys
+    STATUS_MAPPING = {
+      "CONDITIONAL" => "conditional",
+      "FUTURE_RECOMMENDED" => "compliant",
+      "NOT_RECOMMENDED" => "compliant",
+      "RECOMMENDED" => "overdue"
+    }.freeze
+    # Mapping from ICE vaccine groups to our immunization keys
+    VACCINE_MAPPING = {
+      "DTP Vaccine Group" => :dtap_tdap,
+      "Hep A Vaccine Group" => :hep_a,
+      "Hep B Vaccine Group" => :hep_b,
+      "Hib Vaccine Group" => :hib,
+      "HPV Vaccine Group" => :hpv,
+      "Meningococcal Vaccine Group" => :mcv4,
+      "MMR Vaccine Group" => :mmr,
+      "Pneumococcal Vaccine Group" => :pcv,
+      "Polio Vaccine Group" => :ipv_opv,
+      "Varicella Vaccine Group" => :var
+    }.freeze
+    def initialize(recommendations)
+      @recommendations = recommendations
+    end
+    def to_h
+      # Create simplified immunization status mapping
+      simplified_status = {}
+      # Process all recommendations to create the simplified mapping
+      recommendations.each do |recommendation|
+        vaccine_name = recommendation[:vaccine][:name]
+        status_code = recommendation[:status][:code]
+        # Map the vaccine name to our key
+        vaccine_key = VACCINE_MAPPING[vaccine_name]
+        next unless vaccine_key # Skip if we don't have a mapping
+        # Map the status code to our status
+        status = STATUS_MAPPING[status_code] || "overdue" # Default to overdue if unknown
+        # Special handling for conditional status based on reasons
+        if status == "conditional"
+          # Check if any reason indicates medical exemption
+          has_medical_exemption = recommendation[:reasons].any? { |r| r[:code] == "MEDICAL_EXEMPTION" }
+          status = "medically_exempt" if has_medical_exemption
+        end
+        # Store in our simplified mapping
+        simplified_status[vaccine_key] = status
+      end
+      simplified_status
+    end
+    private
+      attr_reader :recommendations
+  end
+end

data/lib/hln_ice/support.rb ADDED Viewed

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require "date"
+module HlnIce
+  # Helpers shared by the request builder and response parsers. Included as
+  # private instance methods.
+  module Support
+    VACCINE_GROUP_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.1"
+    ICE_OUTPUT_FOCUS_CODE_SYSTEM = "2.16.840.1.113883.3.795.12.100.500"
+    private
+      # The observations a vMR statement relates directly to, selected by their
+      # observationFocus rather than by position: ICE orders them differently
+      # from one request to the next, and nests further observations in them.
+      def related_observations(statement, focus_code_system:, focus_code: nil)
+        focus = "@codeSystem='#{focus_code_system}'"
+        focus += " and @code='#{focus_code}'" if focus_code
+        statement.xpath("./relatedClinicalStatement/observationResult[observationFocus[#{focus}]]")
+      end
+      # The observation carrying ICE's status for the vaccine group, e.g. a
+      # recommendation or dose evaluation status. ICE sends one per statement.
+      def vaccine_group_observation(statement)
+        related_observations(statement, focus_code_system: VACCINE_GROUP_CODE_SYSTEM).first
+      end
+      # Plain-Ruby equivalent of ActiveSupport's `blank?`.
+      def blank?(value)
+        return true if value.nil?
+        return value.strip.empty? if value.is_a?(String)
+        return value.empty? if value.respond_to?(:empty?)
+        false
+      end
+      # Plain-Ruby equivalent of ActiveSupport's `present?`.
+      def present?(value)
+        !blank?(value)
+      end
+      # Helper method to format ICE dates to standard format
+      def format_ice_date(ice_date)
+        return nil unless ice_date
+        # ICE dates are in format: YYYYMMDDHHMMSS.000+0000
+        if ice_date.match(/^(\d{4})(\d{2})(\d{2})/)
+          year = ::Regexp.last_match(1)
+          month = ::Regexp.last_match(2)
+          day = ::Regexp.last_match(3)
+          "#{year}-#{month}-#{day}"
+        else
+          ice_date
+        end
+      end
+      # Helper method to format dates for ICE (YYYYMMDD)
+      def format_date_for_ice(date_string)
+        return nil unless date_string
+        begin
+          date = Date.parse(date_string)
+          # Format as YYYYMMDD
+          date.strftime("%Y%m%d")
+        rescue StandardError
+          # If parsing fails, try to use the original string
+          date_string
+        end
+      end
+  end
+end

data/lib/hln_ice/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module HlnIce
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/hln_ice.rb CHANGED Viewed

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 require_relative "hln_ice/version"
+require_relative "hln_ice/support"
+require_relative "hln_ice/request_builder"
+require_relative "hln_ice/series_parser"
+require_relative "hln_ice/evaluations_parser"
+require_relative "hln_ice/simplified_status"
+require_relative "hln_ice/response_parser"
 require_relative "hln_ice/client"
 module HlnIce

metadata CHANGED Viewed

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hln_ice
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Sam Sohn
 bindir: exe
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -61,12 +61,20 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- hln_ice.gemspec
 - lib/hln_ice.rb
 - lib/hln_ice/client.rb
+- lib/hln_ice/evaluations_parser.rb
+- lib/hln_ice/request_builder.rb
+- lib/hln_ice/response_parser.rb
+- lib/hln_ice/series_parser.rb
+- lib/hln_ice/simplified_status.rb
+- lib/hln_ice/support.rb
 - lib/hln_ice/version.rb
 - sig/hln_ice.rbs
 homepage: https://github.com/PrimaryDotHealth/hln_ice
@@ -77,6 +85,7 @@ metadata:
   homepage_uri: https://github.com/PrimaryDotHealth/hln_ice
   source_code_uri: https://github.com/PrimaryDotHealth/hln_ice
   changelog_uri: https://github.com/PrimaryDotHealth/hln_ice/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib