mercury_banking 0.5.34

data/lib/mercury_banking/cli/transactions.rb

@@ -0,0 +1,222 @@
+module MercuryBanking
+  module CLI
+    # Module for transaction-related commands
+    module Transactions
+      # Add transaction-related commands to the CLI class
+      def self.included(base)
+        base.class_eval do
+          include MercuryBanking::Formatters::ExportFormatter
+          
+          desc 'transactions_download', 'Download all Mercury transactions as CSV files'
+          method_option :output_dir, type: :string, default: 'transactions', desc: 'Directory to save transaction files'
+          method_option :start_date, type: :string, default: '2020-01-01', desc: 'Start date for transactions (YYYY-MM-DD)'
+          method_option :end_date, type: :string, desc: 'End date for transactions (YYYY-MM-DD)'
+          method_option :format, type: :string, default: 'csv', enum: ['csv', 'beancount', 'ledger', 'all'], desc: 'Output format (csv, beancount, ledger, or all)'
+          method_option :verbose, type: :boolean, default: false, desc: 'Show detailed debug information'
+          def transactions_download
+            with_api_client do |client|
+              # Create output directory if it doesn't exist
+              output_dir = options[:output_dir]
+              FileUtils.mkdir_p(output_dir)
+              
+              # Get all accounts
+              accounts = client.accounts
+              
+              # Get start and end dates
+              start_date = options[:start_date]
+              end_date = options[:end_date]
+              
+              # Get format
+              format = options[:format]
+              
+              # Get verbose option
+              verbose = options[:verbose]
+              
+              # For each account, get transactions and save to file
+              accounts.each do |account|
+                account_id = account["id"]
+                account_name = account["name"]
+                
+                puts "Fetching transactions for #{account_name} (#{account_id})..."
+                
+                # Get all transactions for this 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 #{account_name}."
+                  next
+                end
+                
+                # Group transactions by month
+                transactions_by_month = {}
+                
+                transactions.each do |t|
+                  # Get the month from the transaction date
+                  date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                  month_key = "#{date.year}-#{date.month.to_s.rjust(2, '0')}"
+                  
+                  # Initialize the month array if it doesn't exist
+                  transactions_by_month[month_key] ||= []
+                  
+                  # Add the transaction to the month array
+                  transactions_by_month[month_key] << t
+                end
+                
+                # For each month, save transactions to file
+                transactions_by_month.each do |month, month_transactions|
+                  # Use the full account number for the filename
+                  account_number = account["accountNumber"]
+                  
+                  # Create filenames for different formats
+                  csv_filename = File.join(output_dir, "#{month}-Mercury-#{account_number}.csv")
+                  beancount_filename = File.join(output_dir, "#{month}-Mercury-#{account_number}.beancount")
+                  ledger_filename = File.join(output_dir, "#{month}-Mercury-#{account_number}.ledger")
+                  
+                  # Export transactions in the requested format
+                  case format
+                  when 'csv'
+                    export_to_csv(month_transactions, csv_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{csv_filename}"
+                  when 'beancount'
+                    export_to_beancount(month_transactions, beancount_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{beancount_filename}"
+                  when 'ledger'
+                    export_to_ledger(month_transactions, ledger_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{ledger_filename}"
+                  when 'all'
+                    export_to_csv(month_transactions, csv_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{csv_filename}"
+                    
+                    export_to_beancount(month_transactions, beancount_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{beancount_filename}"
+                    
+                    export_to_ledger(month_transactions, ledger_filename, [], verbose)
+                    puts "Exported #{month_transactions.size} transactions to #{ledger_filename}"
+                  end
+                end
+              end
+              
+              puts "\nTransaction export complete. Files saved to #{output_dir}/ directory."
+            end
+          end
+          
+          desc "transactions ACCOUNT_ID_OR_NUMBER", "List transactions for an account with their status"
+          method_option :limit, type: :numeric, default: 10, desc: "Number of transactions to show"
+          method_option :start, type: :string, desc: "Start date (YYYY-MM-DD)"
+          method_option :end, type: :string, desc: "End date (YYYY-MM-DD)"
+          method_option :status, type: :string, desc: "Filter by status (pending, sent, complete, failed)"
+          method_option :json, type: :boolean, default: false, desc: "Output in JSON format"
+          method_option :csv, type: :string, desc: "Export to CSV file"
+          def transactions(account_id_or_number)
+            with_api_client do |client|
+              # Find the account by ID or account number
+              account = find_account(client, account_id_or_number)
+              
+              if account.nil?
+                puts "Account not found: #{account_id_or_number}"
+                return
+              end
+              
+              account_id = account["id"]
+              
+              # Get transactions with optional date filters
+              start_date = options[:start]
+              end_date = options[:end]
+              
+              puts "Fetching transactions for #{account["name"]}..."
+              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
+              
+              # Filter by status if specified
+              if options[:status]
+                transactions = transactions.select { |t| t["status"] == options[:status] }
+              end
+              
+              # Limit the number of transactions
+              limit = options[:limit]
+              transactions = transactions.take(limit) if limit > 0
+              
+              # Export to CSV if requested
+              if options[:csv]
+                export_to_csv(transactions, options[:csv])
+                puts "Exported #{transactions.size} transactions to #{options[:csv]}"
+                return
+              end
+              
+              # Output in JSON format if requested
+              if options[:json]
+                puts JSON.pretty_generate(transactions)
+                return
+              end
+              
+              # Create a table for display
+              table = Terminal::Table.new
+              table.title = "Transactions for #{account["name"]}"
+              table.headings = ['Date', 'Description', 'Amount', 'Status']
+              
+              transactions.each do |t|
+                date = t["postedAt"] ? Date.parse(t["postedAt"]) : Date.parse(t["createdAt"])
+                description = t["bankDescription"] || t["externalMemo"] || "Unknown"
+                amount = t["amount"]
+                status = t["status"]
+                
+                table.add_row [date, description, "$#{amount}", status]
+              end
+              
+              puts table
+            end
+          end
+          
+          # Helper methods that should not be exposed as commands
+          no_commands do
+            # Helper method to sort transactions chronologically
+            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
+            
+            # Helper method to find an account by ID or account number
+            def find_account(client, account_id_or_number)
+              accounts = client.accounts
+              
+              # Try to find by ID first
+              account = accounts.find { |a| a["id"] == account_id_or_number }
+              
+              # If not found by ID, try by account number
+              if account.nil?
+                account = accounts.find { |a| a["accountNumber"] == account_id_or_number }
+              end
+              
+              # If still not found, try by the last 4 digits of the account number
+              if account.nil?
+                account = accounts.find { |a| a["accountNumber"]&.end_with?(account_id_or_number) }
+              end
+              
+              account
+            end
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/mercury_banking/cli.rb

@@ -0,0 +1,209 @@
+require 'mercury_banking/cli/base'
+require 'mercury_banking/cli/accounts'
+require 'mercury_banking/cli/reports'
+require 'mercury_banking/cli/transactions'
+require 'mercury_banking/cli/financials'
+require 'mercury_banking/formatters/table_formatter'
+require 'mercury_banking/formatters/export_formatter'
+require 'mercury_banking/reports/balance_sheet'
+
+module MercuryBanking
+  # CLI module for Mercury Banking
+  module CLI
+    # Main CLI class that includes all the modules
+    class Main < Thor
+      include MercuryBanking::CLI::Base
+      include MercuryBanking::CLI::Accounts
+      include MercuryBanking::CLI::Reports
+      include MercuryBanking::CLI::Transactions
+      include MercuryBanking::CLI::Financials
+      include MercuryBanking::Formatters::TableFormatter
+      include MercuryBanking::Formatters::ExportFormatter
+      include MercuryBanking::Reports::BalanceSheet
+      
+      # Add global option for JSON output
+      class_option :json, type: :boolean, default: false, desc: 'Output in JSON format'
+      
+      map %w[--version -v] => :version
+      
+      # Add version banner to help output
+      def self.banner(command, _namespace = nil, _subcommand = false)
+        "#{basename} #{command.usage}"
+      end
+      
+      def self.help(shell, _subcommand = false)
+        shell.say "Mercury Banking CLI v#{MercuryBanking::VERSION} - Command-line interface for Mercury Banking API"
+        shell.say
+        super
+      end
+      
+      # Handle Thor deprecation warning
+      def self.exit_on_failure?
+        true
+      end
+      
+      desc 'version', 'Display Mercury Banking CLI version'
+      def version
+        if options[:json]
+          puts JSON.pretty_generate({
+            'name' => 'mercury-banking',
+            'version' => MercuryBanking::VERSION,
+            'ruby_version' => RUBY_VERSION
+          })
+        else
+          puts "Mercury Banking CLI v#{MercuryBanking::VERSION} (Ruby #{RUBY_VERSION})"
+        end
+      end
+      
+      desc 'set_key', 'Sets and encrypts the API key'
+      def set_key
+        # Create the .mercury-banking directory if it doesn't exist
+        config_dir = File.join(Dir.home, '.mercury-banking')
+        FileUtils.mkdir_p(config_dir)
+        
+        # Generate a random key and IV for encryption
+        key = SecureRandom.random_bytes(32)
+        iv = SecureRandom.random_bytes(16)
+        
+        # Create a cipher config
+        cipher_config = {
+          key: Base64.strict_encode64(key),
+          iv: Base64.strict_encode64(iv),
+          cipher_name: 'aes-256-cbc'
+        }
+        
+        # Save the cipher config to a file
+        key_config_path = File.join(config_dir, 'key_config.json')
+        File.write(key_config_path, JSON.pretty_generate(cipher_config))
+        
+        # Initialize the SymmetricEncryption with the generated cipher
+        cipher = SymmetricEncryption::Cipher.new(
+          key: key,
+          iv: iv,
+          cipher_name: 'aes-256-cbc'
+        )
+        
+        # Set the cipher as the primary one
+        SymmetricEncryption.cipher = cipher
+        
+        # Get the API key from the user
+        api_key = ask('Enter your Mercury API key:')
+        
+        # Encrypt the API key
+        encrypted_key = cipher.encrypt(api_key)
+        
+        # Save the encrypted API key to a file
+        api_key_path = File.join(config_dir, 'api_key.enc')
+        File.write(api_key_path, encrypted_key)
+        
+        puts "API key encrypted and saved to #{api_key_path}"
+      end
+      
+      desc 'transactions ACCOUNT_ID_OR_NUMBER', 'List transactions for an account with their status'
+      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 :status, type: :string, desc: 'Filter by transaction status (e.g., sent, failed, pending)'
+      method_option :format, type: :string, default: 'table', enum: ['table', 'json'], desc: 'Output format (table or json)'
+      method_option :search, type: :string, desc: 'Search for transactions by description'
+      def transactions(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
+          
+          # Filter by status if specified
+          if options[:status]
+            transactions = transactions.select { |t| t["status"] == options[:status] }
+          end
+          
+          # Filter by search term if specified
+          if options[:search]
+            search_term = options[:search].downcase
+            transactions = transactions.select do |t|
+              description = t["bankDescription"] || t["externalMemo"] || ""
+              description.downcase.include?(search_term)
+            end
+          end
+          
+          if options[:json] || options[:format] == 'json'
+            # Format transactions for JSON output
+            formatted_transactions = transactions.map do |t|
+              {
+                'id' => t["id"],
+                'date' => t["postedAt"] || t["createdAt"],
+                'description' => t["bankDescription"] || t["externalMemo"] || "Unknown transaction",
+                'amount' => t["amount"],
+                'status' => t["status"],
+                'kind' => t["kind"],
+                'reconciled' => false,
+                'failed_at' => t["failedAt"],
+                'reason_for_failure' => t["reasonForFailure"]
+              }
+            end
+            
+            puts JSON.pretty_generate({
+              'account_id' => account_id,
+              'account_name' => account['name'],
+              'account_number' => account['accountNumber'],
+              'total_transactions' => transactions.size,
+              'transactions' => formatted_transactions
+            })
+          else
+            # Display transactions in a table
+            puts "Transactions for #{account['name']} (#{account['accountNumber']})"
+            puts "Period: #{start_date} to #{end_date || 'present'}"
+            puts "Total transactions: #{transactions.size}"
+            puts
+            
+            rows = transactions.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 = format("$%.2f", t["amount"])
+              status = t["status"]
+              kind = t["kind"]
+              reconciled = false
+              failure_reason = t["reasonForFailure"] || ""
+              
+              [t["id"], date, description, amount, status, kind, reconciled, failure_reason]
+            end
+            
+            table = ::Terminal::Table.new(
+              headings: ['Transaction ID', 'Date', 'Description', 'Amount', 'Status', 'Type', 'Reconciled', 'Failure Reason'],
+              rows: rows
+            )
+            
+            puts table
+          end
+        end
+      end
+    end
+  end
+end