pvdgm_services 0.1.0

data/app/models/services/available_file.rb

@@ -0,0 +1,73 @@
+module Services
+
+  class AvailableFile < ActiveRecord::Base
+    belongs_to :configured_account
+
+    STATUS_AVAILABLE = 0
+    STATUS_DOWNLOADED = 1
+    STATUS_INVALID = 2
+    STATUS_MISSING = 3
+    STATUS_UPLOADED = 4
+    STATUS_UPLOAD_ERROR = 5
+    STATUS_DELETED = 6
+    STATUS_CLEARED = 7 # Final status
+
+    validates :request_id, presence: true, length: { maximum: 255 }
+    validates :filename, presence: true, length: { maximum: 255 }
+    validates :status, presence: true, inclusion: { in: [ STATUS_AVAILABLE,
+                                                          STATUS_DOWNLOADED,
+                                                          STATUS_INVALID,
+                                                          STATUS_MISSING,
+                                                          STATUS_UPLOADED,
+                                                          STATUS_UPLOAD_ERROR,
+                                                          STATUS_DELETED,
+                                                          STATUS_CLEARED
+                                                        ] }
+    validates :composite_file_name, length: { minimum: 0, maximum: 255 }, allow_blank: true, allow_nil: true
+    validates :error, length: { minimum: 0, maximum: 255 }, allow_blank: true, allow_nil: true
+
+    scope :available, -> { where(status: STATUS_AVAILABLE) }
+    scope :downloaded, -> { where(status: STATUS_DOWNLOADED) }
+    scope :cleared, -> { where(status: STATUS_CLEARED) }
+    scope :uploaded, -> { where(status: STATUS_UPLOADED) }
+    scope :invalid, -> { where(status: STATUS_INVALID) }
+    scope :missing, -> { where(status: STATUS_MISSING) }
+    scope :upload_error, -> { where(status: STATUS_UPLOAD_ERROR) }
+    scope :deleted, -> { where(status: STATUS_DELETED) }
+    scope :with_status, ->(status) { where(status: status) }
+
+    def downloaded_file_path
+      File.join(download_path, filename)
+    end
+
+    def download_path
+      Rails.root.join("tmp", "available_file_#{id}").to_s
+    end
+
+    def split_path
+      File.join(download_path, 'split')
+    end
+
+    def composite_path
+      File.join(split_path, 'MdsFileUtils::ZipSplitter', composite_file_name)
+    end
+
+    def actual_file_path
+      composite_file_name.nil? ? downloaded_file_path : composite_path
+    end
+
+    def downloaded_file_exists?
+      File.exists?(downloaded_file_path)
+    end
+
+    def mds_analyzer
+      @mds_analyzer ||= MdsFileUtils::ZipAnalyzer.new(downloaded_file_path)
+    end
+
+    def valid_mds_file?
+      mds_analyzer.valid_zip?
+    end
+
+  end
+
+end

data/app/models/services/configured_account.rb

@@ -0,0 +1,26 @@
+module Services
+
+  class ConfiguredAccount < ActiveRecord::Base
+    belongs_to :service_definition
+    belongs_to :account
+
+    has_many :credentials, as: :credentialled, dependent: :destroy
+    has_many :available_files, dependent: :destroy
+    has_many :mds_pull_accounts, dependent: :destroy
+
+    validates :username, length: { minimum: 0, maximum: 255 }, allow_blank: true, allow_nil: true
+
+    scope :for_service, ->(service_id) { joins(:service_definition).where(services_service_definitions: { service_id: service_id }) }
+      
+    scope :enabled, -> { where(enabled: true) }
+
+    def application_account
+      ApplicationApi.api_impl.account_by_id(self.account_id)
+    end
+
+    def account_mapping
+      service_definition.third_party.account_mappings.where(account_id: account_id).first
+    end
+  end
+
+end

data/app/models/services/configured_facility.rb

@@ -0,0 +1,16 @@
+module Services
+
+  class ConfiguredFacility < ActiveRecord::Base
+    belongs_to :service_definition
+    belongs_to :facility
+
+    has_many :credentials, as: :credentialled, dependent: :destroy
+
+    validates :username, length: { minimum: 0, maximum: 255 }, allow_nil: true, allow_blank: true
+
+    scope :for_service, ->(service_id) { joins(:service_definition).where(services_service_definitions: { service_id: service_id }) }
+      
+    scope :enabled, -> { where(enabled: true) }
+  end
+
+end

data/app/models/services/credential.rb

@@ -0,0 +1,9 @@
+module Services
+  class Credential < ActiveRecord::Base
+    belongs_to :credentialled, polymorphic: true
+
+    validates :credentialled_type, presence: true, length: { maximum: 255 }
+
+    attr_encrypted :password, :token
+  end
+end

data/app/models/services/facility_mapping.rb

@@ -0,0 +1,12 @@
+module Services
+
+  class FacilityMapping < ActiveRecord::Base
+    belongs_to :third_party
+    belongs_to :facility
+
+    validates :facility_code, presence: true, length: { maximum: 255 }
+
+    scope :sltc_provider_mappings, ->(facility_codes) { select("services_facility_mappings.*").joins(:third_party).where("`key` = ? AND facility_code IN (?)", ThirdParty::SLTC, facility_codes ) }
+  end
+
+end

data/app/models/services/ftp_server.rb

@@ -0,0 +1,69 @@
+module Services
+
+  class FtpServer
+    include FileUtils
+
+    # Allow the private key path to be overridden. The default
+    # is the production location
+    PRIVATE_KEY_FILE = defined?(SSH_PRIVATE_KEY) ? SSH_PRIVATE_KEY : '/etc/pki/abaqis/abaqis_rsa'
+
+    def initialize(hostname, username, password, base_directory='/')
+      @hostname = hostname
+      @username = username
+      @password = password
+      @base_directory = base_directory
+    end
+
+    def connect
+      
+      options = {
+        password: @password, 
+        auth_methods: %w{ publickey password }
+      }
+      # Add the private key to the list if available
+      options[:keys] = PRIVATE_KEY_FILE if File.exists?(PRIVATE_KEY_FILE)
+
+      Net::SFTP.start(@hostname, @username, options) do | sftp |
+        @sftp = sftp
+        begin
+          yield self
+        ensure
+          @sftp = nil
+        end
+      end
+    end
+
+    def path(subdir, file_name=nil)
+      parameters = [ @base_directory, @username, subdir ]
+      parameters << file_name unless file_name.nil?
+      File.join(*parameters)
+    end
+
+    def file_list(in_dir, with_glob='*')
+      raise "Must be called within the block of a connect!" if @sftp.nil?
+      dir = path(in_dir)
+      @sftp.dir.glob(dir, with_glob).select { | entry | entry.file? }.map { | entry | entry.name }
+    end
+
+    def download_files(from_dir, files, to_directory)
+      files.each { | file | download_file from_dir, file, to_directory }
+    end
+
+    def download_file(from_dir, file, to_directory)
+      raise "Must be called within the block of a connect!" if @sftp.nil?
+      mkdir_p to_directory
+      @sftp.download! path(from_dir, file), File.join(to_directory, file)
+    end
+
+    def remove_files(from_dir, files)
+      files.each { | file | remove_file from_dir, file } unless files.nil?
+    end
+
+    def remove_file(from_dir, file)
+      raise "Must be called within the block of a connect!" if @sftp.nil?
+      @sftp.remove! path(from_dir, file)
+    end
+
+  end
+
+end

data/app/models/services/hl7_inbound_service.rb

@@ -0,0 +1,47 @@
+module Services
+
+  class Hl7InboundService < ServiceImplementation
+
+    #
+    # Invoke, in this case will create the service loop on the socket server
+    # port and just hang out and handle the stuff
+    #
+    def invoke
+      server = TCPServer.open(service_definition.hostname, service_definition.port)
+      loop do  # Servers run forever
+        #
+        # We put the accepted client in a separate thread to manage a high volume of
+        # calls better. The AcceptHl7MessageContext call saves the Hl7Message
+        # and puts the processing into beanstalk, so we shouldn't be in this
+        # separate thread for long.
+        #
+        # Note that we fail fast if the message coming in doesn't have the
+        # API key we are expecting. We don't save the incoming message in that
+        # case because we don't know what we're getting. Could be evil.
+        #
+        Thread.start(server.accept) do |client|
+          begin
+            key = client.gets('|').chop # Don't want the last character '|'
+            creds = service_definition.credentials.last
+            if creds.present? && creds.token == key
+              message_type = client.gets('|').chop
+              raw_message = client.gets('|').chop
+              AcceptHl7MessageContext.call(message_type, raw_message)
+              client.puts( { status: 'accepted' }.to_json )
+            else
+              client.puts({ status: 'error', message: 'invalid key' }.to_json )
+            end
+          rescue Exception => ex
+            puts ex.inspect
+            client.puts( { status: 'error', errors: [ ex.message ] } )
+          ensure
+            client.close                # Disconnect from the client
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/app/models/services/hl7_message.rb

@@ -0,0 +1,27 @@
+module Services
+
+  class Hl7Message < ActiveRecord::Base
+
+    STATUS_RECEIVED = 0
+    STATUS_PROCESSED = 1
+    STATUS_ERRORED = 2
+
+    attr_encrypted :message
+
+    belongs_to :facility
+    belongs_to :resident
+
+    validates :message_type, presence: true, length: { maximum: 255 }
+
+    def message_as_hash
+      message.empty? ? {} : ActiveSupport::HashWithIndifferentAccess.new(JSON.parse(message))
+    end
+
+    def raw_hl7_message
+      raw_data = message_as_hash['rawData']
+      Base64.urlsafe_decode64(raw_data) if raw_data.present?
+    end
+
+  end
+
+end

data/app/models/services/isc_code.rb

@@ -0,0 +1,15 @@
+module Services
+
+  class IscCode < ActiveRecord::Base
+
+    has_many :isc_code_lookups
+
+    INACTIVATION_CODE = "XX"
+
+    def self.inactivation_code
+      INACTIVATION_CODE
+    end
+
+  end
+
+end

data/app/models/services/isc_code_lookup.rb

@@ -0,0 +1,75 @@
+module Services
+
+  class IscCodeLookup < ActiveRecord::Base
+
+    belongs_to :isc_code
+
+    scope :isc_lookup, ->(assessment) {
+          joins(:isc_code).
+          where(a0200: assessment.a0200, 
+                a0310a: assessment.a0310a, 
+                a0310b: assessment.a0310b, 
+                a0310c: assessment.a0310c, 
+                a0310d: assessment.a0310d, 
+                a0310f: assessment.a0310f)
+
+          }
+
+    attr_reader :isc_provided_value, :isc_lookup_value
+
+    #------------------------------------------------------------------#
+    # Raises an ArgumentError if itm_sbst_cd (provided isc value)      #
+    # does not exist. since this class depends on the comparison        #
+    # between the calculated isc and the provided isc values.          #
+    #------------------------------------------------------------------#
+    def initialize(assessment)
+      raise(ArgumentError, "The attribute 'itm_sbst_cd' does not exist") unless assessment.respond_to?("itm_sbst_cd")
+      @isc_provided_value = assessment.itm_sbst_cd
+      @isc_lookup_value = find_isc_value(assessment)
+    end
+
+    #------------------------------------------------------------------#
+    #  Finds and returns the actual isc code (eg: "NC")                #
+    #  Returns nil if:                                                 #
+    #    1) any of the attributes required for isc calculation are nil #
+    #    2) isc code is not found due to an invalid combination of     #
+    #       required attributes                                        #
+    #------------------------------------------------------------------#
+    def find_isc_value(assessment)
+      return Services::IscCode.inactivation_code if inactivation_isc?(assessment)
+
+      if all_lookup_attributes_exist?(assessment)
+        isc_lookup = self.class.isc_lookup(assessment).first
+        isc_lookup.isc_code.code if isc_lookup
+      end
+    end
+
+    #----------------------------------------------------------------#
+    #  Returns whether the calculated isc code is the same as        #
+    #  the provided isc code                                         #
+    #----------------------------------------------------------------#
+    def valid_isc_value?()
+      return if @isc_provided_value.nil?
+      @isc_lookup_value == @isc_provided_value
+    end
+
+
+    private
+
+    def all_lookup_attributes_exist?(assessment)
+      assessment.a0200.present? &&
+        assessment.a0310a.present? &&
+        assessment.a0310b.present? &&
+        assessment.a0310c.present? &&
+        assessment.a0310d.present? &&
+        assessment.a0310f.present?
+      # !attributes["a0200"].nil? && !attributes["a0310a"].nil? && !attributes["a0310b"].nil? && !attributes["a0310c"].nil? && !attributes["a0310d"].nil? && !attributes["a0310f"].nil?
+    end
+
+    def inactivation_isc?(assessment)
+      assessment.type_of_record == 3
+    end
+
+  end
+
+end