renalware-core 2.0.0.pre.beta4

data/app/assets/stylesheets/renalware/watermark.scss

@@ -0,0 +1,8 @@
+.letter-wrapper {
+  &.draft, &.pendingreview {
+    background-image: image-url('renalware/draft.jpg');
+    background-repeat: no-repeat;
+    background-position: center center;
+  }
+}
+

data/app/controllers/application_controller.rb

@@ -0,0 +1,6 @@
+
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/app/controllers/renalware/accesses/assessments_controller.rb

@@ -0,0 +1,82 @@
+module Renalware
+  module Accesses
+    class AssessmentsController < Accesses::BaseController
+      before_action :load_patient
+
+      def show
+        assessment = patient.assessments.find(params[:id])
+        render locals: {
+          patient: patient,
+          assessment: AssessmentPresenter.new(assessment)
+        }
+      end
+
+      def new
+        assessment = AssessmentFactory.new(patient: patient).build
+        render_new(assessment)
+      end
+
+      def create
+        assessment = patient.assessments.new(assessment_params)
+
+        if assessment.save
+          redirect_to patient_accesses_dashboard_path(patient),
+            notice: t(".success", model_name: "Access assessment")
+        else
+          flash[:error] = t(".failed", model_name: "Access assessment")
+          render_new(assessment)
+        end
+      end
+
+      def edit
+        assessment = patient.assessments.find(params[:id])
+        render_edit(assessment)
+      end
+
+      def update
+        assessment = patient.assessments.find(params[:id])
+
+        if assessment.update(assessment_params)
+          redirect_to patient_accesses_dashboard_path(patient),
+            notice: t(".success", model_name: "Access assessment")
+        else
+          flash[:error] = t(".failed", model_name: "Access assessment")
+          render_edit(assessment)
+        end
+      end
+
+      protected
+
+      def render_new(assessment)
+        render :new, locals: { patient: patient, assessment: assessment }
+      end
+
+      def render_edit(assessment)
+        render :edit, locals: { patient: patient, assessment: assessment }
+      end
+
+      def assessment_params
+        params
+          .require(:accesses_assessment)
+          .permit(attributes)
+          .merge(document: document_attributes, by: current_user)
+      end
+
+      def attributes
+        [
+          :performed_on, :first_used_on, :failed_on,
+          :side, :type_id,
+          :catheter_make, :catheter_lot_no,
+          :performed_by, :notes, :outcome,
+          document: []
+        ]
+      end
+
+      def document_attributes
+        params
+          .require(:accesses_assessment)
+          .fetch(:document, nil).try(:permit!)
+      end
+    end
+  end
+end

data/app/controllers/renalware/accesses/base_controller.rb

@@ -0,0 +1,19 @@
+module Renalware
+  module Accesses
+    class BaseController < Renalware::BaseController
+
+      protected
+
+      def patient
+        @accesses_patient ||= Renalware::Accesses.cast_patient(super)
+      end
+
+      private
+
+      def load_patient
+        super
+        @patient = Renalware::Accesses.cast_patient(@patient)
+      end
+    end
+  end
+end

data/app/controllers/renalware/accesses/dashboards_controller.rb

@@ -0,0 +1,24 @@
+require "collection_presenter"
+
+module Renalware
+  module Accesses
+    class DashboardsController < Accesses::BaseController
+      before_action :load_patient
+
+      # TODO: Wrap these variables in a DashboardPresenter
+      def show
+        procedures = patient.procedures.ordered
+        profiles = patient.profiles.past_and_future.ordered
+        plans = patient.plans.historical.ordered
+        assessments = patient.assessments.ordered
+
+        @profiles = CollectionPresenter.new(profiles, ProfilePresenter)
+        @plans = CollectionPresenter.new(plans, PlanPresenter)
+        @procedures = CollectionPresenter.new(procedures, ProcedurePresenter)
+        @assessments = CollectionPresenter.new(assessments, AssessmentPresenter)
+        @current_profile = ProfilePresenter.new(patient.current_profile)
+        @current_plan = ProfilePresenter.new(patient.current_plan)
+      end
+    end
+  end
+end

data/app/controllers/renalware/accesses/plans_controller.rb

@@ -0,0 +1,71 @@
+module Renalware
+  module Accesses
+    class PlansController < Accesses::BaseController
+      def new
+        plan = Plan.new
+        authorize plan
+        render_new(plan)
+      end
+
+      def create
+        plan = patient.plans.new(plan_params.merge!(by: current_user))
+        authorize plan
+        if save_as_current(plan)
+          redirect_to patient_accesses_dashboard_path(patient),
+                      notice: success_msg_for("access plan")
+        else
+          render_new(plan)
+        end
+      end
+
+      # Because editing a plan means creating a new current version (and terminating the previous
+      # current one), we just render the new template using an instance of the current plan.
+      def edit
+        render_new(find_and_authorize_plan.dup)
+      end
+
+      def show
+        render locals: {
+          patient: patient,
+          plan: find_and_authorize_plan
+        }
+      end
+
+      private
+
+      def find_and_authorize_plan
+        plan = Plan.find(params[:id])
+        authorize plan
+        plan
+      end
+
+      def save_as_current(plan)
+        Plan.transaction do
+          if current_plan.present?
+            return true if current_plan.identical_to?(plan) # no change, no new plan to be created
+            current_plan.terminate_by(current_user)
+          end
+          plan.save!
+        end
+      rescue ActiveRecord::RecordInvalid
+        false
+      end
+
+      def render_new(plan)
+        render :new, locals: { patient: patient, plan: plan }
+      end
+
+      def render_edit(plan)
+        render :edit, locals: { patient: patient, plan: plan }
+      end
+
+      def plan_params
+        params.require(:accesses_plan).permit(:plan_type_id, :notes, :decided_by_id)
+      end
+
+      def current_plan
+        @current_plan ||= patient.plans.current.first
+      end
+    end
+  end
+end

data/app/controllers/renalware/accesses/procedures_controller.rb

@@ -0,0 +1,70 @@
+module Renalware
+  module Accesses
+    class ProceduresController < Accesses::BaseController
+      before_action :load_patient
+
+      def show
+        procedure = patient.procedures.find(params[:id])
+        presenter = ProcedurePresenter.new(procedure)
+        render locals: { patient: patient, procedure: presenter }
+      end
+
+      def new
+        procedure = patient.procedures.new(by: current_user)
+        render locals: { patient: patient, procedure: procedure }
+      end
+
+      def create
+        procedure = patient.procedures.new(procedure_params)
+
+        if procedure.save
+          redirect_to patient_accesses_dashboard_path(patient),
+            notice: t(".success", model_name: "Access procedure")
+        else
+          flash[:error] = t(".failed", model_name: "Access procedure")
+          render :new, locals: { patient: patient, procedure: procedure }
+        end
+      end
+
+      def edit
+        procedure = find_procedure
+        render locals: { patient: patient, procedure: procedure }
+      end
+
+      def update
+        procedure = find_procedure
+
+        if procedure.update(procedure_params)
+          redirect_to patient_accesses_dashboard_path(patient),
+                      notice: success_msg_for("access procedure")
+        else
+          flash[:error] = failed_msg_for("access procedure")
+          render :edit, locals: { patient: patient, procedure: procedure }
+        end
+      end
+
+      protected
+
+      def find_procedure
+        patient.procedures.find(params[:id])
+      end
+
+      def procedure_params
+        params
+          .require(:accesses_procedure)
+          .permit(attributes)
+          .merge(by: current_user)
+      end
+
+      def attributes
+        [
+          :performed_on, :first_used_on, :failed_on,
+          :side, :type_id,
+          :catheter_make, :catheter_lot_no,
+          :performed_by, :notes, :outcome,
+          :pd_catheter_insertion_technique_id
+        ]
+      end
+    end
+  end
+end

data/app/controllers/renalware/accesses/profiles_controller.rb

@@ -0,0 +1,62 @@
+module Renalware
+  module Accesses
+    class ProfilesController < Accesses::BaseController
+      before_action :load_patient
+
+      def show
+        profile = patient.profiles.find(params[:id])
+        presenter = ProfilePresenter.new(profile)
+        render locals: { patient: patient, profile: presenter }
+      end
+
+      def new
+        profile = patient.profiles.new(by: current_user)
+        render locals: { patient: patient, profile: profile }
+      end
+
+      def create
+        profile = patient.profiles.new(profile_params)
+
+        if profile.save
+          redirect_to patient_accesses_dashboard_path(patient),
+            notice: t(".success", model_name: "Access profile")
+        else
+          flash[:error] = t(".failed", model_name: "Access profile")
+          render :new, locals: { patient: patient, profile: profile }
+        end
+      end
+
+      def edit
+        profile = patient.profiles.find(params[:id])
+        render locals: { patient: patient, profile: profile }
+      end
+
+      def update
+        profile = patient.profiles.find(params[:id])
+
+        if profile.update(profile_params)
+          redirect_to patient_accesses_dashboard_path(patient),
+            notice: t(".success", model_name: "Access profile")
+        else
+          flash[:error] = t(".failed", model_name: "Access profile")
+          render :edit, locals: { patient: patient, profile: profile }
+        end
+      end
+
+      protected
+
+      def profile_params
+        params
+          .require(:accesses_profile)
+          .permit(attributes)
+          .merge(by: current_user)
+      end
+
+      def attributes
+        [
+          :formed_on, :started_on, :terminated_on, :side, :type_id, :notes
+        ]
+      end
+    end
+  end
+end

data/app/controllers/renalware/admin/users_controller.rb

@@ -0,0 +1,51 @@
+module Renalware
+  class Admin::UsersController < BaseController
+
+    def index
+      @search = User.search(params[:q])
+      @users = @search.result(distinct: true)
+
+      authorize @users
+    end
+
+    def edit
+      load_user
+    end
+
+    def update
+      load_user
+
+      if update_user.call(update_params)
+        redirect_to admin_users_path,
+          notice: t(".success", model_name: "user")
+      else
+        flash[:error] = t(".failed", model_name: "user")
+        render :edit
+      end
+    end
+
+    private
+
+    def load_user
+      @user = User.find(params[:id])
+      authorize @user
+    end
+
+    def update_params
+      roles = fetch_roles(user_params[:role_ids]).to_a
+      user_params.merge(roles: roles)
+    end
+
+    def user_params
+      params.require(:user).permit(:approved, :unexpire, :telephone, role_ids: [])
+    end
+
+    def fetch_roles(role_ids)
+      Role.fetch(role_ids)
+    end
+
+    def update_user
+      @service ||= System::UpdateUser.new(@user)
+    end
+  end
+end

data/app/controllers/renalware/api/ukrdc/patients_controller.rb

@@ -0,0 +1,88 @@
+module Renalware
+  module API
+    module UKRDC
+      class PatientsController < ApplicationController
+        respond_to :xml
+
+        def show
+          respond_to do |format|
+            format.xml do
+              render locals: {
+                patient: patient_presenter
+              }
+            end
+          end
+        end
+
+        private
+
+        def patient_presenter
+          patient = Renalware::Patient.find_by!(secure_id: params[:id])
+          Renalware::UKRDC::PatientPresenter.new(patient)
+        end
+      end
+    end
+  end
+end
+
+# An alternative xml rendering implementation - moved to a template based approach
+# for now as its provides clarity
+#
+
+# class Base
+#   include ActiveModel::Serializers::Xml
+#   include Virtus::Model
+# end
+
+# class PatientNumber < Base
+#   attribute :number, String
+#   attribute :organisation, String
+
+#   def self.build_nhs_number(number)
+#     new(number: number, organisation: "NHS")
+#   end
+# end
+
+# class Name < Base
+#   attribute :prefix, String
+#   attribute :family, String
+#   attribute :given, String
+#   attribute :suffix, String
+#   attribute :use, String
+# end
+
+# class Patient < Base
+#   attribute :gender, String # 0=Not Known 1=Male 2=Female 9=Not Specified.
+#   attribute :birth_time, DateTime
+#   attribute :death_time, DateTime
+#   attribute :patient_numbers, Array(PatientNumber)
+#   attribute :name, Name
+#   attribute :country_of_birth, String # ISO 3166-1 3-char alphabetic code
+# end
+
+# rdc_patient = UKRDC::Patient.new(
+#   gender: patient.sex&.code,
+#   birth_time: patient.born_on,
+#   death_time: patient.died_on,
+#   country_of_birth: "???"
+# )
+
+# rdc_patient.name = Name.new(
+#   prefix: patient.title,
+#   family: patient.family_name,
+#   given: patient.given_name,
+#   suffix: patient.suffix
+# )
+
+# rdc_patient.patient_numbers << UKRDC::PatientNumber.build_nhs_number(patient.nhs_number)
+# Renalware.config.patient_hospital_identifiers.each do |_key, field|
+#   number = patient.public_send(field)
+#   unless number.blank?
+#     patient_number = UKRDC::PatientNumber.new(number: number, organisation: "LOCALHOSP")
+#     rdc_patient.patient_numbers << patient_number
+#   end
+# end
+
+# # Render XML
+# respond_with rdc_patient, camelize: true
+#