pvdgm_services 0.1.0

data/app/models/services/sltc_api_exception.rb

@@ -0,0 +1,54 @@
+module Services
+
+  class SltcApiException < StandardError
+
+    attr_reader :inner_exception
+    attr_reader :raw_json, :error_code, :error_message, :error_response
+
+    def initialize(exception)
+      @inner_exception = exception
+      @raw_json = exception.response if exception && exception.respond_to?(:response)
+      @error_code = -1
+      super format_exception_message
+    end
+
+    def http_code
+      inner_exception.http_code if inner_exception && inner_exception.respond_to?(:http_code)
+    end
+
+    def http_message
+      inner_exception.message if inner_exception && inner_exception.respond_to?(:message)
+    end
+
+    private 
+
+    def format_exception_message
+      return "Unknown SimpleLTC API Error (#{basic_message_fmt})" if raw_json.nil?
+
+      extract_sltc_error_information
+    end
+
+    def extract_sltc_error_information
+      @error_response = JSON.parse(raw_json)
+
+      return "No error message in SimpleLTC error response (#{raw_json}) (#{basic_message_fmt})" unless @error_response.is_a?(Hash) && @error_response.has_key?('Message')
+
+      @error_message = @error_response['Message']
+      @error_code = @error_response['ErrorCode']
+
+      "SimpleLTC error response: (#{@error_code.present? ? @error_code : 'N/A'}) #{@error_message} (#{basic_message_fmt})" 
+    rescue Exception => ex
+      "Error parsing SimpleLTC API Error JSON (#{raw_json}): #{ex.message} (#{basic_message_fmt})"
+    end
+
+    def basic_message_fmt
+      if http_code.present?
+        "#{http_code}: #{http_message}"
+      else
+        "no http_code associated with inner exception"
+      end
+    end
+  end
+
+end
+

data/app/models/services/sltc_mds_pull.rb

@@ -0,0 +1,230 @@
+module Services
+
+  class SltcMdsPull < MdsPull
+    include FileUtils
+
+    #
+    # Overridden from MdsPull
+    #
+    def identify_providers(configured_account)
+      api = api_impl(configured_account)
+      provider_list = api.list_providers
+      process_provider_list(configured_account, provider_list)
+    end
+
+    #
+    # Overridden from MdsPull
+    #
+    def request_assessments(configured_account)
+      enabled_providers = providers_for_account(configured_account)
+
+      enabled_providers.each do | provider_id |
+        request_assessments_to_pull(configured_account, provider_id)
+      end
+    end
+
+    def providers_for_account(configured_account)
+      enabled_facility_ids = ApplicationApi.api_impl.enabled_facilities_for_account_id(configured_account.account_id).pluck(:id)
+      FacilityMapping.
+        joins('LEFT OUTER JOIN services_configured_facilities ON services_configured_facilities.facility_id = services_facility_mappings.facility_id').
+        where('services_facility_mappings.facility_id IN (?) AND services_configured_facilities.enabled = 1', enabled_facility_ids).
+        pluck(:facility_code)
+    end
+
+    def list_available_files(configured_account)
+      api = api_impl(configured_account)
+      
+      list_available_assessment_requests api, configured_account
+    end
+
+    def list_available_assessment_requests(api, configured_account)
+      assessment_request_ids = []
+      enabled_providers = providers_for_account(configured_account)
+
+      AssessmentRequest.available.where(facility_code: enabled_providers).each do | assessment_request |
+        status_response = api.assessment_request_status(assessment_request.request_id)
+        case status_response['status']
+        when 'Complete'
+          assessment_request_ids << [ assessment_request.request_id, "#{assessment_request.request_id}.zip" ]
+          assessment_request.update_attribute :status, AssessmentRequest::STATUS_COMPLETED
+        when 'Empty'
+          assessment_request.update_attribute :status, AssessmentRequest::STATUS_EMPTY
+        when 'Error'
+          assessment_request.update_attribute :status, AssessmentRequest::STATUS_ERROR
+        else
+          # Do nothing ... Must be processing so we leave the status as 'Active'
+        end
+      end
+
+      assessment_request_ids
+    end
+
+    def perform_file_downloads(configured_account, files_to_download)
+      api = api_impl(configured_account)
+      downloaded_files = []
+      files_to_download.each do | available_file |
+        downloaded_files << download_file(api, available_file)
+      end
+      downloaded_files.compact
+    end
+
+    def perform_cleanup_on_remote_server(configured_account)
+      configured_account.available_files.deleted.pluck(:id)
+    end
+
+    def download_file(api, available_file)
+      mkdir_p available_file.download_path
+      File.open(available_file.downloaded_file_path, "wb") do |f|
+        f.write(api.download_assessment_request(available_file.request_id))
+      end
+      available_file.id
+    end
+
+    def request_baseline(configured_account, provider_id, uploaded_after, uploaded_before)
+      api = api_impl(configured_account)
+      result = api.assessment_request(provider_id, uploaded_after, uploaded_before, 'Accepted')
+      Rails.logger.info "Response from baseline request: #{result.inspect}"
+      request_id = result['requestId']
+      # Create a new row in the assessment request table
+      AssessmentRequest.create!(request_id: request_id, 
+                                facility_code: provider_id,
+                                pull_from: uploaded_after,
+                                pull_to: uploaded_before,
+                                status: AssessmentRequest::STATUS_AVAILABLE)
+      request_id
+    end
+
+    def api_impl(configured_account)
+      SltcApi.for_configured_account(configured_account)
+    end
+
+    def process_provider_list(configured_account, provider_list)
+      # The provider Ids need to be converted to strings because we store
+      # the provider_codes as strings in the db.
+      sltc_provider_ids = provider_list.map { | provider_info | provider_info['id'].to_s }
+      # Get the provider ids that are currently enabled for this account
+      mapped_facility_ids = providers_for_account(configured_account)
+
+      facilities_removed = mapped_facility_ids - sltc_provider_ids
+      facilities_added = sltc_provider_ids - mapped_facility_ids
+
+      added_facility_info = provider_list.select { | provider | facilities_added.include?(provider['id'].to_s) }
+
+      still_to_add = facilities_added - ProviderChange.
+        added_providers(configured_account.id, facilities_added).
+        pluck(:facility_code) 
+
+      register_provider_deltas configured_account, provider_list.select { |p| still_to_add.include?(p['id'].to_s) }, ProviderChange::VERB_ADD
+
+      still_to_remove = facilities_removed - ProviderChange.
+        deleted_providers(configured_account.id, facilities_removed).
+        pluck(:facility_code) 
+
+      mappings = FacilityMapping.sltc_provider_mappings(still_to_remove).
+        map do | fm |
+        facility = fm.facility
+        {
+          'id' => fm.facility_code,
+          'name' => facility.name,
+          'state' => facility.state,
+          'npi' => facility.npi,
+          'ccn' => facility.govid,
+          'mdsFacilityId' => facility.fac_id
+        }
+      end
+
+      register_provider_deltas configured_account, mappings, ProviderChange::VERB_DELETE
+
+      disable_removed_facilities(facilities_removed) unless facilities_removed.empty?
+      configure_added_facilities(added_facility_info)
+    end
+
+    def register_provider_deltas(configured_account, provider_list, verb)
+      provider_list.each do |pi|
+        ProviderChange.create!(configured_account_id: configured_account.id,
+                               facility_code: pi['id'],
+                               name: pi['name'],
+                               state: pi['state'],
+                               npi: pi['npi'],
+                               ccn: pi['ccn'],
+                               fac_id: pi['mdsFacilityId'],
+                               verb: verb)
+      end
+    end
+
+    def disable_removed_facilities(facility_codes)
+      fac_mappings = FacilityMapping.
+        sltc_provider_mappings(facility_codes)
+
+      facility_ids = fac_mappings.pluck(:facility_id)
+      mapping_ids = fac_mappings.pluck(:id)
+
+      # Delete all the facility configuration entries
+      ConfiguredFacility.where(facility_id: facility_ids).destroy_all
+
+      # Remove all the facility mappings
+      FacilityMapping.where(id: mapping_ids).destroy_all
+    end
+
+    def configure_added_facilities(added_facility_info)
+      configure_existing_enabled_facilities(added_facility_info)
+      
+      # We will not be creating new facilities based on the information from 
+      # SLTC. It will only configure existing, enabled facilities that have 
+      # not yet been configured
+    end
+
+    def configure_existing_enabled_facilities(added_facility_info)
+      govids = added_facility_info.map { | facility_info | facility_info['ccn'] }
+      facilities = ApplicationApi.api_impl.enabled_facilities_with_govids(govids)
+      facilities.each do | facility |
+        facility_info = added_facility_info.detect { | fi | fi['ccn'] == facility.govid }
+        # Set the state code/fac_id if not already set.
+        if facility.state != facility_info['state'] ||
+            facility.fac_id != facility_info['mdsFacilityId']
+          facility.update_attributes(fac_id: facility_info['mdsFacilityId'],
+                                     state: facility_info['state'])
+        end
+        # Create the facility mappings we need
+        FacilityMapping.create!(third_party_id: service_definition.third_party_id,
+                               facility_id: facility.id,
+                               facility_code: facility_info['id'],
+                               top_level: false)
+
+        # Create the configured facility we need
+        ConfiguredFacility.create!(service_definition_id: service_definition.id,
+                                  facility_id: facility.id,
+                                  enabled: true)
+      end
+    end
+
+    def request_assessments_to_pull(configured_account, provider_code)
+      # Find the latest assessment request that we pulled to. We do this because
+      # we want to know from when to start our requested range.
+      latest_assessment_request = AssessmentRequest.
+        where(facility_code: provider_code).
+        order('pull_to DESC').
+        limit(1).
+        first
+
+      # Set the date range for the request
+      pull_to = Time.now
+      pull_from = latest_assessment_request.present? ? latest_assessment_request.pull_to - 1.second : Time.now - 24.hours
+
+      api = api_impl(configured_account)
+      response = api.assessment_request(provider_code,
+                                        pull_from,
+                                        pull_to,
+                                        'Accepted')
+
+      # Register that we made the request
+      AssessmentRequest.create(facility_code: provider_code,
+                               request_id: response['requestId'],
+                               pull_from: pull_from,
+                               pull_to: pull_to,
+                               status: AssessmentRequest::STATUS_AVAILABLE)
+    end
+
+  end
+
+end

data/app/models/services/sltc_registration.rb

@@ -0,0 +1,23 @@
+module Services
+
+  class SltcRegistration < ActiveRecord::Base
+
+    STATUS_NEW = 0
+    STATUS_REGISTERED = 1
+
+    validates :company_name, presence: true, length: { maximum: 255 }, allow_nil: true, allow_blank: true
+    validates :initiated_by, presence: true, length: { maximum: 255 }, allow_nil: true, allow_blank: true
+
+    attr_encrypted :auth_password, :auth_username
+
+    def account_code
+      auth_username.split('@').last if auth_username.present?
+    end
+
+    def username
+      auth_username.split('@').first if auth_username.present?
+    end
+
+  end
+
+end

data/app/models/services/third_party.rb

@@ -0,0 +1,18 @@
+module Services
+
+  class ThirdParty < ActiveRecord::Base
+    has_many :account_mappings, dependent: :destroy
+    has_many :facility_mappings, dependent: :destroy
+    has_many :service_definitions, dependent: :destroy
+
+    PROVIDIGM = 'pvdgm'
+    POINTCLICKCARE = 'pcc'
+    SLTC = 'sltc'
+
+    validates :name, presence: true, uniqueness: true, length: { maximum: 255 }
+    validates :key, presence: true, uniqueness: true, length: { maximum: 255 }
+    validates :contact_email, presence: true, length: { maximum: 255 }
+
+  end
+
+end

data/app/roles/services/account_mapping_creator.rb

@@ -0,0 +1,13 @@
+module Services
+
+  module AccountMappingCreator
+
+    def create(params)
+      account_mappings.new(params).tap do | account_mapping |
+        account_mapping.save if account_mapping.valid?
+      end
+    end
+
+  end
+
+end

data/app/roles/services/account_mapping_updator.rb

@@ -0,0 +1,12 @@
+module Services
+
+  module AccountMappingUpdator
+
+    def update(params)
+      update_attributes(params)
+      self
+    end
+
+  end
+
+end

data/app/roles/services/configured_account_creator.rb

@@ -0,0 +1,13 @@
+module Services
+
+  module ConfiguredAccountCreator
+
+    def create(params)
+      configured_accounts.new(params).tap do | configured_account |
+        configured_account.save if configured_account.valid?
+      end
+    end
+
+  end
+
+end

data/app/roles/services/configured_account_updater.rb

@@ -0,0 +1,12 @@
+module Services
+
+  module ConfiguredAccountUpdater
+
+    def update(params)
+      update_attributes(params)
+      self
+    end
+
+  end
+
+end

data/app/roles/services/configured_facility_creator.rb

@@ -0,0 +1,13 @@
+module Services
+
+  module ConfiguredFacilityCreator
+
+    def create(params)
+      configured_facilities.new(params).tap do | configured_facility |
+        configured_facility.save if configured_facility.valid?
+      end
+    end
+
+  end
+
+end

data/app/roles/services/configured_facility_updater.rb

@@ -0,0 +1,12 @@
+module Services
+
+  module ConfiguredFacilityUpdater
+
+    def update(params)
+      update_attributes(params)
+      self
+    end
+
+  end
+
+end

data/app/roles/services/credential_creator.rb

@@ -0,0 +1,11 @@
+module Services
+
+  module CredentialCreator
+
+    def add_credential(params)
+      credentials << Services::Credential.new(params)
+    end
+
+  end
+
+end

data/app/roles/services/credential_updater.rb

@@ -0,0 +1,20 @@
+module Services
+
+  module CredentialUpdater
+
+    def update_credential(params)
+      credential = credentials.first
+      if credential.present?
+        if params.present?
+          credential.update_attributes(params)
+        else
+          credential.destroy
+        end
+      elsif params.present?
+        credentials << Credential.new(params)
+      end
+    end
+
+  end
+
+end

data/app/roles/services/facility_mapping_creator.rb

@@ -0,0 +1,13 @@
+module Services
+
+  module FacilityMappingCreator
+
+    def create(params)
+      facility_mappings.new(params).tap do | facility_mapping |
+        facility_mapping.save if facility_mapping.valid?
+      end
+    end
+
+  end
+
+end

data/app/roles/services/facility_mapping_updater.rb

@@ -0,0 +1,11 @@
+module Services
+
+  module FacilityMappingUpdater
+
+    def update(params)
+      update_attributes(params)
+    end
+
+  end
+
+end

data/app/roles/services/hl7_adt_message_saver.rb

@@ -0,0 +1,15 @@
+module Services
+
+  module Hl7AdtMessageSaver
+
+    def persist(message_type, message_body)
+      Services::Hl7Message.new.tap do | msg |
+        msg.message_type = message_type
+        msg.message = message_body
+        msg.save if msg.valid?
+      end
+    end
+
+  end
+
+end

data/app/roles/services/hl7_message_trimmer.rb

@@ -0,0 +1,14 @@
+module Services
+
+  module Hl7MessageTrimmer
+
+    def trim_messages
+      Hl7Message.
+        where(status: Hl7Message::STATUS_PROCESSED).
+        where("updated_at < ?", Time.now - 30.days).
+        destroy_all
+    end
+
+  end
+
+end

data/app/roles/services/mds_assessment_categorizer.rb

@@ -0,0 +1,71 @@
+module Services
+
+  module MdsAssessmentCategorizer
+
+    def significant_correction_assessment? 
+      responses.present? && %w{ 05 06 }.include?(a0310a)
+    end
+    
+    def admission_assessment?
+      a0310a.to_i == 1
+    end
+
+    def any_type_of_correction_assessment?
+      significant_correction_assessment? || correction_record?
+    end
+
+    def correction_record?
+      responses.present? && version == MdsAssessment::VERSION1_0 ? x0100 == "2" : a0050 == "2"
+    end
+
+    def correction_applied?
+      responses.present? && prior_isc_cd.present?
+    end
+
+    def inactivated?
+      responses.present? && (corrected? && prior_isc_cd.blank?)
+    end
+
+    def entry_assessment?
+      responses.present? && a0310f.to_i == 1
+    end
+
+    def discharge_assessment? 
+      responses.present? && a0310f.to_i == 10 || a0310f.to_i == 11
+    end
+
+    def death_assessment?
+      responses.present? && a0310f.to_i == 12
+    end
+
+    def discharge_or_death_assessment?
+      discharge_assessment? || death_assessment?
+    end
+
+    def tracking_assessment?
+      responses.present? && %w{ NT ST }.include?(itm_sbst_cd)
+    end
+
+    def quarterly?
+      responses.present? && a0310a == "02"
+    end
+
+    def ninety_day?
+      responses.present? && a0310b == "05"
+    end
+
+    def inactivation_assessment?
+      responses.present? && itm_sbst_cd == IscCode.inactivation_code
+    end
+
+    def entered_from_hospital?
+      responses.present? && a1800 == "03"
+    end
+
+    def a0310f_99?
+      responses.present? && a0310f == "99"
+    end
+
+  end
+
+end

data/app/roles/services/mds_file_processor.rb

@@ -0,0 +1,86 @@
+module Services
+
+  module MdsFileProcessor
+    PCC_METADATA_FILE_RE = %r{PCC_.+_metadata.xml\z}
+
+    # So, the work we're going to do here is to crack open the 
+    # MDS file and save each of the assessments to the MDS
+    # assessments table. We won't process it any further at this
+    # point.
+    def process
+      # Do nothing if we dont' have a status of NEW
+      return unless self.status == MdsUpload::NEW
+      return unless self.mds_content.present?
+
+      start_time = Time.now
+      num_records = 0
+      num_duplicated = 0
+      num_rejected = 0
+      
+      # Loop over all the files in the upload file
+      self.mds_content.each_entry do | entry, relative_path |
+
+        next if File.directory?(entry)
+        basename = File.basename(entry)
+        next if basename =~ PCC_METADATA_FILE_RE
+
+        num_records += 1
+
+        parser = MdsXmlFileParser.new(entry)
+        assessment_data = parser.parse
+
+        if assessment_data.blank?
+          num_rejected += 1
+          self.file_errors.merge!(parser.file_errors) if parser.file_errors.present?
+        else
+          # We use the relative_path to the file from the extration
+          # directory so that the error report will properly show 
+          # the path to the file with the problem, even if the file
+          # was located in an embedded zip file.
+          begin
+            mds = create_assessment(relative_path, assessment_data)
+            if mds.blank?
+              num_duplicated += 1
+              add_file_errors(relative_path, "Duplicate assessment") 
+            elsif !mds.valid?
+              num_rejected += 1
+              add_file_errors(relative_path, mds.errors.values.flatten)
+            end
+          rescue => ex
+            num_rejected += 1
+            add_file_errors(relative_path, ex.message)
+          end
+        end
+      end
+
+      # Need to save any errors
+      update_attributes(status: MdsUpload::ASSESSMENTS_LOADED,
+                        num_records: num_records,
+                        num_duplicated: num_duplicated,
+                        num_rejected: num_rejected,
+                        parse_time: ((Time.now - start_time) * 1000).round)
+    rescue => ex
+      Rails.logger.error("#{ex.message}\n#{ex.backtrace.join("\n")}")
+      update_attribute(:fatal_error, "#{ex.message}\n#{ex.backtrace.join("\n")}")
+    end
+
+    private
+
+    def create_assessment(filename, assessment_data)
+      # Don't bother with duplicates
+      md5_checksum = Digest::MD5.hexdigest(assessment_data.to_s)
+      return if MdsAssessment.where(md5_checksum: md5_checksum).count > 0
+
+      mds_assessment = MdsAssessment.new(mds_upload: self,
+                                         md5_checksum: md5_checksum,
+                                         filename: filename,
+                                         responses: assessment_data)
+      if mds_assessment.valid?
+        mds_assessment.save
+      end
+      mds_assessment
+    end
+
+  end
+
+end