sunnyside 0.0.5 → 0.0.7

data/lib/sunnyside/cash_receipts/cash_receipt.rb

@@ -1,123 +1,149 @@
 module Sunnyside
 
-  def payment_type
+  def self.cash_receipt
     puts "1.) EDI PAYMENT"
     puts "2.) MANUAL PAYMENT"
-    return gets.chomp.upcase == '1' ? EdiPayment.new : ManualPayment.new
+    cash_receipt = 
+      case gets.chomp
+      when '1'
+        CashReceipt.new(:electronic)
+      when '2'
+        CashReceipt.new(:manual)
+      end
+    cash_receipt.collate
   end
 
-  def check_date_abbre
-    puts 'Enter in check number, post date and then followed by the provider abbreviation (separated by a space - ex: 235345 10/12/2013 WEL): '
-    ans = gets.chomp.split
-    if ans.size == 3
-      return ans
-    else
-      raise 'You need to enter in the specified fields.'
+  class CashReceipt
+    attr_reader :post_date, :type_of_entry
+
+    def initialize(type_of_entry)
+      print "Enter in post date (YYYY-MM-DD): "
+      @post_date        = Date.parse(gets.chomp)
+      @type_of_entry    = type_of_entry
     end
-  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
+    def collate
+      case type_of_entry
+      when :electronic
+        Sunnyside.check_prompt { |payment_id| EdiPayment.new(payment_id, post_date).collate }
+      when :manual
+        manual_invoices
+      else
+        exit
+      end
+    end
 
-  class CashReceipt
-    include Sunnyside
-    attr_reader :type
-    def initialize
-      @type = self.payment_type
+    def invoice_selection
+      puts "Enter in the invoices, each separated by a space. If any invoice has a denial, 'flag' it by typing '-d' after the invoice number.\n"
+      invoices = gets.chomp.split
+      print "You have typed out #{invoices.length} number of invoices. Do you wish to add more to the same check? (Y or N): "
+      if gets.chomp.upcase == 'Y'
+        more_invoices = gets.chomp.split
+        return (more_invoices + invoices)
+      else
+        return invoices
+      end
     end
 
-    def process
-      type.collate
+    def manual_invoices
+      print "# of checks to enter for the post date of #{post_date}? "
+      num = gets.chomp.to_i
+      num.times do 
+        prov     = provider
+        print "Enter in the check number: "
+        check    = gets.chomp
+        invoices = invoice_selection
+        manual   = ManualPayment.new(invoices, post_date, prov, check) 
+        manual.seed_claims_and_services
+        manual.create_csv
+      end
+    end
+
+    def provider
+      Provider.all.each { |prov| puts "#{prov.id}: #{prov.name}"}
+      print "Type in the Provider ID: "
+      return Provider[gets.chomp] || ''
     end
   end
 
+
+
   class EdiPayment
     include Sunnyside
-    attr_reader :check_number, :post_date, :prov
-
-    def initialize
-      @check_number, @post_date, @prov = self.check_date_abbre
-    end
+    attr_reader :payment, :post_date
 
-    def invoices
-      Claim.where(check_number: check_number).map { |clm| clm.invoice_id }.uniq
+    def initialize(payment, post_date)
+      @payment, @post_date = payment, post_date
     end
 
     def populated_data
-      invoices.map { |inv| Invoice[inv] }
+      Claim.where(payment_id: payment.id).all.select { |clm| clm.paid > 0.0 }
     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)
+      populated_data.map { |clm| clm.paid }.inject { |x, y| x + y }.round(2)
     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"
+      populated_data.each do |clm| 
+        if not_paid_fully?(clm)
+          self.receivable_csv(clm, payment, post_date)  
+        else
+          print "#{clm.invoice_id} was not added to the spreadsheet because the invoice was already fully paid for.\n"
+          print "Please consider this $#{clm.paid} as an interest payment.\n"
+        end
+      end
+      puts "----------------------------------------------------------------------------------------------------------"
+      puts "------------------------------Check added to #{DRIVE}/EDI-citywide-import.csv-----------------------------"
+      puts "-------------Please note that there are #{denied_services} service days with possible denials-------------"
+      puts "----------------------------------------------------------------------------------------------------------"
+    end
+
+    def not_fully_paid?(clm)
+      Claim.where(invoice_id: clm.invoice_id).sum(:paid).round(2) < clm.paid
     end
 
     def denied_services
-      Service.where(check_number: check_number).exclude(denial_reason: [nil, '']).count
+      Service.where(payment_id: payment.id).exclude(denial_reason: nil).count
     end
   end
 
-  class ManualPayment < CashReceipt
-    attr_reader :check, :manual_invs, :post_date, :prov
-
-    def initialize
-      @check, @post_date, @prov = self.check_date_abbre
-      @manual_invs              = self.invoice_numbers
-    end
+  class ManualPayment
+    include Sunnyside
+    attr_reader :denied_invoices, :paid_invoices, :post_date, :provider, :check, :payment_id
 
-    def provider
-      Provider.where(abbreviation: prov).first
+    def initialize(invoices, post_date, prov, check)
+      @denied_invoices = invoices.select { |inv| inv.include?('-d') }.map { |inv| Invoice[inv.gsub(/-d/, '')] }
+      @paid_invoices   = invoices.reject { |inv| inv.include?('-d') }.map { |inv| Invoice[inv] }
+      @post_date       = post_date
+      @provider        = prov
+      @check           = check
+      @payment_id      = Payment.insert(check_number: check, post_date: post_date, provider_id: prov.id)
     end
 
-    def payment_id
-      if check_exists?
-        Payment.where(check_number: check, post_date: post_date, provider_id: provider.id).get(:id)
-      else
-        Payment.insert(check_number: check, post_date: post_date, provider_id: provider.id)
+    def seed_claims_and_services
+      (denied_invoices + paid_invoices).each do |invoice|
+        claim_id = create_claim(invoice)
+        create_services(invoice, claim_id)
       end
+      edit_services if denied_invoices.length > 0
     end
 
-    def check_exists?
-      Payment.where(check_number: check, post_date: post_date, provider_id: provider.id).count > 0
+    def create_csv
+      claims.each { |clm| self.receivable_csv(clm, Payment[payment_id], post_date) if clm.paid > 0.0 }
     end
 
-    def date
-      Date.strptime(post_date, '%m/%d/%Y')
-    end
-
-    def collate
-      manual_invs.each { |inv| 
-        invoice         = Invoice[inv.gsub(/-d/, '')]
-        claim_id        = create_claim(invoice)
-        create_services(invoice, claim_id)
-        edit_services(claim_id) 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]
+    def claims
+      (denied_invoices + paid_invoices).map { |inv| Claim.where(invoice_id: inv.invoice_number, payment_id: payment_id).first }
     end
 
     def create_claim(invoice)
       Claim.insert(
-        :invoice_id   => invoice.id, 
+        :invoice_id   => invoice.invoice_number, 
         :client_id    => invoice.client_id, 
         :billed       => invoice.amount, 
-        :paid         => 0.0, 
+        :paid         => invoice.amount, 
         :payment_id   => payment_id, 
         :provider_id  => invoice.provider_id
       )
@@ -143,51 +169,53 @@ module Sunnyside
       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)
-      service = EditServices.new(inv, payment_id)
-      loop do 
-        service.show_all
-        service.adjust
-      end
-    end
+    def edit_services
+      denied_invoices.each { |inv| 
+        services     = Service.where(invoice_id: inv.invoice_number, payment_id: payment_id)
+        edit_service = EditService.new(services) 
+        edit_service.show_all
 
-    def denial_present?(invoice)
-      invoice.include?('-d')
+        edit_service.adjust
+        
+        adjust_claim(inv)
+      }
     end
 
     def visits(invoice)
       Visit.where(invoice_id: invoice.invoice_number).all
     end
 
-    class EditServices < ManualPayment::CashReceipt
-      attr_reader :claim
+    def adjust_claim(inv)
+      service_sum = Service.where(payment_id: payment_id, invoice_id: inv.invoice_number).sum(:paid).round(2)
+      Claim.where(invoice_id: inv.invoice_number, payment_id: payment_id).update(:paid => service_sum)
+    end
+  end
 
-      def initialize(claim_id)
-        @claim    = Claim[claim_id]
-        @services = Service.where(claim_id: claim_id).all
-      end
+  class EditService
+    attr_reader :services
 
-      def show_all
-        services.each { |svc| puts "ID: #{svc.id} #{svc.dos} #{svc.amount}" }
-      end
+    def initialize(services)
+      @services = services.all
+    end
+
+    def show_all
+      services.each { |svc| puts "ID: #{svc.id} #{svc.dos} #{svc.service_code} #{svc.paid}" }
+    end
 
-      def adjust
-        print "Type in the Service ID # to change the amount: "
-        id     = gets.chomp
+    def adjust
+      print "Type in the Service(s) ID # to change the amount: "
+      ids     = gets.chomp.split
+      ids.each do |id|
         print "You selected #{id} - Type in the adjusted amount: "
         amt    = gets.chomp
         print "And now type in the denial reason: "
         reason = gets.chomp
         adjust_service(id, amt, reason)
       end
+    end
 
-      def adjust_service
-        Service[id].update(paid: amt, denial_reason: reason)
-      end
+    def adjust_service(id, amt, reason)
+      Service[id].update(paid: amt, denial_reason: reason)
     end
   end
 end

data/lib/sunnyside/ftp.rb

@@ -2,32 +2,47 @@ 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
-    }
+  def self.access_ftp
+    puts "1.) GUILDNET"
+    puts "2.) ELDERSERVE"
+    puts "3.) CPHL"
+    print "Select option: "
+    case gets.chomp
+    when '1'
+      print 'Username for Guildnet? '
+      username = gets.chomp
+      print 'Password for Guildnet? '
+      pass = gets.chomp
+      access = SunnyFTP.new(username, pass, 'GUILDNET')
+    when '2'
+      print 'Username for ELDERSERVE? '
+      username = gets.chomp
+      print 'Password for ELDERSERVE? '
+      pass = gets.chomp
+      access = SunnyFTP.new(username, pass, 'ELDERSERVE')
+    when '3'
+      print 'Username for CPHL? '
+      username = gets.chomp
+      print 'Password for CPHL? '
+      pass = gets.chomp
+      access = SunnyFTP.new(username, pass, 'CPHL')
+    else
+      exit
+    end
+    access.log_on
+    puts "Logged into #{access.name}..."
+    access.download_files
+    access.upload_files
   end
 
   class SunnyFTP
     attr_reader :ftp, :username, :password, :name, :directory
 
-    def initialize(provider = {})
+    def initialize(username, password, name)
       @ftp      = Net::FTP.new('depot.per-se.com')
-      @username = provider[:username]
-      @password = provider[:password]
-      @name     = provider[:name]      
+      @username = username
+      @password = password
+      @name     = name      
     end
 
     def log_on
@@ -44,7 +59,7 @@ module Sunnyside
 
     def download_folder
       ftp.chdir('../outgoing')
-      if !empty?('.')
+      if ftp.nlst.size == 0
         puts "No files found. Exiting..."
         ftp.close
         return []
@@ -54,7 +69,7 @@ module Sunnyside
     end
 
     def up_files
-      Dir["edi/outgoing/*.txt"]
+      Dir["#{DRIVE}/sunnyside-files/ftp/837/#{name}/*.txt"]
     end
 
     def upload_files
@@ -64,14 +79,14 @@ module Sunnyside
           ftp.putbinaryfile(file)
           puts "Upload complete."
           puts "deleting #{file} in local folder."
-          FileUtils.mv(file, "edi/outgoing/uploaded/#{File.basename(file)}")
+          FileUtils.mv(file, "#{DRIVE}/sunnyside-files/ftp/837/#{name}/#{File.basename(file)}")
         end
       }      
       ftp.close
     end
 
     def provider_folder
-      Dir["edi/incoming/#{name}"].map { |file| File.basename(file) }
+      Dir["#{DRIVE}/sunnyside-files/ftp/835/#{name}"].map { |file| File.basename(file) }
     end
 
     def new_file?(file)
@@ -82,12 +97,7 @@ module Sunnyside
       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
+          ftp.getbinaryfile(file, "#{DRIVE}/sunnyside-files/ftp/835/#{name}/#{file}") if File.basename(file).include?('835')
           puts "#{file} placed."
         end
       end

data/lib/sunnyside/ledger/auth_report.rb

@@ -4,11 +4,13 @@ module Sunnyside
   # 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|
+    files = Dir["#{DRIVE}/sunnyside-files/837/*.PDF"].select { |file| Filelib.where(filename: file).count == 0 }
+    files.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 } 
+      data.split(/(?=REG\s+LOC)/).each { |entry| ParseInvoice.new(entry).process } 
       Filelib.insert(filename: file, purpose: '837')
+      FileUtils.mv(file, "#{DRIVE}/sunnyside-files/837/archive/#{File.basename(file)}")
     end
   end
 
@@ -16,8 +18,12 @@ module Sunnyside
     attr_reader :client_line, :visits
 
     def initialize(entry)
-      @client_line = entry.split(/\n/).select { |line| line =~ /\s+001\s+/ }
-      @visits      = entry.split(/\n/).select { |line| line =~ /^\d{6}/         }
+      @client_line = entry.split(/\n/).select { |line| line =~ /\s+001\s+/ }.join
+      @visits      = entry.split(/\n/).select { |line| line =~ /^\d{6}/    }
+    end
+
+    def client_data
+      client_line.slice(9..28) + client_line.slice(54..120)
     end
 
     def invoice_lines
@@ -34,10 +40,7 @@ module Sunnyside
       }
     end
 
-
-    def client_data
-      client_line.map { |line| ( line.slice(9..28) + line.slice(66..120) ).split }[0]
-    end
+    # removes the client name from the line
 
     def process
       invoice_lines.each { |inv| inv.to_db }
@@ -57,12 +60,12 @@ module Sunnyside
       @modifier     = invoice_line[:modifier]
       @dos          = invoice_line[:dos]
       @units        = invoice_line[:units]
-      @amount       = invoice_line[:amount]
+      @amount       = invoice_line[:amount].gsub(/,/, '')
     end
 
     def to_db
       Visit.insert(
-        :client_id    => client.client_number, 
+        :client_id    => client_id, 
         :modifier     => modifier, 
         :invoice_id   => invoice,
         :amount       => amount,
@@ -70,39 +73,30 @@ module Sunnyside
         :dos          => Date.strptime(dos, '%m/%d/%y'),
         :units        => units
       )
-      update_invoice
+      update_client_demographics
     end
 
-    def update_invoice
-      Invoice[invoice].update(:auth => auth, :recipient_id => client.recipient_id)
+    def client_id
+      Invoice[invoice].client_id
     end
 
-    def auth
-      client.authorization
+    def update_client_demographics
+      Invoice[invoice].update(:auth => client.authorization, :recipient_id => client.recipient_id, service_number: client.service_id)
+      Client[client_id].update(:recipient_id => client.recipient_id)
     end
   end
 
   class ClientData < ParseInvoice
-    attr_reader :client_id, :service_id, :recipient_id, :authorization
+    attr_reader :client_id, :service_id, :recipient_id, :authorization, :dob
 
     def initialize(client)
-      @client_id, @service_id, @recipient_id, @authorization = client.map { |line| line.strip }
-    end
-
-    def client_number
-      if client_missing?
-        puts 'how the hell is it happening? ' + client_id
-      else
-        client_id
-      end
+      @client_id, @service_id, @dob, @recipient_id, @authorization = client.split.map { |line| line.strip }
     end
 
-    def auth
-      authorization
-    end
+    # Not parsing correctly.
 
-    def client_missing?
-      Client[client_id].nil?
+    def date_of_birth
+      Date.strptime(dob, '%m/%d/%Y')
     end
   end
 end