mercury_banking 0.5.34

data/lib/mercury_banking/cli/reconciliation.rb

@@ -0,0 +1,406 @@
+module MercuryBanking
+  module CLI
+    # Module for reconciliation-related commands
+    module Reconciliation
+      # Add reconciliation-related commands to the CLI class
+      def self.included(base)
+        base.class_eval do
+          desc 'reconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as reconciled'
+          def reconcile(account_identifier, transaction_id)
+            with_api_client do |client|
+              # Determine if we're dealing with an account ID or account number
+              account_id = nil
+              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+                begin
+                  account = client.find_account_by_number(account_identifier)
+                  account_id = account["id"]
+                rescue => e
+                  # If not found by number, assume it's an ID
+                  account_id = account_identifier
+                  account = client.get_account(account_id)
+                end
+              else
+                account_id = account_identifier
+                account = client.get_account(account_id)
+              end
+              
+              # Get the transaction to verify it exists
+              transaction = client.transaction(account_id, transaction_id)
+              
+              # Mark the transaction as reconciled
+              reconciliation = MercuryBanking::Reconciliation.new
+              result = reconciliation.mark_reconciled(account_id, transaction_id)
+              
+              if options[:json]
+                puts JSON.pretty_generate({
+                  'account_id' => account_id,
+                  'transaction_id' => transaction_id,
+                  'reconciled' => true,
+                  'already_reconciled' => !result
+                })
+              else
+                if result
+                  puts "Transaction #{transaction_id} marked as reconciled."
+                else
+                  puts "Transaction #{transaction_id} was already reconciled."
+                end
+              end
+            end
+          end
+          
+          desc 'unreconcile ACCOUNT_ID_OR_NUMBER TRANSACTION_ID', 'Mark a transaction as unreconciled'
+          def unreconcile(account_identifier, transaction_id)
+            with_api_client do |client|
+              # Determine if we're dealing with an account ID or account number
+              account_id = nil
+              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+                begin
+                  account = client.find_account_by_number(account_identifier)
+                  account_id = account["id"]
+                rescue => e
+                  # If not found by number, assume it's an ID
+                  account_id = account_identifier
+                  account = client.get_account(account_id)
+                end
+              else
+                account_id = account_identifier
+                account = client.get_account(account_id)
+              end
+              
+              # Get the transaction to verify it exists
+              transaction = client.transaction(account_id, transaction_id)
+              
+              # Mark the transaction as unreconciled
+              reconciliation = MercuryBanking::Reconciliation.new
+              result = reconciliation.mark_unreconciled(account_id, transaction_id)
+              
+              if options[:json]
+                puts JSON.pretty_generate({
+                  'account_id' => account_id,
+                  'transaction_id' => transaction_id,
+                  'reconciled' => false,
+                  'was_reconciled' => result
+                })
+              else
+                if result
+                  puts "Transaction #{transaction_id} marked as unreconciled."
+                else
+                  puts "Transaction #{transaction_id} was not reconciled."
+                end
+              end
+            end
+          end
+          
+          desc 'reconciliation_status ACCOUNT_ID_OR_NUMBER', 'Show reconciliation status for an account'
+          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+          method_option :end, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
+          method_option :format, type: :string, default: 'table', enum: ['table', 'json'], desc: 'Output format (table or json)'
+          def reconciliation_status(account_identifier)
+            with_api_client do |client|
+              # Determine if we're dealing with an account ID or account number
+              account_id = nil
+              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+                begin
+                  account = client.find_account_by_number(account_identifier)
+                  account_id = account["id"]
+                rescue => e
+                  # If not found by number, assume it's an ID
+                  account_id = account_identifier
+                  account = client.get_account(account_id)
+                end
+              else
+                account_id = account_identifier
+                account = client.get_account(account_id)
+              end
+              
+              # Get transactions for the account
+              start_date = options[:start]
+              end_date = options[:end]
+              
+              transactions = client.get_transactions(account_id, start_date)
+              
+              # Filter by end date if specified
+              if end_date
+                end_date_obj = Date.parse(end_date)
+                transactions = transactions.select do |t|
+                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                  transaction_date <= end_date_obj
+                end
+              end
+              
+              # Get reconciliation status
+              reconciliation = MercuryBanking::Reconciliation.new
+              status = reconciliation.get_reconciliation_status(account_id, transactions)
+              summary = reconciliation.get_reconciliation_summary(account_id, transactions)
+              
+              if options[:json] || options[:format] == 'json'
+                puts JSON.pretty_generate({
+                  'account_id' => account_id,
+                  'account_name' => account['name'],
+                  'summary' => summary,
+                  'transactions' => status
+                })
+              else
+                # Display summary
+                puts "Reconciliation Status for #{account['name']} (#{account['accountNumber']})"
+                puts "Period: #{start_date} to #{end_date || 'present'}"
+                puts
+                puts "Summary:"
+                puts "- Total Transactions: #{summary[:total_transactions]}"
+                puts "- Reconciled: #{summary[:reconciled_count]} ($#{format("%.2f", summary[:reconciled_amount])})"
+                puts "- Unreconciled: #{summary[:unreconciled_count]} ($#{format("%.2f", summary[:unreconciled_amount])})"
+                puts
+                
+                # Display transactions
+                rows = status.map do |t|
+                  date = t[:date] ? Time.parse(t[:date]).strftime("%Y-%m-%d") : "Unknown"
+                  description = t[:description].length > 30 ? "#{t[:description][0..27]}..." : t[:description]
+                  amount = format("$%.2f", t[:amount])
+                  reconciled = t[:reconciled] ? "✓" : " "
+                  reconciled_at = t[:reconciled_at] || ""
+                  
+                  [t[:transaction_id], date, description, amount, reconciled, reconciled_at]
+                end
+                
+                table = ::Terminal::Table.new(
+                  headings: ['Transaction ID', 'Date', 'Description', 'Amount', 'Reconciled', 'Reconciled At'],
+                  rows: rows
+                )
+                
+                puts table
+              end
+            end
+          end
+          
+          desc 'reconcile_all ACCOUNT_ID_OR_NUMBER', 'Mark all transactions as reconciled up to a specified date'
+          method_option :date, type: :string, desc: 'Date up to which to reconcile transactions (YYYY-MM-DD). Defaults to current date.'
+          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+          method_option :dry_run, type: :boolean, default: false, desc: 'Show what would be reconciled without making changes'
+          method_option :json, type: :boolean, default: false, desc: 'Output in JSON format'
+          method_option :debug, type: :boolean, default: false, desc: 'Show debug information'
+          def reconcile_all(account_identifier)
+            with_api_client do |client|
+              # Determine if we're dealing with an account ID or account number
+              account_id = nil
+              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+                begin
+                  account = client.find_account_by_number(account_identifier)
+                  account_id = account["id"]
+                rescue => e
+                  # If not found by number, assume it's an ID
+                  account_id = account_identifier
+                  account = client.get_account(account_id)
+                end
+              else
+                account_id = account_identifier
+                account = client.get_account(account_id)
+              end
+              
+              # Get transactions for the account
+              start_date = options[:start]
+              puts "Fetching transactions for account #{account['name']} (#{account['accountNumber']}) since #{start_date}..." if options[:debug]
+              transactions = client.get_transactions(account_id, start_date)
+              puts "Found #{transactions.size} total transactions" if options[:debug]
+              
+              # Filter by date if specified
+              cutoff_date = options[:date] ? Date.parse(options[:date]) : Date.today
+              puts "Using cutoff date: #{cutoff_date}" if options[:debug]
+              
+              # Filter transactions that are on or before the cutoff date
+              transactions_to_reconcile = transactions.select do |t|
+                transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                transaction_date <= cutoff_date
+              end
+              puts "Found #{transactions_to_reconcile.size} transactions on or before cutoff date" if options[:debug]
+              
+              if transactions_to_reconcile.empty?
+                if options[:json]
+                  puts JSON.pretty_generate({
+                    'account_id' => account_id,
+                    'account_name' => account['name'],
+                    'transactions_reconciled' => 0,
+                    'message' => "No transactions found to reconcile."
+                  })
+                else
+                  puts "No transactions found to reconcile for #{account['name']} (#{account['accountNumber']})."
+                end
+                return
+              end
+              
+              # Get already reconciled transactions
+              reconciliation = MercuryBanking::Reconciliation.new
+              reconciled_ids = reconciliation.get_reconciled_transactions(account_id)
+              puts "Found #{reconciled_ids.size} already reconciled transactions" if options[:debug]
+              
+              # Filter out already reconciled transactions
+              transactions_to_reconcile = transactions_to_reconcile.reject { |t| reconciled_ids.include?(t["id"]) }
+              puts "Found #{transactions_to_reconcile.size} transactions to reconcile" if options[:debug]
+              
+              if transactions_to_reconcile.empty?
+                if options[:json]
+                  puts JSON.pretty_generate({
+                    'account_id' => account_id,
+                    'account_name' => account['name'],
+                    'transactions_reconciled' => 0,
+                    'message' => "All transactions are already reconciled up to #{cutoff_date}."
+                  })
+                else
+                  puts "All transactions are already reconciled up to #{cutoff_date} for #{account['name']} (#{account['accountNumber']})."
+                end
+                return
+              end
+              
+              # Display what will be reconciled
+              if options[:json]
+                transactions_data = transactions_to_reconcile.map do |t|
+                  {
+                    'id' => t["id"],
+                    'date' => t["postedAt"] || t["createdAt"],
+                    'description' => t["bankDescription"] || t["externalMemo"] || "Unknown transaction",
+                    'amount' => t["amount"]
+                  }
+                end
+                
+                puts JSON.pretty_generate({
+                  'account_id' => account_id,
+                  'account_name' => account['name'],
+                  'cutoff_date' => cutoff_date.to_s,
+                  'transactions_to_reconcile' => transactions_data,
+                  'dry_run' => options[:dry_run]
+                })
+              else
+                puts "Reconciliation for #{account['name']} (#{account['accountNumber']})"
+                puts "Transactions to reconcile up to #{cutoff_date}:"
+                puts
+                
+                total_amount = 0
+                
+                rows = transactions_to_reconcile.map do |t|
+                  date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
+                  description = t["bankDescription"] || t["externalMemo"] || "Unknown transaction"
+                  description = description.length > 30 ? "#{description[0..27]}..." : description
+                  amount = t["amount"]
+                  total_amount += amount
+                  
+                  [t["id"], date, description, format("$%.2f", amount)]
+                end
+                
+                table = ::Terminal::Table.new(
+                  headings: ['Transaction ID', 'Date', 'Description', 'Amount'],
+                  rows: rows
+                )
+                
+                puts table
+                puts
+                puts "Total transactions: #{transactions_to_reconcile.size}"
+                puts "Total amount: #{format("$%.2f", total_amount)}"
+                puts
+                puts "This is a #{options[:dry_run] ? 'DRY RUN' : 'LIVE RUN'}"
+              end
+              
+              # Mark transactions as reconciled if not a dry run
+              unless options[:dry_run]
+                reconciled_count = 0
+                
+                transactions_to_reconcile.each do |t|
+                  result = reconciliation.mark_reconciled(account_id, t["id"])
+                  reconciled_count += 1 if result
+                end
+                
+                if options[:json]
+                  puts JSON.pretty_generate({
+                    'account_id' => account_id,
+                    'account_name' => account['name'],
+                    'transactions_reconciled' => reconciled_count,
+                    'message' => "Successfully reconciled #{reconciled_count} transactions."
+                  })
+                else
+                  puts "Successfully reconciled #{reconciled_count} transactions."
+                end
+              else
+                if !options[:json]
+                  puts "Dry run completed. No transactions were reconciled."
+                  puts "Run without --dry-run to reconcile these transactions."
+                end
+              end
+            end
+          end
+          
+          desc 'export_reconciled ACCOUNT_ID_OR_NUMBER', 'Export reconciled transactions to a ledger file'
+          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+          method_option :end, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
+          method_option :format, type: :string, default: 'ledger', enum: ['ledger', 'beancount', 'hledger', 'csv'], desc: 'Export format'
+          method_option :output, type: :string, desc: 'Output file path (defaults to reconciled_transactions.<format>)'
+          method_option :all, type: :boolean, default: false, desc: 'Export all transactions with reconciliation status'
+          def export_reconciled(account_identifier)
+            with_api_client do |client|
+              # Determine if we're dealing with an account ID or account number
+              account_id = nil
+              if account_identifier.match?(/^\d+$/) && !account_identifier.include?('-')
+                begin
+                  account = client.find_account_by_number(account_identifier)
+                  account_id = account["id"]
+                rescue => e
+                  # If not found by number, assume it's an ID
+                  account_id = account_identifier
+                  account = client.get_account(account_id)
+                end
+              else
+                account_id = account_identifier
+                account = client.get_account(account_id)
+              end
+              
+              # Get transactions for the account
+              start_date = options[:start]
+              end_date = options[:end]
+              format = options[:format]
+              export_all = options[:all]
+              
+              transactions = client.get_transactions(account_id, start_date)
+              
+              # Filter by end date if specified
+              if end_date
+                end_date_obj = Date.parse(end_date)
+                transactions = transactions.select do |t|
+                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                  transaction_date <= end_date_obj
+                end
+              end
+              
+              # Get reconciled transactions
+              reconciliation = MercuryBanking::Reconciliation.new
+              reconciled_ids = reconciliation.get_reconciled_transactions(account_id)
+              
+              # Filter transactions if not exporting all
+              unless export_all
+                transactions = transactions.select { |t| reconciled_ids.include?(t["id"]) }
+              end
+              
+              if transactions.empty?
+                puts "No #{export_all ? '' : 'reconciled '}transactions found to export."
+                return
+              end
+              
+              # Determine output file path
+              output_file = options[:output] || "reconciled_transactions.#{format}"
+              
+              # Export transactions in the specified format
+              case format
+              when 'ledger'
+                export_to_ledger(transactions, output_file, reconciled_ids, false)
+              when 'beancount'
+                export_to_beancount(transactions, output_file, reconciled_ids, false)
+              when 'hledger'
+                export_to_hledger(transactions, output_file, reconciled_ids)
+              when 'csv'
+                export_to_csv(transactions, output_file, reconciled_ids)
+              end
+              
+              puts "Exported #{transactions.count} transaction(s) to #{output_file} in #{format} format."
+            end
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/mercury_banking/cli/reports.rb

@@ -0,0 +1,265 @@
+module MercuryBanking
+  module CLI
+    # Module for report-related commands
+    module Reports
+      # Add report-related commands to the CLI class
+      def self.included(base)
+        base.class_eval do
+          # Methods that should not be exposed as commands
+          no_commands do
+            # The balance_sheet method has been moved to the Financials module
+          end
+          
+          desc 'statement ACCOUNT_NAME', 'Generate a statement for a specific account and period'
+          method_option :start, type: :string, default: '2020-01-01', desc: 'Start date for statement (YYYY-MM-DD)'
+          method_option :end, type: :string, desc: 'End date for statement (YYYY-MM-DD)'
+          method_option :format, type: :string, default: 'text', enum: ['text', 'json', 'csv'], desc: 'Output format'
+          method_option :save, type: :string, desc: 'Save statement to specified file'
+          method_option :debug, type: :boolean, default: false, desc: 'Show debug information about balance calculation'
+          def statement(account_name)
+            with_api_client do |client|
+              start_date = options[:start]
+              end_date = options[:end]
+              format = options[:format]
+              debug = options[:debug]
+              
+              # Find the account by name
+              accounts = client.accounts
+              account = accounts.find { |a| a["name"] == account_name }
+              
+              unless account
+                puts "Error: Account '#{account_name}' not found. Available accounts:"
+                accounts.each { |a| puts "- #{a['name']}" }
+                return
+              end
+              
+              # Get transactions for the account
+              transactions = client.get_transactions(account["id"], start_date)
+              
+              # Filter by end date if specified
+              if end_date
+                end_date_obj = Date.parse(end_date)
+                transactions = transactions.select do |t|
+                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                  transaction_date <= end_date_obj
+                end
+              end
+              
+              if transactions.empty?
+                puts "No transactions found for the specified period."
+                return
+              end
+              
+              # Sort transactions by date
+              transactions = transactions.sort_by do |t|
+                date = t["postedAt"] || t["createdAt"]
+                Time.parse(date)
+              end
+              
+              # Calculate opening and closing balances
+              current_balance = account["currentBalance"]
+              closing_balance = current_balance
+              
+              if debug
+                puts "Debug: Current balance from Mercury API: $#{format("%.2f", current_balance)}"
+              end
+              
+              # Subtract all transactions that occurred after the end date
+              if end_date
+                end_date_obj = Date.parse(end_date)
+                after_end_date_transactions = transactions.select do |t|
+                  transaction_date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                  transaction_date > end_date_obj
+                end
+                
+                if debug && after_end_date_transactions.any?
+                  puts "Debug: Transactions after end date (#{end_date}):"
+                  after_end_date_transactions.each do |t|
+                    date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
+                    puts "  #{date}: $#{format("%.2f", t["amount"])}"
+                  end
+                end
+                
+                after_end_date_sum = after_end_date_transactions.sum { |t| t["amount"] }
+                closing_balance = current_balance - after_end_date_sum
+                
+                if debug
+                  puts "Debug: Sum of transactions after end date: $#{format("%.2f", after_end_date_sum)}"
+                  puts "Debug: Closing balance at end date: $#{format("%.2f", closing_balance)}"
+                end
+              else
+                if debug
+                  puts "Debug: No end date specified, closing balance equals current balance"
+                end
+              end
+              
+              # Calculate opening balance by subtracting all transactions in the period
+              opening_balance = closing_balance
+              
+              if debug
+                puts "Debug: Transactions in the statement period:"
+              end
+              
+              transactions_sum = 0
+              transactions.each do |t|
+                amount = t["amount"]
+                transactions_sum += amount
+                
+                if debug
+                  date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
+                  puts "  #{date}: $#{format("%.2f", amount)}"
+                end
+                
+                opening_balance -= amount
+              end
+              
+              if debug
+                puts "Debug: Sum of transactions in period: $#{format("%.2f", transactions_sum)}"
+                puts "Debug: Opening balance calculation: $#{format("%.2f", closing_balance)} - $#{format("%.2f", transactions_sum)} = $#{format("%.2f", opening_balance)}"
+              end
+              
+              # Generate statement based on format
+              case format
+              when 'text'
+                generate_text_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, options[:save], debug)
+              when 'json'
+                generate_json_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, options[:save])
+              when 'csv'
+                generate_csv_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, options[:save])
+              end
+            end
+          end
+          
+          private
+          
+          def generate_text_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, save_path, debug = false)
+            # Create statement header
+            statement = []
+            statement << "Mercury Banking Statement"
+            statement << "Account: #{account['name']} (#{account['accountNumber']})"
+            statement << "Period: #{start_date} to #{end_date || 'present'}"
+            statement << "Generated on: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+            statement << ""
+            statement << "Opening Balance: $#{format("%.2f", opening_balance)}"
+            statement << ""
+            statement << "Transactions:"
+            statement << "-" * 80
+            statement << "Date".ljust(12) + "Description".ljust(40) + "Amount".ljust(15) + "Balance"
+            statement << "-" * 80
+            
+            # Add transactions
+            running_balance = opening_balance
+            transactions.each do |t|
+              date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
+              description = t["bankDescription"] || t["externalMemo"] || "Unknown transaction"
+              description = description.length > 37 ? "#{description[0..34]}..." : description
+              amount = t["amount"]
+              running_balance += amount
+              
+              statement << date.ljust(12) + description.ljust(40) + format("$%.2f", amount).rjust(15) + format("$%.2f", running_balance).rjust(15)
+            end
+            
+            statement << "-" * 80
+            statement << "Closing Balance: $#{format("%.2f", closing_balance)}"
+            
+            if debug
+              statement << ""
+              statement << "Debug Information:"
+              statement << "- Opening balance is calculated by taking the closing balance and subtracting all transactions in the period"
+              statement << "- Closing balance is the current balance adjusted for any transactions after the end date"
+              statement << "- Running balance starts with the opening balance and adds each transaction amount"
+            end
+            
+            # Output or save
+            if save_path
+              File.write(save_path, statement.join("\n"))
+              puts "Statement saved to #{save_path}"
+            else
+              puts statement.join("\n")
+            end
+          end
+          
+          def generate_json_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, save_path)
+            # Format transactions
+            formatted_transactions = transactions.map do |t|
+              {
+                date: t["postedAt"] || t["createdAt"],
+                description: t["bankDescription"] || t["externalMemo"] || "Unknown transaction",
+                amount: t["amount"],
+                status: t["status"]
+              }
+            end
+            
+            # Create statement object
+            statement = {
+              account: {
+                name: account['name'],
+                number: account['accountNumber'],
+                type: account['kind']
+              },
+              period: {
+                start_date: start_date,
+                end_date: end_date
+              },
+              balances: {
+                opening: opening_balance,
+                closing: closing_balance
+              },
+              transactions: formatted_transactions,
+              generated_at: Time.now.iso8601
+            }
+            
+            # Output or save
+            json_output = JSON.pretty_generate(statement)
+            
+            if save_path
+              File.write(save_path, json_output)
+              puts "Statement saved to #{save_path}"
+            else
+              puts json_output
+            end
+          end
+          
+          def generate_csv_statement(account, transactions, opening_balance, closing_balance, start_date, end_date, save_path)
+            require 'csv'
+            
+            # Prepare CSV data
+            csv_data = []
+            
+            # Add header row
+            csv_data << ["Date", "Description", "Amount", "Balance", "Status"]
+            
+            # Add opening balance row
+            csv_data << [start_date, "Opening Balance", "", opening_balance, ""]
+            
+            # Add transactions
+            running_balance = opening_balance
+            transactions.each do |t|
+              date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : Time.parse(t["createdAt"]).strftime("%Y-%m-%d")
+              description = t["bankDescription"] || t["externalMemo"] || "Unknown transaction"
+              amount = t["amount"]
+              running_balance += amount
+              
+              csv_data << [date, description, amount, running_balance, t["status"]]
+            end
+            
+            # Add closing balance row
+            csv_data << [end_date || Time.now.strftime("%Y-%m-%d"), "Closing Balance", "", closing_balance, ""]
+            
+            # Output or save
+            csv_output = CSV.generate do |csv|
+              csv_data.each { |row| csv << row }
+            end
+            
+            if save_path
+              File.write(save_path, csv_output)
+              puts "Statement saved to #{save_path}"
+            else
+              puts csv_output
+            end
+          end
+        end
+      end
+    end
+  end
+end