sunnyside 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cb352e0ac28b56b294e7736a05ea8c3862c41b0
+  data.tar.gz: 8b00db12da4d56584417a1dc52e5b8cbb73226f8
+SHA512:
+  metadata.gz: 5b8236a4f85643a031ecaed56c69d19bbc426c96443ce2d32624f85e32f27beb26b77a49866d2006d57b5e39ec65711d2ebe123a7c9fcf45d94c811f70c41c6f
+  data.tar.gz: af009aeedc0ecffc3f462233e5c628dd269d455366d84d4b809ba326fb8c3a53bcece65738d18b05870fcf72bf8513b4bea5acb23469ffe61cb7a6c22e1ebf51

data/bin/sunnyside

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'sequel'
+require 'sunnyside'
+
+Sunnyside::Menu.new.start

data/lib/sunnyside/cash_receipts/cash_receipt.rb

@@ -0,0 +1,169 @@
+module Sunnyside
+
+  def payment_type
+    puts 'Type of Payment? (EDI or MANUAL)'
+    return gets.chomp.upcase == 'EDI' ? EdiPayment.new : ManualPayment.new
+  end
+
+  def check_number_and_date
+    puts 'Enter in check number followed by the post date (separated by a space - ex: 235345 10/12/2013): '
+    return gets.chomp.split(' ')
+  end
+
+  def invoice_numbers
+    puts 'Enter in invoices, each separated by a space. If an invoice contains any denials, flag it by typing in a "-d" right after the last number. '
+    return gets.chomp.split(' ')
+  end
+
+  class CashReceipt
+    include Sunnyside
+    attr_reader :type
+    def initialize
+      @type = self.payment_type
+    end
+
+    def process
+      type.collate
+    end
+  end
+
+  class EdiPayment
+    include Sunnyside
+    attr_reader :check_number, :post_date
+
+    def initialize
+      @check_number, @post_date = self.check_number_and_date
+    end
+
+    def invoices
+      Claim.where(check_number: check_number).map { |clm| clm.invoice_id }.uniq
+    end
+
+    def populated_data
+      invoices.map { |inv| Invoice[inv] }
+    end
+
+    def total
+      populated_data.map { |inv| inv.amount }.inject { |x, y| x + y }.round(2)
+    end
+
+    def payment_id
+      Payment.where(check_number: check_number).get(:id)
+    end
+
+    def collate
+      puts "Total Amount Paid for this check is: #{total}\nProcessing..."
+      populated_data.each { |inv| self.receivable_csv(inv, payment_id, check_number, post_date) if inv.amount > 0.0 }
+      puts "Check added to #{LOCAL_FILES}/EDI-citywide-import.csv"
+      puts "Please note that there are #{denied_services} service days with possible denials"
+    end
+
+    def denied_services
+      Service.where(check_number: check_number).exclude(denial_reason: [nil, '']).count
+    end
+  end
+
+  class ManualPayment < CashReceipt
+    attr_reader :check, :invoices, :post_date
+
+    def initialize
+      @check, @post_date = self.check_number_and_date
+      @invoices          = self.invoice_numbers
+    end
+
+    def payment_id
+      if check_exists?
+        Payment.where(check_number: check).get(:id)
+      else
+        Payment.insert(check_number: check)
+      end
+    end
+
+    def check_exists?
+      Payment.where(check_number: check).count > 0
+    end
+
+    def date
+      Date.strptime(post_date, '%m/%d/%Y')
+    end
+
+    def collate
+      invoices.each { |inv|
+        invoice_data(inv) { |invoice| 
+          claim_id = create_claim(invoice)
+          create_services(invoice, claim_id)
+          edit_services(inv) if denial_present?(inv)
+          self.receivable_csv(invoice, payment_id, check, post_date)
+        }
+      }
+    end
+
+    def invoice_data(inv)
+      invoice = inv.gsub(/-d/, '').to_i
+      yield Invoice[invoice]
+    end
+
+    def create_claim(invoice)
+      Claim.insert(
+        :invoice_id   => invoice.invoice_number, 
+        :client_id    => invoice.client_id, 
+        :billed       => invoice.amount, 
+        :paid         => 0.0, 
+        :payment_id   => payment_id, 
+        :check_number => check, 
+        :provider_id  => invoice.provider_id
+      )
+    end
+
+    def create_services(invoice, claim_id)
+      visits(invoice).each { |visit| 
+        Service.insert(
+          :invoice_id   => visit.invoice_id, 
+          :payment_id   => payment_id, 
+          :claim_id     => claim_id, 
+          :service_code => visit.service_code, 
+          :paid         => visit.amount, 
+          :billed       => visit.amount, 
+          :dos          => visit.dos,
+          :units        => visit.units 
+        )
+      }
+    end
+
+    def visits(invoice)
+      Visit.where(invoice_id: invoice.invoice_number).all
+    end
+
+
+
+    def services(inv)
+      Service.where(payment_id: payment_id, invoice_id: inv)
+    end
+
+    def edit_services(inv)
+      invoice = inv.gsub(/-d/, '').to_i
+      print "Select the day you wish to edit by the corresponding number followed by the adjusted amount\n"
+      print "When you are finished, type 'done'."
+      print "(e.g. 3451 23.50) Enter in the number now: "
+      loop do 
+        services(invoice).all.each { |svc| puts "#{svc.id} #{svc.dos} #{svc.service_code} #{svc.modifier} #{svc.paid}" }
+        id, adjusted_amt = gets.chomp.split
+        if !id.nil?
+          print "Type in the denial reason now: "
+          denial_reason = gets.chomp
+          Service[id].update(paid: adjusted_amt, denial_reason: denial_reason)
+        else 
+          break
+        end
+      end
+    end
+
+    def denial_present?(invoice)
+      invoice.include?('-d')
+    end
+
+    def visits(invoice)
+      Visit.where(invoice_id: invoice.invoice_number).all
+    end
+  end
+end

data/lib/sunnyside/cash_receipts/ics.rb

@@ -0,0 +1,69 @@
+# Not implemented yet
+
+module Sunnyside
+  def self.ics_file
+    Dir['data/icseop/*.csv'].each { |file| ICS.new(file).process }
+  end
+
+  class ICS
+    attr_reader :rows
+
+    def initialize(file)
+      p "processing #{file}..."
+      @rows = CSV.read(file)
+    end
+
+    def checks
+      rows.map { |row| row[0] }.uniq
+    end
+
+    def invoices(check)
+      rows.select { |row| row[0] == check }.map { |row| row[1] }.uniq.map { |inv| Invoice[inv] }
+    end
+
+    def paid(inv, check)
+      rows.select { |row| row[1].to_i == inv.get(:invoice_number) && row[0] == check }.map { |i| i[3].to_f }.inject { |x, y| x + y}.round(2)
+    end
+
+    def seed_claims
+      checks.each do |check|
+        payment_id = Payment.insert(check_number: check)
+        invoices(check).each { |invoice| 
+          Claim.insert(
+            :payment_id     => payment_id, 
+            :invoice_id     => invoice, 
+            :client_name    => invoice.get(:client_name), 
+            :amount_charged => invoice.get(:amount), 
+            :amount_paid    => paid(invoice, check), 
+            :provider       => invoice.get(:provider) ) 
+        }
+      end
+    end
+
+    def process
+      seed_claims
+      rows.each { |row| ICSEop.new(row).write }
+    end
+  end
+
+  class ICSEop < ICS
+    attr_reader :check, :invoice, :charged, :paid, :dos, :service_code, :provider
+
+    def initialize(row)
+      @check, @invoice, @charged, @paid, @dos, @service_code = row
+      @provider = Provider[13]
+    end
+
+    def write
+      Service.insert(claim_id: claim_id, service_code: service_code, amount_charged: charged, amount_paid: paid, dos: date, check_number: check)
+    end
+
+    def date
+      Date.strptime(dos, '%m/%d/%Y')
+    end
+
+    def claim_id
+      Claim.where(invoice_number: invoice, check_number: check).get(:id)
+    end
+  end
+end

data/lib/sunnyside/expiring_auth.rb

@@ -0,0 +1,101 @@
+module Sunnyside
+  def self.expiring_auth
+    Dir["data/exp auth/*.txt"].each do |file|
+      file = File.open(file)
+      data = file.read.split("\n").reject { |line| line =~ /\f/}
+      data.each { |line| 
+        if line =~ /^.{27}\d{7}\s+\d{7}\s/
+          client = line.slice!(0..26)
+          line   = line.split(' ').keep_if { |elem| elem.length >= 4 }
+          data   = ExpiringAuth.new(file, client, line)
+          print "#{line}\n"
+        end
+      }
+      file.close
+      FileUtils.mv(file, "data/exp auth/previous/#{File.basename(file)}")
+    end
+    clients = Authorization.map(:client_number).uniq
+    clients.each { |client| 
+      most_recent_auth = Authorization.where(client_number: client).exclude(auth: 'Blanket').order(:end_date).last
+      # that gets the most recent auth that isnt a blanket.
+      # visits           = Visit.where(member_id: client).where('dos > ?', most_recent_auth.end_date) if !most_recent_auth.nil?
+      # puts "#{client} #{visits.count}" if !visits.nil?
+    #   that gets all the visits that has that particular client number that is also GREATER than the most_recent_auth's end date
+      # client.each { |x| puts x.client }
+      auth_data = Authorization.where(client_number: client)
+      auth      = auth_data.order(:end_date).all.last
+      AuthReport.new(auth_data, auth).create_csv
+    }
+  end
+
+  class ExpiringAuth
+    attr_reader :file, :line, :client_id, :auth, :start_date, :end_date, :service_id, :client
+
+    def initialize(file, client, line)
+      @file                                                  = file
+      @client                                                = client.strip
+      @service_id, @client_id, @auth, @start_date, @end_date = line
+      if Authorization.where(auth: auth, client: client.strip).count == 0
+        process
+      end
+    end
+
+    def provider
+      if invoice.count > 0
+        invoice.all.last.provider
+      else
+        nil
+      end
+    end
+
+    def invoice
+      Invoice.where(service_number: client_id) || Invoice.where(service_number: service_id)
+    end
+
+    def process
+      Authorization.insert(auth: auth, provider: provider, client: client, start_date: begin_date, end_date: final_date, client_number: client_id, service_number: service_id)
+    end
+
+    def begin_date
+      if start_date.nil?
+        Date.new
+      else
+        Date.strptime(start_date, '%m/%d/%y')
+      end
+    end
+
+    def final_date
+      if end_date.nil?
+        Date.new
+      else
+        Date.strptime(end_date, '%m/%d/%y') 
+      end
+    end
+  end
+
+  class AuthReport
+    attr_reader :client_auth, :invoices, :visits, :auth
+
+    def initialize(client, auth)
+      @auth   = auth
+      @client_auth            = client
+      @visits                 = Visit.where(member_id: client.get(:client_number)).all.select { |visit| auth.end_date < visit.dos }
+    end
+
+    def create_csv
+      if expired?
+        CSV.open('auth_report', 'a+') { |row| row << ['EXPIRED', auth.client, auth.provider, auth.start_date, auth.end_date, auth.auth] }
+        if visits.count > 0
+          # puts visits
+          visits.each { |visit| CSV.open('auth_report', 'a+') { |row| row << [''       , visit.dos, visit.service_code, visit.units, visit.amount] } }
+        end
+      else
+        CSV.open('auth_report', 'a+') { |row| row << ['PENDING', auth.client, auth.provider, auth.start_date, auth.end_date, auth.auth] }
+      end
+    end
+
+    def expired?
+      auth.end_date < Date.today
+    end
+  end
+end

data/lib/sunnyside/ftp.rb

@@ -0,0 +1,97 @@
+require "net/ftp"
+require 'rubygems'
+
+module Sunnyside
+  PROVIDERS = [ 
+                { :username => '****', :password => '****', :name => 'GUILDNET'}, 
+                { :username => '****', :password => '****', :name => 'ELDERSERVE'}, 
+                { :username => '****', :password => '****', :name => 'CPHL'}
+              ]
+  def self.access_ftp(process)
+    PROVIDERS.each { |provider| 
+      access = SunnyFTP.new(provider)
+      access.log_on
+      puts "Logged into #{provider[:name]}..."
+      if process == :download
+        access.download_files
+      elsif process == :upload
+        access.upload_files
+      end
+    }
+  end
+
+  class SunnyFTP
+    attr_reader :ftp, :username, :password, :name, :directory
+
+    def initialize(provider = {})
+      @ftp      = Net::FTP.new('depot.per-se.com')
+      @username = provider[:username]
+      @password = provider[:password]
+      @name     = provider[:name]      
+    end
+
+    def log_on
+      ftp.login(username, password)
+    end
+
+    def empty?(folder)
+      ftp.list(folder) == ["total 0"]
+    end
+
+    def outgoing_contents
+      ftp.nlst('../outgoing') if empty?('../outgoing') 
+    end
+
+    def download_folder
+      ftp.chdir('../outgoing')
+      if !empty?('.')
+        puts "No files found. Exiting..."
+        ftp.close
+        return []
+      else
+        return ftp.nlst
+      end
+    end
+
+    def up_files
+      Dir["edi/outgoing/*.txt"]
+    end
+
+    def upload_files
+      up_files.each { |file| 
+        if file.include?(name)
+          puts "uploading #{file} for #{name}"
+          ftp.putbinaryfile(file)
+          puts "Upload complete."
+          puts "deleting #{file} in local folder."
+          FileUtils.mv(file, "edi/outgoing/uploaded/#{File.basename(file)}")
+        end
+      }      
+      ftp.close
+    end
+
+    def provider_folder
+      Dir["edi/incoming/#{name}"].map { |file| File.basename(file) }
+    end
+
+    def new_file?(file)
+      provider_folder.include?(file)
+    end
+
+    def download_files
+      download_folder.each do |file|
+        if !provider_folder.include?(file)
+          puts "Downloading #{file}..."
+          case file
+          when file.include?('TA1') then ftp.getbinaryfile(file, "edi/incoming/#{name}/TA1/#{file}")
+          when file.include?('997') then ftp.getbinaryfile(file, "edi/incoming/#{name}/997/#{file}")
+          else
+            ftp.getbinaryfile(file, "edi/incoming/#{name}/#{file}")
+          end
+          puts "#{file} placed."
+        end
+      end
+      ftp.close
+    end
+  end
+end

data/lib/sunnyside/ledger/auth_report.rb

@@ -0,0 +1,110 @@
+module Sunnyside
+
+  # REG LOC is the only repeating element that would indicate that there's a new client being read. So instead of reading the pdf
+  # report page by page, it would be best to compress the text from every page into a single string and then parse from there.
+
+  def self.parse_pdf
+    Dir["#{LOCAL_FILES}/837/*.PDF"].select { |file| Filelib.where(filename: file).count == 0 }.each do |file|
+      puts "processing #{file}..."
+      data = PDF::Reader.new(file).pages.map { |page| page.raw_content.gsub(/^\(\s|\)'$/, '') }.join
+      data.split(/^\((?=REG\s+LOC)/).each { |entry| ParseInvoice.new(entry).process } 
+      Filelib.insert(filename: file, purpose: '837')
+    end
+  end
+
+  class ParseInvoice
+    attr_reader :client_line, :visits
+
+    def initialize(entry)
+      @client_line = entry.split(/\n/).select { |line| line =~ /(NY|\s+)\s+001/ }
+      @visits      = entry.split(/\n/).select { |line| line =~ /^\d{6}/         }
+    end
+
+    def invoice_lines
+      visits.map { |inv| 
+          InvoiceDetail.new(
+            client_data, 
+            { :invoice  => inv[0..5], 
+              :svc_code => inv[18..22], 
+              :modifier => inv[25..30], 
+              :dos      => inv[57..66], 
+              :units    => inv[69..75], 
+              :amount   => inv[79..88] }
+          )
+      }
+    end
+
+
+    def client_data
+      client_line.map { |line| ( line.slice(9..28) + line.slice(66..120) ).split }[0]
+    end
+
+    def process
+      invoice_lines.each { |inv| inv.to_db }
+    end
+
+    # only the invoices lines and the client info line gets selected and passed onto the next object level
+  end
+  class ClientData < ParseInvoice
+    attr_reader :client_id, :service_id, :recipient_id, :authorization
+
+    def initialize(client)
+      @client_id, @service_id, @recipient_id, @authorization = client.map { |line| line.strip }
+    end
+
+    def show_me
+      puts "#{client_id} #{service_id} #{recipient_id} #{authorization}"
+    end
+
+    def client_number
+      if client_exists?
+        client_id
+      else
+        insert_client
+      end
+    end
+
+    def client_exists?
+      Client.where(client_number: client_id).count > 0
+    end
+
+    def insert_client
+      Client.insert(client_number: client_id)
+    end
+  end
+
+  class InvoiceDetail < ParseInvoice
+    attr_reader :invoice, :service_code, :modifier, :dos, :units, :amount, :client
+
+    def initialize(client, invoice_line = {})
+      @client       = ClientData.new(client)
+      @invoice      = invoice_line[:invoice]
+      @service_code = invoice_line[:svc_code]
+      @modifier     = invoice_line[:modifier]
+      @dos          = invoice_line[:dos]
+      @units        = invoice_line[:units]
+      @amount       = invoice_line[:amount]
+    end
+
+    def show
+      puts "#{invoice} #{service_code} #{modifier} #{dos} #{units} #{amount} #{client.show_me}"
+    end
+
+    def to_db
+      Visit.insert(
+        :client_id    => client.client_number, 
+        :modifier     => modifier, 
+        :invoice_id   => invoice,
+        :amount       => amount,
+        :service_code => service_code,
+        :dos          => Date.strptime(dos, '%m/%d/%y'),
+        :units        => units
+      )
+      update_invoice
+    end
+
+    def update_invoice
+      Invoice[invoice].update(:authorization => client.authorization, :recipient_id => client.recipient_id)
+    end
+  end
+end