malawi_hiv_program_reports 1.0.1 → 1.0.2

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module MalawiHivProgramReports
+  module Clinic
+    class ViralLoad
+      include MalawiHivProgramReports::Utils::CommonSqlQueryUtils
+      include MalawiHivProgramReports::Utils::ModelUtils
+
+      def initialize(start_date:, end_date:, **kwargs)
+        @start_date = start_date.to_date.strftime('%Y-%m-%d 00:00:00')
+        @end_date = end_date.to_date.strftime('%Y-%m-%d 23:59:59')
+        @program = ::Program.find_by_name 'HIV PROGRAM'
+        @possible_milestones = possible_milestones
+        @use_filing_number = ::GlobalProperty.find_by(property: 'use.filing.numbers')
+                                             &.property_value
+                                             &.casecmp?('true')
+        @occupation = kwargs[:occupation]
+      end
+
+      def clients_due
+        clients = potential_get_clients
+        return [] if clients.blank?
+
+        clients_due_list = []
+
+        clients.each do |person|
+          vl_details = get_vl_due_details(person) # person[:patient_id], person[:appointment_date], person[:start_date])
+          next if vl_details.blank?
+
+          clients_due_list << vl_details
+        end
+
+        clients_due_list
+      end
+
+      def vl_results
+        read_results
+      end
+
+      private
+
+      def start_date
+        ActiveRecord::Base.connection.quote(@start_date)
+      end
+
+      def end_date
+        ActiveRecord::Base.connection.quote(@end_date)
+      end
+
+      def patient_identifier_type_id
+        identifier_type_name = @use_filing_number ? 'Filing Number' : 'ARV Number'
+        identifier_type = ::PatientIdentifierType.find_by_name!(identifier_type_name)
+
+        ActiveRecord::Base.connection.quote(identifier_type.id)
+      end
+
+      def program_id
+        ActiveRecord::Base.connection.quote(@program.program_id)
+      end
+
+      def closing_states
+        # state_concepts = ::ConceptName.where(name: ['Patient died', 'Patient transferred out', 'Treatment stopped'])
+        #                             .select(:concept_id)
+        # states = ::ProgramWorkflowState.where(concept_id: state_concepts)
+        #                              .joins(:program_workflow)
+        #                              .merge(::ProgramWorkflow.where(program: @program))
+
+        # ::PatientState.joins(:program_workflow_state)
+        #             .merge(states)
+        #             .select(:state)
+        #             .distinct(:state)
+        #             .to_sql
+        ::ProgramWorkflowState.joins(:program_workflow)
+                              .where(initial: 0, terminal: 1,
+                                     program_workflow: { program_id: @program.id })
+                              .select(:program_workflow_state_id).to_sql
+      end
+
+      def potential_get_clients
+        observations = ActiveRecord::Base.connection.select_all <<~SQL
+          SELECT obs.person_id,
+                 obs.value_datetime,
+                 date_antiretrovirals_started(obs.person_id, NULL) AS start_date,
+                 patient_identifier.identifier,
+                 person_name.given_name,
+                 person_name.family_name,
+                 person.birthdate,
+                 person.gender
+          FROM obs
+          INNER JOIN encounter
+            ON encounter.encounter_id = obs.encounter_id
+            AND encounter.program_id = #{program_id}
+            AND encounter_type = (
+              SELECT encounter_type_id
+              FROM encounter_type
+              WHERE encounter_type.name = 'Appointment'
+                AND encounter_type.retired = 0
+              LIMIT 1
+            )
+            AND encounter.voided = 0
+          LEFT JOIN person
+            ON person.person_id = obs.person_id
+            AND person.voided = 0
+          LEFT JOIN person_name
+            ON person_name.person_id = obs.person_id
+            AND person_name.voided = 0
+          LEFT JOIN patient_identifier
+            ON patient_identifier.patient_id = obs.person_id
+            AND patient_identifier.identifier_type = #{patient_identifier_type_id}
+            AND patient_identifier.voided = 0
+          INNER JOIN patient_program
+            ON patient_program.program_id = encounter.program_id
+            AND patient_program.patient_id = encounter.patient_id
+            AND patient_program.voided = 0
+          INNER JOIN patient_state
+            ON patient_state.patient_program_id = patient_program.patient_program_id
+            AND patient_state.voided = 0
+            AND patient_state.state NOT IN (#{closing_states})
+          /* Limit states above to most recent states for each patient */
+          INNER JOIN (
+            SELECT patient_state.patient_program_id,
+                   MAX(patient_state.start_date) AS start_date
+            FROM patient_state
+            INNER JOIN patient_program
+              ON patient_program.program_id = #{program_id}
+              AND patient_program.voided = 0
+              AND patient_program.patient_program_id = patient_state.patient_program_id
+            WHERE patient_state.start_date < DATE(#{end_date}) + INTERVAL 1 DAY
+              AND patient_state.voided = 0
+            GROUP BY patient_state.patient_program_id
+          ) AS patient_recent_state_dates
+            ON patient_recent_state_dates.patient_program_id = patient_state.patient_program_id
+            AND patient_recent_state_dates.start_date = patient_state.start_date
+          LEFT JOIN (#{current_occupation_query}) a ON a.person_id = obs.person_id
+          WHERE obs.concept_id = (
+              SELECT concept_id
+              FROM concept_name
+              WHERE concept_name.name = 'Appointment date'
+                AND concept_name.voided = 0
+              LIMIT 1
+            ) #{%w[Military Civilian].include?(@occupation) ? 'AND' : ''} #{occupation_filter(occupation: @occupation, field_name: 'value', table_name: 'a', include_clause: false)}
+            AND obs.value_datetime >= DATE(#{start_date})
+            AND obs.value_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+            AND obs.voided = 0
+          GROUP BY obs.person_id
+          ORDER BY obs.value_datetime
+        SQL
+
+        observations.map do |ob|
+          {
+            patient_id: ob['person_id'].to_i,
+            appointment_date: ob['value_datetime'],
+            start_date: ob['start_date'],
+            given_name: ob['given_name'],
+            family_name: ob['family_name'],
+            birthdate: ob['birthdate'],
+            gender: ob['gender'],
+            arv_number: ob['identifier']
+          }
+        end
+      end
+
+      # patient_id, appointment_date, patient_start_date)
+      def get_vl_due_details(person)
+        patient_start_date = begin
+          person[:start_date].to_date
+        rescue StandardError
+          nil
+        end
+        return if patient_start_date.blank?
+
+        # start_date = patient_start_date
+        appointment_date = person[:appointment_date].to_date
+        # months_on_art = date_diff(patient_start_date.to_date, @end_date.to_date)
+        vl_info = get_vl_due_info(person[:patient_id], appointment_date)
+        months_on_art = vl_info[:period_on_art]
+
+        # if @possible_milestones.include?(months_on_art)
+        return unless vl_info[:eligibile] || (vl_info[:due_date] <= end_date.to_date + 28.day)
+
+        last_result = last_vl_result(person[:patient_id])
+        {
+          patient_id: person[:patient_id],
+          mile_stone: vl_info[:due_date], # (patient_start_date.to_date + months_on_art.month).to_date,
+          start_date: patient_start_date,
+          months_on_art:,
+          appointment_date:,
+          given_name: person[:given_name],
+          family_name: person[:family_name],
+          gender: person[:gender],
+          birthdate: person[:birthdate],
+          arv_number: use_filing_number(person[:patient_id], person[:arv_number]),
+          last_result_order_date: begin
+            last_result.order_date.to_date
+          rescue StandardError
+            'N/A'
+          end,
+          last_result: last_result.result_value,
+          last_result_date: last_result.result_date
+        }
+      end
+
+      def date_diff(date1, date2)
+        diff_cal = ActiveRecord::Base.connection.select_one <<~SQL
+          SELECT TIMESTAMPDIFF(MONTH, DATE('#{date1.to_date}'), DATE('#{date2.to_date}')) AS months;
+        SQL
+
+        diff_cal['months'].to_i
+      end
+
+      def possible_milestones
+        milestones = [6]
+        start_month = 6
+
+        1.upto(1000).each do |_y|
+          milestones << (start_month += 12)
+        end
+
+        milestones
+      end
+
+      def read_results
+        all_results = LaboratoryService::Reports::Clinic::ProcessedResults.new(start_date: @start_date,
+                                                                               end_date: @end_date,
+                                                                               occupation: @occupation).read
+        processed_vl_results = []
+
+        all_results.each do |result|
+          measures = result[:measures]
+          measures.each do |measure|
+            next unless measure[:name].include?('viral load')
+
+            processed_vl_results << {
+              accession_number: result[:accession_number],
+              result_date: result[:result_date],
+              patient_id: result[:patient_id],
+              order_date: result[:order_date],
+              specimen: result[:test],
+              gender: result[:gender],
+              arv_number: result[:arv_number],
+              birthdate: result[:birthdate],
+              age_group: result[:age_group],
+              result: measure[:value],
+              result_modifier: measure[:modifier]
+            }
+          end
+        end
+
+        processed_vl_results
+      end
+
+      def last_vl_result(patient_id)
+        viral_load_concept = ::ConceptName.where(name: 'HIV Viral Load').select(:concept_id)
+        result_sql = <<~SQL
+          INNER JOIN obs AS parent
+            ON parent.obs_id = obs.obs_group_id
+            AND parent.concept_id IN (SELECT concept_id FROM concept_name WHERE name = 'Lab test result' AND voided = 0)
+            AND parent.voided = 0
+            AND parent.person_id = #{patient_id}
+        SQL
+
+        measure = ::Observation.joins(result_sql)
+                               .where(concept: viral_load_concept)
+                               .where('(obs.value_numeric IS NOT NULL OR obs.value_text IS NOT NULL)
+                                 AND obs.obs_datetime < DATE(?) + INTERVAL 1 DAY',
+                                      @end_date)
+                               .order(obs_datetime: :desc)
+                               .first
+
+        return OpenStruct.new(order_date: 'N/A', result_date: 'N/A', result_value: 'N/A') unless measure
+
+        OpenStruct.new(order_date: measure&.order&.start_date&.to_date,
+                       result_date: measure&.obs_datetime&.to_date,
+                       result_value: "#{measure&.value_modifier || '='}#{measure&.value_numeric || measure&.value_text}")
+      end
+
+      def use_filing_number(patient_id, arv_number)
+        return arv_number unless @use_filing_number
+
+        identifier_types = ::PatientIdentifierType.where("name LIKE '%Filing number%'").map(&:patient_identifier_type_id)
+        filing_numbers = PatientIdentifier.where('patient_id = ? AND identifier_type IN(?)',
+                                                 patient_id, identifier_types)
+        filing_numbers.blank? ? '' : filing_numbers.last.identifier
+      end
+
+      def get_vl_due_info(patient_id, appointment_date)
+        vl_info = ArtService::VlReminder.new(patient_id:, date: appointment_date)
+        vl_info.vl_reminder_info
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module MalawiHivProgramReports
+  module Clinic
+    class ViralLoadDisaggregated
+      attr_reader :start_date, :end_date, :from, :to
+
+      def initialize(start_date:, end_date:, from: nil, to: nil, **_kwargs)
+        @start_date = start_date.to_date
+        @end_date = end_date.to_date
+        @from = from&.to_f
+        @to = to&.to_f
+      end
+
+      def find_report
+        patients.each_with_object({}) do |patient, report|
+          age_group = find_age_group(patient.birthdate)
+          regimen = patient.regimen&.upcase
+          report[age_group] ||= {}
+
+          if report[age_group].include?(regimen)
+            report[age_group][regimen] += 1
+          else
+            report[age_group][regimen] = 1
+          end
+        end
+      end
+
+      private
+
+      AGE_GROUPS = [
+        [1, 4],
+        [5, 9],
+        [10, 14],
+        [15, 19],
+        [20, 24],
+        [25, 29],
+        [30, 34],
+        [35, 39],
+        [40, 44],
+        [45, 49],
+        [50, 54],
+        [55, 59],
+        [60, 64],
+        [65, 69],
+        [70, 74],
+        [75, 79],
+        [80, 84],
+        [85, 89],
+        [90, Float::INFINITY]
+      ].freeze
+
+      # Returns all patients with a viral load in the selected range
+      # and the regimens they are on the given point in time.
+      def patients
+        ::Observation.select('patient_id, birthdate, patient_current_regimen(patient_id, obs_datetime) as regimen')
+                     .joins(:encounter)
+                     .joins('INNER JOIN person USING (person_id)')
+                     .where(concept_id: ::ConceptName.find_by_name('Viral load').concept_id,
+                            obs_datetime: (start_date..end_date),
+                            value_numeric: viral_load_range)
+                     .merge(::Encounter.where(encounter_type: ::EncounterType.find_by_name('LAB ORDERS').encounter_type_id))
+                     .group(:person_id)
+                     .order(obs_datetime: :desc)
+      end
+
+      DAYS_IN_YEAR = 365
+
+      def find_age_group(birthdate)
+        return 'Unknown' unless birthdate
+
+        age = (end_date.to_date - birthdate.to_date).to_i / DAYS_IN_YEAR
+        return '<1 year' if age < 1
+
+        start_age, end_age = AGE_GROUPS.find { |start_age, end_age| (start_age..end_age).cover?(age) }
+
+        if end_age == Float::INFINITY
+          "#{start_age} years +"
+        else
+          "#{start_age} - #{end_age} years"
+        end
+      end
+
+      def viral_load_range
+        if from && to
+          from..to
+        elsif from
+          from..Float::INFINITY
+        elsif to
+          0..to
+        else
+          0...1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+##
+# Pulls patient's whose most recent viral load result in selected reporting period
+# is in specified viral load classification.
+#
+# Classification are passed as parameter range and are limited to the following
+# values:
+#   - suppressed
+#   - low-level-viraemia
+#   - viraemia-1000
+#
+# The classifications above follow the ART guidelines 2018 Addendum.
+module MalawiHivProgramReports
+  module Clinic
+    class ViralLoadResults
+      include MalawiHivProgramReports::Utils::CommonSqlQueryUtils
+
+      def initialize(start_date:, end_date: nil, range: nil, **kwargs)
+        @start_date = start_date
+        @end_date = end_date
+        @range = range || 'viraemia-1000+'
+        @occupation = kwargs[:occupation]
+      end
+
+      def find_report
+        start_date = ActiveRecord::Base.connection.quote(@start_date)
+        end_date = ActiveRecord::Base.connection.quote(@end_date)
+
+        ActiveRecord::Base.connection.select_all <<~SQL
+          SELECT orders.patient_id,
+                 patient_identifier.identifier AS arv_number,
+                 person.birthdate AS birthdate,
+                 disaggregated_age_group(person.birthdate, #{end_date}) AS age_group,
+                 person.gender AS gender,
+                 orders.start_date AS order_date,
+                 specimen_type.name AS specimen,
+                 COALESCE(orders.discontinued_date, orders.start_date) AS specimen_drawn_date,
+                 test_results_obs.obs_datetime AS result_date,
+                 COALESCE(test_result_measure_obs.value_modifier, '=') AS result_modifier,
+                 COALESCE(test_result_measure_obs.value_numeric, test_result_measure_obs.value_text) AS result,
+                 patient_current_regimen(orders.patient_id, orders.start_date) AS current_regimen
+          FROM orders
+          INNER JOIN concept_name AS specimen_type
+            ON specimen_type.concept_id = orders.concept_id
+            AND specimen_type.name IN ('Blood', 'DBS (Free drop to DBS card)', 'DBS (Using capillary tube)', 'Plasma')
+            AND specimen_type.voided = 0
+          LEFT JOIN patient_identifier
+            ON patient_identifier.patient_id = orders.patient_id
+            AND patient_identifier.voided = 0
+            AND patient_identifier.identifier_type IN (
+              SELECT patient_identifier_type_id FROM patient_identifier_type WHERE name = 'ARV Number' AND retired = 0
+            )
+          INNER JOIN person
+            ON person.person_id = orders.patient_id
+            AND person.voided = 0
+          LEFT JOIN (#{current_occupation_query}) AS a ON a.person_id = orders.patient_id
+          /* For each lab order find an HIV Viral Load test */
+          INNER JOIN obs AS test_obs
+            ON test_obs.order_id = orders.order_id
+            AND test_obs.concept_id IN (
+              SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+              WHERE concept_name.name = 'Test type' AND concept.retired = 0 AND concept_name.voided = 0
+            )
+            AND test_obs.value_coded IN (
+              SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+              WHERE concept_name.name = 'Viral load' AND concept.retired = 0 AND concept_name.voided = 0
+            )
+            AND test_obs.voided = 0
+          /* Select each test's results */
+          INNER JOIN obs AS test_results_obs
+            ON test_results_obs.obs_group_id = test_obs.obs_id
+            AND test_results_obs.concept_id IN (
+              SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+              WHERE concept_name.name = 'Lab test result' AND concept.retired = 0 AND concept_name.voided = 0
+            )
+            AND test_results_obs.voided = 0
+            AND test_results_obs.obs_datetime >= DATE(#{start_date})
+            AND test_results_obs.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+          /* Limit the test result's to each patient's most recent result. */
+          INNER JOIN (
+            SELECT MAX(obs_datetime) AS obs_datetime,
+                   person_id
+            FROM obs
+            INNER JOIN orders
+              ON orders.order_id = obs.order_id
+              AND orders.order_type_id IN (SELECT order_type_id FROM order_type WHERE name = 'Lab' AND retired = 0)
+              AND orders.concept_id IN (
+                SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+                WHERE concept_name.name IN ('Blood', 'DBS (Free drop to DBS card)', 'DBS (Using capillary tube)', 'Plasma')
+                  AND concept.retired = 0 AND concept_name.voided = 0
+              )
+              AND orders.voided = 0
+            WHERE obs.concept_id IN (
+                SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+                WHERE concept_name.name = 'Lab test result' AND concept.retired = 0 AND concept_name.voided = 0
+              )
+              AND obs.voided = 0
+              AND obs.obs_datetime >= DATE(#{start_date})
+              AND obs.obs_datetime < DATE(#{end_date}) + INTERVAL 1 DAY
+            GROUP BY person_id
+          ) AS max_test_results
+            ON max_test_results.obs_datetime = test_results_obs.obs_datetime
+            AND max_test_results.person_id = test_results_obs.person_id
+          /* Find a viral load measure that can be classified as High on the test results */
+          INNER JOIN obs AS test_result_measure_obs
+            ON test_result_measure_obs.obs_group_id = test_results_obs.obs_id
+            AND test_result_measure_obs.concept_id IN (
+              SELECT concept_id FROM concept_name INNER JOIN concept USING (concept_id)
+              WHERE concept_name.name = 'Viral load' AND concept.retired = 0 AND concept_name.voided = 0
+            )
+            AND (test_result_measure_obs.value_numeric IS NOT NULL
+                 OR test_result_measure_obs.value_text IS NOT NULL)
+            AND test_result_measure_obs.voided = 0
+            AND (#{query_range})
+          WHERE orders.order_type_id IN (SELECT order_type_id FROM order_type WHERE name = 'Lab' AND retired = 0)
+            AND orders.voided = 0 #{%w[Military Civilian].include?(@occupation) ? 'AND' : ''} #{occupation_filter(occupation: @occupation, field_name: 'value', table_name: 'a', include_clause: false)}
+          GROUP BY orders.patient_id
+        SQL
+      end
+
+      def specimen_types
+        ::Concept.joins(:concept_names)
+                 .merge(::ConceptName.where(name: ['Blood']))
+                 .select(:concept_id)
+                 .to_sql
+      end
+
+      def dbs_query_range
+        case @range.downcase
+        when 'suppressed' then <<~SQL
+
+        SQL
+        when 'low-level-viremia' then <<~SQL
+
+        SQL
+        when 'viraemia-1000+' then <<~SQL
+          (test_result_measure_obs.value_numeric >= 1000)
+        SQL
+        else
+          raise ::InvalidParameterError, "Invalid viral load range: #{@range}"
+        end
+      end
+
+      def query_range
+        case @range.downcase
+        when 'suppressed' then <<~SQL
+          (/* Plasma/Blood */
+           (specimen_type.name IN ('Blood', 'Plasma')
+            AND ((test_result_measure_obs.value_modifier IN ('<', '=') AND test_result_measure_obs.value_text = 'LDL')
+                 OR (test_result_measure_obs.value_modifier = '<' AND test_result_measure_obs.value_numeric IN (20, 40, 150)))
+                 OR (test_result_measure_obs.value_numeric >= 20 AND test_result_measure_obs.value_numeric < 200))
+          /* DBS */
+          OR (specimen_type.name IN ('DBS (Free drop to DBS card)', 'DBS (Using capillary tube)')
+              AND (test_result_measure_obs.value_modifier IN ('<', '=') AND test_result_measure_obs.value_text = 'LDL')))
+        SQL
+        when 'low-level-viraemia' then <<~SQL
+          (/* Plasma/Blood */
+           (specimen_type.name IN ('Blood', 'Plasma')
+            AND (test_result_measure_obs.value_numeric >= 200 AND test_result_measure_obs.value_numeric < 1000))
+           /* DBS */
+           OR (specimen_type.name IN ('DBS (Free drop to DBS card)', 'DBS (Using capillary tube)')
+               AND (test_result_measure_obs.value_modifier = '<' AND test_result_measure_obs.value_numeric IN (400, 550, 839))
+               OR (test_result_measure_obs.value_numeric >= 400 AND test_result_measure_obs.value_numeric < 1000)))
+        SQL
+        when 'viraemia-1000' then <<~SQL
+          (test_result_measure_obs.value_numeric >= 1000)
+        SQL
+        else
+          raise ::InvalidParameterError, "Invalid viral load range: #{@range}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module MalawiHivProgramReports
+  module Clinic
+    class VisitsReport
+      include MalawiHivProgramReports::Utils::ModelUtils
+
+      def initialize(name:, type:, start_date:, end_date:)
+        @name = name
+        @type = type
+        @start_date = start_date.to_date
+        @end_date = end_date.to_date
+      end
+
+      def build_report
+        visits = (@start_date..@end_date).each_with_object({}) do |date, visits|
+          visits[date] ||= { incomplete: 0, complete: 0 }
+
+          find_visiting_patients(date).each do |patient|
+            if workflow_engine(patient, date).next_encounter
+              visits[date][:incomplete] += 1
+            else
+              visits[date][:complete] += 1
+            end
+          end
+        end
+
+        save_report visits
+      end
+
+      def find_report
+        (@start_date..@end_date).each_with_object({}) do |date, parsed_report|
+          report = fetch_report date
+
+          parsed_values = report.values.each_with_object({}) do |report_value, parsed_values|
+            parsed_values[report_value.indicator_name] = report_value.contents.to_i
+          end
+
+          break nil if parsed_values.empty? # Force regeneration of report
+
+          parsed_report[date] = parsed_values
+        end
+      end
+
+      private
+
+      # Returns a list of patients who visited the ART clinic on given day.
+      def find_visiting_patients(date)
+        day_start, day_end = ::TimeUtils.day_bounds(date)
+        query = <<~SQL
+          SELECT patient.* FROM patient INNER JOIN encounter USING (patient_id)
+           WHERE encounter.encounter_datetime BETWEEN ? AND ?
+            AND encounter.encounter_type NOT IN (
+              SELECT encounter_type_id FROM encounter_type WHERE name IN ('LAB', 'LAB ORDER', 'LAB ORDERS', 'LAB RESULTS')
+            )
+            AND encounter.program_id = #{hiv_program.program_id}
+            AND encounter.voided = 0
+            AND patient.voided = 0
+           GROUP BY patient.patient_id
+        SQL
+
+        ::Patient.find_by_sql([query, day_start, day_end])
+      end
+
+      def workflow_engine(patient, date)
+        ::ArtService::WorkflowEngine.new patient:,
+                                         program: hiv_program,
+                                         date:
+      end
+
+      def hiv_program
+        @hiv_program ||= program('HIV PROGRAM')
+      end
+
+      def save_report(visits)
+        visits.each do |date, values|
+          report = fetch_report date
+
+          values.each do |indicator, value|
+            ::ReportValue.create name: "#{date} - #{indicator}",
+                                 indicator_name: indicator,
+                                 contents: value,
+                                 content_type: 'integer',
+                                 report:,
+                                 creator: ::User.first.user_id
+          end
+        end
+      end
+
+      def fetch_report(date)
+        report = ::Report.find_by type: report_type('Visits'),
+                                  name: 'Daily visits',
+                                  start_date: date,
+                                  end_date: date
+        report || create_report(date)
+      end
+
+      def create_report(date)
+        ::Report.create type: fetch_report_type,
+                        name: 'Daily visits',
+                        start_date: date,
+                        end_date: date,
+                        renderer_type: 'Plain text',
+                        creator: ::User.first.user_id
+      end
+
+      def fetch_report_type
+        type = report_type('Visits')
+        type || ::ReportType.create(name: 'Visits', creator: ::User.current.id)
+      end
+    end
+  end
+end