mirror of
https://github.com/firefly-iii/firefly-iii.git
synced 2024-11-30 20:54:04 -06:00
387 lines
13 KiB
PHP
387 lines
13 KiB
PHP
<?php
|
|
/**
|
|
* ImportValidator.php
|
|
* Copyright (C) 2016 thegrumpydictator@gmail.com
|
|
*
|
|
* This software may be modified and distributed under the terms
|
|
* of the MIT license. See the LICENSE file for details.
|
|
*/
|
|
|
|
declare(strict_types = 1);
|
|
|
|
namespace FireflyIII\Import;
|
|
|
|
use Carbon\Carbon;
|
|
use FireflyIII\Crud\Account\AccountCrudInterface;
|
|
use FireflyIII\Models\Account;
|
|
use FireflyIII\Models\AccountType;
|
|
use FireflyIII\Models\TransactionType;
|
|
use FireflyIII\Repositories\Currency\CurrencyRepositoryInterface;
|
|
use FireflyIII\User;
|
|
use Illuminate\Support\Collection;
|
|
use Log;
|
|
|
|
/**
|
|
* Class ImportValidator
|
|
*
|
|
* @package FireflyIII\Import
|
|
*/
|
|
class ImportValidator
|
|
{
|
|
/** @var Account */
|
|
protected $defaultImportAccount;
|
|
/** @var Collection */
|
|
protected $entries;
|
|
/** @var User */
|
|
protected $user;
|
|
|
|
/**
|
|
* ImportValidator constructor.
|
|
*
|
|
* @param Collection $entries
|
|
*/
|
|
public function __construct(Collection $entries)
|
|
{
|
|
$this->entries = $entries;
|
|
}
|
|
|
|
/**
|
|
* Clean collection by filling in all the blanks.
|
|
*/
|
|
public function clean(): Collection
|
|
{
|
|
$newCollection = new Collection;
|
|
/** @var ImportEntry $entry */
|
|
foreach ($this->entries as $entry) {
|
|
Log::debug('--- import validator start ---');
|
|
/*
|
|
* X Adds the date (today) if no date is present.
|
|
* X Determins the types of accounts involved (asset, expense, revenue).
|
|
* X Determins the type of transaction (withdrawal, deposit, transfer).
|
|
* - Determins the currency of the transaction.
|
|
* X Adds a default description if there isn't one present.
|
|
*/
|
|
$entry = $this->checkAmount($entry);
|
|
$entry = $this->setDate($entry);
|
|
$entry = $this->setAssetAccount($entry);
|
|
Log::debug(sprintf('Opposing account is of type %s', $entry->fields['opposing-account']->accountType->type));
|
|
$entry = $this->setOpposingAccount($entry);
|
|
Log::debug(sprintf('Opposing account is of type %s', $entry->fields['opposing-account']->accountType->type));
|
|
$entry = $this->cleanDescription($entry);
|
|
$entry = $this->setTransactionType($entry);
|
|
$entry = $this->setTransactionCurrency($entry);
|
|
|
|
$newCollection->push($entry);
|
|
}
|
|
|
|
return $newCollection;
|
|
}
|
|
|
|
/**
|
|
* @param Account $defaultImportAccount
|
|
*/
|
|
public function setDefaultImportAccount(Account $defaultImportAccount)
|
|
{
|
|
$this->defaultImportAccount = $defaultImportAccount;
|
|
}
|
|
|
|
/**
|
|
* @param User $user
|
|
*/
|
|
public function setUser(User $user)
|
|
{
|
|
$this->user = $user;
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function checkAmount(ImportEntry $entry): ImportEntry
|
|
{
|
|
if ($entry->fields['amount'] == 0) {
|
|
$entry->valid = false;
|
|
Log::error('Amount of transaction is zero, cannot handle.');
|
|
|
|
return $entry;
|
|
}
|
|
Log::debug('Amount is OK.');
|
|
|
|
return $entry;
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function cleanDescription(ImportEntry $entry): ImportEntry
|
|
{
|
|
if (!isset($entry->fields['description'])) {
|
|
Log::debug('Set empty transaction description because field was not set.');
|
|
$entry->fields['description'] = '(empty transaction description)';
|
|
|
|
return $entry;
|
|
}
|
|
if (is_null($entry->fields['description'])) {
|
|
Log::debug('Set empty transaction description because field was null.');
|
|
$entry->fields['description'] = '(empty transaction description)';
|
|
|
|
return $entry;
|
|
}
|
|
|
|
if (strlen($entry->fields['description']) == 0) {
|
|
Log::debug('Set empty transaction description because field was empty.');
|
|
$entry->fields['description'] = '(empty transaction description)';
|
|
|
|
return $entry;
|
|
}
|
|
Log::debug('Transaction description is OK.');
|
|
$entry->fields['description'] = trim($entry->fields['description']);
|
|
|
|
return $entry;
|
|
}
|
|
|
|
/**
|
|
* @param Account $account
|
|
* @param string $type
|
|
*
|
|
* @return Account
|
|
*/
|
|
private function convertAccount(Account $account, string $type): Account
|
|
{
|
|
$accountType = $account->accountType->type;
|
|
if ($accountType === $type) {
|
|
Log::debug(sprintf('Account %s already of type %s', $account->name, $type));
|
|
|
|
return $account;
|
|
}
|
|
// find it first by new type:
|
|
/** @var AccountCrudInterface $repository */
|
|
$repository = app(AccountCrudInterface::class, [$this->user]);
|
|
$result = $repository->findByName($account->name, [$type]);
|
|
if (is_null($result->id)) {
|
|
// can convert account:
|
|
Log::debug(sprintf('No account named %s of type %s, will convert.', $account->name, $type));
|
|
$result = $repository->updateAccountType($account, $type);
|
|
|
|
}
|
|
|
|
return $result;
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* @return Account
|
|
*/
|
|
private function fallbackExpenseAccount(): Account
|
|
{
|
|
|
|
/** @var AccountCrudInterface $repository */
|
|
$repository = app(AccountCrudInterface::class, [$this->user]);
|
|
$name = 'Unknown expense account';
|
|
$result = $repository->findByName($name, [AccountType::EXPENSE]);
|
|
if (is_null($result->id)) {
|
|
$result = $repository->store(
|
|
['name' => $name, 'iban' => null, 'openingBalance' => 0, 'user' => $this->user->id, 'accountType' => 'expense', 'virtualBalance' => 0,
|
|
'active' => true]
|
|
);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @return Account
|
|
*/
|
|
private function fallbackRevenueAccount(): Account
|
|
{
|
|
|
|
/** @var AccountCrudInterface $repository */
|
|
$repository = app(AccountCrudInterface::class, [$this->user]);
|
|
$name = 'Unknown revenue account';
|
|
$result = $repository->findByName($name, [AccountType::REVENUE]);
|
|
if (is_null($result->id)) {
|
|
$result = $repository->store(
|
|
['name' => $name, 'iban' => null, 'openingBalance' => 0, 'user' => $this->user->id, 'accountType' => 'revenue', 'virtualBalance' => 0,
|
|
'active' => true]
|
|
);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function setAssetAccount(ImportEntry $entry): ImportEntry
|
|
{
|
|
if (is_null($entry->fields['asset-account'])) {
|
|
if (!is_null($this->defaultImportAccount)) {
|
|
Log::debug('Set asset account from default asset account');
|
|
$entry->fields['asset-account'] = $this->defaultImportAccount;
|
|
|
|
return $entry;
|
|
}
|
|
// default import is null? should not happen. Entry cannot be imported.
|
|
// set error message and block.
|
|
$entry->valid = false;
|
|
Log::error('Cannot import entry. Asset account is NULL and import account is also NULL.');
|
|
|
|
}
|
|
Log::debug('Asset account is OK.', ['id' => $entry->fields['asset-account']->id, 'name' => $entry->fields['asset-account']->name]);
|
|
|
|
return $entry;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function setDate(ImportEntry $entry): ImportEntry
|
|
{
|
|
if (is_null($entry->fields['date-transaction'])) {
|
|
// empty date field? find alternative.
|
|
$alternatives = ['date-book', 'date-interest', 'date-process'];
|
|
foreach ($alternatives as $alternative) {
|
|
if (!is_null($entry->fields[$alternative])) {
|
|
Log::debug(sprintf('Copied date-transaction from %s.', $alternative));
|
|
$entry->fields['date-transaction'] = clone $entry->fields[$alternative];
|
|
|
|
return $entry;
|
|
}
|
|
}
|
|
// date is still null at this point
|
|
Log::debug('Set date-transaction to today.');
|
|
$entry->fields['date-transaction'] = new Carbon;
|
|
|
|
return $entry;
|
|
}
|
|
Log::debug('Date-transaction is OK');
|
|
|
|
return $entry;
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function setOpposingAccount(ImportEntry $entry): ImportEntry
|
|
{
|
|
// empty opposing account. Create one based on amount.
|
|
if (is_null($entry->fields['opposing-account'])) {
|
|
|
|
if ($entry->fields['amount'] < 0) {
|
|
// create or find general opposing expense account.
|
|
Log::debug('Created fallback expense account');
|
|
$entry->fields['opposing-account'] = $this->fallbackExpenseAccount();
|
|
|
|
return $entry;
|
|
}
|
|
Log::debug('Created fallback revenue account');
|
|
$entry->fields['opposing-account'] = $this->fallbackRevenueAccount();
|
|
|
|
return $entry;
|
|
}
|
|
|
|
// opposing is of type "import". Convert to correct type (by amount):
|
|
$type = $entry->fields['opposing-account']->accountType->type;
|
|
if ($type == AccountType::IMPORT && $entry->fields['amount'] < 0) {
|
|
$account = $this->convertAccount($entry->fields['opposing-account'], AccountType::EXPENSE);
|
|
$entry->fields['opposing-account'] = $account;
|
|
Log::debug('Converted import account to expense account');
|
|
|
|
return $entry;
|
|
}
|
|
if ($type == AccountType::IMPORT && $entry->fields['amount'] > 0) {
|
|
$account = $this->convertAccount($entry->fields['opposing-account'], AccountType::REVENUE);
|
|
$entry->fields['opposing-account'] = $account;
|
|
Log::debug('Converted import account to revenue account');
|
|
|
|
return $entry;
|
|
}
|
|
// amount < 0, but opposing is revenue
|
|
if ($type == AccountType::REVENUE && $entry->fields['amount'] < 0) {
|
|
$account = $this->convertAccount($entry->fields['opposing-account'], AccountType::EXPENSE);
|
|
$entry->fields['opposing-account'] = $account;
|
|
Log::debug('Converted revenue account to expense account');
|
|
|
|
return $entry;
|
|
}
|
|
|
|
// amount > 0, but opposing is expense
|
|
if ($type == AccountType::EXPENSE && $entry->fields['amount'] < 0) {
|
|
$account = $this->convertAccount($entry->fields['opposing-account'], AccountType::REVENUE);
|
|
$entry->fields['opposing-account'] = $account;
|
|
Log::debug('Converted expense account to revenue account');
|
|
|
|
return $entry;
|
|
}
|
|
// account type is OK
|
|
Log::debug('Opposing account is OK.');
|
|
|
|
return $entry;
|
|
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function setTransactionCurrency(ImportEntry $entry): ImportEntry
|
|
{
|
|
if (is_null($entry->fields['currency'])) {
|
|
/** @var CurrencyRepositoryInterface $repository */
|
|
$repository = app(CurrencyRepositoryInterface::class);
|
|
$entry->fields['currency'] = $repository->findByCode(env('DEFAULT_CURRENCY', 'EUR'));
|
|
Log::debug('Set currency to EUR');
|
|
|
|
return $entry;
|
|
}
|
|
Log::debug('Currency is OK');
|
|
|
|
return $entry;
|
|
}
|
|
|
|
/**
|
|
* @param ImportEntry $entry
|
|
*
|
|
* @return ImportEntry
|
|
*/
|
|
private function setTransactionType(ImportEntry $entry): ImportEntry
|
|
{
|
|
Log::debug(sprintf('Opposing account is of type %s', $entry->fields['opposing-account']->accountType->type));
|
|
$type = $entry->fields['opposing-account']->accountType->type;
|
|
switch ($type) {
|
|
case AccountType::EXPENSE:
|
|
$entry->fields['transaction-type'] = TransactionType::whereType(TransactionType::WITHDRAWAL)->first();
|
|
Log::debug('Transaction type is now withdrawal.');
|
|
|
|
return $entry;
|
|
case AccountType::REVENUE:
|
|
$entry->fields['transaction-type'] = TransactionType::whereType(TransactionType::DEPOSIT)->first();
|
|
Log::debug('Transaction type is now deposit.');
|
|
|
|
return $entry;
|
|
case AccountType::ASSET:
|
|
$entry->fields['transaction-type'] = TransactionType::whereType(TransactionType::TRANSFER)->first();
|
|
Log::debug('Transaction type is now transfer.');
|
|
|
|
return $entry;
|
|
}
|
|
Log::error(sprintf('Opposing account is of type %s, cannot handle this.', $type));
|
|
$entry->valid = false;
|
|
|
|
return $entry;
|
|
}
|
|
|
|
|
|
} |