renalware-core 2.0.0.pre.rc8 → 2.0.0.pre.rc9

data/db/migrate/20171206140738_create_fn_to_load_practice_memberships_csv.rb

@@ -1,61 +1,10 @@
 class CreateFnToLoadPracticeMembershipsCSV < ActiveRecord::Migration[5.1]
   def up
-    sql = <<-SQL
-      CREATE OR REPLACE FUNCTION renalware.import_practice_memberships_csv(file text) RETURNS void
-          AS $$
-          BEGIN
-
-          DROP TABLE IF EXISTS memberships_via_copy;
-          CREATE TEMP TABLE copied_memberships (
-            gp_code text NOT NULL,
-            practice_code text NOT NULL,
-            unused3 text,
-            unused4 text,
-            unused5 text,
-            unused7 text
-          );
-
-          -- Import the CSV file into copied_memberships - note there is no CSV header in this file
-          EXECUTE format ('COPY copied_memberships FROM %L DELIMITER %L CSV ', file, ',');
-
-          DROP TABLE IF EXISTS tmp_memberships;
-          CREATE TEMP TABLE tmp_memberships AS
-            SELECT
-              gp_code,
-              practice_code,
-              patient_primary_care_physicians.id primary_care_physician_id,
-              patient_practices.id as practice_id
-              from copied_memberships
-              INNER JOIN patient_practices on patient_practices.code = practice_code
-              INNER JOIN patient_primary_care_physicians on patient_primary_care_physicians.code = gp_code;
-
-          -- Insert any new memberships, ignoring any conflicts where the
-          -- practice_id + primary_care_physician_id already exists
-          INSERT INTO renalware.patient_practice_memberships
-            (practice_id, primary_care_physician_id, created_at, updated_at)
-          SELECT
-            practice_id,
-            primary_care_physician_id,
-            CURRENT_TIMESTAMP,
-            CURRENT_TIMESTAMP
-          FROM tmp_memberships
-          ON CONFLICT (practice_id, primary_care_physician_id) DO NOTHING;
-
-          -- Mark as deleted any memberships not in the latest uploaded data set - ie those gps have retired or moved on
-          UPDATE patient_practice_memberships mem
-            SET deleted_at = CURRENT_TIMESTAMP
-            WHERE NOT EXISTS (select 1 FROM tmp_memberships tmem
-            WHERE tmem.practice_id = mem.practice_id AND tmem.primary_care_physician_id = mem.primary_care_physician_id);
-
-        END;
-        $$ LANGUAGE plpgsql;
-    SQL
-
-    ActiveRecord::Base.connection.execute(sql)
+    load_function("import_practice_memberships_csv_v01.sql")
   end
 
    def down
-    ActiveRecord::Base.connection.execute(
+    connection.execute(
       "DROP FUNCTION IF EXISTS import_practice_memberships_csv(file text);"
     )
   end

data/db/migrate/20171213111513_create_fn_to_refresh_current_obs.rb

@@ -1,50 +1,9 @@
 class CreateFnToRefreshCurrentObs < ActiveRecord::Migration[5.1]
   def up
-    sql = <<-SQL
-      CREATE OR REPLACE FUNCTION refresh_current_observation_set(a_patient_id integer)
-        -- Function to update the pathology_current_observation_set for a patient.
-        -- It stores the most recent results into the jsonb hash on that table.
-        -- To run for all patients, use
-        --   select refresh_current_observation_set(id) from patients;
-        --
-          RETURNS integer
-          LANGUAGE 'plpgsql'
-          as $$
-        BEGIN
-        with current_patient_obs as(
-            select
-              DISTINCT ON (p.id, obxd.id)
-        p.id as patient_id,
-              obxd.code,
-              json_build_object('result',(obx.result),'observed_at',obx.observed_at) as value
-              from patients p
-              inner join pathology_observation_requests obr on obr.patient_id = p.id
-              inner join pathology_observations obx on obx.request_id = obr.id
-              inner join pathology_observation_descriptions obxd on obx.description_id = obxd.id
-              where p.id = a_patient_id
-              order by p.id, obxd.id, obx.observed_at desc
-          ),
-          current_patient_obs_as_jsonb as (
-            select patient_id,
-              jsonb_object_agg(code, value) as values,
-              CURRENT_TIMESTAMP,
-              CuRRENT_TIMESTAMP
-              from current_patient_obs
-              group by patient_id order by patient_id
-          )
-          insert into pathology_current_observation_sets (patient_id, values, created_at, updated_at)
-            select * from current_patient_obs_as_jsonb
-            ON conflict (patient_id)
-            DO UPDATE
-            SET values = excluded.values, updated_at = excluded.updated_at;
-        RETURN a_patient_id;
-      END
-      $$;
-    SQL
-    ActiveRecord::Base.connection.execute(sql)
+    load_function("refresh_current_observation_set_v01.sql")
   end
 
   def down
-    ActiveRecord::Base.connection.execute("drop function if exists refresh_current_observation_set(integer)")
+    connection.execute("drop function if exists refresh_current_observation_set(integer)")
   end
 end

data/db/migrate/20171214141335_create_trigger_to_update_current_observation_sets.rb

@@ -1,109 +1,11 @@
 class CreateTriggerToUpdateCurrentObservationSets < ActiveRecord::Migration[5.1]
   def up
-    sql = <<-SQL
-      CREATE OR REPLACE FUNCTION update_current_observation_set_from_trigger() RETURNS TRIGGER AS $body$
-        -- TC 14/12/2017
-        -- This function is called by a trigger when a row is inserted or updated in
-        -- pathology_observations. Its purpose is to keep current_observation_sets up to date
-        -- with the latest observations for any patient.
-        -- The current_observation_sets table maintains a jsonb hash into which we insert or replace
-        -- the observation, keyed by OBX code.
-        -- e.g.  .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-        DECLARE
-          a_patient_id bigint;
-          a_code text;
-          current_observed_at timestamp;
-          current_result text;
-          new_observed_at timestamp;
-        BEGIN
-          RAISE NOTICE 'TRIGGER called on %',TG_TABLE_NAME ;
-
-          /*
-          If inserting or updating, we _could_ assume the last observation to be inserted is
-          the most 'recent' one (with the latest observed_at date).
-          However the order of incoming messages is not guaranteed, so we have two options:
-          1. Refresh the entire current_observation_set for the patient
-          2. Check the current observed_at date in the jsonb and only update if we have a more
-             recent one
-          We have gone for 2.
-          */
-
-          IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-
-            -- Note we could re-generate the entire current pathology for the patient using
-            --  select refresh_current_observation_set(a_patient_id);
-            -- which is safer but uses more resources, so avoiding this for now.
-
-            -- Find and store patient_id into local variable
-            select request.patient_id into a_patient_id
-              from pathology_observation_requests request
-              where request.id = NEW.request_id;
-
-            -- Find and store the obx code into local variable
-            select description.code into a_code
-              from pathology_observation_descriptions description
-              where description.id = NEW.description_id;
-
-            -- Important! Create the observation_set if it doesn exist yet
-            -- ignore the error id the row already exists
-            insert into pathology_current_observation_sets (patient_id)
-            values (a_patient_id)
-            ON CONFLICT DO NOTHING;
-
-            -- We are going to compare the current and new observed_at dates
-            -- so need to cast them  to a timestamp
-            select cast(New.observed_at as timestamp) into new_observed_at;
-
-            -- Get the most recent date and value for this observation
-            -- and store to variables.
-            select
-            cast(values -> a_code ->> 'observed_at' as timestamp),
-            values -> a_code ->> 'result'
-            into current_observed_at, current_result from
-            pathology_current_observation_sets
-            where patient_id = a_patient_id;
-
-            -- Output some info to helps us debug. This can be removed later.
-            RAISE NOTICE '  Request id % Patient id % Code %', NEW.request_id, a_patient_id, a_code;
-            RAISE NOTICE '  Last %: % at %', a_code, current_result, current_observed_at;
-            RAISE NOTICE '  New  %: % at %', a_code, NEW.result, new_observed_at;
-
-            IF current_observed_at IS NULL OR new_observed_at >= current_observed_at THEN
-              -- The new pathology_observation row contain a more recent result that the old one.
-              -- (note there may not be an old one if the patient has neve had this obs before).
-
-              RAISE NOTICE '  Updating pathology_current_observation_sets..';
-
-              -- Update the values jsonb column with the new hash for this code, e.g.
-              -- .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-                    -- Note the `set values` below actually reads in the jsonb, updates it,
-                    -- and wites the whole thing back.
-              update pathology_current_observation_sets
-                set values = jsonb_set(
-                  values,
-                  ('{'||a_code||'}')::text[], -- defined in the fn path::text[]
-                  jsonb_build_object('result', NEW.result, 'observed_at', new_observed_at),
-                  true)
-                where patient_id = a_patient_id;
-            END IF;
-          END IF;
-          RETURN NULL ;
-        END $body$ LANGUAGE plpgsql VOLATILE COST 100;
-      -- End function
-
-      -- Create the trigger which will call out function every time a row in pathology_observations
-      -- is inserted or updated
-      DROP TRIGGER IF EXISTS update_current_observation_set_trigger ON pathology_observations;
-      CREATE TRIGGER update_current_observation_set_trigger
-        AFTER INSERT OR UPDATE
-        ON pathology_observations
-        FOR EACH ROW EXECUTE PROCEDURE update_current_observation_set_from_trigger();
-    SQL
-    ActiveRecord::Base.connection.execute(sql)
+    load_function("update_current_observation_set_from_trigger_v01.sql")
+    load_trigger("update_current_observation_set_trigger_v01.sql")
   end
 
   def down
-    ActiveRecord::Base.connection.execute("
+    connection.execute("
       DROP TRIGGER IF EXISTS update_current_observation_set_trigger ON pathology_observations;
       DROP FUNCTION IF EXISTS update_current_observation_set_from_trigger();
     ")

data/db/migrate/20180119121243_create_trigger_to_preprocess_hl7_msg.rb

@@ -1,46 +1,7 @@
 class CreateTriggerToPreprocessHL7Msg < ActiveRecord::Migration[5.1]
   def up
-    # Note that we need to use a quoted heredoc ('SQL') here in order to preserve our
-    # SQL escaping e.g. E'\\S\\' which would otherwise be interpreted by Ruby as E'\S\'
-    sql = <<-'SQL'
-      /* Create a function for the trigger to call */
-      CREATE FUNCTION preprocess_hl7_message() RETURNS trigger AS
-      $body$
-      BEGIN
-        /*
-        Mirth inserts a row into delayed job when a new HL7 message needs to be processed by Renalware.
-        The SQL it uses looks like this:
-          insert into renalware.delayed_jobs (handler, run_at)
-          values(E'--- !ruby/struct:FeedJob\nraw_message: |\n  ' || REPLACE(${message.rawData},E'\r',E'\n  '), NOW());
-        This works unless there is a 10^12 value in the unit of measurement segment for an OBX (e.g.
-        for WBC or HGB). Then Mirth encodes the ^ as \S\ because ^ is a significant character in Mirth
-        (field separator). Unfortunately this creates the combination
-        10\S\12 and S\12 is converted to \n when the handler's payload is loaded in by the delayed_job worker.
-        To get around this we need to convert instances of \S\ with another escape sequence eg «
-        and manually map this back to a ^ in the job handler ruby code.
-
-        So here, if this delayed_job is destined to be picked up by a Feed job handler
-        make sure we convert the Mirth escape sequence \S\ to \\S\\
-        */
-        IF position('Feed' in NEW.handler) > 0 THEN
-          NEW.handler = replace(NEW.handler, E'\\S\\', E'\\\\S\\\\');
-        END IF;
-
-        RETURN NEW;
-      END
-
-      $body$
-      LANGUAGE plpgsql;
-
-      /* Create the trigger! */
-      CREATE TRIGGER feed_messages_preprocessing_trigger
-        BEFORE INSERT
-        ON delayed_jobs
-        FOR EACH ROW
-        EXECUTE PROCEDURE preprocess_hl7_message();
-    SQL
-
-    connection.execute(sql)
+    load_function("preprocess_hl7_message_v01.sql")
+    load_trigger("feed_messages_preprocessing_trigger_v01.sql")
   end
 
   def down

data/db/migrate/20180121115246_add_include_pathology_in_letter_to_letters_letterheads.rb

@@ -0,0 +1,5 @@
+class AddIncludePathologyInLetterToLettersLetterheads < ActiveRecord::Migration[5.1]
+  def change
+    add_column :letter_letterheads, :include_pathology_in_letter_body, :boolean, default: true
+  end
+end

data/db/migrate/20180125201356_make_obs_set_trigger_change_updated_at.rb

@@ -1,191 +1,9 @@
 class MakeObsSetTriggerChangeUpdatedAt < ActiveRecord::Migration[5.1]
   def up
-    sql = <<-SQL
-      CREATE OR REPLACE FUNCTION update_current_observation_set_from_trigger() RETURNS TRIGGER AS $body$
-        -- TC 14/12/2017
-        -- This function is called by a trigger when a row is inserted or updated in
-        -- pathology_observations. Its purpose is to keep current_observation_sets up to date
-        -- with the latest observations for any patient.
-        -- The current_observation_sets table maintains a jsonb hash into which we insert or replace
-        -- the observation, keyed by OBX code.
-        -- e.g.  .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-        DECLARE
-          a_patient_id bigint;
-          a_code text;
-          current_observed_at timestamp;
-          current_result text;
-          new_observed_at timestamp;
-        BEGIN
-          RAISE NOTICE 'TRIGGER called on %',TG_TABLE_NAME ;
-
-          /*
-          If inserting or updating, we _could_ assume the last observation to be inserted is
-          the most 'recent' one (with the latest observed_at date).
-          However the order of incoming messages is not guaranteed, so we have two options:
-          1. Refresh the entire current_observation_set for the patient
-          2. Check the current observed_at date in the jsonb and only update if we have a more
-             recent one
-          We have gone for 2.
-          */
-
-          IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-
-            -- Note we could re-generate the entire current pathology for the patient using
-            --  select refresh_current_observation_set(a_patient_id);
-            -- which is safer but uses more resources, so avoiding this for now.
-
-            -- Find and store patient_id into local variable
-            select request.patient_id into a_patient_id
-              from pathology_observation_requests request
-              where request.id = NEW.request_id;
-
-            -- Find and store the obx code into local variable
-            select description.code into a_code
-              from pathology_observation_descriptions description
-              where description.id = NEW.description_id;
-
-            -- Important! Create the observation_set if it doesn't exist yet
-            -- ignore the error if the row already exists
-            insert into pathology_current_observation_sets (patient_id)
-            values (a_patient_id)
-            ON CONFLICT DO NOTHING;
-
-            -- We are going to compare the current and new observed_at dates
-            -- so need to cast them  to a timestamp
-            select cast(New.observed_at as timestamp) into new_observed_at;
-
-            -- Get the most recent date and value for this observation
-            -- and store to variables.
-            select
-            cast(values -> a_code ->> 'observed_at' as timestamp),
-            values -> a_code ->> 'result'
-            into current_observed_at, current_result from
-            pathology_current_observation_sets
-            where patient_id = a_patient_id;
-
-            -- Output some info to helps us debug. This can be removed later.
-            RAISE NOTICE '  Request id % Patient id % Code %', NEW.request_id, a_patient_id, a_code;
-            RAISE NOTICE '  Last %: % at %', a_code, current_result, current_observed_at;
-            RAISE NOTICE '  New  %: % at %', a_code, NEW.result, new_observed_at;
-
-            IF current_observed_at IS NULL OR new_observed_at >= current_observed_at THEN
-              -- The new pathology_observation row contain a more recent result that the old one.
-              -- (note there may not be an old one if the patient has neve had this obs before).
-
-              RAISE NOTICE '  Updating pathology_current_observation_sets..';
-
-              -- Update the values jsonb column with the new hash for this code, e.g.
-              -- .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-                    -- Note the `set values` below actually reads in the jsonb, updates it,
-                    -- and wites the whole thing back.
-              update pathology_current_observation_sets
-                set updated_at = CURRENT_TIMESTAMP,
-                  values = jsonb_set(
-                  values,
-                  ('{'||a_code||'}')::text[], -- defined in the fn path::text[]
-                  jsonb_build_object('result', NEW.result, 'observed_at', new_observed_at),
-                  true)
-                where patient_id = a_patient_id;
-            END IF;
-          END IF;
-          RETURN NULL ;
-        END $body$ LANGUAGE plpgsql VOLATILE COST 100;
-      -- End function
-    SQL
-    ActiveRecord::Base.connection.execute(sql)
+    load_function("update_current_observation_set_from_trigger_v02.sql")
   end
 
   def down
-    sql = <<-SQL
-      CREATE OR REPLACE FUNCTION update_current_observation_set_from_trigger() RETURNS TRIGGER AS $body$
-        -- TC 14/12/2017
-        -- This function is called by a trigger when a row is inserted or updated in
-        -- pathology_observations. Its purpose is to keep current_observation_sets up to date
-        -- with the latest observations for any patient.
-        -- The current_observation_sets table maintains a jsonb hash into which we insert or replace
-        -- the observation, keyed by OBX code.
-        -- e.g.  .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-        DECLARE
-          a_patient_id bigint;
-          a_code text;
-          current_observed_at timestamp;
-          current_result text;
-          new_observed_at timestamp;
-        BEGIN
-          RAISE NOTICE 'TRIGGER called on %',TG_TABLE_NAME ;
-
-          /*
-          If inserting or updating, we _could_ assume the last observation to be inserted is
-          the most 'recent' one (with the latest observed_at date).
-          However the order of incoming messages is not guaranteed, so we have two options:
-          1. Refresh the entire current_observation_set for the patient
-          2. Check the current observed_at date in the jsonb and only update if we have a more
-             recent one
-          We have gone for 2.
-          */
-
-          IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-
-            -- Note we could re-generate the entire current pathology for the patient using
-            --  select refresh_current_observation_set(a_patient_id);
-            -- which is safer but uses more resources, so avoiding this for now.
-
-            -- Find and store patient_id into local variable
-            select request.patient_id into a_patient_id
-              from pathology_observation_requests request
-              where request.id = NEW.request_id;
-
-            -- Find and store the obx code into local variable
-            select description.code into a_code
-              from pathology_observation_descriptions description
-              where description.id = NEW.description_id;
-
-            -- Important! Create the observation_set if it doesn exist yet
-            -- ignore the error id the row already exists
-            insert into pathology_current_observation_sets (patient_id)
-            values (a_patient_id)
-            ON CONFLICT DO NOTHING;
-
-            -- We are going to compare the current and new observed_at dates
-            -- so need to cast them  to a timestamp
-            select cast(New.observed_at as timestamp) into new_observed_at;
-
-            -- Get the most recent date and value for this observation
-            -- and store to variables.
-            select
-            cast(values -> a_code ->> 'observed_at' as timestamp),
-            values -> a_code ->> 'result'
-            into current_observed_at, current_result from
-            pathology_current_observation_sets
-            where patient_id = a_patient_id;
-
-            -- Output some info to helps us debug. This can be removed later.
-            RAISE NOTICE '  Request id % Patient id % Code %', NEW.request_id, a_patient_id, a_code;
-            RAISE NOTICE '  Last %: % at %', a_code, current_result, current_observed_at;
-            RAISE NOTICE '  New  %: % at %', a_code, NEW.result, new_observed_at;
-
-            IF current_observed_at IS NULL OR new_observed_at >= current_observed_at THEN
-              -- The new pathology_observation row contain a more recent result that the old one.
-              -- (note there may not be an old one if the patient has neve had this obs before).
-
-              RAISE NOTICE '  Updating pathology_current_observation_sets..';
-
-              -- Update the values jsonb column with the new hash for this code, e.g.
-              -- .. {"HGB": { "result": 123.1, "observed_at": '2017-12-12-01:01:01'}, ..
-                    -- Note the `set values` below actually reads in the jsonb, updates it,
-                    -- and wites the whole thing back.
-              update pathology_current_observation_sets
-                set values = jsonb_set(
-                  values,
-                  ('{'||a_code||'}')::text[], -- defined in the fn path::text[]
-                  jsonb_build_object('result', NEW.result, 'observed_at', new_observed_at),
-                  true)
-                where patient_id = a_patient_id;
-            END IF;
-          END IF;
-          RETURN NULL ;
-        END $body$ LANGUAGE plpgsql VOLATILE COST 100;
-    SQL
-    ActiveRecord::Base.connection.execute(sql)
+    load_function("update_current_observation_set_from_trigger_v01.sql")
   end
 end