pvdgm_services 0.1.0

data/app/models/services/mds_upload.rb

@@ -0,0 +1,64 @@
+module Services
+
+  class MdsUpload < ActiveRecord::Base
+    include MdsUploadContent
+    include MdsNotifications
+
+    NEW = 0
+    ASSESSMENTS_LOADED = 1
+    COMPLETE = 2
+    ERROR = 3
+
+    TIME_TO_RUN = 36000
+    PRIORITY = 500
+    ASYNC_SEND_OPTIONS = { :priority => PRIORITY, :time_to_run => TIME_TO_RUN }
+
+
+    belongs_to :account
+    belongs_to :upload_user, class_name: "User"
+    has_many :mds_assessments
+    has_many :facilities, through: :mds_assessments
+    has_many :residents, through: :mds_assessments
+    has_one :mds_content, as: :uploadable
+
+    serialize :file_errors, JSON
+
+    scope :by_upload_user, ->(user_id) { where("upload_user_id = ?", user_id ) }
+    scope :completed, -> { where(status: COMPLETE) }
+
+    mds_upload_content :mds_file, max_size: { size: 75.megabytes, 
+                                              message: "MDS Files need to be less than 75 MB in size." },
+                                  presence: { message: "Please select an MDS file for upload." },
+                                  name_match: { regex: /\.zip$/i,
+                                                message: "Uploaded file must have a .zip extension." },
+                                  file_type: { regex: /zip/i,
+                                               message: "Uploaded file must be a ZIP file" }
+
+    before_create { self.file_errors ||= {} }
+    after_save :handle_mds_notifications, :if => :ready_for_notification?
+
+    def add_file_errors(file_name, error)
+      self.file_errors ||= {}
+      error_array = error.is_a?(Array) ? error : [ error ]
+      if self.file_errors[file_name].present?
+        self.file_errors[file_name].concat(error_array)
+      else
+        self.file_errors[file_name] = error_array
+      end
+    end
+
+    def has_errors?
+      status == COMPLETE && (fatal_error.present? || file_errors.size > num_duplicated)
+    end
+
+    def successful?
+      status == COMPLETE
+    end
+
+    def ready_for_notification?
+      status == COMPLETE
+    end
+
+  end
+
+end

data/app/models/services/mds_upload_content.rb

@@ -0,0 +1,148 @@
+module Services
+
+  module MdsUploadContent
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      #
+      # Specify that there is a file attachment associated with this model.
+      #
+      #  attr_name - the name of the parameter in the request that contains the file upload.
+      #  args       - a hash of options to control operations. Valid options include:
+      #
+      #       :max_size => { :size => size-in-bytes,
+      #                      :message => 'Error message if size exceeded' }
+      # If :size is not specified, a default of 5.megabytes is used
+      # If :message is not specified, a default message of "uploaded file exceedes maximum of #{args[:max_size][:size] bytes" is used
+      #
+      #       :presence => { :message => 'Error message if upload not provided.' }
+      # If :message is not specified, a default message of "no file upload provided"
+      #
+      #       :name_match => { :regex => regular expression for file name to match,
+      #                        :message => 'Error message if upload not provided.' }
+      # If :regex is not specified, all names will match.
+      # If :message is not specified, a default message of "uploaded file name does not match regular expression".
+      #
+      #       :file_type => { :message => 'Error message if no match on file type',
+      #                       :regex => regular expression for the results of 'file -b --mime' to match }
+      # If :message is not specified, a default message of "unexpected upload file type"
+      # If :regex is not specified, then there will be no check of the file type.
+      #
+      def mds_upload_content(attr_name, args={})
+        
+        # Define the setter method for the upload file.
+        define_method("#{attr_name}=".to_sym) do | upload_file |
+          return if upload_file.nil?
+          self.original_file_name = File.basename(upload_file.original_filename)
+          self.content_type = upload_file.content_type
+          self.size = upload_file.size
+          @upload_file = upload_file
+        end
+
+        define_method("clear_#{attr_name}".to_sym) do
+          @upload_file = nil
+        end
+
+        define_max_size_validation(attr_name, args[:max_size]) if args.has_key?(:max_size)
+
+        define_presence_validation(attr_name, args[:presence]) if args.has_key?(:presence)
+
+        define_name_match_validation(attr_name, args[:name_match]) if args.has_key?(:name_match)
+
+        define_file_type_validation(attr_name, args[:file_type]) if args.has_key?(:file_type)
+
+        before_create :construct_file_contents
+      end
+
+      private
+
+      def define_max_size_validation(attr_name, max_size_args)
+        max_size_args ||= {}
+        max_size_args[:size] ||= 5.megabytes
+        max_size_args[:message] ||= "uploaded file exceedes maximum of #{max_size_args[:size]} bytes"
+
+        # set up the validator
+        validate :attachment_size, :on => :create
+
+        define_method(:attachment_size) do
+          return if self.size.nil? # If the size isn't set, what's the point?
+          errors.add(attr_name, max_size_args[:message]) if self.size > max_size_args[:size]
+        end
+      end
+
+      def define_presence_validation(attr_name, presence_args)
+        presence_args ||= {}
+        presence_args[:message] ||= "no file upload provided"
+
+        # Set up the validator
+        validate :attachment_presence, :on => :create
+
+        define_method(:attachment_presence) do
+          errors.add(attr_name, presence_args[:message]) if @upload_file.nil?
+        end
+      end
+
+      def define_name_match_validation(attr_name, name_match_args)
+        name_match_args ||= {}
+        name_match_args[:regex] ||= nil
+        name_match_args[:message] ||= "uploaded file name does not match regular expression"
+
+        # Set up the validator
+        validate :attachment_name_match, :on => :create
+
+        define_method(:attachment_name_match) do
+          return if self.original_file_name.blank?
+          errors.add(attr_name, name_match_args[:message]) if name_match_args[:regex].present? && !(self.original_file_name =~ name_match_args[:regex])
+        end
+      end
+
+      def define_file_type_validation(attr_name, file_type_args)
+        file_type_args ||= {}
+        file_type_args[:regex] ||= nil
+        file_type_args[:message] ||= "unexpected upload file type"
+
+        # Set up the validator
+        validate :file_type_match, :on => :create
+
+        define_method(:file_type_match) do
+          return if @upload_file.nil? || file_type_args[:regex].nil?
+          mime_type = mime_file_type(@upload_file.path)
+          errors.add(attr_name, file_type_args[:message]) if mime_type.present? && !(mime_type =~ file_type_args[:regex])
+        end
+      end
+
+    end # End of ClassMethods
+
+    private
+
+    #
+    # This is the implementation of a before_create method. It's responsibility is to
+    # set the content attribute of the model to the contents of the uploaded file.
+    # This method has effect only in the case of saving a new record.
+    #
+    def construct_file_contents
+      return if @upload_file.nil?
+
+      # Construct and populate the content record
+      content_record = content_class.new
+      content_record.content = @upload_file.read
+
+      # Make the association
+      self.send(content_assn_assignment, content_record)
+    end
+
+    def content_class() MdsContent end
+    def content_assn_assignment() "mds_content=".to_sym end
+
+    def mime_file_type(path)
+      raise "Unable to find upload file at: #{path}" if !File.exists?(path)
+      `file -b --mime #{path}`
+    end
+
+  end
+
+end

data/app/models/services/mds_ws_response.rb

@@ -0,0 +1,21 @@
+module Services
+
+  class MdsWsResponse
+    
+    STATUS_ERROR = "ERROR"
+    STATUS_SUCCESS = "SUCCESS"
+
+    attr_accessor :status, :error_message, :filename, :acknowledgement_id, :submission_datetime
+
+    def self.parse_xml_response(response_xml)
+      handler = MdsWsResponseHandler.new
+      parser = LibXML::XML::SaxParser.string(response_xml)
+      parser.callbacks = handler
+      parser.parse
+
+      handler.response
+    end
+
+  end
+
+end

data/app/models/services/mds_ws_response_handler.rb

@@ -0,0 +1,31 @@
+require 'libxml'
+
+module Services
+
+  class MdsWsResponseHandler
+    include LibXML::XML::SaxParser::Callbacks
+
+    COMPOSITE_FILE_RESPONSE = 'composite_file_response'
+    RESPONSE_NAME = 'Response'
+
+    attr_reader :response
+
+    def on_start_element(element_name, attributes)
+      @current_reader = element_name.to_sym
+      @current_writer = "#{element_name}=".to_sym
+
+      if element_name == COMPOSITE_FILE_RESPONSE
+        @response = MdsWsResponse.new
+      end
+    end
+
+    def on_characters(text)
+      return unless @response.respond_to?(@current_reader)
+
+      current_value = @response.send(@current_reader)
+      @response.send(@current_writer, current_value ? current_value + text.strip : text.strip)
+    end
+
+  end
+
+end

data/app/models/services/pcc_mds_pull.rb

@@ -0,0 +1,77 @@
+module Services
+
+  class PccMdsPull < MdsPull
+
+    #
+    # Factory method to return one and only one instance of the ftp server
+    # class for an instance of the PccMdsPull class.
+    #
+    def ftp_server
+      # Create a new FtpServer instance only if necessary
+      @ftp_server ||= FtpServer.new(service_definition.hostname,
+                                    service_definition.username,
+                                    server_credentials.password,
+                                    service_definition.base_uri)
+    end
+
+    #
+    # Overridden from MdsPull.
+    #
+    def list_available_files(configured_account)
+      mapped_account = account_map(configured_account.account_id)
+
+      files = []
+      ftp_server.connect do | server |
+        files = server.file_list mapped_account.account_code, '*.zip'
+      end
+      files.map { | fn | [ fn, fn ] }
+    end
+
+    #
+    # Overridden from MdsPull.
+    #
+    def perform_file_downloads(configured_account, files_to_download)
+      mapped_account = account_map(configured_account.account_id)
+
+      downloaded_files = []
+      ftp_server.connect do | server |
+        files_to_download.each do | available_file |
+          downloaded_files << download_file(server, available_file, mapped_account.account_code)
+        end
+      end
+      downloaded_files.compact # The compact is here because there could be nil's in the list
+    end
+
+    #
+    # Overridden from MdsPull
+    #
+    def perform_cleanup_on_remote_server(configured_account)
+      mapped_account = account_map(configured_account.account_id)
+      
+      cleared_files = []
+      ftp_server.connect do | server |
+        configured_account.available_files.deleted.each do | available_file |
+          cleared_files << remove_file(server, available_file, mapped_account.account_code)
+        end
+      end
+      cleared_files.compact
+    end
+
+    def download_file(server, available_file, account_directory)
+      server.download_file account_directory, available_file.request_id, available_file.download_path
+      available_file.id
+    rescue Exception => ex
+      Rails.logger.error "Error downloading file: #{available_file.to_rrepr}: #{ex.message}\n#{ex.backtrace.join("\n")}"
+      nil # Return nil; we failed to download the specified file and 'nil' is the correct response
+    end
+
+    def remove_file(server, available_file, account_directory)
+      server.remove_file account_directory, available_file.request_id
+      available_file.id
+    rescue Exception => ex
+      Rails.logger.error "Error removing server file: #{available_file.to_rrepr}: #{ex.message}\n#{ex.backtrace.join("\n")}"
+      nil # Return nil; we failed to remove the specified file and 'nil' is the correct response
+    end
+  end
+
+end

data/app/models/services/provider_change.rb

@@ -0,0 +1,26 @@
+module Services
+
+  class ProviderChange < ActiveRecord::Base
+    belongs_to :configured_account
+
+    VERB_ADD = 1
+    VERB_DELETE = 2
+
+    STATUS_NEW = 0
+    STATUS_REPORTED = 1
+
+    validates :configured_account_id, presence: true
+    validates :facility_code, presence: true, length: { maximum: 255 }
+    validates :name, presence: true, length: { maximum: 255 }
+    validates :ccn, presence: true, length: { maximum: 255 }
+    validates :npi, length: { maximum: 255 }
+    validates :fac_id, length: { maximum: 16 }
+    validates :state, length: { maximum: 15 }
+    validates :verb, presence: true
+
+    scope :added_providers, ->(ca_id, facility_codes) { where(configured_account_id: ca_id, facility_code: facility_codes, verb: VERB_ADD).order("facility_code ASC")}
+    scope :deleted_providers, ->(ca_id, facility_codes) { where(configured_account_id: ca_id, facility_code: facility_codes, verb: VERB_DELETE).order("facility_code ASC")}
+
+  end
+
+end

data/app/models/services/public_key.rb

@@ -0,0 +1,11 @@
+module Services
+
+  class PublicKey < ActiveRecord::Base
+
+    scope :active, -> { where("valid_until IS NULL OR valid_until >= NOW()") }
+
+    validates :name, presence: true, uniqueness: true, length: { maximum: 255 }
+    validates :key, presence: true
+  end
+
+end

data/app/models/services/service.rb

@@ -0,0 +1,20 @@
+module Services
+
+  class Service < ActiveRecord::Base
+    has_many :service_definitions, dependent: :destroy
+
+    #
+    # The MDS Pull service is specified by the DB ID. This is the only one
+    # we can predict this way. In production, the IDs of the other records
+    # will be unpredictable
+    #
+    MDS_PULL = 'mds_pull'
+    MDS_PUSH = "mds_push"
+    HL7_INBOUND = "hl7_inbound"
+
+    validates :name, presence: true, uniqueness: true, length: { maximum: 255 }
+    validates :key, presence: true, uniqueness: true, length: { maximum: 255 }
+
+  end
+
+end

data/app/models/services/service_definition.rb

@@ -0,0 +1,37 @@
+module Services
+
+  class ServiceDefinition < ActiveRecord::Base
+    belongs_to :third_party
+    belongs_to :service
+    
+    has_many :configured_accounts, dependent: :destroy
+    has_many :configured_facilities, dependent: :destroy
+    has_many :credentials, as: :credentialled, dependent: :destroy
+
+    validates :hostname, length: { minimum: 0, maximum: 255 }, allow_nil: true, allow_blank: true
+    validates :base_uri, length: { minimum: 0, maximum: 255 }, allow_nil: true, allow_blank: true
+    validates :username, length: { minimum: 0, maximum: 255 }, allow_nil: true, allow_blank: true
+    validates :service_class, presence: true, length: { maximum: 255 }
+
+    def invoke
+      service_implementation.invoke
+    end
+
+    def service_implementation
+      clazz = eval(service_class)
+      clazz.new(self)
+    end
+
+    def hostname_with_port
+      hwp = hostname
+      hwp << ":#{port}" if self.port.present?
+      hwp
+    end
+
+    def server_base_url
+      ERB.new(base_uri).result(binding)
+    end
+
+  end
+
+end

data/app/models/services/service_implementation.rb

@@ -0,0 +1,29 @@
+module Services
+
+  class ServiceImplementation
+
+    attr_reader :service_definition
+
+    def initialize(srv_def)
+      @service_definition = srv_def
+    end
+
+    #
+    # Returns the credentials assocated with this service definition's server
+    #
+    def server_credentials
+      (@credentials ||= service_definition.credentials.first).tap do | cred |
+        raise "No credentials configured for server: (#{service_definition.to_rrepr})" if cred.blank?
+      end
+    end
+
+    def account_map(account_id)
+      AccountMapping.where(account_id: account_id,
+                             third_party_id: service_definition.third_party_id).first.tap do |am|
+        raise "No account mapping associated with #{service_definition.to_rrepr} and account_id = #{account_id}" if am.blank?
+      end
+    end
+
+  end
+
+end

data/app/models/services/sltc_api.rb

@@ -0,0 +1,179 @@
+module Services
+
+  class SltcApi 
+
+    BATCH_SIZE = 100
+
+    attr_reader :base_uri, :api_key, :account, :username, :password
+
+    def self.for_configured_account(configured_account)
+      service_definition = configured_account.service_definition
+      mapped_account = configured_account.account_mapping
+      credentials = configured_account.credentials.last
+
+      SltcApi.new(service_definition.server_base_url,
+                  service_definition.credentials.last.token,
+                  mapped_account.account_code,
+                  configured_account.username,
+                  credentials.password)
+    end
+
+    def initialize(base_uri, api_key, account, username, password)
+      @base_uri = base_uri
+      @api_key = api_key
+      @account = account
+      @username = username
+      @password = password
+    end
+
+    def list_providers
+      get_response do
+        RestClient::Request.execute(method: :get,
+                                    url: build_url(:Providers),
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge({ 'Accept' => 'application/json' }))
+      end
+    end
+
+    def list_batches(provider, pull_from, pull_to)
+      batches = []
+      page = 1
+      while true
+        response = get_response do
+          RestClient::Request.execute(method: :get,
+                                      url: build_url(:MdsBatches, { provider_id: provider,
+                                                                    page: page,
+                                                                    uploaded_after: pull_from,
+                                                                    uploaded_before: pull_to }),
+                                      user: "#{username}@#{account}",
+                                      password: password,
+                                      headers: authentication_headers.merge({ 'Accept' => 'application/json' }))
+        end
+        batches += response
+        if response.size < BATCH_SIZE
+          break
+        else
+          page += 1
+        end
+      end
+      batches
+    end
+
+    def search_assessments(provider, pull_from, pull_to, status='Accepted')
+      get_response do
+        RestClient::Request.execute(method: :get,
+                                    url: build_url(:MdsAssessments, { provider_id: provider,
+                                                                      status_updated_after: pull_from,
+                                                                      status_updated_before: pull_to, 
+                                                                      status: status }),
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge({ 'Accept' => 'application/json' }))
+      end
+    end
+
+    def upload_batch(provider_id, path)
+      file = nil
+      File.open(path, "rb") { |f| file = f.read }
+      get_response do
+        RestClient::Request.execute(method: :post,
+                                    url: build_url(:MdsBatches, { filename: path }),
+                                    payload: file,
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge( { :content_type => 'application/octet-stream',
+                                                                             'Accept' => 'application/json' } ))
+      end
+    end
+
+    def download_batch(batch_id)
+      get_response(true) do
+        RestClient::Request.execute(method: :get,
+                                    url: build_url(:MdsBatches, batch_id),
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge( { 'Accept' => 'application/octet-stream' } ))
+      end
+    end
+
+    def download_assessment_request(request_id)
+      get_response(true) do
+        RestClient::Request.execute(method: :get,
+                                    url: build_url(:MdsAssessmentsAsync, request_id),
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge({ 'Accept' => 'application/octet-stream' }))
+      end
+    end
+
+    def assessment_request_status(request_id)
+      get_response do
+        RestClient::Request.execute(method: :get,
+                                    url: build_url(:MdsAssessmentsAsync, request_id),
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge( { 'Accept' => 'application/json' }))
+      end
+    end
+
+    def assessment_request(provider_id, uploaded_after, uploaded_before, status)
+      parameters = {
+        'provider_id' => provider_id,
+        'status_updated_after' => uploaded_after.strftime("%Y-%m-%dT%H:%MZ"),
+        'status_updated_before' => uploaded_before.strftime("%Y-%m-%dT%H:%MZ"),
+        'status' => status
+      }
+
+      get_response do
+        RestClient::Request.execute(method: :post,
+                                    url: build_url(:MdsAssessmentsAsync),
+                                    payload: parameters.to_json,
+                                    user: "#{username}@#{account}",
+                                    password: password,
+                                    headers: authentication_headers.merge({ :content_type => :json,
+                                                                            'Accept' => 'application/json' }))
+      end
+    end
+
+    private
+
+    def get_response(binary_response=false)
+      response = nil
+      begin
+        response = yield 
+      rescue RestClient::Exception => ex
+        raise SltcApiException.new(ex)
+      end
+      binary_response ? response : JSON.parse(response)
+    end
+
+    def authentication_headers
+      {
+        'SLTC-Api-Key' => api_key,
+        'Host' => URI(base_uri).host
+      }
+    end
+
+    def build_url(api_name, parameters=nil)
+      url = "#{base_uri}/#{api_name.to_s}"
+      if parameters.present?
+        if parameters.is_a?(Fixnum)
+          url << '/' << parameters.to_s
+        elsif parameters.is_a?(String)
+          url << '/' << parameters
+        elsif parameters.is_a?(Hash)
+          url << "?"
+          url << parameters.keys.each.reduce([]) do | a, key | 
+            raw_value = parameters[key]
+            value = raw_value.respond_to?(:strftime) ? raw_value.strftime("%Y-%m-%dT%H:%MZ") : raw_value
+            a << "#{key}=#{value}" 
+          end.join("&")
+        end
+      end
+      url
+    end
+
+  end
+
+end