renalware-core 2.0.64 → 2.0.67

data/app/models/renalware/letters/letter_query.rb

@@ -36,7 +36,7 @@ module Renalware
       end
 
       def search
-        @search ||= Letter.include(QueryableLetter).includes(:event).search(@q)
+        @search ||= Letter.include(QueryableLetter).includes(:event).ransack(@q)
       end
     end
   end

data/app/models/renalware/letters/recipient.rb

@@ -88,6 +88,8 @@ module Renalware
 
       def practice_address_for_patient
         address = letter.patient&.practice&.address
+        ensure_practice_name_is_present_in(address)
+
         if address.present? && letter.primary_care_physician.present?
           ensure_address_has_a_name_required_when_displaying_letters(
             address,
@@ -97,6 +99,15 @@ module Renalware
         address
       end
 
+      # There may not be an organisation name eg "Mill House Clinic" on the address record
+      # (in fact is unlikely) in which case copy it over from the practice so it will be displayed
+      # under the GP's name on the letter.
+      def ensure_practice_name_is_present_in(address)
+        return if address.blank?
+
+        address.organisation_name ||= letter.patient&.practice&.name
+      end
+
       def address_for_addressee_eg_contact
         addressee.address.tap do |address|
           ensure_address_has_a_name_required_when_displaying_letters(

data/app/models/renalware/letters/resolve_default_electronic_ccs.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "attr_extras"
+
+module Renalware
+  module Letters
+    # This class is responsible for collating the complete set of default electronic ccs for a new
+    # patient letter.
+    # An HD patient for instance might have a named nurse who should always be eCCed into any
+    # letters about them.
+    # Important to note here is that we are of course in the Letters module and have no knowledge
+    # of who should be eCCs and how to resolve those users; these are matters that relate for
+    # example to the user's current modality and the corresponding module (HD, PD, Transplant etc).
+    # So here all we can do is broadcast a (synchronous) event asking anyone listening (ie any
+    # class that is configured to listen in the broadcast_map) to add their eCC users to the
+    # passed in array_of_user_ids array. We will then dedupe and return that array,
+    # where it will be used to initialize the eCC component on the letters UI form with the correct
+    # initial default set up eCC users. This only applies to new letters, ie when displaying the
+    # the UI form for a new letter.
+    #
+    # Example usage:
+    #
+    #   array_of_ecc_users = ResolveDefaultElectronicCCs
+    #     .for(patient)
+    #     .broadcasting_to_configured_subscribers
+    #     .call
+    #
+    class ResolveDefaultElectronicCCs
+      include Broadcasting
+      pattr_initialize :patient
+
+      def self.for(patient)
+        new(patient)
+      end
+
+      def call
+        array_of_user_ids = []
+        broadcast(
+          :request_default_electronic_cc_recipients_for_use_in_letters,
+          patient: patient,
+          array_of_user_ids: array_of_user_ids
+        )
+        array_of_user_ids.compact.uniq
+      end
+    end
+  end
+end

data/app/models/renalware/low_clearance/mdm_patients_query.rb

@@ -33,7 +33,7 @@ module Renalware
             .left_outer_joins(:current_observation_set)
             .with_current_modality_of_class(LowClearance::ModalityDescription)
             .public_send(named_filter.to_s)
-            .search(query)
+            .ransack(query)
         end
       end
       # rubocop:enable Metrics/MethodLength

data/app/models/renalware/medications/prescriptions_by_drug_type_query.rb

@@ -23,7 +23,7 @@ module Renalware
             .includes(patient: { current_modality: :description })
             .eager_load(drug: [:drug_types])
             .where("lower(drug_types.name) = lower(?)", drug_type_name)
-            .search(search_params)
+            .ransack(search_params)
         end
       end
     end

data/app/models/renalware/medications/prescriptions_query.rb

@@ -16,7 +16,7 @@ module Renalware
       end
 
       def search
-        @search ||= @relation.search(@search_params)
+        @search ||= @relation.ransack(@search_params)
       end
 
       private

data/app/models/renalware/patients/bookmarks_query.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Patients
+    class BookmarksQuery
+      attr_reader :default_relation, :query
+
+      def initialize(default_relation:, params: nil)
+        @default_relation = default_relation
+        @query = params || {}
+        @query[:s] ||= "created_at desc"
+      end
+
+      def call
+        search.result
+      end
+
+      # Note we *MUST* join onto patients for PatientsRansackHelper.identity_match to work.
+      # It might be better to refactor PatientsRansackHelper so we can include where required
+      # eg below using .extending(PatientsRansackHelper) rather than relying on it being in
+      # included in the model file.
+      # note that adding .includes(:created_by) here creates an ambigous column
+      # 'family_name' error
+      def search
+        @search ||= begin
+          (default_relation || Bookmark)
+            .extend(RansackScopes)
+            .joins(:patient)
+            .eager_load(patient: [current_modality: :description])
+            .order(created_at: :desc)
+            .ransack(query)
+        end
+      end
+
+      module RansackScopes
+        def self.extended(base)
+          # Using a custom ransacker here in order to sort by modality description name
+          # because using a predicate like  :patient_current_modality_description_name
+          # results in an INNER JOIN onto modalities.
+          base.ransacker :modality_desc do
+            Arel.sql("modality_descriptions.name")
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/patients/patient_search.rb

@@ -6,7 +6,7 @@ module Renalware
       def self.call(params)
         Renalware::Patient
           .includes(current_modality: [:description])
-          .search(params[:patient_search]).tap do |search|
+          .ransack(params[:patient_search]).tap do |search|
             search.sorts = %w(family_name_case_insensitive given_name)
           end
       end

data/app/models/renalware/pd/mdm_patients_query.rb

@@ -29,7 +29,7 @@ module Renalware
             .with_current_pathology
             .with_registration_statuses
             .left_outer_joins(:current_observation_set)
-            .search(q)
+            .ransack(q)
         end
       end
     end

data/app/models/renalware/renal/prd_descriptions/search_query.rb

@@ -21,7 +21,7 @@ module Renalware
         private
 
         def search
-          @search ||= PRDDescription.search(term_or_code_cont: term).tap do |s|
+          @search ||= PRDDescription.ransack(term_or_code_cont: term).tap do |s|
             s.sorts = ["term"]
           end
         end

data/app/models/renalware/transplants/live_donors_query.rb

@@ -16,7 +16,7 @@ module Renalware
 
       def search
         @search ||= begin
-          relation.search(q).tap do |search|
+          relation.ransack(q).tap do |search|
             search.sorts = DEFAULT_ORDER
           end
         end

data/app/models/renalware/transplants/mdm_patients_query.rb

@@ -35,7 +35,7 @@ module Renalware
             .with_current_pathology
             .left_outer_joins(:current_observation_set)
             .public_send(named_filter.to_s)
-            .search(q)
+            .ransack(q)
         end
       end
 

data/app/models/renalware/transplants/registrations/wait_list_query.rb

@@ -26,7 +26,7 @@ module Renalware
               .eager_load(current_status: :description)
               .merge(HD::Patient.with_profile)
               .merge(Renal::Patient.with_profile)
-              .search(query).tap do |s|
+              .ransack(query).tap do |s|
 
               s.sorts = ["patient_family_name, patient_given_name"]
             end

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

@@ -17,10 +17,9 @@ module Renalware
         :changed_since,
         :logger,
         :request_uuid,
-        :paths,
         :timestamp,
-        :summary,
-        :batch_number
+        :batch_number,
+        :summary
       )
 
       def initialize(changed_since: nil, patient_ids: nil, logger: nil)
@@ -29,20 +28,13 @@ module Renalware
         @logger = logger || Rails.logger
         @request_uuid = SecureRandom.uuid # helps group logs together
         @timestamp = Time.zone.now.strftime("%Y%m%d%H%M%S%L")
-
+        @batch_number ||= BatchNumber.next.number
         @summary = ExportSummary.new
       end
 
       def call
         logger.tagged(request_uuid) do
-          # Skipping transaction for now as worried about the quantity of rows and data invovled.
           ActiveRecord::Base.transaction do
-            @batch_number = BatchNumber.next.number
-            @paths = Paths.new(
-              timestamp: timestamp,
-              batch_number: batch_number,
-              working_path: config.ukrdc_working_path
-            )
             summary.milliseconds_taken = Benchmark.ms do
               create_patient_xml_files
               encrypt_patient_xml_files
@@ -62,6 +54,16 @@ module Renalware
 
       private
 
+      def paths
+        @paths ||= begin
+          Paths.new(
+            timestamp: timestamp,
+            batch_number: batch_number,
+            working_path: config.ukrdc_working_path
+          )
+        end
+      end
+
       def create_patient_xml_files
         patients = ukrdc_patients_who_have_changed_since_last_send
         summary.num_changed_patients = patients.count

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

@@ -10,24 +10,28 @@ module Renalware
         :patient!,
         :dir!,
         :request_uuid!,
-        :renderer,
         :changes_since,
         :logger,
-        :batch_number
+        :batch_number,
+        :renderer, # so we can pass a test renderer to bypass real rendering
+        :log
       ]
 
       # rubocop:disable Metrics/AbcSize
       def call
         update_patient_to_indicated_we_checked_them_for_any_relevant_changes
         UKRDC::TransmissionLog.with_logging(patient, request_uuid) do |log|
+          @log = log
           logger.info "  Patient #{patient.ukrdc_external_id}"
           xml_payload = build_payload(log)
-          if xml_payload_same_as_last_sent_payload?(xml_payload)
-            logger.info "    skipping as no change in XML file"
-            log.unsent_no_change_since_last_send!
-          else
-            create_xml_file(xml_payload, log)
-            update_patient_to_indicate_we_have_sent_their_data_to_ukrdc
+          if xml_payload.present?
+            if xml_payload_same_as_last_sent_payload?(xml_payload)
+              logger.info "    skipping as no change in XML file"
+              log.unsent_no_change_since_last_send!
+            else
+              create_xml_file(xml_payload, log)
+              update_patient_to_indicate_we_have_sent_their_data_to_ukrdc
+            end
           end
           logger.info "    Status: #{log.status}"
         end
@@ -72,17 +76,30 @@ module Renalware
       end
 
       def build_payload(log)
-        Payload.new(render_xml_for(patient)).tap do |payload|
-          log.payload = payload.to_s
-          log.payload_hash = payload.to_md5_hash
+        result = attempt_to_generate_patient_ukrdc_xml
+        if result.failure?
+          handle_invalid_xml(result)
+          nil
+        else
+          Payload.new(result.xml).tap do |payload|
+            log.payload = payload.to_s
+            log.payload_hash = payload.to_md5_hash
+          end
         end
       end
 
-      def render_xml_for(patient)
-        renderer.render(
-          "renalware/api/ukrdc/patients/show",
-          locals: { patient: presenter_for(patient) }
-        )
+      def attempt_to_generate_patient_ukrdc_xml
+        (renderer || default_renderer).call
+      end
+
+      def handle_invalid_xml(result)
+        log.error = result.validation_errors
+        log.status = :error
+        nil
+      end
+
+      def default_renderer
+        Renalware::UKRDC::XmlRenderer.new(locals: { patient: presenter_for(patient) })
       end
 
       def presenter_for(patient)
@@ -92,11 +109,6 @@ module Renalware
         )
       end
 
-      # Note a test might have passed in a mock renderer
-      def renderer
-        @renderer ||= Renalware::API::UKRDC::PatientsController.renderer
-      end
-
       def xml_filepath
         xml_filename = Filename.new(patient: patient, batch_number: batch_number).to_s
         File.join(dir, xml_filename)

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

@@ -16,7 +16,7 @@ module Renalware
         yield log if block_given?
         log.save!
       rescue StandardError => error
-        log.error = formatted_exception(error)
+        log.error << formatted_exception(error)
         log.status = :error
         log.save!
         raise error

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+
+module Renalware
+  module UKRDC
+    class XmlRenderer
+      DEFAULT_TEMPLATE = "/renalware/api/ukrdc/patients/show"
+      attr_reader :template, :xsd_path, :locals, :errors
+
+      class Success < Renalware::Success
+        alias_method :xml, :object
+      end
+
+      class Failure < Renalware::Failure
+        alias_method :validation_errors, :object
+      end
+
+      def initialize(template: nil, xsd_path: nil, locals: {})
+        @template = template || DEFAULT_TEMPLATE
+        @xsd_path = xsd_path || default_xsd_path
+        @locals = locals
+      end
+
+      # If we successfully generate the UKRDC XML for a patient, return a Success object where
+      # success#xml is the valid XML
+      # If there are XSD validation messages, we return a Failure object where
+      # failure#validation_messages is an array of XSD validation messages.
+      def call
+        return XmlRenderer::Failure.new(validation_errors) if validation_errors.any?
+
+        XmlRenderer::Success.new(xml)
+      end
+
+      def xml
+        @xml ||= begin
+          API::UKRDC::PatientsController.new.render_to_string(
+            template: template,
+            format: :xml,
+            locals: locals,
+            encoding: "UTF-8"
+          )
+        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
+      end
+
+      private
+
+      def default_xsd_path
+        File.join(Renalware::Engine.root, "vendor/xsd/ukrdc/Schema/UKRDC.xsd")
+      end
+    end
+  end
+end
+
+#
+# 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
+# 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
+#   end
+# end
+
+# # Render XML
+# respond_with rdc_patient, camelize: true
+#