mirror of
https://github.com/firefly-iii/firefly-iii.git
synced 2025-09-18 18:44:16 +00:00
375 lines
12 KiB
PHP
375 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* ImportStorage.php
|
|
* Copyright (c) 2017 thegrumpydictator@gmail.com
|
|
* This software may be modified and distributed under the terms of the Creative Commons Attribution-ShareAlike 4.0 International License.
|
|
*
|
|
* See the LICENSE file for details.
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace FireflyIII\Import\Storage;
|
|
|
|
use Amount;
|
|
use Carbon\Carbon;
|
|
use FireflyIII\Exceptions\FireflyException;
|
|
use FireflyIII\Import\Object\ImportAccount;
|
|
use FireflyIII\Import\Object\ImportJournal;
|
|
use FireflyIII\Models\Account;
|
|
use FireflyIII\Models\AccountType;
|
|
use FireflyIII\Models\Bill;
|
|
use FireflyIII\Models\Budget;
|
|
use FireflyIII\Models\Category;
|
|
use FireflyIII\Models\ImportJob;
|
|
use FireflyIII\Models\Rule;
|
|
use FireflyIII\Models\Transaction;
|
|
use FireflyIII\Models\TransactionCurrency;
|
|
use FireflyIII\Models\TransactionJournal;
|
|
use FireflyIII\Models\TransactionType;
|
|
use FireflyIII\Rules\Processor;
|
|
use Illuminate\Support\Collection;
|
|
use Illuminate\Support\MessageBag;
|
|
use Log;
|
|
use Steam;
|
|
|
|
/**
|
|
* Is capable of storing individual ImportJournal objects.
|
|
* Class ImportStorage
|
|
*
|
|
* @package FireflyIII\Import\Storage
|
|
*/
|
|
class ImportStorage
|
|
{
|
|
/** @var Collection */
|
|
public $errors;
|
|
public $journals;
|
|
/** @var string */
|
|
private $dateFormat = 'Ymd';
|
|
/** @var TransactionCurrency */
|
|
private $defaultCurrency;
|
|
/** @var ImportJob */
|
|
private $job;
|
|
/** @var Collection */
|
|
private $objects;
|
|
/** @var Collection */
|
|
private $rules;
|
|
|
|
/**
|
|
* ImportStorage constructor.
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->objects = new Collection;
|
|
$this->journals = new Collection;
|
|
$this->errors = new Collection;
|
|
}
|
|
|
|
/**
|
|
* @param string $dateFormat
|
|
*/
|
|
public function setDateFormat(string $dateFormat)
|
|
{
|
|
$this->dateFormat = $dateFormat;
|
|
}
|
|
|
|
/**
|
|
* @param ImportJob $job
|
|
*/
|
|
public function setJob(ImportJob $job)
|
|
{
|
|
$this->job = $job;
|
|
$this->rules = $this->getUserRules();
|
|
}
|
|
|
|
/**
|
|
* @param Collection $objects
|
|
*/
|
|
public function setObjects(Collection $objects)
|
|
{
|
|
$this->objects = $objects;
|
|
}
|
|
|
|
/**
|
|
* Do storage of import objects
|
|
*/
|
|
public function store()
|
|
{
|
|
$this->defaultCurrency = Amount::getDefaultCurrencyByUser($this->job->user);
|
|
|
|
// routine below consists of 3 steps.
|
|
/**
|
|
* @var int $index
|
|
* @var ImportJournal $object
|
|
*/
|
|
foreach ($this->objects as $index => $object) {
|
|
try {
|
|
$this->storeImportJournal($index, $object);
|
|
} catch (FireflyException $e) {
|
|
$this->errors->push($e->getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* @param TransactionJournal $journal
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function applyRules(TransactionJournal $journal): bool
|
|
{
|
|
if ($this->rules->count() > 0) {
|
|
|
|
/** @var Rule $rule */
|
|
foreach ($this->rules as $rule) {
|
|
Log::debug(sprintf('Going to apply rule #%d to journal %d.', $rule->id, $journal->id));
|
|
$processor = Processor::make($rule);
|
|
$processor->handleTransactionJournal($journal);
|
|
|
|
if ($rule->stop_processing) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param int $journalId
|
|
* @param int $accountId
|
|
* @param int $currencyId
|
|
* @param string $amount
|
|
*
|
|
* @return bool
|
|
* @throws FireflyException
|
|
*/
|
|
private function createTransaction(int $journalId, int $accountId, int $currencyId, string $amount): bool
|
|
{
|
|
$transaction = new Transaction;
|
|
$transaction->account_id = $accountId;
|
|
$transaction->transaction_journal_id = $journalId;
|
|
$transaction->transaction_currency_id = $currencyId;
|
|
$transaction->amount = $amount;
|
|
$transaction->save();
|
|
if (is_null($transaction->id)) {
|
|
$errorText = join(', ', $transaction->getErrors()->all());
|
|
throw new FireflyException($errorText);
|
|
}
|
|
Log::debug(sprintf('Created transaction with ID #%d and account #%d', $transaction->id, $accountId));
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param ImportJournal $importJournal
|
|
*
|
|
* @return TransactionCurrency
|
|
*/
|
|
private function getCurrency(ImportJournal $importJournal): TransactionCurrency
|
|
{
|
|
$currency = $importJournal->getCurrency()->getTransactionCurrency();
|
|
if (is_null($currency->id)) {
|
|
$currency = $this->defaultCurrency;
|
|
}
|
|
|
|
return $currency;
|
|
}
|
|
|
|
/**
|
|
* @param ImportAccount $account
|
|
* @param $amount
|
|
*
|
|
* @return Account
|
|
*/
|
|
private function getOpposingAccount(ImportAccount $account, $amount): Account
|
|
{
|
|
if (bccomp($amount, '0') === -1) {
|
|
Log::debug(sprintf('%s is negative, create opposing expense account.', $amount));
|
|
$account->setExpectedType(AccountType::EXPENSE);
|
|
|
|
return $account->getAccount();
|
|
}
|
|
Log::debug(sprintf('%s is positive, create opposing revenue account.', $amount));
|
|
// amount is positive, it's a deposit, opposing is an revenue:
|
|
$account->setExpectedType(AccountType::REVENUE);
|
|
|
|
return $account->getAccount();
|
|
|
|
}
|
|
|
|
/**
|
|
* @param string $amount
|
|
*
|
|
* @return TransactionType
|
|
*/
|
|
private function getTransactionType(string $amount): TransactionType
|
|
{
|
|
$transactionType = new TransactionType();
|
|
// amount is negative, it's a withdrawal, opposing is an expense:
|
|
if (bccomp($amount, '0') === -1) {
|
|
$transactionType = TransactionType::whereType(TransactionType::WITHDRAWAL)->first();
|
|
}
|
|
if (bccomp($amount, '0') === 1) {
|
|
$transactionType = TransactionType::whereType(TransactionType::DEPOSIT)->first();
|
|
}
|
|
|
|
return $transactionType;
|
|
}
|
|
|
|
/**
|
|
* @return Collection
|
|
*/
|
|
private function getUserRules(): Collection
|
|
{
|
|
$set = Rule::distinct()
|
|
->where('rules.user_id', $this->job->user->id)
|
|
->leftJoin('rule_groups', 'rule_groups.id', '=', 'rules.rule_group_id')
|
|
->leftJoin('rule_triggers', 'rules.id', '=', 'rule_triggers.rule_id')
|
|
->where('rule_groups.active', 1)
|
|
->where('rule_triggers.trigger_type', 'user_action')
|
|
->where('rule_triggers.trigger_value', 'store-journal')
|
|
->where('rules.active', 1)
|
|
->orderBy('rule_groups.order', 'ASC')
|
|
->orderBy('rules.order', 'ASC')
|
|
->get(['rules.*', 'rule_groups.order']);
|
|
Log::debug(sprintf('Found %d user rules.', $set->count()));
|
|
|
|
return $set;
|
|
|
|
}
|
|
|
|
/**
|
|
* @param TransactionJournal $journal
|
|
* @param Bill $bill
|
|
*/
|
|
private function storeBill(TransactionJournal $journal, Bill $bill)
|
|
{
|
|
if (!is_null($bill->id)) {
|
|
Log::debug(sprintf('Linked bill #%d to journal #%d', $bill->id, $journal->id));
|
|
$journal->bill()->associate($bill);
|
|
$journal->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param TransactionJournal $journal
|
|
* @param Budget $budget
|
|
*/
|
|
private function storeBudget(TransactionJournal $journal, Budget $budget)
|
|
{
|
|
if (!is_null($budget->id)) {
|
|
Log::debug(sprintf('Linked budget #%d to journal #%d', $budget->id, $journal->id));
|
|
$journal->budgets()->save($budget);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param TransactionJournal $journal
|
|
* @param Category $category
|
|
*/
|
|
private function storeCategory(TransactionJournal $journal, Category $category)
|
|
{
|
|
|
|
if (!is_null($category->id)) {
|
|
Log::debug(sprintf('Linked category #%d to journal #%d', $category->id, $journal->id));
|
|
$journal->categories()->save($category);
|
|
}
|
|
|
|
}
|
|
|
|
private function storeImportJournal(int $index, ImportJournal $importJournal): bool
|
|
{
|
|
Log::debug(sprintf('Going to store object #%d with description "%s"', $index, $importJournal->description));
|
|
|
|
$asset = $importJournal->asset->getAccount();
|
|
$amount = $importJournal->getAmount();
|
|
$currency = $this->getCurrency($importJournal);
|
|
$date = $importJournal->getDate($this->dateFormat);
|
|
$transactionType = $this->getTransactionType($amount);
|
|
$opposing = $this->getOpposingAccount($importJournal->opposing, $amount);
|
|
|
|
// if opposing is an asset account, it's a transfer:
|
|
if ($opposing->accountType->type === AccountType::ASSET) {
|
|
Log::debug(sprintf('Opposing account #%d %s is an asset account, make transfer.', $opposing->id, $opposing->name));
|
|
$transactionType = TransactionType::whereType(TransactionType::TRANSFER)->first();
|
|
}
|
|
|
|
/*** First step done! */
|
|
$this->job->addStepsDone(1);
|
|
|
|
// create a journal:
|
|
$journal = new TransactionJournal;
|
|
$journal->user_id = $this->job->user_id;
|
|
$journal->transaction_type_id = $transactionType->id;
|
|
$journal->transaction_currency_id = $currency->id;
|
|
$journal->description = $importJournal->description;
|
|
$journal->date = $date->format('Y-m-d');
|
|
$journal->order = 0;
|
|
$journal->tag_count = 0;
|
|
$journal->completed = false;
|
|
|
|
if (!$journal->save()) {
|
|
$errorText = join(', ', $journal->getErrors()->all());
|
|
$this->job->addStepsDone(3);
|
|
throw new FireflyException($errorText);
|
|
}
|
|
|
|
// save meta data:
|
|
$journal->setMeta('importHash', $importJournal->hash);
|
|
Log::debug(sprintf('Created journal with ID #%d', $journal->id));
|
|
|
|
// create transactions:
|
|
$this->createTransaction($journal->id, $asset->id, $currency->id, $amount);
|
|
$this->createTransaction($journal->id, $opposing->id, $currency->id, Steam::opposite($amount));
|
|
|
|
/*** Another step done! */
|
|
$this->job->addStepsDone(1);
|
|
|
|
// store meta object things:
|
|
$this->storeCategory($journal, $importJournal->category->getCategory());
|
|
$this->storeBudget($journal, $importJournal->budget->getBudget());
|
|
$this->storeBill($journal, $importJournal->bill->getBill());
|
|
$this->storeMeta($journal, $importJournal->metaDates);
|
|
|
|
// sepa thing as note:
|
|
if (strlen($importJournal->notes) > 0) {
|
|
$journal->setMeta('notes', $importJournal->notes);
|
|
}
|
|
|
|
// set journal completed:
|
|
$journal->completed = true;
|
|
$journal->save();
|
|
|
|
$this->job->addStepsDone(1);
|
|
|
|
// run rules:
|
|
$this->applyRules($journal);
|
|
$this->job->addStepsDone(1);
|
|
|
|
$this->journals->push($journal);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param TransactionJournal $journal
|
|
* @param array $dates
|
|
*/
|
|
private function storeMeta(TransactionJournal $journal, array $dates)
|
|
{
|
|
// all other date fields as meta thing:
|
|
foreach ($dates as $name => $value) {
|
|
try {
|
|
$date = new Carbon($value);
|
|
$journal->setMeta($name, $date);
|
|
} catch (\Exception $e) {
|
|
// don't care, ignore:
|
|
Log::warning(sprintf('Could not parse "%s" into a valid Date object for field %s', $value, $name));
|
|
}
|
|
}
|
|
}
|
|
|
|
} |