dde_client 0.1.0

data/app/services/dde_client/rollback_service.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+# this class will basically handle rolling back patients that were merged
+# rubocop:disable Metrics/ClassLength
+class DdeClient::RollbackService
+  attr_accessor :primary_patient, :secondary_patient, :merge_type, :visit_type
+
+  Dde_CONFIG_PATH = 'config/application.yml'
+
+  # rubocop:disable Metrics/MethodLength
+  def rollback_merged_patient(patient_id, visit_type_id)
+    @visit_type = VisitType.find(visit_type_id)
+    tree = DdeClient::MergeAuditService.new.fetch_merge_audit(patient_id)
+    ActiveRecord::Base.transaction do
+      tree.each do |record|
+        @primary_patient = record['primary_id']
+        @secondary_patient = record['secondary_id']
+        @merge_type = record['merge_type']
+        Rails.logger.debug("Processing rollback for patients: #{primary_patient} <=> #{secondary_patient}")
+        process_rollback
+        MergeAudit.find(record['id']).void("Rolling back to #{secondary_patient}")
+        @common_void_reason = nil
+      end
+    end
+    Patient.find(patient_id)
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  private
+
+  def process_rollback
+    rollback_dde
+    rollback_patient
+    rollback_encounter
+    rollback_order
+    rollback_observation
+    rollback_address
+    rollback_attributes
+    rollback_identifiers
+    rollback_remote_identifiers
+    rollback_name
+  end
+
+  # fetch patient doc id
+  def fetch_patient_doc_id(patient_id)
+    result = ActiveRecord::Base.connection.select_one <<~SQL
+      SELECT identifier
+      FROM patient_identifier
+      WHERE patient_id = #{patient_id}
+      AND identifier_type = #{PatientIdentifierType.find_by_name!('Dde person document ID').id}
+    SQL
+    result.blank? ? nil : result['identifier']
+  end
+
+  def rollback_dde
+    return unless merge_type.match(/remote/i)
+
+    response, status = dde_client.post('rollback_merge',
+                                       primary_person_doc_id: fetch_patient_doc_id(primary_patient),
+                                       secondary_person_doc_id: fetch_patient_doc_id(secondary_patient))
+
+    raise "Failed to rollback patients on Dde side: #{status} - #{response}" unless status == 200
+  end
+
+  # this is the method to rollback patient name
+  def rollback_name
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM person_name
+      WHERE voided = 1
+      AND person_id = #{secondary_patient}
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_name(voided_names: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE person_name SET #{common_void_columns} #{extra_fields}  WHERE person_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_identifiers
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM patient_identifier
+      WHERE patient_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_identifiers(voided_identifiers: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE patient_identifier SET #{common_void_columns} WHERE patient_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_remote_identifiers
+    return unless merge_type.match(/remote/i)
+
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE patient_identifier SET #{common_void_columns} WHERE patient_id = #{secondary_patient} AND void_reason = 'Assigned new id: #{fetch_patient_doc_id(primary_patient)}'
+    SQL
+  end
+
+  def rollback_attributes
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM person_attribute
+      WHERE person_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_attributes(voided_attributes: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE person_attribute SET #{common_void_columns} #{extra_fields} WHERE person_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_address
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM person_address
+      WHERE person_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_addresses(voided_addresses: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE person_address SET #{common_void_columns} WHERE person_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_encounter
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM encounter
+      WHERE patient_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_encounters(voided_encounters: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE encounter SET #{common_void_columns} #{extra_fields}  WHERE patient_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_observation
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM obs
+      WHERE person_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_observations(voided_observations: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE obs SET #{common_void_columns} WHERE person_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_order
+    result = ActiveRecord::Base.connection.select_all <<~SQL
+      SELECT * FROM orders
+      WHERE patient_id = #{secondary_patient} AND voided = 1
+      AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'
+    SQL
+    process_orders(voided_orders: result)
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE orders SET #{common_void_columns} WHERE patient_id = #{common_void_reason}
+    SQL
+  end
+
+  def rollback_patient
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE patient SET #{common_void_columns} #{extra_fields}  WHERE patient_id = #{common_void_reason}
+    SQL
+    rollback_person
+  end
+
+  def rollback_person
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE person SET #{common_void_columns} #{extra_fields} WHERE person_id = #{common_void_reason}
+    SQL
+    rollback_patient_visit_type_and_state
+    rollback_relationship
+  end
+
+  def rollback_patient_visit_type_and_state
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE patient_state ps
+      INNER JOIN patient_visit_type pp ON ps.patient_visit_type_id = pp.patient_visit_type_id
+      SET ps.date_voided = NULL, ps.void_reason = NULL, ps.voided_by = NULL, ps.voided = 0, ps.date_changed = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}', ps.changed_by = #{User.current.id},
+      pp.date_voided = NULL, pp.void_reason = NULL, pp.voided_by = NULL, pp.voided = 0, pp.date_changed = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}', pp.changed_by = #{User.current.id}
+      WHERE pp.patient_id = #{secondary_patient}
+      AND ps.void_reason = 'Merged into patient ##{primary_patient}:0'
+      AND pp.void_reason = 'Merged into patient ##{primary_patient}:0'
+    SQL
+  end
+
+  def rollback_relationship
+    ActiveRecord::Base.connection.execute <<~SQL
+      UPDATE relationship SET #{common_void_columns} WHERE person_a = #{common_void_reason}
+    SQL
+  end
+
+  def process_name(voided_names: nil)
+    return if voided_names.blank?
+
+    voided_names.each do |name|
+      patient_id, row_id = process_patient_id_and_row_id(name['void_reason'])
+      record = PersonName.find_by(person_name_id: row_id, person_id: patient_id)
+      record&.void("Rollback to patient ##{name['person_id']}:#{name['person_name_id']}")
+    end
+  end
+
+  def process_identifiers(voided_identifiers: nil)
+    return if voided_identifiers.blank?
+
+    voided_identifiers.each do |identifier|
+      patient_id, row_id = process_patient_id_and_row_id(identifier['void_reason'])
+      record = PatientIdentifier.find_by(patient_identifier_id: row_id, patient_id: patient_id)
+      record&.void("Rollback to patient ##{identifier['patient_id']}:#{identifier['patient_identifier_id']}")
+    end
+  end
+
+  def process_attributes(voided_attributes: nil)
+    return if voided_attributes.blank?
+
+    voided_attributes.each do |attribute|
+      patient_id, row_id = process_patient_id_and_row_id(attribute['void_reason'])
+      record = PersonAttribute.find_by(person_attribute_id: row_id, person_id: patient_id)
+      record&.void("Rollback to patient ##{attribute['person_id']}:#{attribute['person_attribute_id']}")
+    end
+  end
+
+  def process_addresses(voided_addresses: nil)
+    return if voided_addresses.blank?
+
+    voided_addresses.each do |address|
+      patient_id, row_id = process_patient_id_and_row_id(address['void_reason'])
+      record = PersonAddress.find_by(person_address_id: row_id, person_id: patient_id)
+      record&.void("Rollback to patient ##{address['person_id']}:#{address['person_address_id']}")
+    end
+  end
+
+  def process_encounters(voided_encounters: nil)
+    return if voided_encounters.blank?
+
+    voided_encounters.each do |encounter|
+      patient_id, row_id = process_patient_id_and_row_id(encounter['void_reason'])
+      record = Encounter.find_by(encounter_id: row_id, patient_id: patient_id)
+      record&.void("Rollback to patient ##{encounter['patient_id']}:#{encounter['encounter_id']}")
+    end
+  end
+
+  def process_observations(voided_observations: nil)
+    return if voided_observations.blank?
+
+    voided_observations.each do |obs|
+      patient_id, row_id = process_patient_id_and_row_id(obs['void_reason'])
+      record = Observation.find_by(obs_id: row_id, person_id: patient_id)
+      record&.void("Rollback to patient ##{obs['person_id']}:#{obs['obs_id']}")
+    end
+  end
+
+  def process_orders(voided_orders: nil)
+    return if voided_orders.blank?
+
+    voided_orders.each do |order|
+      patient_id, row_id = process_patient_id_and_row_id(order['void_reason'])
+      record = Order.find_by(order_id: row_id, patient_id: patient_id)
+      record&.void("Rollback to patient ##{order['patient_id']}:#{order['order_id']}")
+    end
+  end
+
+  def process_patient_id_and_row_id(reason)
+    reason.split('#')[1].split(':')
+  end
+
+  def remove_common_field(record)
+    record.delete('uuid')
+    record.delete('voided')
+    record.delete('voided_by')
+    record.delete('date_voided')
+    @reason = record.delete('void_reason')
+    record
+  end
+
+  def common_void_columns
+    @common_void_columns ||= 'date_voided = NULL, void_reason = NULL, voided_by = NULL, voided = 0'
+  end
+
+  def extra_fields
+    @extra_fields ||= ", date_changed = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}', changed_by = #{User.current.id}"
+  end
+
+  def common_void_reason
+    @common_void_reason ||= " #{secondary_patient} AND void_reason LIKE 'Merged into patient ##{primary_patient}:%'"
+  end
+
+  def dde_client
+    client = DdeClient.new
+
+    connection = dde_connections[visit_type.id]
+
+    dde_connections[visit_type.id] = if connection
+                                    client.restore_connection(connection)
+                                  else
+                                    client.connect(dde_config)
+                                  end
+
+    client
+  end
+
+  def dde_connections
+    @dde_connections ||= {}
+  end
+
+  # Loads a dde client into the dde_clients_cache for the
+  def dde_config
+    main_config = YAML.load_file(Dde_CONFIG_PATH)['dde']
+    raise 'No configuration for Dde found' unless main_config
+
+    visit_type_config = main_config[visit_type.name.downcase]
+    raise "No Dde config for visit_type #{visit_type.name} found" unless visit_type_config
+
+    {
+      url: main_config['url'],
+      username: visit_type_config['username'],
+      password: visit_type_config['password']
+    }
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/app/services/merge_audit_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# This service will handle merge audits with their tree structure
+class MergeAuditService
+  # This method a merge audit for us
+  def create_merge_audit(primary_patient, secondary_patient, merge_type)
+    recent_merge_id = MergeAudit.where(primary_id: secondary_patient).last&.id
+    merge_audit = MergeAudit.create({ primary_id: primary_patient, secondary_id: secondary_patient,
+                                      creator: User.current.id, merge_type: merge_type,
+                                      secondary_previous_merge_id: recent_merge_id })
+    raise "Could not create audit trail due to #{merge_audit.errors.as_json}" unless merge_audit.errors.empty?
+  end
+
+  # this uses the patient identifier to get the audit tree
+  def get_patient_audit(identifier)
+    fetch_merge_audit(find_voided_identifier(identifier))
+  end
+
+  # this uses the patient id to get the audit tree and it is used by get patient_audit
+  def fetch_merge_audit(secondary)
+    first_merge = common_merge_fetch('ma.secondary_id', secondary)
+    raise NotFoundError, "There is no merge for #{secondary}" if first_merge.blank?
+
+    count = 0
+    tree = [first_merge.merge({ 'merge_number' => count += 1 })]
+    merge_id = MergeAudit.where(primary_id: first_merge['primary_id']).last&.id
+    until merge_id.blank?
+      parent = common_merge_fetch('ma.secondary_previous_merge_id', merge_id)
+      tree << parent.merge({ 'merge_number' => count += 1 }) unless parent.blank?
+      merge_id = parent.blank? ? nil : MergeAudit.where(primary_id: parent['primary_id']).last&.id
+    end
+    tree.reverse
+  end
+
+  def common_merge_fetch(field, fetch_value)
+    ActiveRecord::Base.connection.select_one <<~SQL
+      SELECT ma.id, ma.primary_id, ma.secondary_id, ma.created_at merge_date, ma.merge_type, pn.given_name primary_first_name, pn.family_name primary_surname, p.gender primary_gender, p.birthdate primary_birthdate,
+      spn.given_name secondary_first_name, spn.family_name secondary_surname, sp.gender secondary_gender, sp.birthdate secondary_birthdate
+      FROM merge_audits ma
+      INNER JOIN person_name pn ON pn.person_id = ma.primary_id
+      INNER JOIN person p ON p.person_id = ma.primary_id
+      INNER JOIN person_name spn ON spn.person_id = ma.secondary_id AND spn.voided = 1
+      INNER JOIN person sp ON sp.person_id = ma.secondary_id AND sp.voided = 1
+      WHERE #{field} = #{fetch_value} AND ma.voided = 0
+    SQL
+  end
+
+  def find_voided_identifier(identifier)
+    result = ActiveRecord::Base.connection.select_one <<~SQL
+      SELECT patient_id FROM patient_identifier WHERE identifier = '#{identifier}' AND identifier_type = 3 AND voided = 1 ORDER BY date_voided ASC
+    SQL
+    raise NotFoundError, "Failed to find voided identifier: #{identifier}" if result.blank?
+
+    result['patient_id']
+  end
+end

data/app/utils/model_utils.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# This module contains utility methods for retrieving models
+module ModelUtils
+  # Retrieve concept by its name
+  #
+  # Parameters:
+  #  name - A string repr of the concept name
+  def concept(name)
+    Concept.joins(:concept_names).where('concept_name.name = ?', name).first
+  end
+
+  def concept_name(name)
+    ConceptName.find_by(name: name)
+  end
+
+  def concept_name_to_id(name)
+    return nil if name.blank?
+
+    concept_name(name)&.concept_id
+  end
+
+  def concept_id_to_name(id)
+    return nil if id.blank?
+
+    concept = Concept.find_by_concept_id(id)
+    concept&.fullname
+  end
+
+  def visit_type(name)
+    VisitType.find_by_name(name)
+  end
+
+  def encounter_type(name)
+    EncounterType.find_by name: name
+  end
+
+  def global_property(name)
+    GlobalProperty.find_by property: name
+  end
+
+  def user_property(name, user_id: nil)
+    user_id ||= User.current.user_id
+    UserProperty.find_by(user_id: user_id, property: name)
+  end
+
+  def order_type(name)
+    OrderType.find_by_name(name)
+  end
+
+  def report_type(name)
+    ReportType.find_by_name(name)
+  end
+
+  def patient_identifier_type(name)
+    PatientIdentifierType.find_by_name(name)
+  end
+
+  def drug(name)
+    Drug.find_by_name(name)
+  end
+end

data/app/views/layouts/dde/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dde</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "dde/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,14 @@
+DdeClient::Engine.routes.draw do
+    get '/patients/find_by_npid', to: 'api/v1/dde#find_patients_by_npid'
+    get '/patients/find_by_name_and_gender', to: 'api/v1/dde#find_patients_by_name_and_gender'
+    get '/patients/import_by_doc_id', to: 'api/v1/dde#import_patients_by_doc_id'
+    get '/patients/import_by_npid', to: 'api/v1/dde#import_patients_by_npid'
+    get '/patients/match_by_demographics', to: 'api/v1/dde#match_patients_by_demographics'
+    get '/patients/diff', to: 'api/v1/dde#patient_diff'
+    get '/patients/refresh', to: 'api/v1/dde#refresh_patient'
+    post '/patients/reassign_npid', to: 'api/v1/dde#reassign_patient_npid'
+    post '/patients/merge', to: 'api/v1/dde#merge_patients'
+    get '/patients/remaining_npids', to: 'api/v1/dde#remaining_npids'
+    get '/rollback/merge_history', to: 'rollback#merge_history'
+    post '/rollback/rollback_patient', to: 'rollback#rollback_patient'
+end

data/lib/dde_client/client_error.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class ClientError < StandardError; end

data/lib/dde_client/engine.rb

@@ -0,0 +1,5 @@
+module DdeClient
+  class Engine < ::Rails::Engine
+    isolate_namespace DdeClient
+  end
+end

data/lib/dde_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DdeClient
+  VERSION = "0.1.0"
+end

data/lib/dde_client.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "dde_client/version"
+require "dde_client/engine"
+
+module DdeClient
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: dde_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bryan-mw
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.8
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- brianmsyamboza@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/dde_client_manifest.js
+- app/assets/stylesheets/dde_client/application.css
+- app/controllers/dde_client/api/v1/dde_controller.rb
+- app/controllers/dde_client/api/v1/rollback_controller.rb
+- app/controllers/dde_client/application_controller.rb
+- app/helpers/dde/application_helper.rb
+- app/jobs/dde/application_job.rb
+- app/mailers/dde/application_mailer.rb
+- app/models/dde/application_record.rb
+- app/services/dde_client/dde_client.rb
+- app/services/dde_client/dde_service.rb
+- app/services/dde_client/matcher.rb
+- app/services/dde_client/merging_service.rb
+- app/services/dde_client/rollback_service.rb
+- app/services/merge_audit_service.rb
+- app/utils/model_utils.rb
+- app/views/layouts/dde/application.html.erb
+- config/routes.rb
+- lib/dde_client.rb
+- lib/dde_client/client_error.rb
+- lib/dde_client/engine.rb
+- lib/dde_client/version.rb
+homepage: https://github.com/orgs/Malawi-Ministry-of-Health/dde_client
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/orgs/Malawi-Ministry-of-Health/dde_client
+  source_code_uri: https://github.com/orgs/Malawi-Ministry-of-Health/dde_client
+  changelog_uri: https://github.com/orgs/Malawi-Ministry-of-Health/dde_client/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.6
+signing_key:
+specification_version: 4
+summary: DDE stands for Demographics Data Exchange. Its main purpose is to manage
+  patient IDs.
+test_files: []