mirror of
https://github.com/firefly-iii/firefly-iii.git
synced 2025-10-31 18:54:58 +00:00
374 lines
12 KiB
PHP
374 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* ExpandedProcessor.php
|
|
* Copyright (c) 2018 thegrumpydictator@gmail.com
|
|
*
|
|
* This file is part of Firefly III.
|
|
*
|
|
* Firefly III is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Firefly III 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Firefly III. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/** @noinspection PhpDynamicAsStaticMethodCallInspection */
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace FireflyIII\Export;
|
|
|
|
use Crypt;
|
|
use DB;
|
|
use FireflyIII\Exceptions\FireflyException;
|
|
use FireflyIII\Export\Collector\AttachmentCollector;
|
|
use FireflyIII\Export\Collector\UploadCollector;
|
|
use FireflyIII\Export\Entry\Entry;
|
|
use FireflyIII\Export\Exporter\ExporterInterface;
|
|
use FireflyIII\Helpers\Collector\JournalCollectorInterface;
|
|
use FireflyIII\Helpers\Filter\InternalTransferFilter;
|
|
use FireflyIII\Models\AccountMeta;
|
|
use FireflyIII\Models\ExportJob;
|
|
use FireflyIII\Models\Note;
|
|
use FireflyIII\Models\Transaction;
|
|
use FireflyIII\Models\TransactionJournal;
|
|
use FireflyIII\Repositories\Currency\CurrencyRepositoryInterface;
|
|
use Illuminate\Support\Collection;
|
|
use Log;
|
|
use Storage;
|
|
use ZipArchive;
|
|
|
|
/**
|
|
* Class ExpandedProcessor.
|
|
*
|
|
* @SuppressWarnings(PHPMD.CouplingBetweenObjects) // its doing a lot.
|
|
*/
|
|
class ExpandedProcessor implements ProcessorInterface
|
|
{
|
|
/** @var Collection All accounts */
|
|
public $accounts;
|
|
/** @var string The export format*/
|
|
public $exportFormat;
|
|
/** @var bool Should include attachments */
|
|
public $includeAttachments;
|
|
/** @var bool Should include old uploads */
|
|
public $includeOldUploads;
|
|
/** @var ExportJob The export job itself */
|
|
public $job;
|
|
/** @var array The settings*/
|
|
public $settings;
|
|
/** @var Collection The entries to export. */
|
|
private $exportEntries;
|
|
/** @var Collection The files to export */
|
|
private $files;
|
|
/** @var Collection The journals. */
|
|
private $journals;
|
|
|
|
/**
|
|
* Processor constructor.
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->journals = new Collection;
|
|
$this->exportEntries = new Collection;
|
|
$this->files = new Collection;
|
|
}
|
|
|
|
/**
|
|
* Collect all attachments
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function collectAttachments(): bool
|
|
{
|
|
/** @var AttachmentCollector $attachmentCollector */
|
|
$attachmentCollector = app(AttachmentCollector::class);
|
|
$attachmentCollector->setJob($this->job);
|
|
$attachmentCollector->setDates($this->settings['startDate'], $this->settings['endDate']);
|
|
$attachmentCollector->run();
|
|
$this->files = $this->files->merge($attachmentCollector->getEntries());
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Collects all transaction journals.
|
|
*
|
|
* @return bool
|
|
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
|
|
*/
|
|
public function collectJournals(): bool
|
|
{
|
|
// use journal collector thing.
|
|
/** @var JournalCollectorInterface $collector */
|
|
$collector = app(JournalCollectorInterface::class);
|
|
$collector->setUser($this->job->user);
|
|
$collector->setAccounts($this->accounts)->setRange($this->settings['startDate'], $this->settings['endDate'])
|
|
->withOpposingAccount()->withBudgetInformation()->withCategoryInformation()
|
|
->removeFilter(InternalTransferFilter::class);
|
|
$transactions = $collector->getJournals();
|
|
// get some more meta data for each entry:
|
|
$ids = $transactions->pluck('journal_id')->toArray();
|
|
$assetIds = $transactions->pluck('account_id')->toArray();
|
|
$opposingIds = $transactions->pluck('opposing_account_id')->toArray();
|
|
$notes = $this->getNotes($ids);
|
|
$tags = $this->getTags($ids);
|
|
/** @var array $ibans */
|
|
$ibans = array_merge($this->getIbans($assetIds), $this->getIbans($opposingIds));
|
|
$currencies = $this->getAccountCurrencies($ibans);
|
|
$transactions->each(
|
|
function (Transaction $transaction) use ($notes, $tags, $ibans, $currencies) {
|
|
$journalId = (int)$transaction->journal_id;
|
|
$accountId = (int)$transaction->account_id;
|
|
$opposingId = (int)$transaction->opposing_account_id;
|
|
$currencyId = (int)($ibans[$accountId]['currency_id'] ?? 0.0);
|
|
$opposingCurrencyId = (int)($ibans[$opposingId]['currency_id'] ?? 0.0);
|
|
$transaction->notes = $notes[$journalId] ?? '';
|
|
$transaction->tags = implode(',', $tags[$journalId] ?? []);
|
|
$transaction->account_number = $ibans[$accountId]['accountNumber'] ?? '';
|
|
$transaction->account_bic = $ibans[$accountId]['BIC'] ?? '';
|
|
$transaction->account_currency_code = $currencies[$currencyId] ?? '';
|
|
$transaction->opposing_account_number = $ibans[$opposingId]['accountNumber'] ?? '';
|
|
$transaction->opposing_account_bic = $ibans[$opposingId]['BIC'] ?? '';
|
|
$transaction->opposing_currency_code = $currencies[$opposingCurrencyId] ?? '';
|
|
}
|
|
);
|
|
|
|
$this->journals = $transactions;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get old oploads.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function collectOldUploads(): bool
|
|
{
|
|
/** @var UploadCollector $uploadCollector */
|
|
$uploadCollector = app(UploadCollector::class);
|
|
$uploadCollector->setJob($this->job);
|
|
$uploadCollector->run();
|
|
|
|
$this->files = $this->files->merge($uploadCollector->getEntries());
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Convert journals to export objects.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function convertJournals(): bool
|
|
{
|
|
$this->journals->each(
|
|
function (Transaction $transaction) {
|
|
$this->exportEntries->push(Entry::fromTransaction($transaction));
|
|
}
|
|
);
|
|
Log::debug(sprintf('Count %d entries in exportEntries (convertJournals)', $this->exportEntries->count()));
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Create a ZIP file.
|
|
*
|
|
* @return bool
|
|
*
|
|
* @throws FireflyException
|
|
* @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
|
|
*/
|
|
public function createZipFile(): bool
|
|
{
|
|
$zip = new ZipArchive;
|
|
$file = $this->job->key . '.zip';
|
|
$fullPath = storage_path('export') . '/' . $file;
|
|
|
|
if (true !== $zip->open($fullPath, ZipArchive::CREATE)) {
|
|
throw new FireflyException('Cannot store zip file.');
|
|
}
|
|
// for each file in the collection, add it to the zip file.
|
|
$disk = Storage::disk('export');
|
|
foreach ($this->getFiles() as $entry) {
|
|
// is part of this job?
|
|
$zipFileName = str_replace($this->job->key . '-', '', $entry);
|
|
$zip->addFromString($zipFileName, $disk->get($entry));
|
|
}
|
|
|
|
$zip->close();
|
|
|
|
// delete the files:
|
|
$this->deleteFiles();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Export the journals.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function exportJournals(): bool
|
|
{
|
|
$exporterClass = config('firefly.export_formats.' . $this->exportFormat);
|
|
/** @var ExporterInterface $exporter */
|
|
$exporter = app($exporterClass);
|
|
$exporter->setJob($this->job);
|
|
$exporter->setEntries($this->exportEntries);
|
|
$exporter->run();
|
|
$this->files->push($exporter->getFileName());
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get files.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function getFiles(): Collection
|
|
{
|
|
return $this->files;
|
|
}
|
|
|
|
/**
|
|
* Save export job settings to class.
|
|
*
|
|
* @param array $settings
|
|
*/
|
|
public function setSettings(array $settings): void
|
|
{
|
|
// save settings
|
|
$this->settings = $settings;
|
|
$this->accounts = $settings['accounts'];
|
|
$this->exportFormat = $settings['exportFormat'];
|
|
$this->includeAttachments = $settings['includeAttachments'];
|
|
$this->includeOldUploads = $settings['includeOldUploads'];
|
|
$this->job = $settings['job'];
|
|
}
|
|
|
|
/**
|
|
* Delete files.
|
|
*/
|
|
private function deleteFiles():void
|
|
{
|
|
$disk = Storage::disk('export');
|
|
foreach ($this->getFiles() as $file) {
|
|
$disk->delete($file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get currencies.
|
|
*
|
|
* @param array $array
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getAccountCurrencies(array $array): array
|
|
{
|
|
/** @var CurrencyRepositoryInterface $repository */
|
|
$repository = app(CurrencyRepositoryInterface::class);
|
|
$return = [];
|
|
$ids = [];
|
|
$repository->setUser($this->job->user);
|
|
foreach ($array as $value) {
|
|
$ids[] = (int)($value['currency_id'] ?? 0.0);
|
|
}
|
|
$ids = array_unique($ids);
|
|
$result = $repository->getByIds($ids);
|
|
|
|
foreach ($result as $currency) {
|
|
$return[$currency->id] = $currency->code;
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Get all IBAN / SWIFT / account numbers.
|
|
*
|
|
* @param array $array
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getIbans(array $array): array
|
|
{
|
|
$array = array_unique($array);
|
|
$return = [];
|
|
$set = AccountMeta::whereIn('account_id', $array)
|
|
->leftJoin('accounts', 'accounts.id', 'account_meta.account_id')
|
|
->where('accounts.user_id', $this->job->user_id)
|
|
->whereIn('account_meta.name', ['accountNumber', 'BIC', 'currency_id'])
|
|
->get(['account_meta.id', 'account_meta.account_id', 'account_meta.name', 'account_meta.data']);
|
|
/** @var AccountMeta $meta */
|
|
foreach ($set as $meta) {
|
|
$id = (int)$meta->account_id;
|
|
$return[$id][$meta->name] = $meta->data;
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Returns, if present, for the given journal ID's the notes.
|
|
*
|
|
* @param array $array
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getNotes(array $array): array
|
|
{
|
|
$array = array_unique($array);
|
|
$notes = Note::where('notes.noteable_type', TransactionJournal::class)
|
|
->whereIn('notes.noteable_id', $array)
|
|
->get(['notes.*']);
|
|
$return = [];
|
|
/** @var Note $note */
|
|
foreach ($notes as $note) {
|
|
if (\strlen(trim((string)$note->text)) > 0) {
|
|
$id = (int)$note->noteable_id;
|
|
$return[$id] = $note->text;
|
|
}
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Returns a comma joined list of all the users tags linked to these journals.
|
|
*
|
|
* @param array $array
|
|
*
|
|
* @return array
|
|
* @throws \Illuminate\Contracts\Encryption\DecryptException
|
|
*/
|
|
private function getTags(array $array): array
|
|
{
|
|
$set = DB::table('tag_transaction_journal')
|
|
->whereIn('tag_transaction_journal.transaction_journal_id', $array)
|
|
->leftJoin('tags', 'tag_transaction_journal.tag_id', '=', 'tags.id')
|
|
->leftJoin('transaction_journals', 'transaction_journals.id', '=', 'tag_transaction_journal.transaction_journal_id')
|
|
->where('transaction_journals.user_id', $this->job->user_id)
|
|
->get(['tag_transaction_journal.transaction_journal_id', 'tags.tag']);
|
|
$result = [];
|
|
foreach ($set as $entry) {
|
|
$id = (int)$entry->transaction_journal_id;
|
|
$result[$id] = $result[$id] ?? [];
|
|
$result[$id][] = Crypt::decrypt($entry->tag);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
}
|