malawi_hiv_program_reports 1.0.15 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ce22e02f1228c154f6012ab0a902d6840a7e1549d87e98086e5d2fd012bdf01
-  data.tar.gz: 16039bf5d7a249f56ff008396d3e4174e46b224ec687ee44aa181512977a820c
+  metadata.gz: 2528255432f2df888bfc40d425af064647391095c2a0ceebe9512e348fbe2f63
+  data.tar.gz: 75916f779053f8acf6e1aa4ef258668961266eff12eadd92bdd4cd3cbf3e5a7f
 SHA512:
-  metadata.gz: a954668190f6d5191f0e3ae7a2bad0f429d8069906df593f0965fa01e3a0415821cfa94afc79e49a1c4dae6c1ae80c17eb9e4d5c459a65a9d736b6b3a4bb5176
-  data.tar.gz: 3bc66cb64a5fb07fcafb22391d29e828fac5cb93a5487c27087213775584239c2e6757facae70162e07bffd47ba295dd452ccb47b18001d2a27d2bacc97f9d29
+  metadata.gz: 7f98b4442247cc8fce9df43887e4ee9cccfdae8017d15fd8f67a301c89428cf54a1c1e411c9e61fc4c56f99de41a45a2732303063ecf7b17a18b46efedba8aa3
+  data.tar.gz: c3d0300aa8341c5bc387cf3ff89b854012d2b093cd058453278fbb378129b0e29ddd650a973d53d0e830953779e922e5a81a5c214006b7cbc53788473a86fa19

data/app/services/malawi_hiv_program_reports/clinic/patients_alive_and_on_treatment.rb

@@ -34,7 +34,7 @@ module MalawiHivProgramReports
       end
 
       def query
-        with_lock(Cohort::LOCK_FILE) do
+        with_lock(Moh::Cohort::LOCK_FILE) do
           refresh_outcomes_table if @rebuild_outcomes || !outcomes_table_exists?
 
           ::Patient.find_by_sql <<~SQL

data/app/services/malawi_hiv_program_reports/clinic/regimens_by_weight_and_gender.rb

@@ -36,7 +36,7 @@ module MalawiHivProgramReports
       ].freeze
 
       def regimen_counts
-        with_lock(Cohort::LOCK_FILE) do
+        with_lock(Moh::Cohort::LOCK_FILE) do
           PatientsAliveAndOnTreatment.new(start_date:, end_date:, occupation: @occupation)
                                      .refresh_outcomes_table
 

data/app/services/malawi_hiv_program_reports/moh/{cohort.rb → art_cohort.rb}

@@ -8,7 +8,7 @@ module MalawiHivProgramReports
     # the constructor. This method must be called to build report and save
     # it to database.
     # rubocop:disable Metrics/ClassLength
-    class Cohort
+    class ArtCohort
       include MalawiHivProgramReports::Utils::ConcurrencyUtils
       include MalawiHivProgramReports::Utils::ModelUtils
       include MalawiHivProgramReports::Adapters::Moh::Custom
@@ -30,8 +30,8 @@ module MalawiHivProgramReports
       def build_report
         with_lock(LOCK_FILE, blocking: false) do
           init_drill_down_table
-          clear_drill_down
           @cohort_builder.build(@cohort_struct, @start_date, @end_date, @occupation)
+          clear_drill_down
           save_report
         end
       rescue ::FailedToAcquireLock => e
@@ -152,6 +152,12 @@ module MalawiHivProgramReports
 
       LOGGER = Rails.logger
 
+      def find_saved_report
+        result = ::Report.where(type: @type, name: "#{@name}#{"-#{@occupation}"}#{"-#{@location_name}"}",
+                                start_date: @start_date, end_date: @end_date)
+        result&.map { |r| r['id'] } || []
+      end
+
       # Writes the report to database
       def save_report
         ::Report.transaction do
@@ -196,6 +202,7 @@ module MalawiHivProgramReports
       def clear_drill_down
         ActiveRecord::Base.connection.execute <<~SQL
           DELETE FROM cohort_drill_down #{site_manager(operator: 'WHERE', column: 'site_id', location: @location)}
+          #{find_saved_report.count.positive? ? "AND reporting_report_design_resource_id IN (#{find_saved_report.join(',')})" : ''}
         SQL
       rescue StandardError => e
         ActiveRecord::Base.connection.execute 'DROP TABLE IF EXISTS cohort_drill_down;'

data/app/services/malawi_hiv_program_reports/moh/cumulative_cohort.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module MalawiHivProgramReports
+  module Moh
+    # This is the Cumulative Cohort Builder class
+    # rubocop:disable Metrics/ClassLength
+    class CumulativeCohort
+      include MalawiHivProgramReports::Utils::CommonSqlQueryUtils
+
+      attr_reader :start_date, :end_date, :locations, :rebuild, :outcome, :definition
+
+      LOCK_FILE = 'art_service/reports/cumulative_cohort.lock'
+
+      def initialize(start_date:, end_date:, **kwargs)
+        @start_date = ActiveRecord::Base.connection.quote(start_date)
+        @end_date = ActiveRecord::Base.connection.quote(end_date)
+        @rebuild = kwargs[:rebuild]&.casecmp?('true')
+        locations = kwargs[:locations]
+        @locations = locations.present? ? locations.split(',') : []
+        @definition = kwargs[:definition]
+      end
+
+      def find_report
+        start_time = Time.now
+        prepare_tables
+        clear_tables if rebuild
+        process_thread
+        end_time = Time.now
+        time_in_minutes = ((end_time - start_time) / 60).round(2)
+        Rails.logger.info("Cumulative Cohort report took #{time_in_minutes} minutes to generate")
+        { cohort_time: time_in_minutes }
+      end
+
+      private
+
+      # we have these steps to build the cohort report for all patients nation wide
+      # 1. We want to filter out patients who are drug refills and consultations as at the end of the quarter
+      # 2. We want to check who in 1 was registered as facility client at the end of the quarter
+      # 3. We want to the first ARV dispensation date for each patient and may not necessarily be in 2 above but as at the end of the quarter
+      # 4. We want to get information on whether the clients in 3 above have ever registered somewhere else. This is to check if they are transfers in
+      # 5. We want to get information on clients birthdate etc after joining all the above
+      # 6. Finally we want to get the outcomes of the clients in 5 above
+
+      # rubocop:disable Metrics/MethodLength
+      def process_thread
+        # use locations to thread but process 10 locations at a time
+        queue = Queue.new
+        locations.each { |loc| queue << loc }
+
+        threads = Array.new(10) do
+          Thread.new do
+            until queue.empty?
+              loc = begin
+                queue.pop(true)
+              rescue StandardError
+                nil
+              end
+              next unless loc
+
+              ActiveRecord::Base.connection_pool.with_connection do
+                process_data loc
+              end
+            end
+          end
+        end
+
+        threads.each(&:join)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def process_data(location)
+        cdr_other_patient_types location
+        external_clients location
+        transfer_ins location
+        min_drug_orders location
+        potential_cohort_members location
+        reason_for_starting_art location
+        cohort_members location
+        outcome = MalawiHivProgramReports::Moh::CumulativeOutcome.new(end_date:, location:, definition:, rebuild:)
+        outcome.find_report
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def prepare_tables
+        create_cdr_other_patient_types unless check_if_table_exists('cdr_other_patient_types')
+        create_temp_potential_cohort_members_table unless check_if_table_exists('cdr_temp_potential_cohort_members')
+        create_min_drug_orders_table unless check_if_table_exists('cdr_temp_min_drug_orders')
+        create_transfer_ins_table unless check_if_table_exists('cdr_temp_transfer_ins')
+        create_external_clients_table unless check_if_table_exists('cdr_temp_external_clients')
+        create_temp_cohort_members_table unless check_if_table_exists('cdr_temp_cohort_members')
+        create_cdr_reason_for_starting_art unless check_if_table_exists('cdr_reason_for_starting_art')
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def create_external_clients_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_external_clients (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              patient_types VARCHAR(255) DEFAULT NULL,
+              encounter_id INT(11) DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+      end
+
+      def create_min_drug_orders_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_min_drug_orders (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              start_date DATE DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+      end
+
+      def create_transfer_ins_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_transfer_ins (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              value_datetime DATE DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def create_temp_potential_cohort_members_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_potential_cohort_members (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              birthdate DATE DEFAULT NULL,
+              birthdate_estimated TINYINT(1) DEFAULT NULL,
+              death_date DATE DEFAULT NULL,
+              gender CHAR(1) DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+      end
+
+      def create_temp_cohort_members_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_cohort_members (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              birthdate DATE DEFAULT NULL,
+              birthdate_estimated TINYINT(1) DEFAULT NULL,
+              death_date DATE DEFAULT NULL,
+              gender CHAR(1) DEFAULT NULL,
+              date_enrolled DATE DEFAULT NULL,
+              earliest_start_date DATE DEFAULT NULL,
+              recorded_start_date DATE DEFAULT NULL,
+              age_at_initiation INT(11) DEFAULT NULL,
+              age_in_days INT(11) DEFAULT NULL,
+              reason_for_starting_art INT(11) DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_cohort_member_indexes
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def check_if_table_exists(table_name)
+        result = ActiveRecord::Base.connection.select_one <<~SQL
+          SELECT COUNT(*) AS count
+          FROM information_schema.tables
+          WHERE table_schema = DATABASE()
+          AND table_name = '#{table_name}'
+        SQL
+        result['count'].to_i.positive?
+      end
+
+      def create_cohort_member_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_enrolled ON cdr_temp_cohort_members (date_enrolled)
+        SQL
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_earliest ON cdr_temp_cohort_members (earliest_start_date)
+        SQL
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_recorded ON cdr_temp_cohort_members (recorded_start_date)
+        SQL
+      end
+
+      def create_cdr_other_patient_types
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_other_patient_types (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+      end
+
+      def create_cdr_reason_for_starting_art
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_reason_for_starting_art (
+              patient_id INT(11) NOT NULL,
+              site_id INT(11) NOT NULL,
+              reason_for_starting_art INT(11) DEFAULT NULL,
+              PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_cdr_reason_for_starting_art_indexes
+      end
+
+      def create_cdr_reason_for_starting_art_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_reason_for_starting_art ON cdr_reason_for_starting_art (reason_for_starting_art)
+        SQL
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def cohort_members(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_cohort_members
+          SELECT
+              pcm.patient_id,
+              pcm.site_id,
+              pcm.birthdate,
+              pcm.birthdate_estimated,
+              pcm.death_date,
+              pcm.gender,
+              mdo.start_date AS date_enrolled,
+              COALESCE(ti.value_datetime, mdo.start_date) AS earliest_start_date,
+              ti.value_datetime AS recorded_start_date,
+              IF(pcm.birthdate IS NOT NULL, TIMESTAMPDIFF(YEAR, pcm.birthdate,  COALESCE(ti.value_datetime, mdo.start_date)), NULL) AS age_at_initiation,
+              IF(pcm.birthdate IS NOT NULL, TIMESTAMPDIFF(DAY, pcm.birthdate,  COALESCE(ti.value_datetime, mdo.start_date)), NULL) AS age_in_days,
+              rfsa.reason_for_starting_art
+          FROM cdr_temp_potential_cohort_members pcm
+          INNER JOIN cdr_temp_min_drug_orders mdo ON mdo.patient_id = pcm.patient_id AND mdo.site_id = pcm.site_id
+          INNER JOIN cdr_reason_for_starting_art rfsa ON rfsa.patient_id = pcm.patient_id AND rfsa.site_id = pcm.site_id
+          LEFT JOIN cdr_temp_transfer_ins ti ON ti.patient_id = pcm.patient_id AND ti.site_id = pcm.site_id
+          WHERE pcm.site_id = #{location}
+          HAVING reason_for_starting_art IS NOT NULL
+            ON DUPLICATE KEY UPDATE birthdate = VALUES(birthdate), birthdate_estimated = VALUES(birthdate_estimated), death_date = VALUES(death_date),
+            gender = VALUES(gender), date_enrolled = VALUES(date_enrolled), earliest_start_date = VALUES(earliest_start_date),
+            recorded_start_date = VALUES(recorded_start_date), age_at_initiation = VALUES(age_at_initiation),
+            age_in_days = VALUES(age_in_days), reason_for_starting_art = VALUES(reason_for_starting_art)
+        SQL
+      end
+
+      def potential_cohort_members(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_potential_cohort_members
+          SELECT
+              pp.patient_id,
+              pp.site_id,
+              p.birthdate,
+              p.birthdate_estimated,
+              p.death_date,
+              LEFT(p.gender, 1) gender
+          FROM patient_program pp
+          INNER JOIN person p ON p.person_id = pp.patient_id AND p.site_id = pp.site_id AND p.voided = 0
+          INNER JOIN patient_state ps ON ps.patient_program_id = pp.patient_program_id AND ps.site_id = pp.site_id
+              AND ps.voided = 0 AND ps.state = 7 AND ps.start_date IS NOT NULL -- 7 is On antiretrovirals
+              AND ps.start_date < (DATE(#{end_date}) + INTERVAL 1 DAY)
+          WHERE pp.program_id = 1 AND pp.voided = 0 AND (pp.patient_id, pp.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_external_clients)
+          AND pp.site_id = #{location}
+          GROUP BY pp.patient_id, pp.site_id
+          ON DUPLICATE KEY UPDATE birthdate = VALUES(birthdate), birthdate_estimated = VALUES(birthdate_estimated), death_date = VALUES(death_date),
+            gender = VALUES(gender)
+        SQL
+      end
+
+      def min_drug_orders(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_min_drug_orders
+          SELECT o.patient_id, o.site_id, DATE(MIN(o.start_date)) start_date
+          FROM orders o
+          INNER JOIN drug_order do ON do.order_id = o.order_id AND do.site_id = o.site_id AND do.quantity > 0
+          LEFT JOIN (
+            SELECT o.person_id patient_id, o.site_id, DATE(MIN(o.obs_datetime)) registered_date
+            FROM obs o
+            INNER JOIN cdr_other_patient_types other ON other.patient_id = o.person_id AND other.site_id = o.site_id
+            WHERE o.concept_id = 3289 -- Type of patient
+                AND o.value_coded = 7572 -- New patient
+                AND o.voided = 0
+                AND o.obs_datetime < (DATE(#{end_date}) + INTERVAL 1 DAY)
+            GROUP BY o.person_id, o.site_id
+          ) np ON np.patient_id = o.patient_id AND np.site_id = o.site_id
+          WHERE o.voided = 0 AND o.start_date < (DATE(#{end_date}) + INTERVAL 1 DAY)
+            AND o.start_date > COALESCE(np.registered_date, DATE('1900-01-01'))
+            AND o.concept_id IN (SELECT concept_id FROM concept_set WHERE concept_set = 1085) -- 1085 is ARV DRUGS
+            AND o.order_type_id = 1 AND o.site_id = #{location}
+          GROUP BY o.patient_id, o.site_id
+          ON DUPLICATE KEY UPDATE start_date = VALUES(start_date)
+        SQL
+      end
+
+      def transfer_ins(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_transfer_ins
+          SELECT o.person_id, o.site_id, DATE(MIN(o.value_datetime)) value_datetime
+          FROM obs o
+          INNER JOIN encounter e ON e.patient_id = o.person_id AND e.site_id = o.site_id AND e.encounter_id = o.encounter_id
+           AND e.program_id = 1 AND e.encounter_datetime < (DATE(#{end_date}) + INTERVAL 1 DAY)
+           AND e.encounter_type = 9 -- HIV CLINIC REGISTRATION
+           AND e.voided = 0
+          WHERE o.concept_id = 2516 AND o.voided = 0 AND o.obs_datetime < (DATE(#{end_date}) + INTERVAL 1 DAY) -- 2516 is Date antiretrovirals started
+          AND o.site_id = #{location}
+          GROUP BY o.person_id, o.site_id
+          ON DUPLICATE KEY UPDATE value_datetime = VALUES(value_datetime)
+        SQL
+      end
+
+      def external_clients(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_external_clients
+          SELECT e.patient_id, e.site_id, GROUP_CONCAT(DISTINCT(patient_type.value_coded)) AS patient_types, clinic_registration.encounter_id
+          FROM patient_program as e
+          INNER JOIN obs AS patient_type ON patient_type.person_id = e.patient_id
+            AND patient_type.site_id = e.site_id
+            AND patient_type.voided = 0
+            AND patient_type.concept_id = 3289 -- Type of patient
+            AND patient_type.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+          LEFT JOIN encounter as clinic_registration ON clinic_registration.patient_id  = e.patient_id
+            AND clinic_registration.site_id = e.site_id
+            AND clinic_registration.program_id = 1
+            AND clinic_registration.encounter_type = 9 -- HIV CLINIC REGISTRATION
+            AND clinic_registration.encounter_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND clinic_registration.voided = 0
+          WHERE e.program_id = 1 -- HIV program
+            AND e.voided = 0
+            AND e.site_id = #{location}
+            -- AND clinic_registration.encounter_id IS NOT NULL -- bone of contention
+          GROUP BY e.patient_id, e.site_id
+          HAVING FIND_IN_SET('7572', patient_types) = 0 AND encounter_id IS NULL
+          ON DUPLICATE KEY UPDATE patient_types = VALUES(patient_types)
+        SQL
+      end
+
+      def cdr_other_patient_types(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_other_patient_types
+          SELECT o.person_id, o.site_id
+          FROM obs o
+          WHERE o.concept_id = 3289 -- Type of patient
+              AND o.value_coded != 7572 -- New patient
+              AND o.voided = 0
+              AND o.obs_datetime < (DATE(#{end_date}) + INTERVAL 1 DAY)
+              AND o.site_id = #{location}
+          GROUP BY o.person_id, o.site_id
+          -- on duplicate just ignore
+          ON DUPLICATE KEY UPDATE site_id = VALUES(site_id)
+        SQL
+      end
+
+      def reason_for_starting_art(location)
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_reason_for_starting_art
+          SELECT a.person_id, a.site_id, a.value_coded
+          FROM obs a
+          INNER JOIN cdr_temp_potential_cohort_members ct ON ct.patient_id = a.person_id AND ct.site_id = a.site_id
+          LEFT OUTER JOIN obs b ON a.person_id = b.person_id AND a.site_id = b.site_id AND b.concept_id  = a.concept_id
+          AND b.concept_id  = 7563
+          AND a.obs_datetime < b.obs_datetime AND b.voided = 0 AND b.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY AND a.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+          WHERE b.obs_id IS NULL AND a.concept_id = 7563 AND a.voided = 0 AND a.site_id = #{location}
+          GROUP BY a.person_id, a.site_id
+          ON DUPLICATE KEY UPDATE reason_for_starting_art = VALUES(reason_for_starting_art)
+        SQL
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      def clear_tables
+        # if locations is empty then we truncating otherwise we clear the locations
+        if locations.empty?
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_other_patient_types')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_temp_potential_cohort_members')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_temp_min_drug_orders')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_temp_transfer_ins')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_temp_cohort_members')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_temp_external_clients')
+          ActiveRecord::Base.connection.execute('TRUNCATE TABLE cdr_reason_for_starting_art')
+        else
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_other_patient_types WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_potential_cohort_members WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_min_drug_orders WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_transfer_ins WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_cohort_members WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_external_clients WHERE site_id IN (#{locations.join(',')})")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_reason_for_starting_art WHERE site_id IN (#{locations.join(',')})")
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/app/services/malawi_hiv_program_reports/moh/cumulative_outcome.rb

@@ -0,0 +1,545 @@
+# frozen_string_literal: true
+
+module MalawiHivProgramReports
+  module Moh
+    # This is the Cumulative Cohort Builder class
+    # rubocop:disable Metrics/ClassLength
+    class CumulativeOutcome
+      include MalawiHivProgramReports::Utils::CommonSqlQueryUtils
+      attr_reader :end_date, :definition, :rebuild, :location
+
+      def initialize(end_date:, definition: 'moh', **kwargs)
+        @end_date = ActiveRecord::Base.connection.quote(end_date.to_date)
+        @definition = definition
+        @rebuild = kwargs[:rebuild]
+        @location = kwargs[:location]
+      end
+
+      def find_report
+        start_time = Time.now
+        prepare_tables
+        clear_tables if rebuild
+        update_steps unless rebuild
+        process_data
+        end_time = Time.now
+        total_time_in_minutes = ((end_time - start_time) / 60).round(2)
+        Rails.logger.info("Cumulative Outcome report completed in #{total_time_in_minutes} minutes")
+        { cumulative_outcome_time: total_time_in_minutes, definition: }
+      end
+
+      private
+
+      # The main idea here is to come up with cumulative outcomes for patients in cdr_temp_cohort_members
+      # 1. load_patients_who_died
+      # 2. load_patients_who_stopped_treatment
+      # 3. load_patients_on_pre_art
+      # 4. load_patients_without_state
+      # 5. load_patients_without_drug_orders
+      # 6. load_patients_on_treatment
+      # 7. load_defaulters
+
+      def program_states(*names)
+        ::ProgramWorkflowState.joins(:program_workflow)
+                              .joins(:concept)
+                              .merge(::ProgramWorkflow.where(program: ::Program.find_by_name('HIV Program')))
+                              .merge(::Concept.joins(:concept_names)
+                                          .merge(::ConceptName.where(name: names)))
+                              .select(:program_workflow_state_id)
+      end
+
+      # ===================================
+      #  Data Management Region
+      # ===================================
+      # rubocop:disable Metrics/MethodLength
+      def process_data
+        load_max_drug_orders
+        load_min_auto_expire_date
+        load_max_patient_state
+        load_max_appointment_date
+        # HIC SUNT DRACONIS: The order of the operations below matters,
+        # do not change it unless you know what you are doing!!!
+        load_patients_who_died
+        load_patients_who_stopped_treatment
+        load_patients_on_pre_art
+        load_patients_without_state
+        load_patients_without_drug_orders
+        load_patients_on_treatment
+        load_without_clinical_contact
+        load_defaulters
+      end
+
+      def load_max_drug_orders
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_max_drug_orders
+          SELECT o.patient_id, o.site_id, MAX(o.start_date) AS start_date
+          FROM orders o
+          INNER JOIN cdr_temp_cohort_members tesd ON tesd.patient_id = o.patient_id AND tesd.site_id = o.site_id
+          INNER JOIN drug_order ON drug_order.order_id = o.order_id
+            AND drug_order.site_id = o.site_id AND drug_order.quantity > 0
+            AND drug_order.drug_inventory_id IN (#{arv_drug})
+          WHERE o.order_type_id = 1 -- drug order
+            AND o.start_date < (DATE(#{end_date}) + INTERVAL 1 DAY)
+            AND o.voided = 0 AND o.site_id = #{location}
+          GROUP BY o.patient_id, o.site_id
+          ON DUPLICATE KEY UPDATE start_date = VALUES(start_date)
+        SQL
+      end
+
+      def load_min_auto_expire_date
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_min_auto_expire_date
+          SELECT patient_id, o.site_id, MIN(auto_expire_date) AS auto_expire_date
+          FROM orders o
+          INNER JOIN cdr_temp_max_drug_orders USING (patient_id, site_id, start_date)
+          INNER JOIN drug_order ON drug_order.order_id = o.order_id
+            AND drug_order.site_id = o.site_id AND drug_order.quantity > 0
+            AND drug_order.drug_inventory_id IN (#{arv_drug})
+          WHERE o.order_type_id = 1
+            AND o.voided = 0 AND o.site_id = #{location}
+          GROUP BY patient_id, o.site_id
+          HAVING auto_expire_date IS NOT NULL
+          ON DUPLICATE KEY UPDATE auto_expire_date = VALUES(auto_expire_date)
+        SQL
+      end
+
+      def load_max_appointment_date
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_max_patient_appointment
+          SELECT o.person_id, o.site_id, DATE(MAX(o.value_datetime)) appointment_date
+          FROM obs o
+          INNER JOIN encounter e ON e.encounter_id = o.encounter_id AND e.site_id = o.site_id AND e.voided = 0
+            AND e.program_id = 1 AND e.encounter_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+          WHERE o.concept_id = 5096 AND o.voided = 0 AND o.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY AND o.site_id = #{location}
+          GROUP BY o.person_id, o.site_id
+          HAVING appointment_date IS NOT NULL
+          ON DUPLICATE KEY UPDATE appointment_date = VALUES(appointment_date)
+        SQL
+      end
+
+      def load_max_patient_state
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_max_patient_state
+          SELECT pp.patient_id, pp.site_id, MAX(ps.start_date) start_date
+          FROM patient_state ps
+          INNER JOIN patient_program pp ON pp.patient_program_id = ps.patient_program_id AND pp.site_id = ps.site_id AND pp.program_id = 1 AND pp.voided = 0
+          WHERE ps.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND ps.voided = 0 AND ps.site_id = #{location}
+          GROUP BY pp.patient_id, pp.site_id
+          HAVING start_date IS NOT NULL
+          ON DUPLICATE KEY UPDATE start_date = VALUES(start_date)
+        SQL
+      end
+
+      # Loads all patiens with an outcome of died as of given date
+      # into the temp_patient_outcomes table.
+      def load_patients_who_died
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id, 'Patient died', patient_state.start_date, patients.site_id, 1
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.site_id = patient_program.site_id
+            AND patient_state.state = (#{program_states('Patient died').limit(1).to_sql})
+            AND patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND patient_state.voided = 0
+          WHERE patients.date_enrolled <= DATE(#{end_date}) AND patients.site_id = #{location}
+          AND patient_state.date_created = (
+            SELECT MAX(date_created)
+            FROM patient_state ps
+            WHERE ps.patient_program_id = patient_state.patient_program_id AND ps.site_id = patient_state.site_id
+            AND ps.state = patient_state.state AND ps.voided = 0 AND ps.start_date <= #{end_date})
+          GROUP BY patients.patient_id, patients.site_id
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Loads all patients with an outcome of transferred out or
+      # treatment stopped into temp_patient_outcomes table.
+      def load_patients_who_stopped_treatment
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id,
+                 (
+                   SELECT name FROM concept_name
+                   WHERE concept_id = (
+                   SELECT concept_id FROM program_workflow_state
+                   WHERE program_workflow_state_id = patient_state.state
+                   LIMIT 1
+                   )
+                 ) AS cum_outcome,
+                 patient_state.start_date, patients.site_id, 2
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.site_id = patient_program.site_id
+            AND patient_state.state IN (#{program_states('Patient transferred out', 'Treatment stopped').to_sql})
+            AND patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND (patient_state.end_date >= #{end_date} OR patient_state.end_date IS NULL)
+            AND patient_state.voided = 0
+          INNER JOIN cdr_temp_max_patient_state AS max_patient_state
+            ON max_patient_state.patient_id = patient_program.patient_id
+            AND max_patient_state.site_id = patient_state.site_id
+            AND max_patient_state.start_date = patient_state.start_date
+          WHERE patients.date_enrolled <= #{end_date} AND patients.site_id = #{location}
+            AND (patients.patient_id, patients.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step = 1)
+          GROUP BY patients.patient_id, patients.site_id
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Load all patients on Pre-ART.
+      def load_patients_on_pre_art
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id,
+                CASE
+                  WHEN #{current_defaulter_function('patients.patient_id', 'patients.site_id')} = 1 THEN 'Defaulted'
+                  ELSE 'Pre-ART (Continue)'
+                END AS cum_outcome,
+                patient_state.start_date, patients.site_id, 3
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.site_id = patient_program.site_id
+            AND patient_state.state = (#{program_states('Pre-ART (Continue)').limit(1).to_sql})
+            AND patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND (patient_state.end_date >= #{end_date} OR patient_state.end_date IS NULL)
+            AND patient_state.voided = 0
+          INNER JOIN cdr_temp_max_patient_state AS max_patient_state
+            ON max_patient_state.patient_id = patient_program.patient_id
+            AND max_patient_state.site_id = patient_state.site_id
+            AND max_patient_state.start_date = patient_state.start_date
+          WHERE patients.date_enrolled <= #{end_date} AND patients.site_id = #{location}
+            AND (patients.patient_id, patients.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2))
+          GROUP BY patients.patient_id, patients.site_id
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Load all patients without a state
+      def load_patients_without_state
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id,
+                 CASE
+                    WHEN #{current_defaulter_function('patients.patient_id', 'patients.site_id')} = 1 THEN 'Defaulted'
+                    ELSE 'Unknown'
+                  END AS cum_outcome,
+                 NULL, patients.site_id, 4
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          WHERE patients.date_enrolled <= #{end_date} AND patients.site_id = #{location}
+            AND (patient_program.patient_program_id, patient_program.site_id) NOT IN (
+              SELECT patient_program_id, site_id
+              FROM patient_state
+              WHERE start_date < DATE(#{end_date}) + INTERVAL 1 DAY AND voided = 0
+            )
+            AND (patients.patient_id, patients.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2, 3))
+          GROUP BY patients.patient_id, patients.site_id
+          HAVING cum_outcome = 'Defaulted'
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Load all patients without drug orders or have drug orders
+      # without a quantity.
+      def load_patients_without_drug_orders
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id,
+                 'Unknown',
+                 NULL, patients.site_id, 5
+          FROM cdr_temp_cohort_members AS patients
+          WHERE date_enrolled <= #{end_date} AND site_id = #{location}
+            AND (patient_id, site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2, 3, 4))
+            AND (patient_id, site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_max_drug_orders)
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Loads all patients who are on treatment
+      def load_patients_on_treatment
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id, 'On antiretrovirals', patient_state.start_date, patients.site_id, 6
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          /* Get patients' `on ARV` states that are before given date */
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.site_id = patient_program.site_id
+            AND patient_state.state = 7 -- ON ART
+            AND patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND (patient_state.end_date >= #{end_date} OR patient_state.end_date IS NULL)
+            AND patient_state.voided = 0
+          /* Select only the most recent state out of those retrieved above */
+          INNER JOIN cdr_temp_max_patient_state AS max_patient_state
+            ON max_patient_state.patient_id = patient_program.patient_id
+            AND max_patient_state.site_id = patient_state.site_id
+            AND max_patient_state.start_date = patient_state.start_date
+          /* HACK: Ensure that the states captured above do correspond have corresponding
+                   ARV dispensations. In other words filter out any `on ARVs` states whose
+                   dispensation's may have been voided or states that were created manually
+                   without any drugs being dispensed.  */
+          INNER JOIN cdr_temp_min_auto_expire_date AS first_order_to_expire
+            ON first_order_to_expire.patient_id = patient_program.patient_id
+            AND first_order_to_expire.site_id = patient_program.site_id
+            AND (first_order_to_expire.auto_expire_date >= #{end_date} OR TIMESTAMPDIFF(DAY,first_order_to_expire.auto_expire_date, #{end_date}) <= #{@definition == 'pepfar' ? 28 : 56})
+          WHERE patients.date_enrolled <= #{end_date} AND patients.site_id = #{location}
+           AND (patients.patient_id, patients.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2, 3, 4, 5))
+          GROUP BY patients.patient_id, patients.site_id
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      def load_without_clinical_contact
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patients.patient_id, 'Defaulted', null, patients.site_id, 7
+          FROM cdr_temp_cohort_members AS patients
+          INNER JOIN patient_program
+            ON patient_program.patient_id = patients.patient_id
+            AND patient_program.site_id = patients.site_id
+            AND patient_program.program_id = 1
+            AND patient_program.voided = 0
+          /* Get patients' `on ARV` states that are before given date */
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.site_id = patient_program.site_id
+            AND patient_state.state = 7 -- On ART
+            AND patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND (patient_state.end_date >= #{end_date} OR patient_state.end_date IS NULL)
+            AND patient_state.voided = 0
+          /* Select only the most recent state out of those retrieved above */
+          INNER JOIN cdr_temp_max_patient_state AS max_patient_state
+            ON max_patient_state.patient_id = patient_program.patient_id
+            AND max_patient_state.site_id = patient_state.site_id
+            AND max_patient_state.start_date = patient_state.start_date
+          INNER JOIN cdr_temp_max_patient_appointment app ON app.patient_id = patients.patient_id
+          AND app.site_id = patients.site_id AND app.appointment_date < #{end_date}
+          INNER JOIN cdr_temp_min_auto_expire_date AS first_order_to_expire
+            ON first_order_to_expire.patient_id = patient_program.patient_id
+            AND first_order_to_expire.site_id = patient_program.site_id
+            AND TIMESTAMPDIFF(DAY,app.appointment_date, first_order_to_expire.auto_expire_date) >= 0
+            AND TIMESTAMPDIFF(DAY,app.appointment_date, first_order_to_expire.auto_expire_date) <= 5
+            AND first_order_to_expire.auto_expire_date < #{end_date}
+            AND TIMESTAMPDIFF(DAY,first_order_to_expire.auto_expire_date, #{end_date}) >= 365
+          WHERE patients.date_enrolled <= #{end_date} AND patients.site_id = #{location}
+          AND (patients.patient_id, patients.site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2, 3, 4, 5, 6))
+          GROUP BY patients.patient_id, patients.site_id
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # Load defaulters
+      def load_defaulters
+        ActiveRecord::Base.connection.execute <<~SQL
+          INSERT INTO cdr_temp_patient_outcomes
+          SELECT patient_id, #{patient_outcome_function('patient_id', 'site_id')}, NULL, site_id, 8
+          FROM cdr_temp_cohort_members
+          WHERE date_enrolled <= #{end_date} AND site_id = #{location}
+          AND (patient_id, site_id) NOT IN (SELECT patient_id, site_id FROM cdr_temp_patient_outcomes WHERE step IN (1, 2, 3, 4, 5, 6, 7))
+          ON DUPLICATE KEY UPDATE cum_outcome = VALUES(cum_outcome), outcome_date = VALUES(outcome_date), step = VALUES(step)
+        SQL
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      # ===================================
+      #  Function Management Region
+      # ===================================
+
+      def current_defaulter_function(sql_column, site_id)
+        case definition
+        when 'moh' then "current_defaulter(#{sql_column}, #{end_date}, #{site_id})"
+        when 'pepfar' then "current_pepfar_defaulter(#{sql_column}, #{end_date}, #{site_id})"
+        else raise "Invalid outcomes definition: #{definition}" # Should never happen but you never know!
+        end
+      end
+
+      def patient_outcome_function(sql_column, site_id)
+        case definition
+        when 'moh' then "patient_outcome(#{sql_column}, #{end_date}, #{site_id})"
+        when 'pepfar' then "pepfar_patient_outcome(#{sql_column}, #{end_date}, #{site_id})"
+        else raise "Invalid outcomes definition: #{definition}"
+        end
+      end
+
+      # ===================================
+      #  Table Management Region
+      # ===================================
+      def prepare_tables
+        create_outcome_table unless check_if_table_exists('cdr_temp_patient_outcomes')
+        create_tmp_max_drug_orders_table unless check_if_table_exists('cdr_temp_max_drug_orders')
+        create_tmp_min_auto_expire_date unless check_if_table_exists('cdr_temp_min_auto_expire_date')
+        create_cdr_temp_max_patient_state unless check_if_table_exists('cdr_temp_max_patient_state')
+        create_max_patient_appointment_date unless check_if_table_exists('cdr_temp_max_patient_appointment')
+      end
+
+      def check_if_table_exists(table_name)
+        result = ActiveRecord::Base.connection.select_one <<~SQL
+          SELECT COUNT(*) AS count
+          FROM information_schema.tables
+          WHERE table_schema = DATABASE()
+          AND table_name = '#{table_name}'
+        SQL
+        result['count'].to_i.positive?
+      end
+
+      def create_outcome_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_patient_outcomes (
+          patient_id INT NOT NULL,
+          cum_outcome VARCHAR(120) NOT NULL,
+          outcome_date DATE DEFAULT NULL,
+          site_id INT NOT NULL,
+          step INT DEFAULT 0,
+          PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_outcome_indexes
+      end
+
+      def create_outcome_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_outcome ON cdr_temp_patient_outcomes (cum_outcome)
+        SQL
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_out_date ON cdr_temp_patient_outcomes (outcome_date)
+        SQL
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_out_step ON cdr_temp_patient_outcomes (step)
+        SQL
+      end
+
+      def create_tmp_max_drug_orders_table
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_max_drug_orders (
+            patient_id INT NOT NULL,
+            site_id INT NOT NULL,
+            start_date DATETIME DEFAULT NULL,
+            PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_max_drug_orders_indexes
+      end
+
+      def create_max_drug_orders_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_max_orders ON cdr_temp_max_drug_orders (start_date)
+        SQL
+      end
+
+      def create_tmp_min_auto_expire_date
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_min_auto_expire_date (
+            patient_id INT NOT NULL,
+            site_id INT NOT NULL,
+            auto_expire_date DATE DEFAULT NULL,
+            PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_min_auto_expire_date_indexes
+      end
+
+      def create_min_auto_expire_date_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_min_auto_expire_date ON cdr_temp_min_auto_expire_date (auto_expire_date)
+        SQL
+      end
+
+      def create_cdr_temp_max_patient_state
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_max_patient_state (
+            patient_id INT NOT NULL,
+            site_id INT NOT NULL,
+            start_date VARCHAR(15) DEFAULT NULL,
+            PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_max_patient_state_indexes
+      end
+
+      def create_max_patient_state_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_max_patient_state ON cdr_temp_max_patient_state (start_date)
+        SQL
+      end
+
+      def create_max_patient_appointment_date
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS cdr_temp_max_patient_appointment (
+            patient_id INT NOT NULL,
+            site_id INT NOT NULL,
+            appointment_date DATE NOT NULL,
+            PRIMARY KEY (patient_id, site_id)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+          PARTITION BY LIST(site_id) (#{partition_by_site})
+        SQL
+        create_max_patient_appointment_date_indexes
+      end
+
+      def create_max_patient_appointment_date_indexes
+        ActiveRecord::Base.connection.execute <<~SQL
+          CREATE INDEX idx_max_patient_appointment_date ON cdr_temp_max_patient_appointment (appointment_date)
+        SQL
+      end
+
+      def update_steps
+        ActiveRecord::Base.connection.execute <<~SQL
+          UPDATE cdr_temp_patient_outcomes SET step = 0 WHERE step > 0 AND site_id = #{location}
+        SQL
+      end
+
+      def arv_drug
+        @arv_drug ||= ::Drug.arv_drugs.map(&:drug_id).join(',')
+      end
+
+      def clear_tables
+        # we truncate if @locations is empty otherwise we only clean the specifieds
+        if location.empty?
+          ActiveRecord::Base.connection.execute('TRUNCATE cdr_temp_patient_outcomes')
+          ActiveRecord::Base.connection.execute('TRUNCATE cdr_temp_max_drug_orders')
+          ActiveRecord::Base.connection.execute('TRUNCATE cdr_temp_min_auto_expire_date')
+          ActiveRecord::Base.connection.execute('TRUNCATE cdr_temp_max_patient_state')
+          ActiveRecord::Base.connection.execute('TRUNCATE cdr_temp_max_patient_appointment')
+        else
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_patient_outcomes WHERE site_id = #{location}")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_max_drug_orders WHERE site_id = #{location}")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_min_auto_expire_date WHERE site_id = #{location}")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_max_patient_state WHERE site_id = #{location}")
+          ActiveRecord::Base.connection.execute("DELETE FROM cdr_temp_max_patient_appointment WHERE site_id = #{location}")
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/app/services/malawi_hiv_program_reports/report_map.rb

@@ -6,7 +6,7 @@ module MalawiHivProgramReports
       'ARCHIVING_CANDIDATES' => MalawiHivProgramReports::ArchivingCandidates,
       'APPOINTMENTS' => MalawiHivProgramReports::Clinic::AppointmentsReport,
       'ARV_REFILL_PERIODS' => MalawiHivProgramReports::ArvRefillPeriods,
-      'COHORT' => MalawiHivProgramReports::Moh::Cohort,
+      'COHORT' => MalawiHivProgramReports::Moh::ArtCohort,
       'COHORT_DISAGGREGATED' => MalawiHivProgramReports::Moh::CohortDisaggregated,
       'COHORT_DISAGGREGATED_ADDITIONS' => MalawiHivProgramReports::Moh::CohortDisaggregatedAdditions,
       'COHORT_SURVIVAL_ANALYSIS' => MalawiHivProgramReports::Moh::CohortSurvivalAnalysis,
@@ -50,7 +50,9 @@ module MalawiHivProgramReports
       'DISCREPANCY_REPORT' => MalawiHivProgramReports::Clinic::DiscrepancyReport,
       'STOCK_CARD' => MalawiHivProgramReports::Clinic::StockCardReport,
       'HYPERTENSION_REPORT' => MalawiHivProgramReports::Clinic::HypertensionReport,
-      'TX_NEW' => MalawiHivProgramReports::Pepfar::TxNew
+      'TX_NEW' => MalawiHivProgramReports::Pepfar::TxNew,
+      'CUMULATIVE_COHORT' => MalawiHivProgramReports::Moh::CumulativeCohort,
+      'CUMULATIVE_OUTCOME' => MalawiHivProgramReports::Moh::CumulativeOutcome
     }.freeze
   end
 end

data/app/services/malawi_hiv_program_reports/utils/common_sql_query_utils.rb

@@ -55,6 +55,12 @@ module MalawiHivProgramReports
           #{site_manager(operator: 'AND', column: 'a.site_id', location: @location)}
         SQL
       end
+
+      def partition_by_site
+        @partition_by_site ||= Location.all.map do |location|
+          "PARTITION p#{location.id} VALUES IN (#{location.id}) ENGINE = InnoDB"
+        end.join(', ')
+      end
     end
   end
 end

data/lib/malawi_hiv_program_reports/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MalawiHivProgramReports
-  VERSION = '1.0.15'
+  VERSION = '1.0.17'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: malawi_hiv_program_reports
 version: !ruby/object:Gem::Version
-  version: 1.0.15
+  version: 1.0.17
 platform: ruby
 authors:
 - Roy Chanunkha
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-04 00:00:00.000000000 Z
+date: 2024-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -129,13 +129,15 @@ files:
 - app/services/malawi_hiv_program_reports/cohort/regimens.rb
 - app/services/malawi_hiv_program_reports/cohort/side_effects.rb
 - app/services/malawi_hiv_program_reports/cohort/tpt.rb
-- app/services/malawi_hiv_program_reports/moh/cohort.rb
+- app/services/malawi_hiv_program_reports/moh/art_cohort.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_builder.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_disaggregated.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_disaggregated_additions.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_disaggregated_builder.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_struct.rb
 - app/services/malawi_hiv_program_reports/moh/cohort_survival_analysis.rb
+- app/services/malawi_hiv_program_reports/moh/cumulative_cohort.rb
+- app/services/malawi_hiv_program_reports/moh/cumulative_outcome.rb
 - app/services/malawi_hiv_program_reports/moh/moh_tpt.rb
 - app/services/malawi_hiv_program_reports/moh/tpt_newly_initiated.rb
 - app/services/malawi_hiv_program_reports/pepfar/defaulter_list.rb
@@ -187,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: Malawi HIV PROGRAM Reports for Ruby on Rails