renalware-core 2.0.113 → 2.0.115

data/app/controllers/renalware/hd/diaries_controller.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd/base_controller"
-
-# The route to the edit route for this controller takes /:year/:week_number segments
-# rather than an id. THat is because when we load the diary, and when we navigate back and forth
-# through diaries, we are concerned with the week more then an id. Its easier to navigate to the
-# next week with /2017/52 than by looking up the id of the next diary ahead of time.
-module Renalware
-  module HD
-    class DiariesController < BaseController
-      include Renalware::Concerns::PdfRenderable
-      include Renalware::Concerns::Pageable
-
-      def edit
-        authorize weekly_diary, :show?
-        render locals: {
-          unit: unit,
-          diary: DiaryPresenter.new(current_user, weekly_diary)
-        }
-      end
-
-      # Renders a list of diaries for a hospital unit
-      def index
-        authorize WeeklyDiary, :index?
-        render locals: { unit: unit, diaries: weekly_diaries }
-      end
-
-      def show
-        diary = WeeklyDiary.find(params[:id])
-        respond_to do |format|
-          format.pdf do
-            authorize diary
-            options = default_pdf_options.merge!(
-              pdf: pdf_filename,
-              locals: { unit: unit, diary: DiaryPresenter.new(current_user, diary) }
-            )
-            render options
-          end
-        end
-      end
-
-      private
-
-      # TODO: give a sensible name
-      def pdf_filename
-        "hd_unit_diary"
-      end
-
-      def weekly_diary
-        @weekly_diary ||= begin
-          FindOrCreateDiaryByWeekQuery.new(
-            relation: WeeklyDiary.eager_load(
-              slots: [:patient, :station, :diurnal_period_code],
-              master_diary: { slots: [:patient, :station, :diurnal_period_code] }
-            ),
-            unit_id: unit_id,
-            week_period: week_period,
-            by: current_user
-          ).call
-        end
-      end
-
-      # The route segments are /:year/:week_number
-      # We use a WeekPeriod value object to wrap those two things.
-      def week_period
-        WeekPeriod.new(
-          week_number: params[:week_number],
-          year: params[:year]
-        )
-      end
-
-      def unit_id
-        params[:unit_id]
-      end
-
-      def unit
-        Hospitals::Unit.find(unit_id)
-      end
-
-      def weekly_diaries
-        WeeklyDiary
-          .where(hospital_unit_id: unit_id)
-          .ordered
-          .page(page).per(per_page)
-      end
-    end
-  end
-end

data/app/controllers/renalware/hd/diary_slots_controller.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Metrics/ClassLength
-require_dependency "renalware/hd/base_controller"
-
-module Renalware
-  module HD
-    class DiarySlotsController < BaseController
-      # GET html -  renders a form
-      # Here we will have been passed in the query string:
-      # - the unit id
-      # - the dirunal_period_code id
-      # - the week and year (and thus the diary)
-      # and from that lot we could look up the master and weekly diaries
-      def new
-        # Be default this assume we are going to add a slot to the weekly diary
-        # but in which button is clicked in the modal dialog determines which diary
-        # (master or weekly) the slot will be added to.
-        slot = DiarySlot.new(
-          diary: weekly_diary,
-          station_id: params[:station_id],
-          day_of_week: params[:day_of_week],
-          diurnal_period_code_id: params[:diurnal_period_code_id]
-        )
-        authorize slot
-        render locals: locals_for(slot), layout: false
-      end
-
-      # POST create js
-      # Here we may be adding a slot to the weekly or master diary.
-      # That should be transparent to us - we make the change and render
-      # create.js.erb which, on the client, will cause an ajax js call to #show. That secondary call
-      # is the one that refreshes the slot in the table with its latest state.
-      # We do this to avoid having to to a check (in each action in this controller) to see if we
-      # are on the master or weekly diary; if we always refresh the diary slot in the ui after any
-      # action, then it will always update correctly.
-      def create
-        diary = Diary.find(params[:diary_id])
-        slot = diary.slots.new(slot_params)
-        slot.patient_id = posted_patient_id
-        authorize slot
-        if slot.save_by(current_user)
-          render locals: { diary: diary, slot: diary.decorate_slot(slot) }
-        else
-          render :new, locals: { slot: DiarySlotPresenter.new(slot) }, layout: false
-        end
-      end
-
-      # GET .js refresh a slot in a *weekly* diary
-      # See comment on #create.
-      # See show.js.erb where we refresh the slot in the diary
-      # To get here we will have manufactured a url like this
-      #   hd/diaries/2/slots/day/1/period/1/station/1
-      # as those bit are will we know.
-      # Basically we are saying find for this weekly diary, find the matching
-      # slot for the station/day/period combo and render the weekly slot if there is
-      # one, or the master behind it if there is one of those, otherwise render an Add button.
-      def show
-        authorize DiarySlot, :show?
-        slot = weekly_then_master_then_empty_slot
-        render layout: false, locals: { slot: DiarySlotPresenter.new(slot) }
-      end
-
-      def edit
-        authorize slot
-        render layout: false, locals: { slot: DiarySlotPresenter.new(slot) }
-      end
-
-      # DELETE js
-      # Delete the slot (we don't know if its on the master or weekly diary).
-      # NB as per #create and #update, the rendered js file (destroy.js.erb) will make a secondary
-      # back into #show to refresh the UI (i.e. we don't attempt to update the UI in destroy.js.erb)
-      def destroy
-        authorize slot
-        slot.destroy!
-        render locals: { slot: DiarySlotPresenter.new(slot) }
-      end
-
-      # PATCH js
-      # See also comments in #create and #destroy.
-      def update
-        authorize slot
-        slot.patient_id = slot_params[:patient_id]
-        slot.save_by!(current_user)
-        diary = slot.diary
-        render locals: { diary: diary, slot: diary.decorate_slot(slot) }
-      end
-
-      private
-
-      # Find the corresponding slot in the master if there is one, otherwise an empty slot
-      # with an 'Add' button ready to set up a new patient
-      def weekly_then_master_then_empty_slot
-        empty_slot = build_empty_weekly_slot
-        find_weekly_slot(empty_slot) || find_master_slot(empty_slot) || empty_slot
-      end
-
-      def find_master_slot(args)
-        slot = master_diary.slots.find_by(
-          diurnal_period_code_id: args.diurnal_period_code_id,
-          station_id: args.station_id,
-          day_of_week: args.day_of_week
-        )
-        slot && master_diary.decorate_slot(slot)
-      end
-
-      def find_weekly_slot(args)
-        slot = weekly_diary.slots.find_by(
-          diurnal_period_code_id: args.diurnal_period_code_id,
-          station_id: args.station_id,
-          day_of_week: args.day_of_week
-        )
-        slot && weekly_diary.decorate_slot(slot)
-      end
-
-      # Used for searching etc
-      def build_empty_weekly_slot
-        weekly_diary.slots.new(
-          day_of_week: params[:day_of_week],
-          station_id: params[:station_id],
-          diurnal_period_code_id: params[:diurnal_period_code_id]
-        )
-      end
-
-      def slot
-        @slot ||= HD::DiarySlot.find(params[:id])
-      end
-
-      # In the url the :diary_id param is always the weekly diary id!
-      def weekly_diary
-        @weekly_diary ||= WeeklyDiary.find(params[:diary_id])
-      end
-
-      def master_diary
-        weekly_diary.master_diary
-      end
-
-      def locals_for(slot)
-        {
-          slot: DiarySlotPresenter.new(slot),
-          weekly_diary: weekly_diary
-        }
-      end
-
-      # In the modal dialog that submits the patient_id there are several (select2) dropdown
-      # a user can use to choose the patient. Each one has the name patient_id[] so they are
-      # submitted in the form as an array. However the array can only hold one id value ie we
-      # might get posted patient_id: ["", "123", ""] but never  ["2", "123", ""].
-      # Here we reduce that array down to one patient id.
-      def posted_patient_id
-        patient_ids = Array(slot_params[:patient_id]).reject(&:blank?).uniq
-        if patient_ids.length > 1
-          raise ArgumentError, "More than one id submitted in patient_id[] : #{patient_ids}"
-        end
-
-        patient_ids.first
-      end
-
-      def slot_params
-        params
-          .require(:hd_diary_slot)
-          .permit(
-            :master_slot,
-            :day_of_week,
-            :diurnal_period_code_id,
-            :station_id,
-            :target_diary_id,
-            :change_type,
-            patient_id: []
-          )
-      end
-    end
-  end
-end
-# rubocop:enable Metrics/ClassLength

data/app/controllers/renalware/letters/descriptions_controller.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/letters"
-
-module Renalware
-  module Letters
-    class DescriptionsController < ApplicationController
-      def search
-        query = Letters::Descriptions::SearchQuery.new(params[:term])
-        render json: DescriptionAutocompleteResponse.to_json(query.call)
-      end
-
-      class DescriptionAutocompleteResponse
-        def self.to_json(collection)
-          collection.map do |item|
-            { id: item.id, label: item.text }
-          end.to_json
-        end
-      end
-    end
-  end
-end

data/app/controllers/renalware/renal/prd_descriptions_controller.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/renal"
-
-module Renalware
-  module Renal
-    class PRDDescriptionsController < BaseController
-      skip_after_action :verify_authorized, only: [:search]
-
-      def search
-        @prd_descriptions = PRDDescriptions::SearchQuery.new(term: params[:term]).call
-      end
-    end
-  end
-end

data/app/models/renalware/hd/archive_yesterdays_slots_job.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "renalware/hd"
-
-# A cron job creates this delayed job, which does the following:
-# For all Weekly Diaries in the past, plus this week
-# for each day that is in the past
-# mark any slots in the weekly diary as archived
-# and where the weekly diary is inheriting slots from the master diary
-# create corresponding slots in the weekly diary (ie migrate thos slots from master to weekly)
-# and archive them.
-# Not slots before the current day (or the up_until: arg) should be touched
-#
-#
-# OK we have a problem,
-# If last week there was no weekly diary created... then there is nothing to archive if eg today is
-# Monday.
-# So really whats the query for finding slots to archive?
-# We need to really always inner join onto weekly diaryies, and within tose for their slots
-# select unarchved onces in the past.
-# So we MUST always have weekly diaries for every possible week and not rely om a user working te UI
-# to create these JIT - because if they don't, unless we have a fn to creatae missing diaries,
-# (from which date?) then we can't query
-# So either
-# - seed next 10 years (520 per unit)
-# - have a fn to generate missing diaries - might be better and safer in the long run?
-# - Otherwise after 5 or 10 years or whatever its bound to have cased a problem.
-
-module Renalware
-  module HD
-    class ArchiveYesterdaysSlotsJob < ApplicationJob
-      attr_reader :up_until
-
-      # :reek:UtilityFunction
-      def perform(up_until: nil)
-        @up_until = up_until&.to_date
-        @up_until ||= (Time.zone.today - 1.day)
-
-        diary = Diary.find_by(year: @up_until.year, week_number: @up_until.cweek)
-        return unless diary
-
-        diary
-          .slots
-          .unarchived
-          .where(day_of_week: @up_until.cwday)
-          .update_all(archived: true, archived_at: Time.zone.now)
-        # DiarySlot
-        #   .unarchived
-        #   .joins(:diary)
-        #   .where(hd_diaries: { year: up_until.year, week_number: up_until.cweek)
-
-        #   .update_all(archived: true, archived_at: Time.zone.now)
-      end
-
-      private
-
-      def create_missing_weekly_diaries
-        # intering query
-        # basic implemenraiton
-        # select all weeklydiaries pluch year week from installation start date??? to now
-        # loop through
-        #  diary year 2017 week 1
-        #  MISSING diary year 2017 week 1 - so create
-        #  diary year 2017 week 3
-        #  select
-      end
-    end
-  end
-end

data/app/models/renalware/hd/diary.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd"
-
-# A Diary is the schedule of HD Station/Patients assignments for one week for a particular unit.
-# A Diary is split into Periods (eg. am pm eve), and each Period has a matrix of slots
-# Imagine Days eg 1 to 6 on the X axis and Stations on the Y axis, and into each 'slot' we
-# put a patient.
-# A patient can only be in one slot in any period.
-#
-# Do not create instances of this class explicity, always use the STI sub classes eg MasterDiary.
-module Renalware
-  module HD
-    class Diary < ApplicationRecord
-      include Accountable
-
-      has_many :slots, class_name: "Renalware::HD::DiarySlot"
-      has_many :patients, through: :slots, class_name: "Renalware::HD::Patient"
-      validates :hospital_unit_id, presence: true
-      validates :master, inclusion: { in: [true, false], allow_nil: true }
-      composed_of :week,
-                  mapping: [%w(week_number week_number), %w(year year)],
-                  constructor: lambda { |week_number, year|
-                    WeekPeriod.new(week_number: week_number, year: year)
-                  }
-
-      def self.policy_class
-        DiaryPolicy
-      end
-
-      # Searchs the object graph rather than a SQL search
-      def slot_for(diurnal_period_code_id, station_id, day_of_week)
-        slots.find do |slot|
-          slot.diurnal_period_code_id == diurnal_period_code_id &&
-            slot.station_id == station_id &&
-            slot.day_of_week == day_of_week
-        end
-      end
-    end
-  end
-end

data/app/models/renalware/hd/diary_slot.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd"
-
-module Renalware
-  module HD
-    # TODO: Document
-    class DiarySlot < ApplicationRecord
-      # Changing to_ary from private to public here is a hack required to remove a SimpleDelgator
-      # warning in eg Renalware::HD::WeeklyDiary::WeeklySlotDecorator:
-      #
-      #   `respond_to?': delegator does not forward private method #to_ary
-      #
-      # Yielding a slot from DiaryPresenter to the view seems to want to call #to_ary on it, (have
-      # not looked into why) and as the slot is wrapped in a decorator using SimpleDelegator,
-      # SimpleDelegatr complains it can't delegate to a private method.
-      # An alternative is to define the following in each Slot decorator
-      #
-      #    def respond_to?(method, include_private = false)
-      #      return false if method == :to_ary
-      #      super
-      #    end
-      #
-      #  or to use method_missnig instead of SimpleDelegator in Slot Decorators.
-      #
-      public :to_ary
-
-      # Virtual attribute used on a form to determine what action as preformed on the slot
-      attr_accessor :change_type
-
-      include Accountable
-      belongs_to :diary, class_name: "Renalware::HD::Diary", touch: true
-      belongs_to :patient, touch: true
-      belongs_to :station, class_name: "Renalware::HD::Station"
-      belongs_to :diurnal_period_code
-
-      validates :diary, presence: true
-      validates :patient, presence: true
-      validates :station, presence: true
-      validates :diurnal_period_code, presence: true
-      validates :day_of_week, presence: true, inclusion: { in: 1..7 }
-
-      scope :weekly, -> { joins(:diary).where(hd_diaries: { master: false }) }
-      scope :archived, -> { weekly.where(archived: true) }
-      scope :unarchived, -> { weekly.where(archived: false) }
-
-      # A patient can only be assigned to one station in any period (e.g. am)/day combination
-      # for a diary. I.e. they can't be on two stations on Monday morning.
-      validates :patient_id,
-                uniqueness: { scope: [:diary, :diurnal_period_code, :day_of_week] }
-
-      # Scoped to a diary, the combination of day + station + diurnal_period is unique
-      validates :diurnal_period_code_id, uniqueness: { scope: [:diary, :station_id, :day_of_week] }
-
-      delegate :id, to: :diary, prefix: true
-
-      def self.policy_class
-        DiaryPolicy
-      end
-
-      def on_master_diary?
-        diary&.master?
-      end
-
-      def description
-        period = diurnal_period_code.code.upcase # e.g. AM
-        if diary.master
-          "Recurring every #{day_of_week_name} #{period}"
-        else
-          "This week only on #{day_of_week_name} #{period}"
-        end
-      end
-
-      def day_of_week_name
-        Time::DAYS_INTO_WEEK.keys[day_of_week - 1].capitalize
-      end
-
-      def cell_id
-        "#{diurnal_period_code&.id}-#{station&.id}-#{day_of_week}"
-      end
-    end
-  end
-end

data/app/models/renalware/hd/find_or_create_diary_by_week_query.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd"
-require "renalware/week_period"
-##
-# Returns a hospital unit's diary for the requested week (passed to #new as a WeekPeriod
-# value object).
-#
-module Renalware
-  module HD
-    class FindOrCreateDiaryByWeekQuery
-      attr_reader :unit_id, :period, :by, :relation
-
-      def initialize(unit_id:, week_period:, by:, relation: WeeklyDiary.all)
-        @relation = relation
-        @period = week_period
-        @unit_id = unit_id
-        @by = by
-      end
-
-      def call
-        find_or_create_diary
-      end
-
-      private
-
-      # Find the diary for the current unit/week/year, or, if for example if a user wants to fill
-      # next week's diary and it does not yet exist, create it
-      # NB we _always_ return a diary from this method - whether it is found or built just-in-time,
-      def find_or_create_diary
-        attrs = {
-          hospital_unit_id: unit_id,
-          week_number: period.week_number,
-          year: period.year,
-          master: false
-        }
-        relation.find_by(**attrs) || build_diary(**attrs)
-      end
-
-      # Create a new Weekly diary for the current week/year/unit
-      # Add in DiaryPeriods for each currently defined diurnal period eg am pm eve
-      def build_diary(attrs)
-        master_diary = FindOrCreateMasterDiary.for_unit(unit_id, by)
-        diary = WeeklyDiary.create!(**attrs, by: by, master_diary: master_diary)
-        # Reload the diary using the supplied relation (might be egager_loads etc)
-        relation.find(diary.id)
-      end
-    end
-  end
-end

data/app/models/renalware/hd/find_or_create_master_diary.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Renalware
-  module HD
-    class FindOrCreateMasterDiary
-      attr_reader :unit_id, :user
-
-      def self.for_unit(unit_id, user)
-        new(unit_id, user).call
-      end
-
-      def initialize(unit_id, user)
-        @unit_id = unit_id
-        @user = user
-      end
-
-      # TODO: !alwasy suing first :0)
-      def call
-        MasterDiary.find_or_initialize_by(hospital_unit_id: unit_id).tap do |master|
-          master.by = user
-          master.save!
-        end
-      end
-    end
-  end
-end

data/app/models/renalware/hd/master_diary.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd"
-
-module Renalware
-  module HD
-    class MasterDiary < Diary
-      # Overwrite the existing master attribute to ensure it defaults to true
-      attribute :master, :boolean, default: true
-      validates :hospital_unit_id, uniqueness: true
-      has_many :weekly_diaries, class_name: "Renalware::HD::WeeklyDiary"
-      # While out DB constraints could check for the string "Renalware::HD::MasterDiary" in the type
-      # column, this feels a bit fragile, so instead a MasterDiary must have a corresponding
-      # master = TRUE column
-      validates :master, inclusion: { in: [true], allow_nil: false }
-
-      class MasterSlotDecorator < SimpleDelegator
-        def master?
-          true
-        end
-      end
-
-      def decorate_slot(slot)
-        MasterSlotDecorator.new(slot)
-      end
-
-      def slot_for(*args)
-        (slot = super) && decorate_slot(slot)
-      end
-    end
-  end
-end

data/app/models/renalware/hd/weekly_diary.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/hd"
-
-module Renalware
-  module HD
-    class WeeklyDiary < Diary
-      # Overwrite the existing master attribute to ensure it defaults to false
-      attribute :master, :boolean, default: false
-      belongs_to :master_diary, class_name: "Renalware::HD::MasterDiary"
-      validates :week_number,
-                presence: true,
-                uniqueness: { scope: [:year, :hospital_unit_id] },
-                inclusion: { in: 1..53 }
-      validates :year, presence: true
-      validates :master, inclusion: { in: [false], allow_nil: false }
-      validates :master_diary, presence: true
-      delegate :to_s, to: :week
-      scope :ordered, -> { order(year: :desc, week_number: :desc) }
-
-      def applies_to_current_week?
-        today = Time.zone.today
-        [today.cweek, today.year] == [week.week_number, week.year]
-      end
-
-      def archived?
-        false
-      end
-
-      class WeeklySlotDecorator < SimpleDelegator
-        def master?
-          false
-        end
-      end
-
-      def decorate_slot(slot)
-        WeeklySlotDecorator.new(slot)
-      end
-
-      def slot_for(*args)
-        (slot = super) && decorate_slot(slot)
-      end
-    end
-  end
-end

data/app/models/renalware/renal/prd_descriptions/search_query.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency "renalware/renal"
-
-module Renalware
-  module Renal
-    module PRDDescriptions
-      class SearchQuery
-        attr_reader :term, :page, :per_page
-
-        def initialize(term:, page: 1, per_page: 50)
-          @term = term
-          @page = page
-          @per_page = per_page
-        end
-
-        def call
-          search.result.page(page).per(per_page).select(fields)
-        end
-
-        private
-
-        def search
-          @search ||= PRDDescription.ransack(term_or_code_cont: term).tap do |s|
-            s.sorts = ["term"]
-          end
-        end
-
-        def fields
-          %i(id code term)
-        end
-      end
-    end
-  end
-end