dde_mahis 0.1.4

data/app/services/matcher.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# module DdeMahis
+  ##
+  # Matches local and remote (DdeMahis) people.
+  #
+  # TODO: Move module to own file
+  class Matcher
+    class << self
+      def find_differences(local_person, remote_person)
+        FIELDS_TO_MATCH
+          .map { |field| [field, diff_field(field, local_person, remote_person)] }
+          .reject { |_field, diff| diff.nil? }
+          .each_with_object({}) { |sub_diff, diff| diff[sub_diff[0]] = sub_diff[1] }
+      end
+
+      private
+
+      FIELDS_TO_MATCH = %w[given_name family_name birthdate birthdate_estimated gender
+                           current_village current_traditional_authority current_district
+                           home_village home_traditional_authority home_district
+                           npid].freeze
+
+      LOCATION_FIELDS = %w[current_village current_traditional_authority current_district
+                           home_village home_traditional_authority home_district].freeze
+
+      def diff_field(field, local_person, remote_person)
+        return diff_location(field, local_person, remote_person) if LOCATION_FIELDS.include?(field)
+
+        send("diff_#{field}", local_person, remote_person)
+      end
+
+      def diff_given_name(local_person, remote_person)
+        local_name = PersonName.find_by_person_id(local_person.person_id)
+
+        return nil if local_name&.given_name&.casecmp?(remote_person['given_name'])
+
+        { local: local_name.given_name, remote: remote_person['given_name'] }
+      end
+
+      def diff_family_name(local_person, remote_person)
+        local_name = PersonName.find_by_person_id(local_person.person_id)
+
+        return nil if local_name&.family_name&.casecmp?(remote_person['family_name'])
+
+        { local: local_name.family_name, remote: remote_person['family_name'] }
+      end
+
+      def diff_birthdate(local_person, remote_person)
+        return nil if local_person.birthdate&.to_date == remote_person['birthdate'].to_date
+
+        { local: local_person.birthdate, remote: remote_person['birthdate'] }
+      end
+
+      def diff_birthdate_estimated(local_person, remote_person)
+        birthdate_estimated = local_person.birthdate_estimated.positive?
+
+        return nil if birthdate_estimated == remote_person['birthdate_estimated']
+
+        { local: birthdate_estimated, remote: remote_person['birthdate_estimated'] }
+      end
+
+      def diff_gender(local_person, remote_person)
+        return nil if local_person.gender.first.casecmp?(remote_person['gender'].first)
+
+        { local: local_person.gender, remote: remote_person['gender'] }
+      end
+
+      def diff_npid(local_person, remote_person)
+        npid_type = PatientIdentifierType.where(name: 'National id')
+        local_npid = PatientIdentifier.find_by(patient_id: local_person.person_id, identifier_type: npid_type)&.identifier
+
+        return nil if local_npid&.casecmp?(remote_person['npid'])
+
+        { local: local_npid, remote: remote_person['npid'] }
+      end
+
+      def diff_location(field, local_person, remote_person)
+        local_address = PersonAddress.find_by_person_id(local_person.person_id)
+        remote_address = remote_person['attributes']
+
+        return nil if local_address.send(field).casecmp?(remote_address[field])
+        { local: local_address.send(field), remote: remote_address[field] }
+      end
+
+      def current_location_id
+        Location.current_health_center.location_id
+      end
+    end
+  end
+
+# end

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