jacques / ofxparser

lib/OfxParser/Ofx.php

<?php declare(strict_types=1);

namespace OfxParser;

use SimpleXMLElement;
use OfxParser\Utils;
use OfxParser\Entities\AccountInfo;
use OfxParser\Entities\BankAccount;
use OfxParser\Entities\Institute;
use OfxParser\Entities\SignOn;
use OfxParser\Entities\Statement;
use OfxParser\Entities\Status;
use OfxParser\Entities\Transaction;

/**
 * The OFX object
 *
 * Heavily refactored from Guillaume Bailleul's grimfor/ofxparser
 *
 * Second refactor by Oliver Lowe to unify the API across all
 * OFX data-types.
 *
 * Based on Andrew A Smith's Ruby ofx-parser
 *
 * @author Guillaume BAILLEUL <contact@guillaume-bailleul.fr>
 * @author James Titcumb <hello@jamestitcumb.com>
 * @author Oliver Lowe <mrtriangle@gmail.com>
 */
class Ofx
{
    /**
     * @var Header[]
     */
    public $header = [];

    /**
     * @var SignOn
     */
    public $signOn;

    /**
     * @var AccountInfo[]
     */
    public $signupAccountInfo;

    /**
     * @var BankAccount[]
     */
    public $bankAccounts = [];

    /**
     * Only populated if there is only one bank account
     * @var BankAccount|null
     * @deprecated This will be removed in future versions
     */
    public $bankAccount;

    /**
     * @param SimpleXMLElement $xml
     * @throws \Exception
     */
    public function __construct(SimpleXMLElement $xml)
    {
        $this->signOn = $this->buildSignOn($xml->SIGNONMSGSRSV1->SONRS);
        $this->signupAccountInfo = $this->buildAccountInfo($xml->SIGNUPMSGSRSV1->ACCTINFOTRNRS);

        if (property_exists($xml, 'BANKMSGSRSV1') && $xml->BANKMSGSRSV1 !== null) {
            $this->bankAccounts = $this->buildBankAccounts($xml);
        } elseif (property_exists($xml, 'CREDITCARDMSGSRSV1') && $xml->CREDITCARDMSGSRSV1 !== null) {
            $this->bankAccounts = $this->buildCreditAccounts($xml);
        }

        // Set a helper if only one bank account
        if (count($this->bankAccounts) === 1) {
            $this->bankAccount = $this->bankAccounts[0];

The property OfxParser\Ofx::$bankAccount has been deprecated: This will be removed in future versions

        }
    }

    /**
     * Get the transactions that have been processed
     *
     * @return \OfxParser\Entities\Transaction[]
     * @deprecated This will be removed in future versions
     */
    public function getTransactions(): array
    {
        return $this->bankAccount->statement->transactions;

The property OfxParser\Ofx::$bankAccount has been deprecated: This will be removed in future versions

    }

    /**
     * @param array $header
     * @return Ofx
     */
    public function buildHeader(array $header): self
    {
        $this->header = $header;

        return $this;
    }

    /**
     * @param SimpleXMLElement $xml
     * @return \OfxParser\Entities\SignOn
     * @throws \Exception
     */
    protected function buildSignOn(SimpleXMLElement $xml): \OfxParser\Entities\SignOn
    {
        $signOn = new SignOn();
        $signOn->status = $this->buildStatus($xml->STATUS);
        $signOn->date = Utils::createDateTimeFromStr($xml->DTSERVER, true);
        $signOn->language = $xml->LANGUAGE;

        $signOn->institute = new Institute();
        $signOn->institute->name = $xml->FI->ORG;
        $signOn->institute->id = $xml->FI->FID;

        return $signOn;
    }

    /**
     * @param SimpleXMLElement|null $xml
     * @return array AccountInfo
     */
    private function buildAccountInfo(SimpleXMLElement $xml = null): array
    {
        if (null === $xml) {
            return [];
        }

        if (!(property_exists($xml, 'ACCTINFO') && $xml->ACCTINFO !== null)) {
            return [];
        }

        $accounts = [];
        foreach ($xml->ACCTINFO as $account) {
            $accountInfo = new AccountInfo();
            $accountInfo->desc = $account->DESC;
            $accountInfo->number = $account->ACCTID;
            $accounts[] = $accountInfo;
        }

        return $accounts;
    }

    /**
     * @param SimpleXMLElement $xml
     * @throws \Exception
     * @return \OfxParser\Entities\BankAccount[]
     */
    private function buildCreditAccounts(SimpleXMLElement $xml): array
    {
        // Loop through the bank accounts
        $bankAccounts = [];

        foreach ($xml->CREDITCARDMSGSRSV1->CCSTMTTRNRS as $accountStatement) {
            $bankAccounts[] = $this->buildCreditAccount($accountStatement);

It seems like $accountStatement can also be of type null; however, parameter $xml of OfxParser\Ofx::buildCreditAccount() does only seem to accept SimpleXMLElement, maybe add an additional type check?

        }
        return $bankAccounts;
    }

    /**
     * @param SimpleXMLElement $xml
     * @throws \Exception
     * @return \OfxParser\Entities\BankAccount[]
     */
    private function buildBankAccounts(SimpleXMLElement $xml): array
    {
        // Loop through the bank accounts
        $bankAccounts = [];
        foreach ($xml->BANKMSGSRSV1->STMTTRNRS as $accountStatement) {
            foreach ($accountStatement->STMTRS as $statementResponse) {
                $bankAccounts[] = $this->buildBankAccount($accountStatement->TRNUID, $statementResponse);

It seems like $statementResponse can also be of type null; however, parameter $statementResponse of OfxParser\Ofx::buildBankAccount() does only seem to accept SimpleXMLElement, maybe add an additional type check?

            }
        }
        return $bankAccounts;
    }

    /**
     * @param string $transactionUid
     * @param SimpleXMLElement $statementResponse
     * @throws \Exception
     * @return \OfxParser\Entities\BankAccount
     */
    private function buildBankAccount(?\SimpleXMLElement $transactionUid, SimpleXMLElement $statementResponse): \OfxParser\Entities\BankAccount
    {
        $bankAccount = new BankAccount();
        $bankAccount->transactionUid = $transactionUid;
        $bankAccount->agencyNumber = $statementResponse->BANKACCTFROM->BRANCHID;
        $bankAccount->accountNumber = $statementResponse->BANKACCTFROM->ACCTID;
        $bankAccount->routingNumber = $statementResponse->BANKACCTFROM->BANKID;
        $bankAccount->accountType = $statementResponse->BANKACCTFROM->ACCTTYPE;
        $bankAccount->balance = $statementResponse->LEDGERBAL->BALAMT;
        $bankAccount->balanceDate = Utils::createDateTimeFromStr(
            $statementResponse->LEDGERBAL->DTASOF,
            true
        );

        $bankAccount->statement = new Statement();
        $bankAccount->statement->currency = $statementResponse->CURDEF;

        $bankAccount->statement->startDate = Utils::createDateTimeFromStr(
            $statementResponse->BANKTRANLIST->DTSTART
        );

        $bankAccount->statement->endDate = Utils::createDateTimeFromStr(
            $statementResponse->BANKTRANLIST->DTEND
        );

        $bankAccount->statement->transactions = $this->buildTransactions(
            $statementResponse->BANKTRANLIST->STMTTRN
        );

        return $bankAccount;
    }

    /**
     * @param SimpleXMLElement $xml
     * @throws \Exception
     * @return \OfxParser\Entities\BankAccount
     */
    private function buildCreditAccount(SimpleXMLElement $xml): \OfxParser\Entities\BankAccount
    {
        $nodeName = 'CCACCTFROM';
        if (!isset($xml->CCSTMTRS->$nodeName)) {
            $nodeName = 'BANKACCTFROM';
        }

        $creditAccount = new BankAccount();
        $creditAccount->transactionUid = $xml->TRNUID;
        $creditAccount->agencyNumber = $xml->CCSTMTRS->$nodeName->BRANCHID;
        $creditAccount->accountNumber = $xml->CCSTMTRS->$nodeName->ACCTID;
        $creditAccount->routingNumber = $xml->CCSTMTRS->$nodeName->BANKID;
        $creditAccount->accountType = $xml->CCSTMTRS->$nodeName->ACCTTYPE;
        $creditAccount->balance = $xml->CCSTMTRS->LEDGERBAL->BALAMT;
        $creditAccount->balanceDate = Utils::createDateTimeFromStr($xml->CCSTMTRS->LEDGERBAL->DTASOF, true);

        $creditAccount->statement = new Statement();
        $creditAccount->statement->currency = $xml->CCSTMTRS->CURDEF;
        $creditAccount->statement->startDate = Utils::createDateTimeFromStr($xml->CCSTMTRS->BANKTRANLIST->DTSTART);
        $creditAccount->statement->endDate = Utils::createDateTimeFromStr($xml->CCSTMTRS->BANKTRANLIST->DTEND);
        $creditAccount->statement->transactions = $this->buildTransactions($xml->CCSTMTRS->BANKTRANLIST->STMTTRN);

        return $creditAccount;
    }

    /**
     * @param SimpleXMLElement $transactions
     * @throws \Exception
     * @return \OfxParser\Entities\Transaction[]
     */
    private function buildTransactions(SimpleXMLElement $transactions): array
    {
        $return = [];
        foreach ($transactions as $t) {
            $transaction = new Transaction();
            $transaction->type = (string)$t->TRNTYPE;
            $transaction->date = Utils::createDateTimeFromStr($t->DTPOSTED);
            if ('' !== (string)$t->DTUSER) {
                $transaction->userInitiatedDate = Utils::createDateTimeFromStr($t->DTUSER);
            }
            $transaction->amount = Utils::createAmountFromStr($t->TRNAMT);
            $transaction->uniqueId = (string)$t->FITID;
            $transaction->name = (string)$t->NAME;
            $transaction->memo = (string)$t->MEMO;
            $transaction->sic = $t->SIC;
            $transaction->checkNumber = $t->CHECKNUM;
            $return[] = $transaction;
        }

        return $return;
    }

    /**
     * @param SimpleXMLElement $xml
     * @return \OfxParser\Entities\Status
     */
    private function buildStatus(SimpleXMLElement $xml): \OfxParser\Entities\Status
    {
        $status = new Status();
        $status->code = $xml->CODE;
        $status->severity = $xml->SEVERITY;
        $status->message = $xml->MESSAGE;

        return $status;
    }
}