Overloaded: Rabo has different way of storing account info.

@inheritdoc
198146
protected function parseTransactionAccount()
    {
        $results = [];
        // SEPA MT940 Structured
        if (preg_match('/^:61:.*\n(.*?)(\n|\:8)/im', $this->getCurrentTransactionData(), $results)
            && !empty($results[1])
        ) {
            return $this->sanitizeAccount($results[1]);
        }

        if (preg_match('/^:61:.{26}(.{16})/m', $this->getCurrentTransactionData(), $results)
            && !empty($results[1])
        ) {
            return $this->sanitizeAccount($results[1]);
        }

        return '';
    }
98249
function _storeEof()
	{
		$record    = 0x000A;   // Record identifier
		$length    = 0x0000;   // Number of bytes to follow

		$header    = pack("vv", $record, $length);
		$this->_append($header);
	}
72652
private function buildTree($account, &$data, $parent) {
    $data[] = array($account['name'], null, 1);
    if ($account['subAccounts']) {
      foreach($account['subAccounts'] as $subAccount) {
        $this->buildTree($subAccount, $data, $account['name']);
      }
    }
  }
431455
public function edit($id)
    {
        if (!$this->request->is(['get', 'put'])) {
            throw new MethodNotAllowedException();
        }

        /** @var User $user */
        $user = $this->Users->getUserAndGroups($id);

        if ($this->request->is('put')) {
            $user = $this->Users->patchEntity($user, $this->request->data, ['associated' => 'Groups']);
            $userActivated = ($user->dirty('active') && $user->active);
            if ($userActivated) {
                // do not allow a user to be activated if his email address is not verified
                if (!$user->verified) {
                    $user->active = false;
                    $userActivated = false;
                } else {
                    $user->activate();
                }
            }
            $userDeactivated = ($user->dirty('active') && !$user->active);
            if ($userDeactivated) {
                // do not allow a user to deactivate his own account
                if ($user->id === Wasabi::user()->id) {
                    $user->active = true;
                    $userDeactivated = false;
                } else {
                    $user->deactivate();
                }
            }
            if ($this->Users->save($user, ['associated' => 'Groups'])) {
                if ($user->id === Wasabi::user()->id) {
                    $updateUser = $this->Users->get($user->id);
                    $updateUser->group_id = $this->Users->UsersGroups->getGroupIds($updateUser->id);
                    $this->Auth->setUser($updateUser->toArray());
                    Wasabi::user($updateUser);
                }
                if ($userActivated && $user->verified) {
                    $this->getMailer('Wasabi/Core.User')->send('activatedEmail', [$user]);
                }
                if ($userDeactivated && $user->verified) {
                    $this->getMailer('Wasabi/Core.User')->send('deactivatedEmail', [$user]);
                }
                $this->Flash->success(__d('pb', 'The user <strong>{0}</strong> has been updated.', $user->fullName()));
                $this->redirect($this->Filter->getBacklink(['action' => 'index'], $this->request));
                return;
            } else {
                $this->Flash->error($this->formErrorMessage);
            }
        }

        $groups = $this->Users->Groups->find('list')->order('id ASC');

        // users that are no admin, may not select the admin group
        if (Wasabi::user()->hasAccessLevel(Permission::OWN)) {
            $groups->where(['id <>' => 1]);
        }

        $this->set([
            'user' => $user,
            'groups' => $groups,
            'languages' => Hash::map(Configure::read('languages.backend'), '{n}', function ($language) {
                return [
                    'value' => $language->id,
                    'text' => $language->name
                ];
            })
        ]);

        $this->render('add');
    }
1279459
public function store($record)
    {
        $params['index'] = $this->getName();
        $params['type'] = $record['type'];
        $params['id'] = $record['id'];
        $params['body'] = $record['data'];

        self::getClient()->index($params);
    }
1284224
public function getAccountKey($key, $default = null, $account = null)
    {
        if (!$this->account || ($account && $account !== $this->account)) {
            $this->useAccount($account);
        }

        return Core::instance()->getConfig("accounts.{$this->account}.{$key}", $default);
    }
732352
function accountName( $order = false )
    {
        if ( $order === false )
            $user = eZUser::currentUser();
        else
            $user = $order->attribute( 'user' );

        if ( is_object( $user ) )
        {
            $userObject = $user->attribute( 'contentobject' );
            $accountName = $userObject->attribute( 'name' );
        }
        else
            $accountName = null;
        return $accountName;
    }
614180
private function setAuthorData()
    {
        $this->Author = trim($this->Author);
        $nameParts = explode(' ', $this->Author);
        foreach ($nameParts as $key => $namePart) {
            if ($namePart === '') {
                unset($nameParts[$key]);
            }
        }
        $this->Author = implode(' ', $nameParts);
        /** @var AuthorHelper $author */
        $author = AuthorHelper::get()->filter('OriginalName', trim($this->Author));
        if (!$author->Count()) {
            $author = AuthorHelper::create();
            $author->OriginalName = trim($this->Author);
            $author->write();
        } else {
            $author = $author->first();
        }
        $this->AuthorHelperID = $author->ID;
    }
390874
public static function updateInheritedAccount()
    {
        if (!Podium::getInstance()->user->isGuest) {
            $userNameField = Podium::getInstance()->userNameField;
            if ($userNameField === null) {
                return true;
            }
            if (empty(Podium::getInstance()->user->identity->$userNameField)) {
                throw new InvalidConfigException("Non-existing or empty '$userNameField' field!");
            }
            $savedUser = static::find()->where(['inherited_id' => Podium::getInstance()->user->id])->limit(1)->one();
            if (empty($savedUser)) {
                throw new InvalidConfigException('Can not find inherited account in database!');
            }
            if ($savedUser->username === Podium::getInstance()->user->identity->$userNameField) {
                return true;
            }
            $savedUser->scenario = 'installation';
            $savedUser->username = Podium::getInstance()->user->identity->$userNameField;
            if ($savedUser->save()) {
                Log::info('Inherited account updated', $savedUser->id, __METHOD__);
                return true;
            }
            throw new Exception('Inherited account updating error');
        }
        return true;
    }
263688
public function impersonateAccount(\TYPO3\Flow\Security\Account $account = NULL) {
		if ($this->impersonatedAccount !== $account) {
			$this->impersonatedAccount = $account;

			$this->destroyRegisteredClientSessions();

			$this->emitAccountImpersonated($account);
		}
	}
1260103
public function createSetOfAccounts()
    {
        if ($this->getRootAccount())
        {
            throw new \Exception('Profile already has a set of accounts');
        }

        $account = new \HarvestCloud\CoreBundle\Entity\RootAccount('Root Account for '.$this->getName());
        $account->setProfile($this);

        $this->setRootAccount($account);

        // Assets
        $asset    = new \HarvestCloud\CoreBundle\Entity\AssetAccount('Assets');
        $ar       = new \HarvestCloud\CoreBundle\Entity\AssetAccount('Accounts Receivable');
        $current  = new \HarvestCloud\CoreBundle\Entity\AssetAccount('Current Assets');
        $arPrePay = new \HarvestCloud\CoreBundle\Entity\AssetAccount('AR Pre-Payments');
        $cash     = new \HarvestCloud\CoreBundle\Entity\AssetAccount('Cash');
        $bank     = new \HarvestCloud\CoreBundle\Entity\AssetAccount('Bank');
        $payPal   = new \HarvestCloud\CoreBundle\Entity\AssetAccount('PayPal');

        $this->setAccountsReceivableAccount($ar);
        $this->setPayPalAccount($payPal);
        $this->setArPrePaymentAccount($arPrePay);

        $account->addAccount($asset);
        $asset->addAccount($ar);
        $ar->addAccount($arPrePay);
        $asset->addAccount($current);
        $current->addAccount($bank);
        $current->addAccount($cash);
        $current->addAccount($payPal);

        // Liability
        $liability = new \HarvestCloud\CoreBundle\Entity\LiabilityAccount('Liabilities');
        $ap        = new \HarvestCloud\CoreBundle\Entity\LiabilityAccount('Accounts Payable');
        $apPrePay  = new \HarvestCloud\CoreBundle\Entity\LiabilityAccount('AP Pre-Payment');

        $this->setAccountsPayableAccount($ap);
        $this->setApPrePaymentAccount($apPrePay);

        $account->addAccount($liability);
        $liability->addAccount($ap);
        $ap->addAccount($apPrePay);

        // Income
        $income = new \HarvestCloud\CoreBundle\Entity\IncomeAccount('Income');
        $sales  = new \HarvestCloud\CoreBundle\Entity\IncomeAccount('Sales');

        $this->setSalesAccount($sales);

        $account->addAccount($income);
        $income->addAccount($sales);

        // Expenses
        $expenses        = new \HarvestCloud\CoreBundle\Entity\ExpenseAccount('Expenses');
        $purchases       = new \HarvestCloud\CoreBundle\Entity\ExpenseAccount('Purchases');
        $costOfGoodsSold = new \HarvestCloud\CoreBundle\Entity\ExpenseAccount('Cost of Goods Sold');

        $this->setExpenseAccount($expenses);
        $this->setPurchasesAccount($purchases);
        $this->setCostOfGoodsSoldAccount($costOfGoodsSold);

        $account->addAccount($expenses);
        $expenses->addAccount($purchases);
        $expenses->addAccount($costOfGoodsSold);

        return $account;
    }
1237789
public function fromArray($options)
    {
        if (isset($options['AccountId'])) {
            Validate::isString($options['AccountId'], 'options[AccountId]');
            $this->_accountId = $options['AccountId'];
        }

        if (isset($options['ReservedUnitType'])) {
            Validate::isInteger($options['ReservedUnitType'], 'options[ReservedUnitType]');
            $this->_reservedUnitType = intval($options['ReservedUnitType']);
        }

        if (isset($options['MaxReservableUnits'])) {
            Validate::isInteger($options['MaxReservableUnits'], 'options[MaxReservableUnits]');
            $this->_maxReservableUnits = intval($options['MaxReservableUnits']);
        }

        if (isset($options['CurrentReservedUnits'])) {
            Validate::isString($options['CurrentReservedUnits'], 'options[CurrentReservedUnits]');
            $this->_currentReservedUnits = intval($options['CurrentReservedUnits']);
        }
    }
362899
function storedFileInformation( $object, $objectVersion, $objectLanguage,
                                    $objectAttribute )
    {
        $binaryFile = eZBinaryFile::fetch( $objectAttribute->attribute( "id" ),
                                            $objectAttribute->attribute( "version" ) );
        if ( $binaryFile )
        {
            return $binaryFile->storedFileInfo();
        }
        return false;
    }
514514
function o_info( $id, $action, $options = '' )
    {
        if ( $action != 'new' )
        {
            $o =& $this->objects[$id];
        }
        switch ($action)
        {
        case 'new':
            $this->infoObject = $id;
            $date = 'D:' . date( 'Ymd' );
            $this->objects[$id] = array( 't' => 'info',
                                         'info' => array( 'Creator' => 'eZ Publish CMS, http://ez.no',
                                                          'CreationDate' => $date ) );
            break;
        case 'Title':
        case 'Author':
        case 'Subject':
        case 'Keywords':
        case 'Creator':
        case 'Producer':
        case 'CreationDate':
        case 'ModDate':
        case 'Trapped':
            $o['info'][$action]=$options;
            break;
        case 'out':
            if ( $this->encrypted )
            {
                $this->encryptInit( $id );
            }
            $res = "\n" . $id . " 0 obj\n<<\n";
            foreach ( $o['info']  as $k => $v )
            {
                $res .= '/' . $k . ' (';
                if ( $this->encrypted )
                {
                    $res .= $this->filterText( $this->ARC4( $v ) );
                }
                else
                {
                    $res .= $this->filterText( $v );
                }
                $res .= ")\n";
            }
            $res .= ">>\nendobj";
            return $res;
            break;
        }
    }
986257
public function getAssignedPartyOfAccount(Account $account)
    {
        $accountIdentifier = $this->persistenceManager->getIdentifierByObject($account);

        // We need to prevent stale object references and therefore only cache the identifier.
        if (!array_key_exists($accountIdentifier, $this->accountsInPartyRuntimeCache)) {
            $party = $this->partyRepository->findOneHavingAccount($account);
            $this->accountsInPartyRuntimeCache[$accountIdentifier] = $party === null ? null : $this->persistenceManager->getIdentifierByObject($party);

            return $party;
        }

        if ($this->accountsInPartyRuntimeCache[$accountIdentifier] !== null) {
            $partyIdentifier = $this->accountsInPartyRuntimeCache[$accountIdentifier];

            return $this->persistenceManager->getObjectByIdentifier($partyIdentifier, AbstractParty::class);
        }

        return null;
    }
791747
protected function _serializeAccountID()
        {
        	$isToken = $this->getIsToken();
                $accountID = $this->getAccountID();

                if( $isToken && $isToken != false && $isToken != "false" )
                {
                        return $accountID ? "<AccountID isToken=\"true\">{$accountID}</AccountID>" : '';
                } else {
                        return $accountID ? "<AccountID isToken=\"0\">{$accountID}</AccountID>" : '';
                }
	}
1200979
public function assignData($data)
    {
        $storeId = $this->getInfoInstance()->getQuote()->getStoreId();
        $details = array();

        if ($this->getAccountName()) {
            $details['account_name'] = $this->getAccountName($storeId);
        }

        if ($this->getAccountBSB()) {
            $details['account_bsb'] = $this->getAccountBSB($storeId);
        }

        if ($this->getAccountNumber()) {
            $details['account_number'] = $this->getAccountNumber($storeId);
        }

        if ($this->getMessage()) {
            $details['message'] = $this->getMessage($storeId);
        }

        if (!empty($details)) {
            $this->getInfoInstance()->setAdditionalData(serialize($details));
        }

        return $this;
    }