renalware-core 2.0.130 → 2.0.131

data/app/models/renalware/ukrdc/outgoing/rendering/patient_number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class PatientNumber < Rendering::Base
+          pattr_initialize [:number!, :organisation!, :type!]
+
+          def xml
+            name_element
+          end
+
+          private
+
+          def name_element
+            create_node("PatientNumber") do |elem|
+              elem << create_node("Number", number)
+              elem << create_node("Organization", organisation)
+              elem << create_node("NumberType", type)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/patient_numbers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class PatientNumbers < Rendering::Base
+          pattr_initialize [:patient!]
+
+          def xml
+            patient_numbers_element
+          end
+
+          private
+
+          def patient_numbers_element
+            create_node("PatientNumbers") do |patient_numbers|
+              patient_numbers << nhs_number_element if patient.nhs_number.present?
+              patient_numbers << hospital_number_element if first_hospital_number.present?
+            end
+          end
+
+          def nhs_number_element
+            Rendering::PatientNumber.new(
+              number: patient.nhs_number,
+              organisation: "NHS",
+              type: "NI"
+            ).xml
+          end
+
+          def hospital_number_element
+            Rendering::PatientNumber.new(
+              number: first_hospital_number,
+              organisation: "LOCALHOSP",
+              type: "MRN"
+            ).xml
+          end
+
+          def first_hospital_number
+            @first_hospital_number ||= patient.hospital_identifier&.id
+            # @first_hospital_number || begin
+            #   Renalware.config.patient_hospital_identifiers.values.each do |field|
+            #     next if (number = patient.public_send(field)).blank?
+
+            #     return number
+            #   end
+            # end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/pd_treatment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        # Handles rendering a PD Trweatment (aka modality). We defer to the base Treatment
+        # class but pass in some extra arguments to the ctor.
+        class PDTreatment < Rendering::Treatment
+          def initialize(treatment:)
+            encounter_number = [
+              treatment.modality_id,
+              treatment.pd_regime_id
+            ].compact.join("-")
+
+            super(
+              treatment: treatment,
+              encounter_number: encounter_number
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/primary_language.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class PrimaryLanguage < Rendering::Base
+          pattr_initialize [:patient!]
+
+          def xml
+            return unless render_primary_language?
+
+            primary_langauge_element
+          end
+
+          private
+
+          # Omit 'Other' language as it is not part of the ISO set, but we have it for some reason
+          def render_primary_language?
+            patient.language.present? && patient.language.code != "ot"
+          end
+
+          # NB NHS_DATA_DICTIONARY_LANGUAGE_CODE is ISO 639-1 plus braille and sign
+          def primary_langauge_element
+            create_node("PrimaryLanguage") do |lang|
+              lang << create_node("CodingStandard", "NHS_DATA_DICTIONARY_LANGUAGE_CODE")
+              lang << create_node("Code", patient.language&.code)
+              lang << create_node("Description", patient.language)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/procedures.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class Procedures < Rendering::Base
+          pattr_initialize [:patient!]
+
+          def xml
+            procedures_element
+          end
+
+          private
+
+          def procedures_element
+            create_node("Procedures") do |elem|
+              dialysis_session_elements_inside(elem)
+              transplant_operation_elements_inside(elem)
+            end
+          end
+
+          def dialysis_session_elements_inside(elem)
+            patient.finished_hd_sessions.each do |session|
+              session_presenter = Renalware::HD::SessionPresenter.new(session)
+              elem << Rendering::DialysisSession.new(session: session_presenter).xml
+            end
+          end
+
+          def transplant_operation_elements_inside(elem)
+            patient.transplant_operations.each do |operation|
+              operation_presenter = Renalware::UKRDC::TransplantOperationPresenter.new(operation)
+              elem << Rendering::Transplant.new(operation: operation_presenter).xml
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/renal_diagnosis.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class RenalDiagnosis < Rendering::Base
+          pattr_initialize [:patient!]
+
+          def xml
+            return if patient.prd_description_code.blank?
+
+            renal_diagnosis_element
+          end
+
+          private
+
+          # The nested Diagnosis is correct.
+          def renal_diagnosis_element
+            elem = Rendering::Diagnosis.new(
+              coding_standard: "EDTA2",
+              code: patient.prd_description_code,
+              description: patient.prd_description_term,
+              root_elemment_name: "RenalDiagnosis"
+            )
+            if patient.first_seen_on.present?
+              elem.identification_time = patient.first_seen_on
+            end
+            elem.xml
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/transplant.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class Transplant < Rendering::Base
+          pattr_initialize [:operation!]
+
+          def xml
+            transplant_element
+          end
+
+          private
+
+          def transplant_element
+            create_node("Transplant") do |elem|
+              elem << procedure_type_element
+              elem << procecure_time_element
+              elem << entered_at_element
+              elem << attributes_element
+            end
+          end
+
+          def procedure_type_element
+            return if operation.operation_type.blank?
+
+            create_node("ProcedureType") do |elem|
+              elem << create_node("CodingStandard", "SNOMED")
+              elem << create_node("Code", operation.procedure_type_snomed_code.to_i)
+              elem << create_node("Description", operation.procedure_type_name)
+            end
+          end
+
+          def procecure_time_element
+            create_node("ProcedureTime", operation.performed_at&.iso8601)
+          end
+
+          def entered_at_element
+            return if operation.hospital_centre_code.blank?
+
+            create_node("EnteredAt") do |elem|
+              elem << create_node("CodingStandard", "ODS")
+              elem << create_node("Code", operation.hospital_centre_code)
+              elem << create_node("Description", operation.hospital_centre_name)
+            end
+          end
+
+          def attributes_element
+            create_node("Attributes") do |elem|
+              if operation.nhsbt_type.present?
+                elem << create_node("TRA77", operation.nhsbt_type)
+              end
+            end
+          end
+
+          # Not sending TRA76 yet as defined as datetime in XSD and needs changeing there.
+          # if operation.rr_tra76_options.present?
+          #   xml.TRA76 do
+          #     xml.CodingStandard "CF_RR7_TREATMENT"
+          #     xml.Code operation.rr_tra76_options[:code]
+          #     xml.Description operation.rr_tra76_options[:description]
+          #   end
+          # end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/treatment.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class Treatment < Rendering::Base
+          pattr_initialize [:treatment!, :encounter_number, :attributes]
+
+          def xml
+            treatment_element
+          end
+
+          private
+
+          # rubocop:disable Metrics/AbcSize
+          def treatment_element
+            create_node("Treatment") do |elem|
+              elem << create_node("EncounterNumber", encounter_number || treatment.modality_id)
+              elem << create_node("EncounterType", "N")
+              elem << create_node("FromTime", treatment.started_on&.iso8601)
+              if treatment.ended_on.present?
+                elem << create_node("ToTime", treatment.ended_on&.iso8601)
+              end
+              elem << healthcare_facility_element
+              elem << admin_reason_element
+              elem << discharge_reason_element
+              elem << attributes_element
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def healthcare_facility_element
+            create_node("HealthCareFacility") do |elem|
+              elem << create_node("CodingStandard", "ODS")
+              code = treatment.hospital_unit&.renal_registry_code || default_unit_code
+              elem << create_node("Code", code)
+            end
+          end
+
+          def admin_reason_element
+            create_node("AdmitReason") do |elem|
+              elem << create_node("CodingStandard", "CF_RR7_TREATMENT")
+              elem << create_node("Code", treatment.modality_code&.txt_code)
+            end
+          end
+
+          def discharge_reason_element
+            return if treatment&.discharge_reason_code.blank?
+
+            create_node("DischargeReason") do |elem|
+              elem << create_node("CodingStandard", "CF_RR7_DISCHARGE")
+              elem << create_node("Code", treatment.discharge_reason_code)
+            end
+          end
+
+          # Attributes is a hash eg { "QBL05" => "HOME" }
+          def attributes_element
+            return if attributes.blank?
+            return unless attributes.values.detect(&:present?)
+
+            create_node("Attributes") do |elem|
+              attributes.each do |key, value|
+                next if value.blank?
+
+                elem << create_node(key, value)
+              end
+            end
+          end
+
+          def default_unit_code
+            Renalware.config.ukrdc_site_code
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/outgoing/rendering/user.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UKRDC
+    module Outgoing
+      module Rendering
+        class User < Rendering::Base
+          pattr_initialize [:user!]
+
+          def xml
+            user_element
+          end
+
+          private
+
+          def user_element
+            Ox::Element.new(element_name).tap do |elem|
+              elem << create_node("CodingStandard", "LOCAL")
+              elem << create_node("Code", user&.username)
+              elem << create_node("Description", user&.to_s)
+            end
+          end
+
+          # If a superclass called Clinician inherits from this class then the name of
+          # element output will be <Clinician>
+          def element_name
+            self.class.name.demodulize
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/pathology_observation_requests_query.rb

@@ -23,6 +23,7 @@ module Renalware
             :description,
             observations: { description: :measurement_unit }
           )
+          .order(observed_at: :asc)
       end
 
       # If there is a pathology_start_date configured in an ENV var, use this

data/app/models/renalware/ukrdc/xml_renderer.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_dependency "renalware/ukrdc"
+require "benchmark"
 
 module Renalware
   module UKRDC
     class XmlRenderer
       DEFAULT_TEMPLATE = "/renalware/api/ukrdc/patients/show"
-      attr_reader :template, :xsd_path, :locals, :errors
+      attr_reader :template, :errors, :locals
 
       class Success < Renalware::Success
         alias xml object
@@ -16,9 +17,11 @@ module Renalware
         alias validation_errors object
       end
 
-      def initialize(template: nil, xsd_path: nil, locals: {})
+      # Schema is an instance of Nokogiri::XML::Schema passed in for optimisation reasons.
+      # If it is not passed in we create it.
+      def initialize(schema: nil, template: nil, locals: {})
         @template = template || DEFAULT_TEMPLATE
-        @xsd_path = xsd_path || default_xsd_path
+        @schema = schema
         @locals = locals
       end
 
@@ -34,93 +37,69 @@ module Renalware
 
       def xml
         @xml ||= begin
-          API::UKRDC::PatientsController.new.render_to_string(
-            template: template,
-            format: :xml,
-            locals: locals,
-            encoding: "UTF-8"
-          )
+          Ox.default_options = { no_empty: false, encoding: "UTF-8" }
+          doc = Ox::Document.new
+          doc << instruct_element
+          doc << UKRDC::Outgoing::Rendering::Patient.new(locals).xml
+          Ox.dump(doc)
         end
       end
 
       # Returns an array of SchemaValidation errors
       def validation_errors
-        @validation_errors ||= begin
-          document = Nokogiri::XML(xml)
-          xsddoc = Nokogiri::XML(File.read(xsd_path), xsd_path)
-          schema = Nokogiri::XML::Schema.from_document(xsddoc)
-          schema.validate(document)
-        end
+        @validation_errors ||= schema.validate(Nokogiri::XML(xml))
       end
 
       private
 
-      def default_xsd_path
-        File.join(Renalware::Engine.root, "vendor/xsd/ukrdc/Schema/UKRDC.xsd")
+      def instruct_element
+        Ox::Instruct.new(:xml).tap do |instruct|
+          instruct[:version] = "1.0"
+          instruct[:encoding] = "UTF-8"
+        end
+      end
+
+      # It is more performant if schema is passed in in the ctor - but if it isn't we create it.
+      def schema
+        @schema ||= begin
+          Rails.logger.warn "Creating JIT Nokogiri::XML::Schema!"
+          xsd_path = File.join(Renalware::Engine.root, "vendor/xsd/ukrdc/Schema/UKRDC.xsd")
+          xsddoc = Nokogiri::XML(File.read(xsd_path), xsd_path)
+          Nokogiri::XML::Schema.from_document(xsddoc)
+        end
       end
     end
   end
 end
 
+# rubocop:disable Layout/LineLength
+# For reference this is the code used to compare old and new methods of exporting the XML
+# in the #call method:
 #
-# An alternative xml rendering implementation - we moved to a template based approach
-# for now as its provides more clarity
-#
-
-# class Base
-#   include ActiveModel::Serializers::Xml
-#   include Virtus::Model
+# modified_old_xml = xml_old.gsub("<FamilyDoctor>\n    </FamilyDoctor>", "<FamilyDoctor/>")
+# modified_old_xml = modified_old_xml.gsub("<Diagnoses>\n  </Diagnoses>", "<Diagnoses/>")
+# modified_old_xml = modified_old_xml.gsub("<Encounters>\n  </Encounters>", "<Encounters/>")
+# modified_old_xml = modified_old_xml.gsub("<Medications>\n  </Medications>", "<Medications/>")
+# modified_old_xml = modified_old_xml.gsub("<Procedures>\n  </Procedures>", "<Procedures/>")
+# modified_old_xml = modified_old_xml.gsub("<Attributes>\n      </Attributes>", "<Attributes/>")
+# modified_old_xml = modified_old_xml.gsub("<ResultValue></ResultValue>", "<ResultValue/>")
+# modified_old_xml = modified_old_xml.gsub("<LabOrders start=\"2017-01-01\" stop=\"2019-12-29\">\n  </LabOrders>", "<LabOrders/>")
+# modified_old_xml = modified_old_xml.gsub("<Observations start=\"2017-01-01\" stop=\"2019-12-29\">\n  </Observations>", "<Observations start=\"2017-01-01\" stop=\"2019-12-29\"/>")
+# modified_old_xml = modified_old_xml.gsub("<LabOrders/>", "<LabOrders start=\"2017-01-01\" stop=\"2019-12-29\"/>")
+
+# if modified_old_xml != xml
+#   File.open(Rails.root.join("tmp", "#{locals[:patient].id}_old.txt"), "wb") { |f| f.write modified_old_xml }
+#   File.open(Rails.root.join("tmp", "#{locals[:patient].id}_new.txt"), "wb") { |f| f.write xml }
 # end
-
-# class PatientNumber < Base
-#   attribute :number, String
-#   attribute :organisation, String
-
-#   def self.build_nhs_number(number)
-#     new(number: number, organisation: "NHS")
-#   end
-# end
-
-# class Name < Base
-#   attribute :prefix, String
-#   attribute :family, String
-#   attribute :given, String
-#   attribute :suffix, String
-#   attribute :use, String
-# end
-
-# class Patient < Base
-#   attribute :gender, String # 0=Not Known 1=Male 2=Female 9=Not Specified.
-#   attribute :birth_time, DateTime
-#   attribute :death_time, DateTime
-#   attribute :patient_numbers, Array(PatientNumber)
-#   attribute :name, Name
-#   attribute :country_of_birth, String # ISO 3166-1 3-char alphabetic code
-# end
-
-# rdc_patient = UKRDC::Patient.new(
-#   gender: patient.sex&.code,
-#   birth_time: patient.born_on,
-#   death_time: patient.died_on,
-#   country_of_birth: "???"
-# )
-
-# rdc_patient.name = Name.new(
-#   prefix: patient.title,
-#   family: patient.family_name,
-#   given: patient.given_name,
-#   suffix: patient.suffix
-# )
-
-# rdc_patient.patient_numbers << UKRDC::PatientNumber.build_nhs_number(patient.nhs_number)
-# Renalware.config.patient_hospital_identifiers.each do |_key, field|
-#   number = patient.public_send(field)
-#   unless number.blank?
-#     patient_number = UKRDC::PatientNumber.new(number: number, organisation: "LOCALHOSP")
-#     rdc_patient.patient_numbers << patient_number
+#
+# def xml_old
+#   @xml_old ||= begin
+#     API::UKRDC::PatientsController.new.render_to_string(
+#       template: template,
+#       format: :xml,
+#       locals: locals,
+#       encoding: "UTF-8"
+#     )
 #   end
 # end
-
-# # Render XML
-# respond_with rdc_patient, camelize: true
-#
+# rubocop:enable Layout/LineLength