syrup 0.0.3 → 0.0.4

data/lib/syrup/institutions/institution_base.rb

@@ -1,149 +1,149 @@
-module Syrup
-  module Institutions
-    class InstitutionBase
-      
-      class << self
-        # This method is called whenever a class inherits from this class. We keep track of
-        # all of them because they should all be institutions. This way we can provide a
-        # list of supported institutions via code.
-        def inherited(subclass)
-          @subclasses ||= []
-          @subclasses << subclass
-        end
-        
-        # Returns an array of all classes that inherit from this class. Or, in other words,
-        # an array of all supported institutions
-        def subclasses
-          @subclasses
-        end
-      end
-      
-      ##
-      # :attr_writer: populated
-      
-      ##
-      # :attr_reader: populated?
-      
-      ##
-      # :attr_reader: agent
-      # Gets an instance of Mechanize for use by any subclasses.
-      
-      ##
-      # :attr_reader: accounts
-      # Returns an array of all of the user's accounts at this institution.
-      # If accounts hasn't been populated, it populates accounts and then returns them.
-      
-      #
-      attr_accessor :username, :password, :secret_questions
-      
-      def initialize
-        @accounts = []
-      end
-      
-      # This method allows you to setup an institution with block syntax
-      #
-      #   InstitutionBase.setup do |config|
-      #     config.username = 'my_user"
-      #     ...
-      #   end
-      def setup
-        yield self
-        self
-      end
-      
-      def populated?
-        @populated
-      end
-      
-      def populated=(value)
-        @populated = value
-      end
-      
-      def accounts
-        populate_accounts
-        @accounts
-      end
+module Syrup
+  module Institutions
+    class InstitutionBase
+      
+      class << self
+        # This method is called whenever a class inherits from this class. We keep track of
+        # all of them because they should all be institutions. This way we can provide a
+        # list of supported institutions via code.
+        def inherited(subclass)
+          @subclasses ||= []
+          @subclasses << subclass
+        end
+        
+        # Returns an array of all classes that inherit from this class. Or, in other words,
+        # an array of all supported institutions
+        def subclasses
+          @subclasses
+        end
+      end
+      
+      ##
+      # :attr_writer: populated
+      
+      ##
+      # :attr_reader: populated?
+      
+      ##
+      # :attr_reader: agent
+      # Gets an instance of Mechanize for use by any subclasses.
+      
+      ##
+      # :attr_reader: accounts
+      # Returns an array of all of the user's accounts at this institution.
+      # If accounts hasn't been populated, it populates accounts and then returns them.
+      
+      #
+      attr_accessor :username, :password, :secret_questions
+      
+      def initialize
+        @accounts = []
+      end
+      
+      # This method allows you to setup an institution with block syntax
+      #
+      #   InstitutionBase.setup do |config|
+      #     config.username = 'my_user"
+      #     ...
+      #   end
+      def setup
+        yield self
+        self
+      end
+      
+      def populated?
+        @populated
+      end
+      
+      def populated=(value)
+        @populated = value
+      end
+      
+      def accounts
+        populate_accounts
+        @accounts
+      end
       
       # Returns an account with the specified +account_id+. Always use this method to
       # create a new `Account` object. If you do, it will get populated correctly whenever
-      # the population occurs.
-      def find_account_by_id(account_id)
-        account = @accounts.find { |a| a.id == account_id }
-        unless account || populated?
-          account = Account.new(:id => account_id)
-          @accounts << account
-        end
-        account
-      end
+      # the population occurs.
+      def find_account_by_id(account_id)
+        account = @accounts.find { |a| a.id == account_id }
+        unless account || populated?
+          account = Account.new(:id => account_id, :institution => self)
+          @accounts << account
+        end
+        account
+      end
       
       # Populates an account given an `account_id`. The implementing institution may populate
       # all accounts when this is called if there isn't a way to only request one account's
-      # information.
-      def populate_account(account_id)
-        unless populated?
-          result = fetch_account(account_id)
-          return nil if result.nil?
-          
-          if result.respond_to?(:each)
-            populate_accounts(result)
-            find_account_by_id(account_id)
-          else
-            result.populated = true
-            account = find_account_by_id(account_id)
-            account.merge! result if account
-          end
-        end
-      end
-      
-      # Populates all of the user's accounts at this institution.
-      def populate_accounts(populated_accounts = nil)
-        unless populated?
-          all_accounts = populated_accounts || fetch_accounts
-          
-          # Remove any accounts that were added, that don't actually exist
-          @accounts.keep_if do |a|
-            if all_accounts.include?(a)
-              true
-            else
-              a.valid = false
-              false
-            end
-          end
-          
-          # Add any additional account information
-          new_accounts = []
-          all_accounts.each do |filled_account|
-            account = @accounts.find { |a| a.id == filled_account.id }
-            
-            filled_account.populated = true
-            
-            # If we already had an account with this id, fill it with data
-            if account
-              account.merge! filled_account
-            else
-              new_accounts << filled_account
-            end
-          end
-          @accounts |= new_accounts # Uses set union
-          
-          self.populated = true
-        end
-      end
-      
-      protected
-      
-      def agent
-        @agent ||= Mechanize.new
-      end
-      
-      # This is just a helper method that simplifies the common process of extracting a number
-      # from a string representing a currency.
-      # 
-      #   parse_currency('$ 1,234.56') #=> 1234.56
-      def parse_currency(currency)
-        currency.scan(/[0-9.]/).join.to_f
-      end
-      
-    end
-  end
+      # information.
+      def populate_account(account_id)
+        unless populated?
+          result = fetch_account(account_id)
+          return nil if result.nil?
+          
+          if result.respond_to?(:each)
+            populate_accounts(result)
+            find_account_by_id(account_id)
+          else
+            result.populated = true
+            account = find_account_by_id(account_id)
+            account.merge! result if account
+          end
+        end
+      end
+      
+      # Populates all of the user's accounts at this institution.
+      def populate_accounts(populated_accounts = nil)
+        unless populated?
+          all_accounts = populated_accounts || fetch_accounts
+          
+          # Remove any accounts that were added, that don't actually exist
+          @accounts.keep_if do |a|
+            if all_accounts.include?(a)
+              true
+            else
+              a.valid = false
+              false
+            end
+          end
+          
+          # Add any additional account information
+          new_accounts = []
+          all_accounts.each do |filled_account|
+            account = @accounts.find { |a| a.id == filled_account.id }
+            
+            filled_account.populated = true
+            
+            # If we already had an account with this id, fill it with data
+            if account
+              account.merge! filled_account
+            else
+              new_accounts << filled_account
+            end
+          end
+          @accounts |= new_accounts # Uses set union
+          
+          self.populated = true
+        end
+      end
+      
+      protected
+      
+      def agent
+        @agent ||= Mechanize.new
+      end
+      
+      # This is just a helper method that simplifies the common process of extracting a number
+      # from a string representing a currency.
+      # 
+      #   parse_currency('$ 1,234.56') #=> 1234.56
+      def parse_currency(currency)
+        currency.scan(/[0-9.]/).join.to_f
+      end
+      
+    end
+  end
 end

data/lib/syrup/institutions/uccu.rb

@@ -0,0 +1,135 @@
+require 'date'
+
+module Syrup
+  module Institutions
+    class Uccu < InstitutionBase
+      
+      class << self
+        def name
+          "UCCU"
+        end
+        
+        def id
+          "uccu"
+        end
+      end
+      
+      def fetch_account(account_id)
+        fetch_accounts
+      end
+      
+      def fetch_accounts
+        ensure_authenticated
+
+        # List accounts
+        page = agent.post('https://pb.uccu.com/UCCU/Ajax/RpcHandler.ashx',
+                          '{"id":0,"method":"accounts.getBalances","params":[false]}',
+                          'X-JSON-RPC' => 'accounts.getBalances')
+        
+        json = MultiJson.decode(page.body)
+
+        accounts = []
+        json['result'].each do |account|
+          next if account['accountIndex'] == -1
+          
+          new_account = Account.new(:id => account['accountIndex'], :institution => self)
+          new_account.name = account['displayName'][/^[^(]*/, 0].strip
+          new_account.account_number = account['displayName'][/\(([*0-9-]+)\)/, 1]
+          new_account.current_balance = account['current'].to_f
+          new_account.available_balance = account['available'].to_f
+          # new_account.type = :deposit # :credit
+          
+          accounts << new_account
+        end
+
+        accounts
+      end
+      
+      def fetch_transactions(account_id, starting_at, ending_at)
+        ensure_authenticated
+        
+        transactions = []
+        
+        page = agent.get("https://pb.uccu.com/UCCU/Accounts/Activity.aspx?index=#{account_id}")
+        form = page.form("MAINFORM")
+        form.ddlAccounts = account_id
+        form.ddlType = 0 # 0 = All types of transactions
+        form.field_with(:id => 'txtFromDate_textBox').value = starting_at.month.to_s + starting_at.strftime('/%e/%Y')
+        form.field_with(:id => 'txtToDate_textBox').value = ending_at.month.to_s + ending_at.strftime('/%e/%Y')
+        submit_button = form.button_with(:name => 'btnSubmitHistoryRequest')
+        page = form.submit(submit_button)
+        
+        # Look for the account balance
+        account = find_account_by_id(account_id)
+        page.search('.summaryTable tr').each do |row_element|
+          first_cell_text = ''
+          row_element.children.each do |cell_element|
+            if first_cell_text.empty?
+              first_cell_text = cell_element.content.strip if cell_element.respond_to? :name
+            else
+              case first_cell_text
+              when "Available Balance:"
+                account.available_balance = parse_currency(cell_element.content.strip)
+              when "Current Balance:"
+                account.current_balance = parse_currency(cell_element.content.strip)
+              end
+            end
+          end
+        end
+        
+        # Get all the transactions
+        page.search('#ctlAccountActivityChecking tr').each do |row_element|
+          next if row_element['class'] == 'header'
+          
+          data = row_element.css('td').map {|element| element.content.strip }
+            
+          transaction = Transaction.new
+          transaction.posted_at = Date.strptime(data[0], '%m/%d/%Y')
+          transaction.payee = data[3]
+          transaction.status = :posted # :pending
+          transaction.amount = -parse_currency(data[4]) if data[4].size > 1
+          transaction.amount = parse_currency(data[5]) if data[5].size > 1
+
+          transactions << transaction
+        end
+        
+        transactions
+      end
+      
+      private
+      
+      def ensure_authenticated
+        
+        # Check to see if already authenticated
+        page = agent.get('https://pb.uccu.com/UCCU/Accounts/Activity.aspx')
+        if page.body.include?("Please enter your User ID and Password below.") || page.body.include?("Your Online Banking session has expired.")
+          
+          raise InformationMissingError, "Please supply a username" unless self.username
+          raise InformationMissingError, "Please supply a password" unless self.password
+          
+          @agent = Mechanize.new
+          
+          # Enter the username
+          page = agent.get('https://pb.uccu.com/UCCU/Login.aspx')
+          form = page.form('MAINFORM')
+          form.field_with(:id => 'ctlSignon_txtUserID').value = username
+          form.field_with(:id => 'ctlSignon_txtPassword').value = password
+          form.field_with(:id => 'ctlSignon_ddlSignonDestination').value = 'Accounts.Overview'
+          form.TestJavaScript = 'OK'
+          login_button = form.button_with(:name => 'ctlSignon:btnLogin')
+          page = form.submit(login_button)
+          
+          # If the supplied username/password is incorrect, raise an exception
+          raise InformationMissingError, "Invalid username or password" if page.body.include?("Login not accepted.") || page.body.include?("Please enter a valid signon ID.") || page.body.include?("Please enter a valid Password.")
+
+          # Secret questions???
+          
+          raise "Unknown URL reached. Try logging in manually through a browser." if page.uri.to_s != "https://pb.uccu.com/UCCU/Accounts/Overview.aspx"
+        end
+        
+        true
+      end
+      
+    end
+  end
+end