MigrateToGroups::makeMultiGroup() - Code Metrics - Inspection of "Merge branch 'release/4.8.1.1'" - firefly-iii/firefly-iii - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d550a6...996863 )

by James

created 2019-09-13 17:16 UTC

MigrateToGroups::makeMultiGroup() B

↳ Parent: MigrateToGroups

Complexity

Conditions	4
Paths	4

Size

Total Lines	129
Code Lines	97

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	97
c	2
b	0
f	0
dl	0
loc	129
rs	8.0654
cc	4
nc	4
nop	1

How to fix Long Method

<?php
declare(strict_types=1);
/**
 * MigrateToGroups.php
 * Copyright (c) 2019 [email protected]
 *
 * 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/>.
 */

namespace FireflyIII\Console\Commands\Upgrade;

use DB;
use Exception;
use FireflyIII\Factory\TransactionGroupFactory;
use FireflyIII\Models\Budget;
use FireflyIII\Models\Category;
use FireflyIII\Models\Transaction;
use FireflyIII\Models\TransactionJournal;
use FireflyIII\Repositories\Journal\JournalCLIRepositoryInterface;
use FireflyIII\Repositories\Journal\JournalRepositoryInterface;
use FireflyIII\Services\Internal\Destroy\JournalDestroyService;
use Illuminate\Console\Command;
use Illuminate\Support\Collection;
use Log;

/**
 * This command will take split transactions and migrate them to "transaction groups".
 *
 * It will only run once, but can be forced to run again.
 *
 * Class MigrateToGroups
 */
class MigrateToGroups extends Command
{
    public const CONFIG_NAME = '480_migrated_to_groups';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Migrates a pre-4.7.8 transaction structure to the 4.7.8+ transaction structure.';
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'firefly-iii:migrate-to-groups {--F|force : Force the migration, even if it fired before.}';
    /** @var TransactionGroupFactory */
    private $groupFactory;
    /** @var JournalRepositoryInterface */
    private $journalRepository;
    /** @var JournalCLIRepositoryInterface */
    private $cliRepository;
    /** @var JournalDestroyService */
    private $service;
    private $count;

    /**
     * Execute the console command.
     *
     * @return int
     * @throws Exception
     */
    public function handle(): int
    {
        $this->stupidLaravel();
        $start = microtime(true);
        // @codeCoverageIgnoreStart
        if ($this->isMigrated() && true !== $this->option('force')) {
            $this->info('Database already seems to be migrated.');

            return 0;
        }

        if (true === $this->option('force')) {

            $this->warn('Forcing the migration.');
        }
        // @codeCoverageIgnoreEnd

        Log::debug('---- start group migration ----');
        $this->makeGroupsFromSplitJournals();
        $end = round(microtime(true) - $start, 2);
        $this->info(sprintf('Migrate split journals to groups in %s seconds.', $end));

        $start = microtime(true);
        $this->makeGroupsFromAll();
        Log::debug('---- end group migration ----');
        $end = round(microtime(true) - $start, 2);
        $this->info(sprintf('Migrate all journals to groups in %s seconds.', $end));

        if (0 !== $this->count) {
            $this->line(sprintf('Migrated %d transaction journal(s).', $this->count));
        }
        if (0 === $this->count) {
            $this->line('No journals to migrate to groups.');
        }


        $this->markAsMigrated();


        return 0;
    }

    /**
     * Laravel will execute ALL __construct() methods for ALL commands whenever a SINGLE command is
     * executed. This leads to noticeable slow-downs and class calls. To prevent this, this method should
     * be called from the handle method instead of using the constructor to initialize the command.
     *
     * @codeCoverageIgnore
     */
    private function stupidLaravel(): void
    {
        $this->count             = 0;
        $this->journalRepository = app(JournalRepositoryInterface::class);
        $this->service           = app(JournalDestroyService::class);
        $this->groupFactory      = app(TransactionGroupFactory::class);
        $this->cliRepository     = app(JournalCLIRepositoryInterface::class);
    }

    /**
     * @param TransactionJournal $journal
     * @param Transaction $transaction
     *
     * @return Transaction|null
     */
    private function findOpposingTransaction(TransactionJournal $journal, Transaction $transaction): ?Transaction
    {
        $set = $journal->transactions->filter(
            static function (Transaction $subject) use ($transaction) {
                $amount     = (float)$transaction->amount * -1 === (float)$subject->amount;
                $identifier = $transaction->identifier === $subject->identifier;
                Log::debug(sprintf('Amount the same? %s', var_export($amount, true)));
                Log::debug(sprintf('ID the same?     %s', var_export($identifier, true)));

                return $amount && $identifier;
            }
        );

        return $set->first();
    }

    /**
     * @param TransactionJournal $journal
     *
     * @return Collection
     */
    private function getDestinationTransactions(TransactionJournal $journal): Collection
    {
        return $journal->transactions->filter(
            static function (Transaction $transaction) {
                return $transaction->amount > 0;
            }
        );
    }

    /**
     * @param array $array
     */
    private function giveGroup(array $array): void
    {
        $groupId = DB::table('transaction_groups')->insertGetId(
            [
                'created_at' => date('Y-m-d H:i:s'),
                'updated_at' => date('Y-m-d H:i:s'),
                'title'      => null,
                'user_id'    => $array['user_id'],
            ]
        );
        DB::table('transaction_journals')->where('id', $array['id'])->update(['transaction_group_id' => $groupId]);
        $this->count++;
    }

    /**
     * @return bool
     */
    private function isMigrated(): bool
    {
        $configVar = app('fireflyconfig')->get(self::CONFIG_NAME, false);
        if (null !== $configVar) {
            return (bool)$configVar->data;
        }

        return false; // @codeCoverageIgnore
    }

    /**
     * Gives all journals without a group a group.
     */
    private function makeGroupsFromAll(): void
    {
        $orphanedJournals = $this->cliRepository->getJournalsWithoutGroup();
        $count            = count($orphanedJournals);
        if ($count > 0) {
            Log::debug(sprintf('Going to convert %d transaction journals. Please hold..', $count));
            $this->line(sprintf('Going to convert %d transaction journals. Please hold..', $count));
            /** @var array $journal */
            foreach ($orphanedJournals as $array) {
                $this->giveGroup($array);
            }
        }
        if (0 === $count) {
            $this->info('No need to convert transaction journals.');
        }
    }

    /**
     * @throws Exception
     */
    private function makeGroupsFromSplitJournals(): void
    {
        $splitJournals = $this->cliRepository->getSplitJournals();
        if ($splitJournals->count() > 0) {
            $this->info(sprintf('Going to convert %d split transaction(s). Please hold..', $splitJournals->count()));
            /** @var TransactionJournal $journal */
            foreach ($splitJournals as $journal) {
                $this->makeMultiGroup($journal);
            }
        }
        if (0 === $splitJournals->count()) {
            $this->info('Found no split transaction journals. Nothing to do.');
        }
    }

    /**
     * @param TransactionJournal $journal
     *
     * @throws Exception
     *
     */
    private function makeMultiGroup(TransactionJournal $journal): void
    {
        // double check transaction count.
        if ($journal->transactions->count() <= 2) {
            // @codeCoverageIgnoreStart
            Log::debug(sprintf('Will not try to convert journal #%d because it has 2 or less transactions.', $journal->id));

            return;
            // @codeCoverageIgnoreEnd
        }
        Log::debug(sprintf('Will now try to convert journal #%d', $journal->id));

        $this->journalRepository->setUser($journal->user);
        $this->groupFactory->setUser($journal->user);
        $this->cliRepository->setUser($journal->user);

        $data             = [
            // mandatory fields.
            'group_title'  => $journal->description,
            'transactions' => [],
        ];
        $destTransactions = $this->getDestinationTransactions($journal);
        $budgetId         = $this->cliRepository->getJournalBudgetId($journal);
        $categoryId       = $this->cliRepository->getJournalCategoryId($journal);
        $notes            = $this->cliRepository->getNoteText($journal);
        $tags             = $this->cliRepository->getTags($journal);
        $internalRef      = $this->cliRepository->getMetaField($journal, 'internal-reference');
        $sepaCC           = $this->cliRepository->getMetaField($journal, 'sepa_cc');
        $sepaCtOp         = $this->cliRepository->getMetaField($journal, 'sepa_ct_op');
        $sepaCtId         = $this->cliRepository->getMetaField($journal, 'sepa_ct_id');
        $sepaDb           = $this->cliRepository->getMetaField($journal, 'sepa_db');
        $sepaCountry      = $this->cliRepository->getMetaField($journal, 'sepa_country');
        $sepaEp           = $this->cliRepository->getMetaField($journal, 'sepa_ep');
        $sepaCi           = $this->cliRepository->getMetaField($journal, 'sepa_ci');
        $sepaBatchId      = $this->cliRepository->getMetaField($journal, 'sepa_batch_id');
        $externalId       = $this->cliRepository->getMetaField($journal, 'external-id');
        $originalSource   = $this->cliRepository->getMetaField($journal, 'original-source');
        $recurrenceId     = $this->cliRepository->getMetaField($journal, 'recurrence_id');
        $bunq             = $this->cliRepository->getMetaField($journal, 'bunq_payment_id');
        $hash             = $this->cliRepository->getMetaField($journal, 'import_hash');
        $hashTwo          = $this->cliRepository->getMetaField($journal, 'import_hash_v2');
        $interestDate     = $this->cliRepository->getMetaDate($journal, 'interest_date');
        $bookDate         = $this->cliRepository->getMetaDate($journal, 'book_date');
        $processDate      = $this->cliRepository->getMetaDate($journal, 'process_date');
        $dueDate          = $this->cliRepository->getMetaDate($journal, 'due_date');
        $paymentDate      = $this->cliRepository->getMetaDate($journal, 'payment_date');
        $invoiceDate      = $this->cliRepository->getMetaDate($journal, 'invoice_date');

        Log::debug(sprintf('Will use %d positive transactions to create a new group.', $destTransactions->count()));

        /** @var Transaction $transaction */
        foreach ($destTransactions as $transaction) {
            Log::debug(sprintf('Now going to add transaction #%d to the array.', $transaction->id));
            $opposingTr = $this->findOpposingTransaction($journal, $transaction);

            if (null === $opposingTr) {
                // @codeCoverageIgnoreStart
                $this->error(
                    sprintf(
                        'Journal #%d has no opposing transaction for transaction #%d. Cannot upgrade this entry.',
                        $journal->id, $transaction->id
                    )
                );
                continue;
                // @codeCoverageIgnoreEnd
            }

            // overrule journal category with transaction category.
            $budgetId   = $this->getTransactionBudget($transaction, $opposingTr) ?? $budgetId;
            $categoryId = $this->getTransactionCategory($transaction, $opposingTr) ?? $categoryId;

            $tArray = [
                'type'                => strtolower($journal->transactionType->type),
                'date'                => $journal->date,
                'user'                => $journal->user_id,
                'currency_id'         => $transaction->transaction_currency_id,
                'foreign_currency_id' => $transaction->foreign_currency_id,
                'amount'              => $transaction->amount,
                'foreign_amount'      => $transaction->foreign_amount,
                'description'         => $transaction->description ?? $journal->description,
                'source_id'           => $opposingTr->account_id,
                'destination_id'      => $transaction->account_id,
                'budget_id'           => $budgetId,
                'category_id'         => $categoryId,
                'bill_id'             => $journal->bill_id,
                'notes'               => $notes,
                'tags'                => $tags,
                'internal_reference'  => $internalRef,
                'sepa_cc'             => $sepaCC,
                'sepa_ct_op'          => $sepaCtOp,
                'sepa_ct_id'          => $sepaCtId,
                'sepa_db'             => $sepaDb,
                'sepa_country'        => $sepaCountry,
                'sepa_ep'             => $sepaEp,
                'sepa_ci'             => $sepaCi,
                'sepa_batch_id'       => $sepaBatchId,
                'external_id'         => $externalId,
                'original-source'     => $originalSource,
                'recurrence_id'       => $recurrenceId,
                'bunq_payment_id'     => $bunq,
                'import_hash'         => $hash,
                'import_hash_v2'      => $hashTwo,
                'interest_date'       => $interestDate,
                'book_date'           => $bookDate,
                'process_date'        => $processDate,
                'due_date'            => $dueDate,
                'payment_date'        => $paymentDate,
                'invoice_date'        => $invoiceDate,
            ];

            $data['transactions'][] = $tArray;
        }
        Log::debug(sprintf('Now calling transaction journal factory (%d transactions in array)', count($data['transactions'])));
        $group = $this->groupFactory->create($data);
        Log::debug('Done calling transaction journal factory');

        // delete the old transaction journal.
        $this->service->destroy($journal);

        $this->count++;

        // report on result:
        Log::debug(
            sprintf('Migrated journal #%d into group #%d with these journals: #%s',
                    $journal->id, $group->id, implode(', #', $group->transactionJournals->pluck('id')->toArray()))
        );
        $this->line(
            sprintf('Migrated journal #%d into group #%d with these journals: #%s',
                    $journal->id, $group->id, implode(', #', $group->transactionJournals->pluck('id')->toArray()))
        );
    }

    /**
     * @param Transaction $left
     * @param Transaction $right
     *
     * @return int|null
     */
    private function getTransactionBudget(Transaction $left, Transaction $right): ?int
    {
        Log::debug('Now in getTransactionBudget()');

        // try to get a budget ID from the left transaction:
        /** @var Budget $budget */
        $budget = $left->budgets()->first();
        if (null !== $budget) {
            Log::debug(sprintf('Return budget #%d, from transaction #%d', $budget->id, $left->id));

            return (int)$budget->id;
        }

        // try to get a budget ID from the right transaction:
        /** @var Budget $budget */
        $budget = $right->budgets()->first();
        if (null !== $budget) {
            Log::debug(sprintf('Return budget #%d, from transaction #%d', $budget->id, $right->id));

            return (int)$budget->id;
        }
        Log::debug('Neither left or right have a budget, return NULL');

        // if all fails, return NULL.
        return null;
    }

    /**
     * @param Transaction $left
     * @param Transaction $right
     *
     * @return int|null
     */
    private function getTransactionCategory(Transaction $left, Transaction $right): ?int
    {
        Log::debug('Now in getTransactionCategory()');

        // try to get a category ID from the left transaction:
        /** @var Category $category */
        $category = $left->categories()->first();
        if (null !== $category) {
            Log::debug(sprintf('Return category #%d, from transaction #%d', $category->id, $left->id));

            return (int)$category->id;
        }

        // try to get a category ID from the left transaction:
        /** @var Category $category */
        $category = $right->categories()->first();
        if (null !== $category) {
            Log::debug(sprintf('Return category #%d, from transaction #%d', $category->id, $category->id));

            return (int)$category->id;
        }
        Log::debug('Neither left or right have a category, return NULL');

        // if all fails, return NULL.
        return null;
    }

    /**
     *
     */
    private function markAsMigrated(): void
    {
        app('fireflyconfig')->set(self::CONFIG_NAME, true);
    }

}


1			<?php
2			declare(strict_types=1);
3			/**
4			* MigrateToGroups.php
5			* Copyright (c) 2019 [email protected]
6			*
7			* This file is part of Firefly III.
8			*
9			* Firefly III is free software: you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License as published by
11			* the Free Software Foundation, either version 3 of the License, or
12			* (at your option) any later version.
13			*
14			* Firefly III is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18			*
19			* You should have received a copy of the GNU General Public License
20			* along with Firefly III. If not, see <http://www.gnu.org/licenses/>.
21			*/
22
23			namespace FireflyIII\Console\Commands\Upgrade;
24
25			use DB;
26			use Exception;
27			use FireflyIII\Factory\TransactionGroupFactory;
28			use FireflyIII\Models\Budget;
29			use FireflyIII\Models\Category;
30			use FireflyIII\Models\Transaction;
31			use FireflyIII\Models\TransactionJournal;
32			use FireflyIII\Repositories\Journal\JournalCLIRepositoryInterface;
33			use FireflyIII\Repositories\Journal\JournalRepositoryInterface;
34			use FireflyIII\Services\Internal\Destroy\JournalDestroyService;
35			use Illuminate\Console\Command;
36			use Illuminate\Support\Collection;
37			use Log;
38
39			/**
40			* This command will take split transactions and migrate them to "transaction groups".
41			*
42			* It will only run once, but can be forced to run again.
43			*
44			* Class MigrateToGroups
45			*/
46			class MigrateToGroups extends Command
47			{
48			public const CONFIG_NAME = '480_migrated_to_groups';
49			/**
50			* The console command description.
51			*
52			* @var string
53			*/
54			protected $description = 'Migrates a pre-4.7.8 transaction structure to the 4.7.8+ transaction structure.';
55			/**
56			* The name and signature of the console command.
57			*
58			* @var string
59			*/
60			protected $signature = 'firefly-iii:migrate-to-groups {--F\|force : Force the migration, even if it fired before.}';
61			/** @var TransactionGroupFactory */
62			private $groupFactory;
63			/** @var JournalRepositoryInterface */
64			private $journalRepository;
65			/** @var JournalCLIRepositoryInterface */
66			private $cliRepository;
67			/** @var JournalDestroyService */
68			private $service;
69			private $count;
70
71			/**
72			* Execute the console command.
73			*
74			* @return int
75			* @throws Exception
76			*/
77			public function handle(): int
78			{
79			$this->stupidLaravel();
80			$start = microtime(true);
81			// @codeCoverageIgnoreStart
82			if ($this->isMigrated() && true !== $this->option('force')) {
83			$this->info('Database already seems to be migrated.');
84
85			return 0;
86			}
87
88			if (true === $this->option('force')) {
			0 ignored issues – show introduced 2019-05-29 20:31 UTC by Report Bug Copy Issue Report The condition `true === $this->option('force')` is always `false`. Loading history...
89			$this->warn('Forcing the migration.');
90			}
91			// @codeCoverageIgnoreEnd
92
93			Log::debug('---- start group migration ----');
94			$this->makeGroupsFromSplitJournals();
95			$end = round(microtime(true) - $start, 2);
96			$this->info(sprintf('Migrate split journals to groups in %s seconds.', $end));
97
98			$start = microtime(true);
99			$this->makeGroupsFromAll();
100			Log::debug('---- end group migration ----');
101			$end = round(microtime(true) - $start, 2);
102			$this->info(sprintf('Migrate all journals to groups in %s seconds.', $end));
103
104			if (0 !== $this->count) {
105			$this->line(sprintf('Migrated %d transaction journal(s).', $this->count));
106			}
107			if (0 === $this->count) {
108			$this->line('No journals to migrate to groups.');
109			}
110
111
112			$this->markAsMigrated();
113
114
115			return 0;
116			}
117
118			/**
119			* Laravel will execute ALL __construct() methods for ALL commands whenever a SINGLE command is
120			* executed. This leads to noticeable slow-downs and class calls. To prevent this, this method should
121			* be called from the handle method instead of using the constructor to initialize the command.
122			*
123			* @codeCoverageIgnore
124			*/
125			private function stupidLaravel(): void
126			{
127			$this->count = 0;
128			$this->journalRepository = app(JournalRepositoryInterface::class);
129			$this->service = app(JournalDestroyService::class);
130			$this->groupFactory = app(TransactionGroupFactory::class);
131			$this->cliRepository = app(JournalCLIRepositoryInterface::class);
132			}
133
134			/**
135			* @param TransactionJournal $journal
136			* @param Transaction $transaction
137			*
138			* @return Transaction\|null
139			*/
140			private function findOpposingTransaction(TransactionJournal $journal, Transaction $transaction): ?Transaction
141			{
142			$set = $journal->transactions->filter(
143			static function (Transaction $subject) use ($transaction) {
144			$amount = (float)$transaction->amount * -1 === (float)$subject->amount;
145			$identifier = $transaction->identifier === $subject->identifier;
146			Log::debug(sprintf('Amount the same? %s', var_export($amount, true)));
147			Log::debug(sprintf('ID the same? %s', var_export($identifier, true)));
148
149			return $amount && $identifier;
150			}
151			);
152
153			return $set->first();
154			}
155
156			/**
157			* @param TransactionJournal $journal
158			*
159			* @return Collection
160			*/
161			private function getDestinationTransactions(TransactionJournal $journal): Collection
162			{
163			return $journal->transactions->filter(
164			static function (Transaction $transaction) {
165			return $transaction->amount > 0;
166			}
167			);
168			}
169
170			/**
171			* @param array $array
172			*/
173			private function giveGroup(array $array): void
174			{
175			$groupId = DB::table('transaction_groups')->insertGetId(
176			[
177			'created_at' => date('Y-m-d H:i:s'),
178			'updated_at' => date('Y-m-d H:i:s'),
179			'title' => null,
180			'user_id' => $array['user_id'],
181			]
182			);
183			DB::table('transaction_journals')->where('id', $array['id'])->update(['transaction_group_id' => $groupId]);
184			$this->count++;
185			}
186
187			/**
188			* @return bool
189			*/
190			private function isMigrated(): bool
191			{
192			$configVar = app('fireflyconfig')->get(self::CONFIG_NAME, false);
193			if (null !== $configVar) {
194			return (bool)$configVar->data;
195			}
196
197			return false; // @codeCoverageIgnore
198			}
199
200			/**
201			* Gives all journals without a group a group.
202			*/
203			private function makeGroupsFromAll(): void
204			{
205			$orphanedJournals = $this->cliRepository->getJournalsWithoutGroup();
206			$count = count($orphanedJournals);
207			if ($count > 0) {
208			Log::debug(sprintf('Going to convert %d transaction journals. Please hold..', $count));
209			$this->line(sprintf('Going to convert %d transaction journals. Please hold..', $count));
210			/** @var array $journal */
211			foreach ($orphanedJournals as $array) {
212			$this->giveGroup($array);
213			}
214			}
215			if (0 === $count) {
216			$this->info('No need to convert transaction journals.');
217			}
218			}
219
220			/**
221			* @throws Exception
222			*/
223			private function makeGroupsFromSplitJournals(): void
224			{
225			$splitJournals = $this->cliRepository->getSplitJournals();
226			if ($splitJournals->count() > 0) {
227			$this->info(sprintf('Going to convert %d split transaction(s). Please hold..', $splitJournals->count()));
228			/** @var TransactionJournal $journal */
229			foreach ($splitJournals as $journal) {
230			$this->makeMultiGroup($journal);
231			}
232			}
233			if (0 === $splitJournals->count()) {
234			$this->info('Found no split transaction journals. Nothing to do.');
235			}
236			}
237
238			/**
239			* @param TransactionJournal $journal
240			*
241			* @throws Exception
242			*
243			*/
244			private function makeMultiGroup(TransactionJournal $journal): void
245			{
246			// double check transaction count.
247			if ($journal->transactions->count() <= 2) {
248			// @codeCoverageIgnoreStart
249			Log::debug(sprintf('Will not try to convert journal #%d because it has 2 or less transactions.', $journal->id));
250
251			return;
252			// @codeCoverageIgnoreEnd
253			}
254			Log::debug(sprintf('Will now try to convert journal #%d', $journal->id));
255
256			$this->journalRepository->setUser($journal->user);
257			$this->groupFactory->setUser($journal->user);
258			$this->cliRepository->setUser($journal->user);
259
260			$data = [
261			// mandatory fields.
262			'group_title' => $journal->description,
263			'transactions' => [],
264			];
265			$destTransactions = $this->getDestinationTransactions($journal);
266			$budgetId = $this->cliRepository->getJournalBudgetId($journal);
267			$categoryId = $this->cliRepository->getJournalCategoryId($journal);
268			$notes = $this->cliRepository->getNoteText($journal);
269			$tags = $this->cliRepository->getTags($journal);
270			$internalRef = $this->cliRepository->getMetaField($journal, 'internal-reference');
271			$sepaCC = $this->cliRepository->getMetaField($journal, 'sepa_cc');
272			$sepaCtOp = $this->cliRepository->getMetaField($journal, 'sepa_ct_op');
273			$sepaCtId = $this->cliRepository->getMetaField($journal, 'sepa_ct_id');
274			$sepaDb = $this->cliRepository->getMetaField($journal, 'sepa_db');
275			$sepaCountry = $this->cliRepository->getMetaField($journal, 'sepa_country');
276			$sepaEp = $this->cliRepository->getMetaField($journal, 'sepa_ep');
277			$sepaCi = $this->cliRepository->getMetaField($journal, 'sepa_ci');
278			$sepaBatchId = $this->cliRepository->getMetaField($journal, 'sepa_batch_id');
279			$externalId = $this->cliRepository->getMetaField($journal, 'external-id');
280			$originalSource = $this->cliRepository->getMetaField($journal, 'original-source');
281			$recurrenceId = $this->cliRepository->getMetaField($journal, 'recurrence_id');
282			$bunq = $this->cliRepository->getMetaField($journal, 'bunq_payment_id');
283			$hash = $this->cliRepository->getMetaField($journal, 'import_hash');
284			$hashTwo = $this->cliRepository->getMetaField($journal, 'import_hash_v2');
285			$interestDate = $this->cliRepository->getMetaDate($journal, 'interest_date');
286			$bookDate = $this->cliRepository->getMetaDate($journal, 'book_date');
287			$processDate = $this->cliRepository->getMetaDate($journal, 'process_date');
288			$dueDate = $this->cliRepository->getMetaDate($journal, 'due_date');
289			$paymentDate = $this->cliRepository->getMetaDate($journal, 'payment_date');
290			$invoiceDate = $this->cliRepository->getMetaDate($journal, 'invoice_date');
291
292			Log::debug(sprintf('Will use %d positive transactions to create a new group.', $destTransactions->count()));
293
294			/** @var Transaction $transaction */
295			foreach ($destTransactions as $transaction) {
296			Log::debug(sprintf('Now going to add transaction #%d to the array.', $transaction->id));
297			$opposingTr = $this->findOpposingTransaction($journal, $transaction);
298
299			if (null === $opposingTr) {
300			// @codeCoverageIgnoreStart
301			$this->error(
302			sprintf(
303			'Journal #%d has no opposing transaction for transaction #%d. Cannot upgrade this entry.',
304			$journal->id, $transaction->id
305			)
306			);
307			continue;
308			// @codeCoverageIgnoreEnd
309			}
310
311			// overrule journal category with transaction category.
312			$budgetId = $this->getTransactionBudget($transaction, $opposingTr) ?? $budgetId;
313			$categoryId = $this->getTransactionCategory($transaction, $opposingTr) ?? $categoryId;
314
315			$tArray = [
316			'type' => strtolower($journal->transactionType->type),
317			'date' => $journal->date,
318			'user' => $journal->user_id,
319			'currency_id' => $transaction->transaction_currency_id,
320			'foreign_currency_id' => $transaction->foreign_currency_id,
321			'amount' => $transaction->amount,
322			'foreign_amount' => $transaction->foreign_amount,
323			'description' => $transaction->description ?? $journal->description,
324			'source_id' => $opposingTr->account_id,
325			'destination_id' => $transaction->account_id,
326			'budget_id' => $budgetId,
327			'category_id' => $categoryId,
328			'bill_id' => $journal->bill_id,
329			'notes' => $notes,
330			'tags' => $tags,
331			'internal_reference' => $internalRef,
332			'sepa_cc' => $sepaCC,
333			'sepa_ct_op' => $sepaCtOp,
334			'sepa_ct_id' => $sepaCtId,
335			'sepa_db' => $sepaDb,
336			'sepa_country' => $sepaCountry,
337			'sepa_ep' => $sepaEp,
338			'sepa_ci' => $sepaCi,
339			'sepa_batch_id' => $sepaBatchId,
340			'external_id' => $externalId,
341			'original-source' => $originalSource,
342			'recurrence_id' => $recurrenceId,
343			'bunq_payment_id' => $bunq,
344			'import_hash' => $hash,
345			'import_hash_v2' => $hashTwo,
346			'interest_date' => $interestDate,
347			'book_date' => $bookDate,
348			'process_date' => $processDate,
349			'due_date' => $dueDate,
350			'payment_date' => $paymentDate,
351			'invoice_date' => $invoiceDate,
352			];
353
354			$data['transactions'][] = $tArray;
355			}
356			Log::debug(sprintf('Now calling transaction journal factory (%d transactions in array)', count($data['transactions'])));
357			$group = $this->groupFactory->create($data);
358			Log::debug('Done calling transaction journal factory');
359
360			// delete the old transaction journal.
361			$this->service->destroy($journal);
362
363			$this->count++;
364
365			// report on result:
366			Log::debug(
367			sprintf('Migrated journal #%d into group #%d with these journals: #%s',
368			$journal->id, $group->id, implode(', #', $group->transactionJournals->pluck('id')->toArray()))
369			);
370			$this->line(
371			sprintf('Migrated journal #%d into group #%d with these journals: #%s',
372			$journal->id, $group->id, implode(', #', $group->transactionJournals->pluck('id')->toArray()))
373			);
374			}
375
376			/**
377			* @param Transaction $left
378			* @param Transaction $right
379			*
380			* @return int\|null
381			*/
382			private function getTransactionBudget(Transaction $left, Transaction $right): ?int
383			{
384			Log::debug('Now in getTransactionBudget()');
385
386			// try to get a budget ID from the left transaction:
387			/** @var Budget $budget */
388			$budget = $left->budgets()->first();
389			if (null !== $budget) {
390			Log::debug(sprintf('Return budget #%d, from transaction #%d', $budget->id, $left->id));
391
392			return (int)$budget->id;
393			}
394
395			// try to get a budget ID from the right transaction:
396			/** @var Budget $budget */
397			$budget = $right->budgets()->first();
398			if (null !== $budget) {
399			Log::debug(sprintf('Return budget #%d, from transaction #%d', $budget->id, $right->id));
400
401			return (int)$budget->id;
402			}
403			Log::debug('Neither left or right have a budget, return NULL');
404
405			// if all fails, return NULL.
406			return null;
407			}
408
409			/**
410			* @param Transaction $left
411			* @param Transaction $right
412			*
413			* @return int\|null
414			*/
415			private function getTransactionCategory(Transaction $left, Transaction $right): ?int
416			{
417			Log::debug('Now in getTransactionCategory()');
418
419			// try to get a category ID from the left transaction:
420			/** @var Category $category */
421			$category = $left->categories()->first();
422			if (null !== $category) {
423			Log::debug(sprintf('Return category #%d, from transaction #%d', $category->id, $left->id));
424
425			return (int)$category->id;
426			}
427
428			// try to get a category ID from the left transaction:
429			/** @var Category $category */
430			$category = $right->categories()->first();
431			if (null !== $category) {
432			Log::debug(sprintf('Return category #%d, from transaction #%d', $category->id, $category->id));
433
434			return (int)$category->id;
435			}
436			Log::debug('Neither left or right have a category, return NULL');
437
438			// if all fails, return NULL.
439			return null;
440			}
441
442			/**
443			*
444			*/
445			private function markAsMigrated(): void
446			{
447			app('fireflyconfig')->set(self::CONFIG_NAME, true);
448			}
449
450			}
451

firefly-iii / firefly-iii

GitHub Access Token became invalid

Push — master ( d550a6...996863 )

MigrateToGroups::makeMultiGroup() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like