FireflyIII\Validation\TransactionValidation

Complexity

Total Complexity

65

Size/Duplication

Total Lines	422
Duplicated Lines	0 %

Importance

Changes	12
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	validateAccountInformation()	0	15	2
A	validateTransactionTypesForUpdate()	0	17	3
A	validateSingleAccount()	0	32	5
B	validateSingleUpdate()	0	37	9
A	validateTransactionTypes()	0	18	4
A	arrayEqual()	0	3	1
A	validateAccountInformationUpdate()	0	11	2
A	getTransactionsArray()	0	17	3
A	validateOneRecurrenceTransaction()	0	8	2
A	getOriginalData()	0	25	4
B	validateEqualAccounts()	0	35	10
A	validateOneTransaction()	0	11	2
A	getOriginalType()	0	12	3
C	validateEqualAccountsForUpdate()	0	77	15

<?php
/**
 * TransactionValidation.php
 * Copyright (c) 2019 james@firefly-iii.org
 *
 * This file is part of Firefly III (https://github.com/firefly-iii).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace FireflyIII\Validation;

use FireflyIII\Models\Transaction;
use FireflyIII\Models\TransactionGroup;
use FireflyIII\Models\TransactionJournal;
use Illuminate\Validation\Validator;
use Log;

/**
 * Trait TransactionValidation
 */
trait TransactionValidation
{
    /**
     * Validates the given account information. Switches on given transaction type.
     *
     * @param Validator $validator
     */
    public function validateAccountInformation(Validator $validator): void
    {
        Log::debug('Now in validateAccountInformation()');
        $transactions = $this->getTransactionsArray($validator);
        $data         = $validator->getData();

        $transactionType = $data['type'] ?? 'invalid';

        Log::debug(sprintf('Going to loop %d transaction(s)', count($transactions)));
        /**
         * @var int   $index
         * @var array $transaction
         */
        foreach ($transactions as $index => $transaction) {
            $this->validateSingleAccount($validator, $index, $transactionType, $transaction);
        }
    }

    /**
     * @param Validator $validator
     * @param int       $index
     * @param string    $transactionType
     * @param array     $transaction
     */
    protected function validateSingleAccount(Validator $validator, int $index, string $transactionType, array $transaction): void
    {
        /** @var AccountValidator $accountValidator */
        $accountValidator = app(AccountValidator::class);

        $transactionType = $transaction['type'] ?? $transactionType;
        $accountValidator->setTransactionType($transactionType);

        // validate source account.
        $sourceId    = isset($transaction['source_id']) ? (int) $transaction['source_id'] : null;
        $sourceName  = $transaction['source_name'] ?? null;
        $sourceIban  = $transaction['source_iban'] ?? null;
        $validSource = $accountValidator->validateSource($sourceId, $sourceName, $sourceIban);

        // do something with result:
        if (false === $validSource) {
            $validator->errors()->add(sprintf('transactions.%d.source_id', $index), $accountValidator->sourceError);
            $validator->errors()->add(sprintf('transactions.%d.source_name', $index), $accountValidator->sourceError);

            return;
        }
        // validate destination account
        $destinationId    = isset($transaction['destination_id']) ? (int) $transaction['destination_id'] : null;
        $destinationName  = $transaction['destination_name'] ?? null;
        $destinationIban  = $transaction['destination_iban'] ?? null;
        $validDestination = $accountValidator->validateDestination($destinationId, $destinationName, $destinationIban);
        // do something with result:
        if (false === $validDestination) {
            $validator->errors()->add(sprintf('transactions.%d.destination_id', $index), $accountValidator->destError);
            $validator->errors()->add(sprintf('transactions.%d.destination_name', $index), $accountValidator->destError);

            return;
        }
    }

    /**
     * Validates the given account information. Switches on given transaction type.
     *
     * @param Validator $validator
     */
    public function validateAccountInformationUpdate(Validator $validator): void
    {
        Log::debug('Now in validateAccountInformationUpdate()');
        $transactions = $this->getTransactionsArray($validator);

        /**
         * @var int   $index
         * @var array $transaction
         */
        foreach ($transactions as $index => $transaction) {
            $this->validateSingleUpdate($validator, $index, $transaction);
        }
    }

    /**
     * @param Validator $validator
     * @param int       $index
     * @param array     $transaction
     */
    protected function validateSingleUpdate(Validator $validator, int $index, array $transaction): void
    {
        /** @var AccountValidator $accountValidator */
        $accountValidator = app(AccountValidator::class);
        $originalType     = $this->getOriginalType((int)($transaction['transaction_journal_id'] ?? 0));
        $originalData     = $this->getOriginalData((int)($transaction['transaction_journal_id'] ?? 0));
        $transactionType  = $transaction['type'] ?? $originalType;
        $accountValidator->setTransactionType($transactionType);

        // if no account types are given, just skip the check.
        if (!isset($transaction['source_id'])
            && !isset($transaction['source_name'])
            && !isset($transaction['destination_id'])
            && !isset($transaction['destination_name'])) {
            return;
        }

        // validate source account.
        $sourceId    = isset($transaction['source_id']) ? (int)$transaction['source_id'] : $originalData['source_id'];
        $sourceName  = $transaction['source_name'] ?? $originalData['source_name'];
        $validSource = $accountValidator->validateSource($sourceId, $sourceName, null);

        // do something with result:
        if (false === $validSource) {
            $validator->errors()->add(sprintf('transactions.%d.source_id', $index), $accountValidator->sourceError);
            $validator->errors()->add(sprintf('transactions.%d.source_name', $index), $accountValidator->sourceError);

            return;
        }
        // validate destination account
        $destinationId    = isset($transaction['destination_id']) ? (int)$transaction['destination_id'] : $originalData['destination_id'];
        $destinationName  = $transaction['destination_name'] ?? $originalData['destination_name'];
        $validDestination = $accountValidator->validateDestination($destinationId, $destinationName, null);
        // do something with result:
        if (false === $validDestination) {
            $validator->errors()->add(sprintf('transactions.%d.destination_id', $index), $accountValidator->destError);
            $validator->errors()->add(sprintf('transactions.%d.destination_name', $index), $accountValidator->destError);
        }
    }

    /**
     * Adds an error to the validator when there are no transactions in the array of data.
     *
     * @param Validator $validator
     */
    public function validateOneRecurrenceTransaction(Validator $validator): void
    {
        Log::debug('Now in validateOneRecurrenceTransaction()');
        $transactions = $this->getTransactionsArray($validator);

        // need at least one transaction
        if (0 === count($transactions)) {
            $validator->errors()->add('transactions', (string)trans('validation.at_least_one_transaction'));
        }
    }

    /**
     * Adds an error to the validator when there are no transactions in the array of data.
     *
     * @param Validator $validator
     */
    public function validateOneTransaction(Validator $validator): void
    {
        Log::debug('Now in validateOneTransaction()');
        $transactions = $this->getTransactionsArray($validator);
        // need at least one transaction
        if (0 === count($transactions)) {
            $validator->errors()->add('transactions.0.description', (string)trans('validation.at_least_one_transaction'));
            Log::debug('Added error: at_least_one_transaction.');
            return;
        }
        Log::debug('Added NO errors.');
    }

    /**
     * All types of splits must be equal.
     *
     * @param Validator $validator
     */
    public function validateTransactionTypes(Validator $validator): void
    {
        Log::debug('Now in validateTransactionTypes()');
        $transactions = $this->getTransactionsArray($validator);

        $types = [];
        foreach ($transactions as $transaction) {
            $types[] = $transaction['type'] ?? 'invalid';
        }
        $unique = array_unique($types);
        if (count($unique) > 1) {
            $validator->errors()->add('transactions.0.type', (string)trans('validation.transaction_types_equal'));

            return;
        }
        $first = $unique[0] ?? 'invalid';
        if ('invalid' === $first) {
            $validator->errors()->add('transactions.0.type', (string)trans('validation.invalid_transaction_type'));
        }
    }

    /**
     * All types of splits must be equal.
     *
     * @param Validator $validator
     */
    public function validateTransactionTypesForUpdate(Validator $validator): void
    {
        Log::debug('Now in validateTransactionTypesForUpdate()');
        $transactions = $this->getTransactionsArray($validator);
        $types        = [];
        foreach ($transactions as $transaction) {
            $originalType = $this->getOriginalType((int)($transaction['transaction_journal_id'] ?? 0));
            // if type is not set, fall back to the type of the journal, if one is given.


            $types[] = $transaction['type'] ?? $originalType;
        }
        $unique = array_unique($types);
        if (count($unique) > 1) {
            $validator->errors()->add('transactions.0.type', (string)trans('validation.transaction_types_equal'));

            return;
        }
    }

    /**
     * @param array $array
     *
     * @return bool
     */
    private function arrayEqual(array $array): bool
    {
        return 1 === count(array_unique($array));
    }

    /**
     * @param int $journalId
     *
     * @return array
     */
    private function getOriginalData(int $journalId): array
    {
        $return = [
            'source_id'        => 0,
            'source_name'      => '',
            'destination_id'   => 0,
            'destination_name' => '',
        ];
        if (0 === $journalId) {
            return $return;
        }
        /** @var Transaction $source */
        $source = Transaction::where('transaction_journal_id', $journalId)->where('amount', '<', 0)->with(['account'])->first();
        if (null !== $source) {
            $return['source_id']   = $source->account_id;
            $return['source_name'] = $source->account->name;
        }
        /** @var Transaction $destination */
        $destination = Transaction::where('transaction_journal_id', $journalId)->where('amount', '>', 0)->with(['account'])->first();
        if (null !== $source) {
            $return['destination_id']   = $destination->account_id;
            $return['destination_name'] = $destination->account->name;
        }

        return $return;
    }

    /**
     * @param int $journalId
     *
     * @return string
     */
    private function getOriginalType(int $journalId): string
    {
        if (0 === $journalId) {
            return 'invalid';
        }
        /** @var TransactionJournal $journal */
        $journal = TransactionJournal::with(['transactionType'])->find($journalId);
        if (null !== $journal) {
            return strtolower($journal->transactionType->type);
        }

        return 'invalid';
    }

    /**
     * @param Validator $validator
     *
     * @return array
     */
    protected function getTransactionsArray(Validator $validator): array
    {
        $data         = $validator->getData();
        $transactions = $data['transactions'] ?? [];
        if (!is_countable($transactions)) {
            Log::error(sprintf('Transactions array is not countable, because its a %s', gettype($transactions)));

            return [];
        }
        // a superfluous check but you never know.
        if (!is_array($transactions)) {
            Log::error(sprintf('Transactions array is not an array, because its a %s', gettype($transactions)));

            return [];
        }

        return $transactions;
    }

    /**
     * @param Validator $validator
     */
    private function validateEqualAccounts(Validator $validator): void
    {
        Log::debug('Now in validateEqualAccounts()');
        $transactions = $this->getTransactionsArray($validator);

        // needs to be split
        if (count($transactions) < 2) {
            return;
        }
        $type    = $transactions[0]['type'] ?? 'withdrawal';
        $sources = [];
        $dests   = [];
        foreach ($transactions as $transaction) {
            $sources[] = sprintf('%d-%s', $transaction['source_id'] ?? 0, $transaction['source_name'] ?? '');
            $dests[]   = sprintf('%d-%s', $transaction['destination_id'] ?? 0, $transaction['destination_name'] ?? '');
        }
        $sources = array_unique($sources);
        $dests   = array_unique($dests);
        switch ($type) {
            case 'withdrawal':
                if (count($sources) > 1) {
                    $validator->errors()->add('transactions.0.source_id', (string)trans('validation.all_accounts_equal'));
                }
                break;
            case 'deposit':
                if (count($dests) > 1) {
                    $validator->errors()->add('transactions.0.destination_id', (string)trans('validation.all_accounts_equal'));
                }
                break;
            case'transfer':
                if (count($sources) > 1 || count($dests) > 1) {
                    $validator->errors()->add('transactions.0.source_id', (string)trans('validation.all_accounts_equal'));
                    $validator->errors()->add('transactions.0.destination_id', (string)trans('validation.all_accounts_equal'));
                }
                break;
        }
    }

    /**
     * @param Validator        $validator
     * @param TransactionGroup $transactionGroup
     */
    private function validateEqualAccountsForUpdate(Validator $validator, TransactionGroup $transactionGroup): void
    {
        Log::debug('Now in validateEqualAccountsForUpdate()');
        $transactions = $this->getTransactionsArray($validator);

        // needs to be split
        if (count($transactions) < 2) {
            return;
        }
        $type = $transactions[0]['type'] ?? strtolower($transactionGroup->transactionJournals()->first()->transactionType->type);

        // compare source ID's, destination ID's, source names and destination names.
        // I think I can get away with one combination being equal, as long as the rest
        // of the code picks up on this as well.
        // either way all fields must be blank or all equal
        // but if ID's are equal don't bother with the names.

        $fields     = ['source_id', 'destination_id', 'source_name', 'destination_name'];
        $comparison = [];
        foreach ($fields as $field) {
            $comparison[$field] = [];
            /** @var array $transaction */
            foreach ($transactions as $transaction) {
                // source or destination may be omitted. If this is the case, use the original source / destination name + ID.
                $originalData = $this->getOriginalData((int)($transaction['transaction_journal_id'] ?? 0));

                // get field.
                $comparison[$field][] = $transaction[$field] ?? $originalData[$field];
            }
        }
        // TODO not the best way to loop this.
        switch ($type) {
            case 'withdrawal':
                if ($this->arrayEqual($comparison['source_id'])) {
                    // source ID's are equal, return void.
                    return;
                }
                if ($this->arrayEqual($comparison['source_name'])) {
                    // source names are equal, return void.
                    return;
                }
                // add error:
                $validator->errors()->add('transactions.0.source_id', (string)trans('validation.all_accounts_equal'));
                break;
            case 'deposit':
                if ($this->arrayEqual($comparison['destination_id'])) {
                    // destination ID's are equal, return void.
                    return;
                }
                if ($this->arrayEqual($comparison['destination_name'])) {
                    // destination names are equal, return void.
                    return;
                }
                // add error:
                $validator->errors()->add('transactions.0.destination_id', (string)trans('validation.all_accounts_equal'));
                break;
            case 'transfer':
                if ($this->arrayEqual($comparison['source_id'])) {
                    // source ID's are equal, return void.
                    return;
                }
                if ($this->arrayEqual($comparison['source_name'])) {
                    // source names are equal, return void.
                    return;
                }
                if ($this->arrayEqual($comparison['destination_id'])) {
                    // destination ID's are equal, return void.
                    return;
                }
                if ($this->arrayEqual($comparison['destination_name'])) {
                    // destination names are equal, return void.
                    return;
                }
                // add error:
                $validator->errors()->add('transactions.0.source_id', (string)trans('validation.all_accounts_equal'));
                $validator->errors()->add('transactions.0.destination_id', (string)trans('validation.all_accounts_equal'));
                break;
        }
    }
}