sunnyside 0.0.5 → 0.0.7

data/lib/sunnyside/ledger/edi.rb

@@ -1,216 +1,171 @@
 module Sunnyside
   def self.edi_parser
     print "checking for new files...\n"
-    Dir["#{LOCAL_FILES}/835/*.txt"].select { |file| Filelib.where(:filename => file).count == 0 }.each do |file|
+    Dir["#{DRIVE}/sunnyside-files/835/*.txt"].each do |file|
       print "processing #{file}...\n"
-      data = File.open(file).read
-
+      file_data = File.open(file)
+      data = file_data.read
       # Detect to see if the EDI file already has new lines inserted. If so, the newlines are removed before the file gets processed.
 
-      if data.include?(/\n/)
-        data.gsub!(/\n/, '')
-      end
+      data.gsub!(/\n/, '')
 
-      data  = data.split(/~CLP\*/)
-      edi   = Edi.new(data, file)
-      edi.parse_claim_header
-      Filelib.insert(filename: file, created_at: Time.now, purpose: 'EDI Import', file_type: '835 Remittance')
-      edi.save_payment_to_db
+      data     = data.split(/~CLP\*/)
+
+      edi_file = EdiReader.new(data)
+      edi_file.parse_claims
+      Filelib.insert(filename: file, purpose: '835')
+      file_data.close
+      FileUtils.mv(file, "#{DRIVE}/sunnyside-files/835/archive/#{File.basename(file)}")
     end
   end
 
-  class Edi
-    attr_reader :header, :claims, :file
-    def initialize(data, file)
-      @header, @claims = data[0], data.drop(1)
-      @file            = file
+  class EdiReader 
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
     end
 
-    def process_file
-      claims.map { |clm| clm.split(/~(?=SVC)/) }.each do |claim|
-        claim_head = claim[0]
-        services   = claim.select { |section| section =~ /^SVC/ }
-        InvoiceHeader.new(claim_head, services).parse_data
-      end
+    def claims
+      data.select { |clm| clm =~ /^\d+/ }.map { |clm| clm.split(/~(?=SVC)/) }
     end
 
+
+
     def check_number
-      header[/(?<=~TRN\*\d\*)\w+/, 0]
+      check = data[0][/(?<=~TRN\*\d\*)\w+/]
+      return check.include?('E') ? check[/\d+$/] : check
     end
 
     def check_total
-      header[/(?<=~BPR\*\w\*)[0-9\.\-]+/] || 0.0
+      data[0][/(?<=~BPR\*\w\*)[0-9\.\-]+/, 0]
     end
 
-    def type
-      if header[/(?<=\*C\*)ACH/] == 'ACH'
-        'Electronic Funds Transfer'
-      elsif header[/(?<=\*C\*)CHK/] == 'CHK'
-        'Physical Check Issued'
-      else
-        'Non Payment'
-      end
+    def parse_claims
+      payment_id = Payment.insert(check_number: check_number, check_total: check_total)
+      claims.each { |claim| ClaimParser.new(claim, payment_id).parse }
     end
+  end
 
-    # not working
+  class ClaimParser < EdiReader
+    attr_reader :claim_header, :service_data, :payment_id
 
-    # def check
-    #   if check_number.include?('E') # E for Fidelis
-    #     check_number[/\d+[A-Z]+(\d+)/, 1] 
-    #   else
-    #     check_number
-    #   end
-    # end
+    def initialize(claim, payment_id)
+      @claim_header = claim[0].split(/\*/)
+      @service_data = claim.select { |clm| clm =~ /^SVC/ }
+      @payment_id   = Payment[payment_id]
+    end
 
-    def separate_claims_from_services
-      claims.map {|clm| clm.split(/~(?=SVC)/)}
+    def header
+      {
+        :invoice       => claim_header[0],
+        :response_code => claim_header[1],
+        :billed        => claim_header[2],
+        :paid          => claim_header[3],
+        :units         => claim_header[5], # 4 is not used - that is the patient responsibility amount
+        :claim_number  => claim_header[6][/^\d+/]
+      }
     end
 
-    def parse_claim_header
-      separate_claims_from_services.each do |clm|
-        claim_data = clm[0]
-        services   = clm.reject{|x| x !~ /^SVC/}
-        claims     = InvoiceHeader.new(claim_data, check_number)
-        claims.format_data
-        claims.add_to_db(check_number, file)
-        parse_service(services) {|svc| claims.parse_svc(svc, check_number)}
-      end
+    def parse
+      claim    = ClaimEntry.new(header)
+      claim_id = claim.to_db(payment_id) 
+      service_data.each { |service| ServiceParser.new(service, claim_id).parse }
     end
+  end
 
-    def save_payment_to_db
-      provider = Claim.where(check_number: check_number).get(:provider_id) || 17
-      Payment.insert(provider_id: provider, filelib_id: filelib_id, check_total: check_total, check_number: check_number)
+  class ClaimEntry < EdiReader
+    attr_reader :invoice, :response_code, :billed, :paid, :units, :claim_number
+
+    def initialize(header = {})
+      @invoice       = header[:invoice].gsub(/[OLD]/, 'O' => '0', 'D' => '8', 'L' => '1').gsub(/^0/, '')[0..5].to_i # for the corrupt SHP EDI files
+      @response_code = header[:response_code]
+      @billed        = header[:billed]
+      @paid          = header[:paid]
+      @units         = header[:units]
+      @claim_number  = header[:claim_number]
     end
 
-    def filelib_id
-      Filelib.where(filename: file).get(:id)
+    def to_db(payment)
+      payment.update(provider_id: inv.provider_id) if payment.provider_id.nil?
+      Claim.insert(
+        :invoice_id     => invoice, 
+        :payment_id     => payment.id, 
+        :client_id      => inv.client_id, 
+        :control_number => claim_number, 
+        :paid           => paid, 
+        :billed         => billed, 
+        :status         => response_code, 
+        :provider_id    => inv.provider_id,
+        :recipient_id   => inv.recipient_id
+      )
     end
 
-    def parse_service(services)
-      services.map{|x| x.split(/~/).reject{|x| x !~ /CAS|SVC|DTM/}}.each {|svc| yield svc}
+    def inv
+      Invoice[invoice]
     end
   end
 
-  class InvoiceHeader < Edi
-    attr_accessor :claim_number, :invoice_number, :response_code, :amt_charged, :amt_paid, :check_number
-    def initialize(claim, check_number)
-      @invoice_number, @response_code, @amt_charged, @amt_paid, @whatever, @claim_number = claim.match(/^([\w\.]+)\*(\d+)\*([0-9\.\-]+)\*([0-9\.\-]+)\*([0-9\.\-]+)?\*+\w+\*(\w+)/).captures
-      @check_number   = check_number
-    end
+  class ServiceParser < EdiReader
+    attr_reader :service_line, :claim
 
-    def format_data
-      @invoice_number         = invoice_number[/^\w+/].gsub(/[OLD]/, 'O' => '0', 'D' => '8', 'L' => '1').gsub(/^0/, '')[0..5].to_i
+    def initialize(service_line, claim_id)
+      @service_line = service_line.split(/~/)
+      @claim        = Claim[claim_id]
     end
 
-    def claim_id
-      Claim.where(invoice_id: invoice_number, check_number: check_number).get(:id)
+    def dos
+      service_line.detect { |svc| svc =~ /^DTM/ }[/\w+$/]
     end
 
-    def parse_svc(service, check_number)
-      if service.length == 2
-        svc = Detail.new(service[0], service[1])
-      elsif service.length > 2
-        svc = Detail.new(service[0], service[1])
-        svc.set_denial(service[2])
+    def service_header
+      line = service_line[0].split(/\*/).drop(1)
+      if line.length == 7 || line[1] != line[2]
+        return line.uniq
+      else
+        return line
       end
-      svc.display(invoice_number)
-      svc.save_to_db(invoice_number, check_number, claim_id)
     end
 
-    def prov
-      Invoice.where(invoice_number: invoice_number).get(:provider_id)
+    def error_codes
+      service_line.find_all { |section| section =~ /^CAS|^SE/ }.map { |code| code[/\w+\*\w+\*(\d+)/, 1] }
     end
 
-    def add_to_db(check, file)
-      Claim.insert(provider_id: prov, invoice_id: invoice_number, billed: amt_charged, paid: amt_paid, check_number: check_number, control_number: claim_number, status: response_code)
+    def parse
+      service = ServiceEntry.new(service_header, dos, error_codes)
+      service.to_db(claim)
     end
   end
 
-  class Detail < Edi
-
-    attr_reader :billed, :paid, :denial_reason, :date, :billed, :paid, :units, :service_code
-    def initialize(service, date, denial_reason=nil, denial_code=nil)
-      @service_code, @billed, @paid, @units = service.match(/HC:([A-Z0-9\:]+)\*([0-9\.\-]+)\*([0-9\.\-]+)?\**([0-9\-]+)?/).captures
-      @date = Date.parse(date[/\d+$/])
-    end
-
-    def display(inv)
-      print "#{inv} #{@service_code} #{@date} #{client(inv)} #{denial}\n"
-    end
-
-    def client(inv)
-      Invoice.where(invoice_number: inv).get(:client_name)
-    end
-
-    def denial
-      (billed.to_f - paid.to_f).round(2) if billed > paid
-    end
-
-    def set_denial(denial)
-      @denial_reason = set_code(denial[/\d+/])
-    end
-
-    def save_to_db(invoice, check, claim_id)
-      Service.insert(invoice_id: invoice, service_code: service_code, units: units.to_f, billed: billed.to_f, paid: paid.to_f, denial_reason: denial_reason, dos: date, claim_id: claim_id)
-    end
-
-    def set_code(code)
-      case code
-      when '125' 
-        'Submission/billing error(s). At least one Remark Code must be provided'
-      when '140' 
-        'Patient/Insured health identification number and name do not match.'
-      when '31'  
-        'INVALID MEMBER ID'
-      when '62'  
-        'PAID AUTHORIZED UNITS'
-      when '96'  
-        'NO AUTHORIZATION FOR DOS'
-      when '146' 
-        'DIAGNOSIS WAS INVALID FOR DATES LISTED'
-      when '197' 
-        'Precertification/authorization/notification absent'
-      when '198' 
-        'Precertification/authorization exceeded'
-      when '199' 
-        'Revenue code and Procedure code do not match'
-      when '9'   
-        'DIAGNOSIS ISSUE'
-      when '15'  
-        'AUTHORIZATION MISSING/INVALID'
-      when '18'  
-        'Exact Duplicate Claim/Service'
-      when '19'  
-        'Expenses incurred prior to coverage'
-      when '27'  
-        'Expenses incurred after coverage terminated'
-      when '29'  
-        'Timely Filing'
-      when '39'  
-        'Services denied at the time authorization/pre-certification was requested'
-      when '45'  
-        'Charge exceeds fee schedule/maximum allowable'
-      when '16'  
-        'Claim/service lacks information which is needed for adjudication'
-      when '50'  
-        'These are non-covered services because this is not deemed a medical necessity by the payer'
-      when '192' 
-        'Non standard adjustment code from paper remittance'
-      when '181' 
-        'Procedure code was invalid on the date of service'
-      when '182' 
-        'Procedure modifier was invalid on the date of service'
-      when '204' 
-        'This service/equipment/drug is not covered under the patients current benefit plan'
-      when '151' 
-        '151 Payment adjusted because the payer deems the information submitted does not support this many/frequency of services'
-      when '177' 
-        'Patient has not met the required eligibility requirements'
-      when '109' 
-        'Claim/service not covered by this payer/contractor. You must send the claim/service to the correct payer/contractor.'
-      else
-        "#{code} is UNIDENTIFIED"
-      end
+  class ServiceEntry < EdiReader
+    attr_reader :paid, :billed, :service_code, :units, :res_code, :error_codes, :dos
+
+    def initialize(service_header, dos, error_codes)
+      @service_code, @billed, @paid, @res_code, @units = service_header
+      @dos         = Date.parse(dos)
+      @error_codes = error_codes.map { |id| Denial[id].denial_explanation }
+    end
+
+    def to_db(claim)
+      Service.insert(
+        :claim_id      => claim.id, 
+        :invoice_id    => claim.invoice_id, 
+        :payment_id    => claim.payment_id, 
+        :denial_reason => denial_reason, 
+        :service_code  => service_code.gsub(/HC:/, ''),
+        :paid          => paid,
+        :billed        => billed,
+        :units         => units,
+        :dos           => dos
+      )
+    end
+
+    def denial_reason
+      error_codes.join("\n") if denied?
+    end
+
+    def denied?
+      paid != billed
     end
   end
 end

data/lib/sunnyside/ledger/ledger.rb

@@ -2,17 +2,20 @@ require 'prawn'
 module Sunnyside
   # This should be redone.
   def self.ledger_file
-    Dir["#{LOCAL_FILES}/summary/*.PDF", "#{LOCAL_FILES}/summary/*.pdf"].each {|file| 
+    Dir["#{DRIVE}/sunnyside-files/summary/*.PDF"].each {|file| 
       if Filelib.where(filename: file).count == 0 
         puts "processing #{file}..."
         ledger = Ledger.new(file)
         ledger.process_file
         Filelib.insert(filename: file, purpose: 'summary')
+        FileUtils.mv(file, "#{DRIVE}/sunnyside-files/summary/archive/#{File.basename(file)}")
+        ledger.export_to_csv
       end
     }
   end
   
   class Ledger
+    include Sunnyside
     attr_reader   :post_date, :file, :pages
 
     # when Ledger gets initialized, the page variable filters out the VNS clients
@@ -23,12 +26,17 @@ module Sunnyside
       @pages     = PDF::Reader.new(file).pages.select { |page| !page.raw_content.include?('VISITING NURSE SERVICE') }
     end
 
-    def providers
-      pages.map { |page| PageData.new(page.raw_content, file) }
+    def process_file
+      pages.each { |page| PageData.new(page.raw_content, post_date).invoice_data }
     end
 
-    def process_file
-      providers.each { |page| page.invoice_data }
+    def post_date
+      Date.parse(file[0..7])
+    end
+
+    def export_to_csv
+      CSV.open("#{DRIVE}/sunnyside-files/new-ledger/#{inv.post_date}-IMPORT-FUND-EZ-LEDGER.csv", "a+") { |row| row << ['Seq','inv','post_date','other id','prov','invoice','header memo','batch','doc date','detail memo','fund','account','cc1','cc2','cc3','debit','credit'] }
+      Invoice.where(post_date: post_date).all.each { |inv| self.payable_csv(inv, post_date) }
     end
   end
 
@@ -37,13 +45,12 @@ module Sunnyside
   # Then, the data gets finalized (via the InvoiceLine child class of PageData) and inserted into the database. 
 
   class PageData
-    include Sunnyside
-    attr_reader :page_data, :provider, :post_date
+    attr_reader :page_data, :provider, :post_date, :invoice_data
 
-    def initialize(page_data, file)
+    def initialize(page_data, post_date)
       @provider  = page_data[/CUSTOMER:\s+(.+)(?=\)')/, 1]
-      @post_date = Date.parse(file[0..7])
-      @page_data = page_data.split(/\n/).select { |line| line =~ /^\([0-9\/]+\s/ }
+      @post_date = post_date
+      @page_data = page_data.split(/\n/).select { |line| line =~ /^\([0-9\/]{8}\s/ }
     end
 
     # Since the source data is somewhat unreliable in the format, there have been two different variations of AMERIGROUP and ELDERSERVE.
@@ -69,30 +76,33 @@ module Sunnyside
     end
 
     def invoice_lines
-      page_data.map { |line| InvoiceLine.new(line, formatted_provider, post_date) }
+      page_data.map { |line| 
+        line.gsub!(/^\(|\)'/)
+        client_name = line.slice!(20..45)
+        line        = InvoiceLine.new(line, formatted_provider, post_date, client_name) 
+      }
     end
 
     def invoice_data
       invoice_lines.each { |inv| inv.finalize }
-      # Invoice.where(post_date: post_date).all.each { |inv| self.payable_csv(inv, post_date, formatted_provider) }
     end
 
     # InvoiceLine does all the nitty-gritty parsing of an invoice line into the necessary fields the DB requres.
 
     class InvoiceLine < PageData
       attr_accessor :invoice, :rate, :hours, :amount, :client_id, :client_name, :post_date, :provider
-      def initialize(line, provider, post_date)
-        @provider                                               = provider
-        @post_date                                              = post_date
-        @client_name                                            = line.slice!(20..45)
+      def initialize(line, provider, post_date, client_name)
         @doc_date, @invoice, @client_id, @hours, @rate, @amount = line.split
+        @post_date                                              = post_date
+        @client_name                                            = client_name.strip
+        @provider                                               = provider
       end
 
       # Some invoice totals exceed $999.99, so the strings need to be parsed into a format, sans comma, that the DB will read correctly. 
       # Otherwise, the DB will read 1,203.93 as 1.0.
 
       def amt
-        amount.gsub(/,/, '')
+        amount.gsub(/,|\)'/, '')
       end
 
       # Ocasionally, new clients will appear on the PDF doc. If the DB does not find a client with the client_id, then it executes a method wherein
@@ -100,11 +110,11 @@ module Sunnyside
 
       def finalize
         if !client_missing? 
-          add_invoice
           update_client if new_provider?
+          add_invoice
         else 
           add_client
-          finalize
+          add_invoice
         end
       end
 
@@ -117,16 +127,16 @@ module Sunnyside
       end
 
       def update_client
-        Client[client_id].update(provider_id: provider.id, type: provider.type)
+        Client[client_id].update(provider_id: provider.id, prov_type: provider.prov_type)
       end
 
       def fund_id
-        print "Enter in the FUND EZ ID for this client: #{client_name.strip} of #{provider.name}. "
+        print "Enter in the FUND EZ ID for this client: #{client_name} of #{provider.name}: "
         return gets.chomp
       end
 
       def add_client
-        Client.insert(client_number: client_id, client_name: client_name.strip, fund_id: fund_id, provider_id: provider.id, type: provider.type)
+        Client.insert(client_number: client_id, client_name: client_name.strip, fund_id: fund_id, provider_id: provider.id, prov_type: provider.prov_type)
       end
 
       # rarely there may be an invoice line that contains an invoice number that already exists. This method accounts for it, by merely updating the amount.

data/lib/sunnyside/ledger/private.rb

@@ -1,12 +1,15 @@
 module Sunnyside  
   def self.process_private
-    Dir["#{LOCAL_FILES}/private/*.PDF", "#{LOCAL_FILES}/private/*.pdf"].select { |file| Filelib.where(filename: file).count == 0 }.each do |file|
-      puts "processing #{file}..."
-      PDF::Reader.new(file).pages.each { |inv| 
-        page  = inv.text.split(/\n/)
-        InvoiceParse.new(page).process if page.include?('Remit') 
-      }
+    Dir["#{DRIVE}/sunnyside-files/private/*.PDF"].each do |file| 
+      if Filelib.where(filename: file).count == 0 
+        puts "processing #{file}..."
+        PDF::Reader.new(file).pages.each { |inv| 
+          page  = inv.text.split(/\n/)
+          InvoiceParse.new(page).process if page.include?('Remit') 
+        }
+      end
       Filelib.insert(filename: file, purpose: 'private client visit data')
+      FileUtils.mv(file, "#{DRIVE}/sunnyside-files/private/archive/#{File.basename(file)}")
     end
   end
 
@@ -23,7 +26,7 @@ module Sunnyside
     end
 
     def client_number
-      client_line[/[0-9]{7}/, 0]
+      client_line[/[0-9]{7}/]
     end
 
     def process

data/lib/sunnyside/menu.rb

@@ -2,14 +2,15 @@ module Sunnyside
   class Menu
     def start
       loop do 
-        puts "1.) LEDGER IMPORT"
-        puts "2.) EDI IMPORT"
-        puts "3.) 837 IMPORT"
-        puts "4.) A/R REPORT"
-        puts "5.) CASH RECEIPT IMPORT"
-        puts "6.) ACCESS FTP"
-        puts "7.) EXPIRING AUTHORIZATION REPORT"
-        puts "9.) MCO - MLTC HOURS UPDATE"
+        puts " 1.) LEDGER IMPORT" 
+        puts " 2.) EDI IMPORT"
+        puts " 3.) 837 IMPORT"
+        puts " 4.) A/R REPORT"
+        puts " 5.) CASH RECEIPT IMPORT"
+        puts " 6.) ACCESS FTP"
+        puts " 7.) EXPIRING AUTHORIZATION REPORT"
+        puts " 9.) MCO - MLTC HOURS UPDATE"
+        puts "10.) CUSTOM QUERY"
         print "select option: "
         case gets.chomp
         when '1' 
@@ -20,18 +21,19 @@ module Sunnyside
         when '3'
           Sunnyside.parse_pdf
         when '4' 
-          Sunnyside::Report.new
+          Sunnyside.run_report
         when '5' 
-          Sunnyside::CashReceipt.new.process
+          Sunnyside.cash_receipt
         when '6'
-          Sunnyside.access_ftp(:download)
-          Sunnyside.access_ftp(:upload)
+          Sunnyside.access_ftp
         when '7'
           Sunnyside.show_opts
         when '8'
           Sunnyside.process_private
         when '9'
           Sunnyside.run_mco_mltc
+        when '10'
+          Sunnyside.query
         else
           exit
         end