mercury_banking 0.5.34

data/lib/mercury_banking/formatters/export_formatter.rb

@@ -0,0 +1,306 @@
+module MercuryBanking
+  module Formatters
+    # Formatter for exporting transactions to different formats
+    module ExportFormatter
+      # Export transactions to ledger format
+      def export_to_ledger(transactions, output_file, reconciled_transactions = [], verbose = false)
+        File.open(output_file, 'w') do |file|
+          file.puts "; Mercury Bank Transactions Export"
+          file.puts "; Generated on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+          file.puts
+          
+          # Add account declarations to ensure ledger recognizes them
+          accounts = transactions.map { |t| t["accountName"] || "Mercury Account" }.uniq
+          accounts.each do |account|
+            file.puts "account Assets:#{account}"
+          end
+          file.puts "account Expenses:Unknown"
+          file.puts "account Income:Unknown"
+          file.puts
+          
+          # Debug: Show what accounts are being created
+          if verbose
+            puts "Creating ledger file with the following accounts:"
+            accounts.each do |account|
+              puts "- Assets:#{account}"
+            end
+          end
+          
+          # Filter out failed transactions
+          valid_transactions = transactions.reject { |t| t["status"] == "failed" }
+          
+          # Sort transactions chronologically by timestamp
+          sorted_transactions = sort_transactions_chronologically(valid_transactions)
+          
+          sorted_transactions.each do |t|
+            # Get the full timestamp for precise ordering
+            timestamp = t["postedAt"] || t["createdAt"]
+            date = Time.parse(timestamp).strftime("%Y/%m/%d")
+            time = Time.parse(timestamp).strftime("%H:%M:%S")
+            description = t["bankDescription"] || t["externalMemo"] || "Unknown transaction"
+            amount = t["amount"].to_f
+            account_name = t["accountName"] || "Mercury Account"
+            transaction_id = t["id"]
+            
+            # Check if this transaction is reconciled
+            is_reconciled = reconciled_transactions.include?(transaction_id)
+            
+            # Sanitize description for ledger format - replace newlines with spaces and escape semicolons
+            description = description.gsub(/[\r\n]+/, ' ').gsub(/;/, '\\;')
+            
+            # Ensure the description doesn't start with characters that could be interpreted as a date
+            # or other ledger syntax elements
+            if description =~ /^\d/ || description =~ /^[v#]/ || description =~ /^\s*\d{4}/ || description =~ /^\s*\d{2}\/\d{2}/
+              description = "- #{description}"
+            end
+            
+            # Format the transaction with proper indentation and alignment
+            file.puts "#{date} #{is_reconciled ? '* ' : ''}#{description}"
+            file.puts "    ; Transaction ID: #{transaction_id}"
+            file.puts "    ; Timestamp: #{timestamp}"
+            file.puts "    ; Time: #{time}"
+            file.puts "    ; Status: #{t["status"]}"
+            
+            # Add reconciliation metadata
+            if is_reconciled
+              file.puts "    ; :reconciled: true"
+            end
+            
+            # Add counterparty information if available
+            if t["counterpartyName"]
+              # Sanitize counterparty name
+              counterparty = t["counterpartyName"].gsub(/[\r\n]+/, ' ').gsub(/;/, '\\;')
+              file.puts "    ; Counterparty: #{counterparty}"
+            end
+            
+            # Add additional metadata if available
+            if t["externalMemo"] && t["externalMemo"] != description
+              # Sanitize memo
+              memo = t["externalMemo"].gsub(/[\r\n]+/, ' ').gsub(/;/, '\\;')
+              file.puts "    ; Memo: #{memo}"
+            end
+            
+            # Add the postings
+            if amount > 0
+              # Credit (money coming in)
+              file.puts "    Assets:#{account_name}  $#{format('%.2f', amount)}"
+              file.puts "    Income:Unknown  $#{format('%.2f', -amount)}"
+            else
+              # Debit (money going out)
+              file.puts "    Assets:#{account_name}  $#{format('%.2f', amount)}"
+              file.puts "    Expenses:Unknown  $#{format('%.2f', amount.abs)}"
+            end
+            file.puts
+          end
+        end
+        
+        puts "Verifying ledger file validity..."
+        verify_ledger_file(output_file, verbose)
+      end
+      
+      # Sort transactions chronologically by timestamp
+      def sort_transactions_chronologically(transactions)
+        transactions.sort_by do |t|
+          # Use postedAt if available, otherwise fall back to createdAt
+          timestamp = t["postedAt"] || t["createdAt"]
+          Time.parse(timestamp)
+        end
+      end
+      
+      # Verify that the ledger file is valid
+      def verify_ledger_file(output_file, verbose = false)
+        begin
+          # Debug: Verify the ledger file is valid
+          cmd = "ledger -f #{output_file} balance"
+          output = `#{cmd}`
+          
+          if $?.success?
+            if verbose
+              puts "Ledger verification output: #{output}"
+              
+              # Show all accounts in the ledger file
+              cmd = "ledger -f #{output_file} accounts"
+              output = `#{cmd}`
+              
+              if $?.success?
+                puts "All accounts in the ledger file:"
+                puts output
+              else
+                puts "Warning: Could not list accounts in the ledger file."
+                puts "This may indicate a problem with the file format, but the balance command succeeded."
+              end
+            end
+          else
+            puts "Warning: Ledger verification failed. The file may contain formatting issues."
+            puts "Error output: #{output}"
+            
+            # Try to identify problematic lines
+            cmd = "grep -n '^[0-9]' #{output_file} | head -10"
+            problematic_lines = `#{cmd}`
+            puts "First few transaction lines for inspection:"
+            puts problematic_lines
+          end
+        rescue => e
+          puts "Error during ledger verification: #{e.message}"
+          puts "This doesn't necessarily mean the file is invalid, but there may be issues with the ledger command."
+        end
+      end
+      
+      # Export transactions to beancount format
+      def export_to_beancount(transactions, output_file, reconciled_transactions = [], verbose = false)
+        File.open(output_file, 'w') do |file|
+          file.puts "; Mercury Bank Transactions Export"
+          file.puts "; Generated on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+          file.puts
+          
+          # Filter out failed transactions
+          valid_transactions = transactions.reject { |t| t["status"] == "failed" }
+          
+          # Get unique account names for debug output
+          if verbose
+            accounts = valid_transactions.map { |t| t["accountName"] || "Mercury" }.map { |name| name.gsub(/[^a-zA-Z0-9]/, '-') }.uniq
+            puts "Creating beancount file with the following accounts:"
+            accounts.each do |account|
+              puts "- Assets:#{account}"
+            end
+          end
+          
+          valid_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"].to_f
+            account_name = t["accountName"] || "Mercury"
+            account_name = account_name.gsub(/[^a-zA-Z0-9]/, '-')
+            transaction_id = t["id"]
+            
+            # Check if this transaction is reconciled
+            is_reconciled = reconciled_transactions.include?(transaction_id)
+            flag = is_reconciled ? "*" : "!"
+            
+            # Sanitize description for beancount format
+            description = description.gsub(/[\r\n]+/, ' ').gsub(/"/, '\\"')
+            
+            file.puts "#{date} #{flag} \"#{description}\""
+            file.puts "  ; Transaction ID: #{transaction_id}"
+            file.puts "  ; Status: #{t["status"]}"
+            
+            # Add reconciliation metadata
+            if is_reconciled
+              file.puts "  reconciled: \"true\""
+              file.puts "  reconciled_at: \"#{Time.now.strftime('%Y-%m-%d')}\""
+            else
+              file.puts "  reconciled: \"false\""
+              file.puts "  reconciled_at: \"\""
+            end
+            
+            if amount < 0
+              file.puts "  Expenses:Unknown  #{format("%.2f", amount.abs)} USD"
+              file.puts "  Assets:#{account_name}  #{format("%.2f", amount)} USD"
+            else
+              file.puts "  Assets:#{account_name}  #{format("%.2f", amount)} USD"
+              file.puts "  Income:Unknown  #{format("%.2f", -amount)} USD"
+            end
+            file.puts
+          end
+        end
+      end
+      
+      # Export transactions to hledger format
+      def export_to_hledger(transactions, output_file, reconciled_transactions = [], verbose = false)
+        File.open(output_file, 'w') do |file|
+          file.puts "; Mercury Bank Transactions Export"
+          file.puts "; Generated on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+          file.puts
+          
+          # Filter out failed transactions
+          valid_transactions = transactions.reject { |t| t["status"] == "failed" }
+          
+          # Get unique account names for debug output
+          if verbose
+            accounts = valid_transactions.map { |t| t["accountName"] || "Mercury Account" }.uniq
+            puts "Creating hledger file with the following accounts:"
+            accounts.each do |account|
+              puts "- Assets:#{account}"
+            end
+          end
+          
+          valid_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"].to_f
+            account_name = t["accountName"] || "Mercury Account"
+            transaction_id = t["id"]
+            
+            # Check if this transaction is reconciled
+            is_reconciled = reconciled_transactions.include?(transaction_id)
+            status_marker = is_reconciled ? " * " : " ! "
+            
+            # Sanitize description for hledger format
+            description = description.gsub(/[\r\n]+/, ' ').gsub(/;/, '\\;')
+            
+            file.puts "#{date}#{status_marker}#{description}"
+            file.puts "    ; Transaction ID: #{transaction_id}"
+            file.puts "    ; Status: #{t["status"]}"
+            
+            # Add reconciliation metadata
+            if is_reconciled
+              file.puts "    reconciled: true"
+              file.puts "    reconciled-at: #{Time.now.strftime('%Y-%m-%d')}"
+            else
+              file.puts "    reconciled: false"
+              file.puts "    reconciled-at:"
+            end
+            
+            if amount < 0
+              file.puts "    Expenses:Unknown  $#{format("%.2f", amount.abs)}"
+              file.puts "    Assets:#{account_name}  $#{format("%.2f", amount)}"
+            else
+              file.puts "    Assets:#{account_name}  $#{format("%.2f", amount)}"
+              file.puts "    Income:Unknown  $#{format("%.2f", -amount)}"
+            end
+            file.puts
+          end
+        end
+      end
+      
+      # Export transactions to CSV format
+      def export_to_csv(transactions, output_file, reconciled_transactions = [], verbose = false)
+        require 'csv'
+        
+        CSV.open(output_file, 'w') do |csv|
+          # Write header
+          csv << ['Date', 'Description', 'Amount', 'Account', 'Transaction ID', 'Status', 'Reconciled', 'Reconciled At']
+          
+          # Filter out failed transactions
+          valid_transactions = transactions.reject { |t| t["status"] == "failed" }
+          
+          if verbose
+            puts "Creating CSV file with #{valid_transactions.size} transactions"
+            puts "CSV columns: Date, Description, Amount, Account, Transaction ID, Status, Reconciled, Reconciled At"
+          end
+          
+          # Write transactions
+          valid_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"
+            
+            # Replace newlines with spaces for CSV format
+            description = description.gsub(/[\r\n]+/, ' ')
+            
+            amount = t["amount"].to_f
+            account_name = t["accountName"] || "Mercury Account"
+            transaction_id = t["id"]
+            status = t["status"]
+            
+            # Check if this transaction is reconciled
+            is_reconciled = reconciled_transactions.include?(transaction_id)
+            reconciled = is_reconciled ? "Yes" : "No"
+            reconciled_at = is_reconciled ? Time.now.strftime("%Y-%m-%d") : ""
+            
+            csv << [date, description, amount, account_name, transaction_id, status, reconciled, reconciled_at]
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/mercury_banking/formatters/table_formatter.rb

@@ -0,0 +1,133 @@
+module MercuryBanking
+  module Formatters
+    # Formatter for table output
+    module TableFormatter
+      # Display accounts in a table format
+      def display_accounts_table(accounts)
+        return puts "No accounts found." if accounts.empty?
+        
+        rows = accounts.map do |a|
+          [
+            a["name"],
+            a["accountNumber"],
+            a["kind"].capitalize,
+            format("$%.2f", a["currentBalance"]),
+            format("$%.2f", a["availableBalance"]),
+            a["status"].capitalize
+          ]
+        end
+        
+        table = ::Terminal::Table.new(
+          headings: ['Account Name', 'Account Number', 'Type', 'Current Balance', 'Available Balance', 'Status'],
+          rows: rows
+        )
+        
+        puts table
+      end
+
+      # Display recipients in a table format
+      def display_recipients_table(recipients)
+        return puts "No recipients found." if recipients.empty?
+        
+        rows = recipients.map do |r|
+          account_info = r["electronicRoutingInfo"] || {}
+          address_info = r["address"] || {}
+          
+          [
+            r["id"],
+            r["name"],
+            account_info["routingNumber"] || "N/A",
+            mask_account_number(account_info["accountNumber"]),
+            address_info["city"] || "N/A",
+            r["status"].capitalize
+          ]
+        end
+        
+        table = ::Terminal::Table.new(
+          headings: ['ID', 'Name', 'Routing #', 'Account #', 'City', 'Status'],
+          rows: rows
+        )
+        
+        puts table
+      end
+      
+      # Display transactions in a table format
+      def display_transactions_table(transactions, show_account_name = false)
+        return puts "No transactions found." if transactions.empty?
+        
+        headings = ['Date', 'Amount', 'Type']
+        headings.insert(0, 'Account') if show_account_name
+        headings.concat(['Description', 'Status'])
+        
+        rows = transactions.map do |t|
+          date = t["postedAt"] ? Time.parse(t["postedAt"]).strftime("%Y-%m-%d") : "Pending"
+          amount = format("$%.2f", t["amount"].abs)
+          direction = t["amount"] < 0 ? "DEBIT" : "CREDIT"
+          description = t["bankDescription"] || t["externalMemo"] || "N/A"
+          description = description.length > 50 ? "#{description[0..47]}..." : description
+          status = t["status"].capitalize
+          
+          row = [date, amount, direction, description, status]
+          row.insert(0, t["accountName"]) if show_account_name
+          row
+        end
+        
+        table = ::Terminal::Table.new(
+          headings: headings,
+          rows: rows
+        )
+        
+        puts table
+      end
+      
+      # Display a single transaction's details
+      def display_transaction_details(transaction)
+        return puts "Transaction not found." unless transaction
+        
+        # Format dates
+        created_at = transaction["createdAt"] ? Time.parse(transaction["createdAt"]).strftime("%Y-%m-%d %H:%M:%S") : "N/A"
+        posted_at = transaction["postedAt"] ? Time.parse(transaction["postedAt"]).strftime("%Y-%m-%d %H:%M:%S") : "Pending"
+        estimated_delivery = transaction["estimatedDeliveryDate"] ? Time.parse(transaction["estimatedDeliveryDate"]).strftime("%Y-%m-%d") : "N/A"
+        
+        # Format amount
+        amount = transaction["amount"].to_f
+        amount_str = format("$%.2f", amount.abs)
+        direction = amount < 0 ? "DEBIT" : "CREDIT"
+        
+        # Get counterparty info
+        counterparty = transaction["counterpartyId"] ? "ID: #{transaction["counterpartyId"]}" : "N/A"
+        
+        # Create a table for the transaction details
+        details = [
+          ["Transaction ID", transaction["id"]],
+          ["Amount", "#{amount_str} (#{direction})"],
+          ["Status", transaction["status"].capitalize],
+          ["Created At", created_at],
+          ["Posted At", posted_at],
+          ["Estimated Delivery", estimated_delivery],
+          ["Description", transaction["bankDescription"] || "N/A"],
+          ["Note", transaction["note"] || "N/A"],
+          ["External Memo", transaction["externalMemo"] || "N/A"],
+          ["Counterparty", counterparty]
+        ]
+        
+        table = ::Terminal::Table.new(
+          title: "Transaction Details",
+          rows: details
+        )
+        
+        puts table
+      end
+      
+      private
+      
+      # Mask account number for security
+      def mask_account_number(account_number)
+        return "N/A" unless account_number
+        
+        # Show only the last 4 digits
+        "••••#{account_number[-4..-1]}" if account_number.length >= 4
+      end
+    end
+  end
+end 

data/lib/mercury_banking/multi.rb

@@ -0,0 +1,135 @@
+module MercuryBanking
+  class Multi
+    def initialize(keys = [])
+      @banks = {}
+      @apis  = {}
+      @keys = keys
+      
+      @keys.each do |api_key|
+        next if api_key.empty?
+        mercury = MercuryBanking::API.new(api_key)
+        
+        begin
+          accounts = mercury.accounts
+        rescue StandardError => e
+          puts e
+          next
+        end
+        
+        if accounts.nil?
+          puts "*" * 80
+          puts "* #{api_key} returned no accounts"
+          puts "*" * 80
+          next
+        end
+        
+        checking = find_all_checking_accounts(accounts)
+
+        checking.each do |ac|
+          identifier = ac['name']
+          @banks[identifier] = ac
+        end
+        
+        @identifier = accounts.first["name"]
+        count_checking_accounts(accounts)
+        @apis[@identifier] = mercury
+      end
+    end
+
+    def count_checking_accounts(accounts)
+      checking_count = accounts.count { |a| a["kind"] == "checking" }
+      puts "More than one checking account for #{@identifier}: #{checking_count}" if checking_count > 1
+    end
+
+    def find_all_checking_accounts(accounts)
+      accounts.find_all { |a| a["kind"] == "checking" && a["status"] == "active" }
+    end
+
+    def balances
+      table = Terminal::Table.new rows: @banks.collect { |name, vals|
+        [name, vals["availableBalance"], vals["status"]]
+      }
+      print table.to_s + "\n"
+    end
+
+    def ensure_recipient(from:, to:, email:, address:, city:, region:, postal_code:, country:)
+      raise "Target bank account not found: #{to}" unless @banks[to]
+      mercury_source = @apis[from]
+      target = mercury_source.find_recipient(name: @banks[to]["name"])
+     
+      if target.nil?
+        target = add_target_account_to_recipient_list(mercury_source, to, email, address, city, region, postal_code, country)
+      end
+      target
+    end
+
+    def add_target_account_to_recipient_list(mercury_source, to, email, address, city, region, postal_code, country)
+      puts "Adding recipient: #{@banks[to]["name"]}"
+      rec = MercuryBanking::Recipient.new(
+        name: @banks[to]["name"], 
+        address: address, 
+        email: email, 
+        account_number: @banks[to]["accountNumber"], 
+        routing_number: @banks[to]["routingNumber"],
+        city: city,
+        region: region,
+        postal_code: postal_code,
+        country: country
+      )
+      mercury_source.post(rec.json, "recipients")
+      mercury_source.find_recipient(name: @banks[to]["name"])
+    end
+
+    def ensure_account(account)
+      found = @banks.keys.grep(/#{account}/i)
+      raise "Account: #{account} not found." if found.empty?
+      raise "Account: #{account} matched multiple #{found.join(",")}." if found.size > 1
+      found.first
+    end
+
+    def transfer(from:, to:, amount:, note:, wait: false, email:, address:, city:, region:, postal_code:, country:)
+      puts "#{from} -> #{to} (#{amount})"
+      from_account = ensure_account(from)
+      to_account = ensure_account(to)
+      
+      # Create a recipient with "to" information in "from"'s account:
+      recipient = ensure_recipient(
+        from: from_account, 
+        to: to_account, 
+        email: email, 
+        address: address, 
+        city: city, 
+        region: region, 
+        postal_code: postal_code, 
+        country: country
+      )
+      
+      puts "From account #{@banks[from_account]["id"]} -> Recipient #{recipient["id"]} (account: #{@banks[to_account]["id"]})"
+      transfer = @apis[from_account].transfer(
+        recipient_id: recipient["id"], 
+        amount: amount, 
+        account_id: @banks[from_account]["id"], 
+        note: note, 
+        external: "Ex #{note}"
+      )
+      
+      if wait
+        while transfer["status"] != "sent"
+          puts "Waiting on #{transfer["id"]} (#{transfer["status"]}) to complete."
+          sleep 10
+          transfer = @apis[from_account].transaction(@banks[from_account]["id"], transfer["id"])
+          if transfer["status"] == "failed"
+            puts transfer
+          end
+        end
+      end
+      
+      write_log(from_account, to_account, amount, note, transfer)
+      transfer
+    end
+
+    def write_log(from, to, amount, note, transfer)
+      File.write("log", "\"#{from}\", \"#{to}\", \"#{amount}\", \"#{note}\", \"#{transfer["status"]}\"\n")
+    end
+  end
+end 

data/lib/mercury_banking/recipient.rb

@@ -0,0 +1,29 @@
+module MercuryBanking
+  class Recipient
+    attr_accessor :name
+
+    def initialize(name:, email:, account_number:, routing_number:, address:, city:, region:, postal_code:, country:)
+      @name = name
+      @address = {
+        name: name,
+        address1: address,
+        city: city,
+        region: region,
+        postalCode: postal_code,
+        country: country
+      }
+      @emails = [ email ]
+      @paymentMethod = "electronic"
+      @electronicRoutingInfo = { 
+        accountNumber: account_number, 
+        routingNumber: routing_number, 
+        electronicAccountType: "businessChecking",
+        address: @address 
+      }
+    end
+
+    def json
+      { name: @name, address: @address, emails: @emails, paymentMethod: @paymentMethod, electronicRoutingInfo: @electronicRoutingInfo }
+    end
+  end
+end