jacques / ofxparser

lib/OfxParser/Ofx/Investment.php

<?php declare(strict_types=1);

namespace OfxParser\Ofx;

use SimpleXMLElement;
use OfxParser\Ofx;
use OfxParser\Utils;
use OfxParser\Entities\Statement;
use OfxParser\Entities\Investment\Account as InvestmentAccount;
use OfxParser\Entities\Investment\Transaction\Banking;
use OfxParser\Entities\Investment\Transaction\BuyMutualFund;
use OfxParser\Entities\Investment\Transaction\BuySecurity;
use OfxParser\Entities\Investment\Transaction\BuyStock;
use OfxParser\Entities\Investment\Transaction\Income;
use OfxParser\Entities\Investment\Transaction\Reinvest;
use OfxParser\Entities\Investment\Transaction\SellMutualFund;

final class Investment extends Ofx
{
    /**
     * @param SimpleXMLElement $xml
     * @throws \Exception
     */
    public function __construct(SimpleXMLElement $xml)
    {
        $this->signOn = $this->buildSignOn($xml->SIGNONMSGSRSV1->SONRS);

        if (property_exists($xml, 'INVSTMTMSGSRSV1') && $xml->INVSTMTMSGSRSV1 !== null) {
            $this->bankAccounts = $this->buildAccounts($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

        }
    }

    /**
     * @param SimpleXMLElement $xml
     * @return array Array of InvestmentAccount enities
     * @throws \Exception
     */
    protected function buildAccounts(SimpleXMLElement $xml): array
    {
        // Loop through the bank accounts
        $accounts = [];
        foreach ($xml->INVSTMTMSGSRSV1->INVSTMTTRNRS as $accountStatement) {
            foreach ($accountStatement->INVSTMTRS as $statementResponse) {
                $accounts[] = $this->buildAccount($accountStatement->TRNUID, $statementResponse);

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

            }
        }
        return $accounts;
    }

    /**
     * @param string $transactionUid
     * @param SimpleXMLElement $statementResponse
     * @return InvestmentAccount
     * @throws \Exception
     */
    protected function buildAccount(?SimpleXMLElement $transactionUid, SimpleXMLElement $statementResponse): InvestmentAccount
    {
        $account = new InvestmentAccount();
        $account->transactionUid = (string) $transactionUid;
        $account->brokerId = (string) $statementResponse->INVACCTFROM->BROKERID;
        $account->accountNumber = (string) $statementResponse->INVACCTFROM->ACCTID;

        $account->statement = new Statement();

It seems like new OfxParser\Entities\Statement() of type OfxParser\Entities\Statement is incompatible with the declared type OfxParser\Entities\Investment\Statement of property $statement.

        $account->statement->currency = (string) $statementResponse->CURDEF;

        $account->statement->startDate = Utils::createDateTimeFromStr(
            $statementResponse->INVTRANLIST->DTSTART
        );

        $account->statement->endDate = Utils::createDateTimeFromStr(
            $statementResponse->INVTRANLIST->DTEND
        );

        $account->statement->transactions = $this->buildTransactions(
            $statementResponse->INVTRANLIST->children()
        );

        return $account;
    }

    /**
     * Processes multiple types of investment transactions, ignoring many
     * others.
     *
     * @param SimpleXMLElement $transactions
     * @throws \Exception
     * @return \OfxParser\Entities\Investment\Transaction\Banking[]|\OfxParser\Entities\Investment\Transaction\BuySecurity[]|\OfxParser\Entities\Investment\Transaction\Income[]|\OfxParser\Entities\Investment\Transaction\SellMutualFund[]
     */
    protected function buildTransactions(SimpleXMLElement $transactions): array
    {
        $activity = [];

        foreach ($transactions as $t) {
            $item = null;

            switch ($t->getName()) {

The method getName() does not exist on null.

                case 'BUYMF':
                    $item = new BuyMutualFund();
                    break;
                case 'BUYOTHER':
                    $item = new BuySecurity();
                    break;
                case 'BUYSTOCK':
                    $item = new BuyStock();
                    break;
                case 'INCOME':
                    $item = new Income();
                    break;
                case 'INVBANKTRAN':
                    $item = new Banking();
                    break;
                case 'REINVEST':
                    $item = new Reinvest();
                    break;
                case 'SELLMF':
                    $item = new SellMutualFund();
                    break;
                case 'DTSTART':
                    // already processed
                    break;
                case 'DTEND':
                    // already processed
                    break;
                default:
                    // Log: ignored node....
                    break;
            }

            if (!is_null($item)) {
                $item->loadOfx($t);

It seems like $t can also be of type null; however, parameter $node of OfxParser\Entities\Investment\Transaction\SellStock::loadOfx() does only seem to accept SimpleXMLElement, maybe add an additional type check?

It seems like $t can also be of type null; however, parameter $node of OfxParser\Entities\Investment\Transaction\BuySecurity::loadOfx() does only seem to accept SimpleXMLElement, maybe add an additional type check?

It seems like $t can also be of type null; however, parameter $node of OfxParser\Entities\Investment\Transaction\BuyStock::loadOfx() does only seem to accept SimpleXMLElement, maybe add an additional type check?

It seems like $t can also be of type null; however, parameter $node of OfxParser\Entities\Investment\Transaction\Banking::loadOfx() does only seem to accept SimpleXMLElement, maybe add an additional type check?

It seems like $t can also be of type null; however, parameter $node of OfxParser\Entities\Investment\Transaction\Income::loadOfx() does only seem to accept SimpleXMLElement, maybe add an additional type check?

                $activity[] = $item;
            }
        }

        return $activity;
    }
}