his_emr_api_lab 2.1.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa0a902d0f6f1159525e92598deb3ee77684c17c12a52078fa20d44cf2cafec1
-  data.tar.gz: a0b8c8d773c498dc77b4beaeb460b491695785cca91245bf62149d434e1e4841
+  metadata.gz: bbe2fcb401fa3f57e0cbc85561f9ef2152e0b1736ca33ea08e36fd8aaffbeeb5
+  data.tar.gz: e3ab952d0c5ba09a760b554c079873884b9b937bd4822e822c0b1317ca52694c
 SHA512:
-  metadata.gz: f24e327db48725b4ddffb24e12dcd09e02c1a0965ecdeb6aae08ab547305de6053a2d93d07154ed7750639b376b51bbedaeee54ec6cd44eeeb992f6d46dd5e8e
-  data.tar.gz: beca813e59561a368b4ad8252f82364b19c801adcead63d8c4b3f1562ebe1066b94f4d09a3abb6c1f734728836de5b719bb3deb685598127220741fcb4f42541
+  metadata.gz: 735e54a4be6f1e29cd34c5b1bad5bca0aab35de90630ab0eca52d339bfff626801db089d1bb80d62f5751cd680d3b14bbb7d975c6c5143db5a2ea2ba8d7324e4
+  data.tar.gz: 395df3bcfe287ffbe505df72c6d4256715210147a5b933d464c1ec9c617999ead6b0d9cc90eb5e903dc82ccf274ac9afc482cffd2c767756d6c2f0be499ef315

data/app/controllers/lab/labels_controller.rb

@@ -2,7 +2,8 @@
 
 module Lab
   class LabelsController < ApplicationController
-    skip_before_action :authenticate
+    _callbacks = _process_action_callbacks.map(&:filter)
+    skip_before_action :authenticate if _callbacks.include?(:authenticate)
 
     def print_order_label
       order_id = params.require(:order_id)

data/app/controllers/lab/orders_controller.rb

@@ -2,7 +2,6 @@
 
 module Lab
   class OrdersController < ApplicationController
-    skip_before_action :authenticate, only: %i[order_status order_result summary]
     before_action :authenticate_request, only: %i[order_status order_result summary]
 
     def create
@@ -25,10 +24,19 @@ module Lab
     end
 
     def index
-      filters = params.slice(:patient_id, :accession_number, :date, :status)
+      filters = params.permit(%i[patient_id patient accession_number date status])
 
-      Lab::UpdatePatientOrdersJob.perform_later(filters[:patient_id]) if filters[:patient_id]
-      render json: OrdersSearchService.find_orders(filters)
+      id = filters[:patient_id] || filters[:patient]
+
+      patient = Patient.find(id) if filters[:patient_id] || filters[:patient]
+
+      Lab::UpdatePatientOrdersJob.perform_later(patient.id) if filters[:patient_id] || filters[:patient]
+      orders = OrdersSearchService.find_orders(filters)
+      begin
+        render json: orders.reload, status: :ok
+      rescue StandardError
+        render json: orders
+      end
     end
 
     def verify_tracking_number
@@ -68,27 +76,8 @@ module Lab
     private
 
     def authenticate_request
-      header = request.headers['Authorization']
-      content = header.split(' ')
-      auth_scheme = content.first
-      unless header
-        errors = ['Authorization token required']
-        render json: { errors: errors }, status: :unauthorized
-        return false
-      end
-      unless auth_scheme == 'Bearer'
-        errors = ['Authorization token bearer scheme required']
-        render json: { errors: errors }, status: :unauthorized
-        return false
-      end
-  
-      process_token(content.last)
-    end
-
-    def process_token(token)
-      browser = Browser.new(request.user_agent)
-      decoded = Lab::JsonWebTokenService.decode(token, request.remote_ip + browser.name + browser.version)
-      user(decoded)
+      decoded_user = authorize_request
+      user(decoded_user)
     end
 
     def user(decoded)

data/app/controllers/lab/results_controller.rb

@@ -5,11 +5,12 @@ module Lab
     def create
       result_params = params.require(:result)
                             .permit([:encounter_id,
+                                     :encounter,
                                      :date,
                                      { measures: [:value,
                                                   :value_type,
                                                   :value_modifier,
-                                                  { indicator: [:concept_id] }] }])
+                                                  { indicator: %i[concept_id concept] }] }])
 
       result = Lab::ResultsService.create_results(params[:test_id], result_params, 'user entered')
 

data/app/controllers/lab/specimen_types_controller.rb

@@ -7,7 +7,6 @@ module Lab
 
       specimen_types = ConceptsService.specimen_types(name: filters['name'],
                                                       test_type: filters['test_type'])
-                                      .as_json(only: %w[concept_id name])
 
       render json: specimen_types
     end

data/app/controllers/lab/test_methods_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lab
+  class TestMethodsController < ApplicationController
+    def index
+      render json: ConceptsService.test_methods(params.require(:nlims_code))
+    end
+  end
+end

data/app/controllers/lab/test_types_controller.rb

@@ -7,7 +7,7 @@ module Lab
 
       test_types = ConceptsService.test_types(name: filters['name'],
                                               specimen_type: filters['specimen_type'])
-                                  .as_json(only: %w[concept_id name])
+                                  
 
       render json: test_types
     end

data/app/controllers/lab/tests_controller.rb

@@ -3,9 +3,7 @@
 module Lab
   class TestsController < ApplicationController
     def index
-      filters = params.slice(:order_date, :accession_number, :patient_id, :test_type_id, :specimen_type_id,
-                             :pending_results)
-
+      filters = params.permit(%i[order_date accession_number patient patient_id test_type_id specimen_type_id pending_results])
       tests = service.find_tests(filters)
       render json: tests
     end

data/app/controllers/lab/users_controller.rb

@@ -3,7 +3,8 @@
 # This controller handles creation and authentication of LIMS User
 module Lab
   class UsersController < ::ApplicationController
-    skip_before_action :authenticate
+     _callbacks = _process_action_callbacks.map(&:filter)
+    skip_before_action :authenticate if _callbacks.include?(:authenticate)
     # create a LIMS User that will be responsible for sending lab results
     def create
       user_params = params.permit(:username, :password)

data/app/jobs/lab/process_lab_result_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lab
+  ##
+  # Push an order to LIMS.
+  class ProcessLabResultJob < ApplicationJob
+    queue_as :default
+    def perform(results_obs_id, serializer, result_enter_by)
+      results_obs = Lab::LabResult.find(results_obs_id)
+      Lab::ResultsService.process_result_completion(results_obs, serializer, result_enter_by)
+    end
+  end
+end

data/app/models/lab/lab_order.rb

@@ -41,7 +41,10 @@ module Lab
 
     default_scope do
       joins(:order_type)
-        .merge(OrderType.where(name: Lab::Metadata::ORDER_TYPE_NAME))
+        .merge(OrderType.where(name: [
+          Lab::Metadata::ORDER_TYPE_NAME, 
+          Lab::Metadata::HTS_ORDER_TYPE_NAME
+        ]))
         .where.not(concept_id: ConceptName.where(name: 'Tests ordered').select(:concept_id))
     end
 

data/app/models/lab/lab_result.rb

@@ -2,6 +2,10 @@
 
 module Lab
   class LabResult < Observation
+    def children
+      Observation.where(obs_group_id: obs_id, voided: 0)
+    end
+    
     alias measures children
 
     default_scope do

data/app/models/lab/lab_test.rb

@@ -8,7 +8,7 @@ module Lab
 
     has_one :result,
             -> { where(concept: ConceptName.where(name: Lab::Metadata::TEST_RESULT_CONCEPT_NAME)) },
-            class_name: '::Lab::LabResult',
+            class_name: 'Lab::LabResult',
             foreign_key: :obs_group_id
 
     def void(reason)

data/app/models/lab/order_extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# model managing extra details for orders
+class Lab::OrderExtension < ApplicationRecord
+  include Voidable
+  self.table_name = :order_extension
+  self.primary_key = :order_extension_id
+
+  default_scope { where(voided: 0) }
+  scope :voided, -> { unscoped.where.not(voided: 0) }
+
+  belongs_to :order, foreign_key: :order_id
+  belongs_to :creator, class_name: 'User', foreign_key: :creator
+end

data/app/serializers/lab/lab_order_serializer.rb

@@ -2,18 +2,27 @@
 
 module Lab
   module LabOrderSerializer
-    def self.serialize_order(order, tests: nil, requesting_clinician: nil, reason_for_test: nil, target_lab: nil)
+    def self.serialize_order(order, tests: nil, requesting_clinician: nil, reason_for_test: nil, target_lab: nil, comment_to_fulfiller: nil)
       tests ||= order.voided == 1 ? voided_tests(order) : order.tests
       requesting_clinician ||= order.requesting_clinician
+      comment_to_fulfiller ||= order.comment_to_fulfiller
       reason_for_test ||= order.reason_for_test
       target_lab = target_lab&.value_text || order.target_lab&.value_text || Location.current_health_center&.name
 
+      encounter = Encounter.find_by_encounter_id(order.encounter_id)
+      program = Program.find_by_program_id(encounter.program_id)
+
       ActiveSupport::HashWithIndifferentAccess.new(
         {
           id: order.order_id,
+          order_type_id: order.order_type_id,
           order_id: order.order_id, # Deprecated: Link to :id
           encounter_id: order.encounter_id,
-          order_date: order.start_date,
+          order_date: order.date_created,
+          location_id: encounter.location_id,
+          program_id: encounter.program_id,
+          program_name: program.name,
+          # order_date: order.start_date,
           patient_id: order.patient_id,
           accession_number: order.accession_number,
           specimen: {
@@ -21,7 +30,8 @@ module Lab
             name: concept_name(order.concept_id)
           },
           requesting_clinician: requesting_clinician&.value_text,
-          target_lab:,
+          target_lab: target_lab,
+          comment_to_fulfiller: comment_to_fulfiller.respond_to?(:value_text) ? comment_to_fulfiller.value_text : comment_to_fulfiller,
           reason_for_test: {
             concept_id: reason_for_test&.value_coded,
             name: concept_name(reason_for_test&.value_coded)
@@ -33,7 +43,9 @@ module Lab
             {
               id: test.obs_id,
               concept_id: test.value_coded,
+              uuid: test.uuid,
               name: concept_name(test.value_coded),
+              test_method: test_method(order, test.value_coded),
               result: result_obs && ResultSerializer.serialize(result_obs)
             }
           end
@@ -41,10 +53,21 @@ module Lab
       )
     end
 
+    def self.test_method(order, _concept_id)
+      obs = ::Observation
+            .select(:value_coded)
+            .where(concept_id: ConceptName.find_by_name(Metadata::TEST_METHOD_CONCEPT_NAME).concept_id, order_id: order.id)
+            .first
+      {
+        concept_id: obs&.value_coded,
+        name: ConceptName.find_by_concept_id(obs&.value_coded)&.name
+      }
+    end
+
     def self.concept_name(concept_id)
       return concept_id unless concept_id
 
-      ConceptName.select(:name).find_by_concept_id(concept_id)&.name
+      ::ConceptAttribute.find_by(concept_id:, attribute_type: ConceptAttributeType.test_catalogue_name)&.value_reference
     end
 
     def self.voided_tests(order)

data/app/serializers/lab/result_serializer.rb

@@ -8,6 +8,13 @@ module Lab
       result.children.map do |measure|
         value, value_type = read_value(measure)
         concept_name = ConceptName.find_by_concept_id(measure.concept_id)
+        
+        program_id = ""
+        if measure.obs_id.present?
+          obs = Observation.find(measure.obs_id)
+          encounter = Encounter.find(obs.encounter_id)
+          program_id = encounter.program_id
+        end
 
         {
           id: measure.obs_id,
@@ -18,14 +25,15 @@ module Lab
           date: measure.obs_datetime,
           value:,
           value_type:,
-          value_modifier: measure.value_modifier
+          value_modifier: measure.value_modifier,
+          program_id: program_id
         }
       end
     end
 
     def self.read_value(measure)
       %w[value_numeric value_coded value_boolean value_text].each do |field|
-        value = measure.send(field)
+        value = measure.send(field) if measure.respond_to?(field)
 
         return [value, field.split('_')[1]] if value
       end

data/app/serializers/lab/test_serializer.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Lint/UnreachableLoop
 # frozen_string_literal: true
 
 module Lab
@@ -5,25 +6,47 @@ module Lab
     def self.serialize(test, order: nil, result: nil)
       order ||= test.order
       result ||= test.result
-
       {
         id: test.obs_id,
+        test_uuid: test.uuid,
         concept_id: test.value_coded,
+        concept_uuid: test.value_coded ? Concept.find(test.value_coded)&.uuid : nil,
         name: ConceptName.find_by_concept_id(test.value_coded)&.name,
         order: {
           id: order.order_id,
           concept_id: order.concept_id,
+          concept_uuid: order.concept_id ? Concept.find(order.concept_id)&.uuid : nil,
           name: ConceptName.find_by_concept_id(order.concept_id)&.name,
           accession_number: order.accession_number
         },
+        measures: result_mesures(result),
         result: if result
                   {
                     id: result.obs_id,
+                    uuid: result.uuid,
                     modifier: result.value_modifier,
                     value: result.value_text
                   }
                 end
       }
     end
+
+    def self.result_mesures(result)
+      if result&.measures.present?
+        return result&.measures&.map do |measure|
+          m = {}
+          m[:uuid] = measure.uuid
+          m[:concept_id] = measure.concept_id
+          m[:name] = ConceptName.find_by_concept_id(measure.concept_id)&.name
+          m[:modifier] = measure.value_modifier
+          m[:value] = measure&.value_text || measure&.value_numeric || measure&.value_boolean || measure&.value_coded || measure&.value_datetime || measure&.value_drug || measure&.value_complex || measure&.value_group
+          m
+        end
+      end
+
+      nil
+    end
   end
 end
+
+# rubocop:enable Lint/UnreachableLoop

data/app/services/lab/accession_number_service.rb

@@ -41,8 +41,8 @@ module Lab
         year = format_year(date.year)
         month = format_month(date.month)
         day = format_day(date.day)
-
-        "X#{site_code}#{year}#{month}#{day}#{counter}"
+        time_acc_generated = Time.now.strftime('%H%M')
+        "X#{site_code}#{year}#{month}#{day}#{counter}#{time_acc_generated}"
       end
 
       def format_year(year)

data/app/services/lab/acknowledgement_service.rb

@@ -6,6 +6,9 @@ module Lab
     class << self
       def create_acknowledgement(params)
         order = Order.find(params[:order_id])
+
+        Lab::LabAcknowledgement.find_by(order_id: order.id, test: params[:test])&.destroy
+
         Lab::LabAcknowledgement.create!(order_id: order.id, test: params[:test], pushed: false,
                                         acknowledgement_type: params[:entered_by] == 'LIMS' ? 'test_results_delivered_to_site_electronically' : 'test_results_delivered_to_site_manually',
                                         date_received: params[:date_received])
@@ -27,7 +30,7 @@ module Lab
             Rails.logger.info("Updating acknowledgement ##{acknowledgement_dto[:tracking_number]} in LIMS")
             response = lims_api.acknowledge(acknowledgement_dto)
             Rails.logger.info("Info #{response}")
-            if response['status'] == 200 || response['message'] == 'results already delivered for test name given'
+            if ['results already delivered for test name given', 'test result acknowledged successfully', 'test result already acknowledged electronically at facility'].include?(response['message'])
               acknowledgement.pushed = true
               acknowledgement.date_pushed = Time.now
               acknowledgement.save!

data/app/services/lab/concepts_service.rb

@@ -3,14 +3,45 @@
 module Lab
   # A read-only repository of sort for all lab-centric concepts.
   module ConceptsService
+    def self.test_methods(nlims_code)
+      return ActiveRecord::Base.connection.select_all <<~SQL
+        SELECT cn.name, cn.concept_id
+        FROM concept_set cs
+                INNER JOIN concept_name cn ON cn.concept_id = cs.concept_id
+                INNER JOIN concept_attribute ca ON ca.value_reference = #{ActiveRecord::Base.connection.quote(nlims_code)}
+            AND ca.attribute_type_id = 20
+        WHERE cs.concept_id IN (SELECT concept_set.concept_id
+                                FROM concept_set
+                                WHERE concept_set.concept_set IN (SELECT concept_name.concept_id
+                                                                  FROM concept_name
+                                                                  WHERE concept_name.voided = 0
+                                                                    AND concept_name.name = 'Recommended test method'))
+          AND cs.concept_set IN (SELECT concept_set.concept_id
+                                          FROM concept_set
+                                          WHERE concept_set.concept_set IN (SELECT concept_name.concept_id
+                                                                            FROM concept_name
+                                                                            WHERE concept_name.voided = 0
+                                                                              AND concept_name.name = 'Test type')
+                                            AND concept_set.concept_id = ca.concept_id
+                                            )
+        GROUP BY cn.concept_id
+      SQL
+    end
+
     def self.test_types(name: nil, specimen_type: nil)
       test_types = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
       test_types = test_types.filter_members(name:) if name
 
       unless specimen_type
-        return test_types.joins('INNER JOIN concept_name ON concept_set.concept_id = concept_name.concept_id AND concept_name.voided = 0 AND concept_name.locale_preferred = 1')
-                         .select('concept_name.name, concept_name.concept_id')
-                         .group('concept_name.concept_id')
+        return ActiveRecord::Base.connection.select_all <<~SQL
+          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+            FROM concept_attribute ca
+          INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
+            AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
+          AND ca.concept_id IN (#{test_types.select(:concept_id).to_sql})
+          GROUP BY ca.concept_id
+        SQL
       end
 
       # Filter out only those test types that have the specified specimen
@@ -24,25 +55,37 @@ module Lab
         concept_set: test_types.select(:concept_id)
       )
 
-      concept_set.joins('INNER JOIN concept_name ON concept_set.concept_set = concept_name.concept_id')
-                 .select('concept_name.concept_id, concept_name.name')
-                 .group('concept_name.concept_id')
+      return ActiveRecord::Base.connection.select_all <<~SQL
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+          FROM concept_attribute ca
+        INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
+          AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+        WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
+        AND ca.concept_id IN (#{concept_set.select(:concept_id).to_sql})
+        GROUP BY ca.concept_id
+      SQL
     end
 
     def self.specimen_types(name: nil, test_type: nil)
       specimen_types = ConceptSet.find_members_by_name(Lab::Metadata::SPECIMEN_TYPE_CONCEPT_NAME)
-      specimen_types = specimen_types.filter_members(name:) if name
+      specimen_types = specimen_types.filter_members(name: name) if name
 
       unless test_type
-        return specimen_types.select('concept_name.concept_id, concept_name.name')
-                             .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
-                             .group('concept_name.concept_id')
+        return ActiveRecord::Base.connection.select_all <<~SQL
+          SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+            FROM concept_attribute ca
+          INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
+            AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
+          AND ca.concept_id IN (#{specimen_types.select(:concept_id).to_sql})
+          GROUP BY ca.concept_id
+        SQL
       end
 
       # Retrieve only those specimen types that belong to concept
       # set of the selected test_type
       test_types = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
-                             .filter_members(name: test_type)
+                             .filter_members(name: test_type&.strip)
                              .select(:concept_id)
 
       concept_set = ConceptSet.where(
@@ -50,33 +93,45 @@ module Lab
         concept_set: test_types
       )
 
-      concept_set.select('concept_name.concept_id, concept_name.name')
-                 .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
-                 .group('concept_name.concept_id')
+      return ActiveRecord::Base.connection.select_all <<~SQL
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+          FROM concept_attribute ca
+        INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
+          AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+        WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
+        AND ca.concept_id IN (#{concept_set.pluck(:concept_id).push(0).join(',')})
+        GROUP BY ca.concept_id
+      SQL
     end
 
     def self.test_result_indicators(test_type_id)
       # Verify that the specified test_type is indeed a test_type
       test = ConceptSet.find_members_by_name(Lab::Metadata::TEST_TYPE_CONCEPT_NAME)
-                       .where(concept_id: test_type_id)
+                       .where(concept_id: Concept.find(test_type_id)&.id)
                        .select(:concept_id)
 
       # From the members above, filter out only those concepts that are result indicators
       measures = ConceptSet.find_members_by_name(Lab::Metadata::TEST_RESULT_INDICATOR_CONCEPT_NAME)
                            .select(:concept_id)
 
-      ConceptSet.where(concept_set: measures, concept_id: test)
-                .joins("INNER JOIN concept_name AS measure ON measure.concept_id = concept_set.concept_set AND (measure.locale_preferred = 1 OR measure.concept_name_type = 'SHORT' OR measure.concept_name_type = 'FULLY_SPECIFIED')")
-                .select('measure.concept_id, measure.name')
-                .group('measure.concept_id')
-                .map { |concept| { name: concept.name, concept_id: concept.concept_id } }
+      sets = ConceptSet.where(concept_set: measures, concept_id: test)
+
+      return ActiveRecord::Base.connection.select_all <<~SQL
+        SELECT ca.concept_id, ca.value_reference as name, ca2.value_reference as nlims_code
+          FROM concept_attribute ca
+          INNER JOIN concept_attribute ca2 ON ca.concept_id = ca2.concept_id
+            AND ca2.attribute_type_id = #{ConceptAttributeType.nlims_code.concept_attribute_type_id}
+          WHERE ca.attribute_type_id = #{ConceptAttributeType.test_catalogue_name.concept_attribute_type_id}
+          AND ca.concept_id IN (#{sets.pluck(:concept_set).push(0).join(',')})
+          GROUP BY ca.concept_id
+      SQL
     end
 
     def self.reasons_for_test
       ConceptSet.find_members_by_name(Lab::Metadata::REASON_FOR_TEST_CONCEPT_NAME)
                 .joins('INNER JOIN concept_name ON concept_name.concept_id = concept_set.concept_id')
-                .select('concept_name.concept_id, concept_name.name')
-                .map { |concept| { name: concept.name, concept_id: concept.concept_id } }
+                .select('concept_name.concept_id, concept_name.name, concept_name.uuid')
+                .map { |concept| { name: concept.name, concept_id: concept.concept_id, uuid: concept.uuid } }
     end
   end
 end

data/app/services/lab/lims/acknowledgement_worker.rb

@@ -22,7 +22,7 @@ module Lab
           logger.debug("Found #{acknowledgements.size} acknowledgements...")
           acknowledgements.each do |acknowledgement|
             Lab::AcknowledgementService.push_acknowledgement(acknowledgement, @lims_api)
-          rescue GatewayError => e
+          rescue StandardError => e
             logger.error("Failed to push acknowledgement ##{acknowledgement.order_id}: #{e.class} - #{e.message}")
           end