You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
955 lines
33 KiB
955 lines
33 KiB
<?php
|
|
|
|
/*
|
|
* Configuration.php
|
|
* Copyright (c) 2021 james@firefly-iii.org
|
|
*
|
|
* This file is part of the Firefly III Data Importer
|
|
* (https://github.com/firefly-iii/data-importer).
|
|
*
|
|
* 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 App\Services\Shared\Configuration;
|
|
|
|
use Carbon\Carbon;
|
|
use Illuminate\Support\Facades\Log;
|
|
|
|
/**
|
|
* Class Configuration
|
|
*/
|
|
class Configuration
|
|
{
|
|
public const VERSION = 3;
|
|
private array $accounts;
|
|
private array $newAccounts;
|
|
private bool $addImportTag;
|
|
private string $connection;
|
|
private string $contentType;
|
|
private bool $conversion;
|
|
private string $customTag;
|
|
private string $date;
|
|
private string $dateNotAfter;
|
|
private string $dateNotBefore;
|
|
private string $dateRange;
|
|
private int $dateRangeNumber;
|
|
private string $dateRangeUnit;
|
|
private int $defaultAccount;
|
|
|
|
// nordigen configuration
|
|
private string $delimiter;
|
|
private array $doMapping;
|
|
|
|
// flow and file type
|
|
private string $duplicateDetectionMethod;
|
|
private string $flow;
|
|
|
|
// csv config
|
|
private string $groupedTransactionHandling;
|
|
|
|
// spectre + nordigen configuration
|
|
private bool $headers;
|
|
|
|
// spectre configuration
|
|
private string $identifier;
|
|
private bool $ignoreDuplicateLines;
|
|
private bool $ignoreDuplicateTransactions;
|
|
|
|
// camt configuration
|
|
private bool $ignoreSpectreCategories;
|
|
private bool $mapAllData;
|
|
|
|
// simplefin configuration
|
|
private bool $pendingTransactions;
|
|
|
|
// date range settings
|
|
private array $mapping;
|
|
private string $nordigenBank;
|
|
private string $nordigenCountry;
|
|
private string $nordigenMaxDays;
|
|
private array $nordigenRequisitions;
|
|
|
|
// what type of import?
|
|
private array $roles;
|
|
|
|
// how to do double transaction detection?
|
|
private bool $rules; // 'classic' or 'cell'
|
|
|
|
// configuration for "classic" method:
|
|
private bool $skipForm;
|
|
private array $specifics;
|
|
|
|
// configuration for "cell" method:
|
|
private int $uniqueColumnIndex;
|
|
private string $uniqueColumnType;
|
|
private bool $useEntireOpposingAddress;
|
|
|
|
// configuration for utf-8
|
|
private int $version;
|
|
|
|
/**
|
|
* Configuration constructor.
|
|
*/
|
|
private function __construct()
|
|
{
|
|
$this->date = 'Y-m-d';
|
|
$this->defaultAccount = 1;
|
|
$this->delimiter = 'comma';
|
|
$this->headers = false;
|
|
$this->rules = true;
|
|
$this->skipForm = false;
|
|
$this->addImportTag = true;
|
|
$this->specifics = [];
|
|
$this->roles = [];
|
|
$this->mapping = [];
|
|
$this->doMapping = [];
|
|
$this->accounts = [];
|
|
$this->newAccounts = [];
|
|
$this->flow = 'file';
|
|
$this->contentType = 'csv';
|
|
$this->customTag = '';
|
|
|
|
// date range settings
|
|
$this->dateRange = 'all';
|
|
$this->dateRangeNumber = 30;
|
|
$this->dateRangeUnit = 'd';
|
|
$this->dateNotBefore = '';
|
|
$this->dateNotAfter = '';
|
|
|
|
// camt settings
|
|
$this->groupedTransactionHandling = 'single';
|
|
$this->useEntireOpposingAddress = false;
|
|
|
|
// nordigen configuration
|
|
$this->nordigenCountry = '';
|
|
$this->nordigenBank = '';
|
|
$this->nordigenRequisitions = [];
|
|
$this->nordigenMaxDays = '90';
|
|
|
|
// spectre + nordigen configuration
|
|
$this->accounts = [];
|
|
|
|
// spectre
|
|
$this->identifier = '0';
|
|
$this->connection = '0';
|
|
$this->ignoreSpectreCategories = false;
|
|
|
|
// mapping for spectre + nordigen
|
|
$this->mapAllData = false;
|
|
|
|
// simplefin configuration
|
|
$this->pendingTransactions = true;
|
|
|
|
// double transaction detection:
|
|
$this->duplicateDetectionMethod = 'classic';
|
|
|
|
// config for "classic":
|
|
Log::debug('Configuration __construct. ignoreDuplicateTransactions = true');
|
|
$this->ignoreDuplicateTransactions = true;
|
|
$this->ignoreDuplicateLines = true;
|
|
|
|
// config for "cell":
|
|
$this->uniqueColumnIndex = 0;
|
|
$this->uniqueColumnType = 'internal_reference';
|
|
|
|
// utf8
|
|
$this->conversion = false;
|
|
|
|
$this->version = self::VERSION;
|
|
}
|
|
|
|
/**
|
|
* @return $this
|
|
*/
|
|
public static function fromFile(array $data): self
|
|
{
|
|
Log::debug('Now in Configuration::fromFile. Data is omitted and will not be printed.');
|
|
$version = $data['version'] ?? 1;
|
|
if (1 === $version) {
|
|
Log::debug('v1, going for classic.');
|
|
|
|
return self::fromClassicFile($data);
|
|
}
|
|
if (2 === $version) {
|
|
Log::debug('v2 config file!');
|
|
|
|
return self::fromVersionTwo($data);
|
|
}
|
|
if (3 === $version) {
|
|
Log::debug('v3 config file!');
|
|
|
|
return self::fromVersionThree($data);
|
|
}
|
|
|
|
throw new \UnexpectedValueException(sprintf('Configuration file version "%s" cannot be parsed.', $version));
|
|
}
|
|
|
|
/**
|
|
* @return static
|
|
*/
|
|
private static function fromClassicFile(array $data): self
|
|
{
|
|
$delimiters = config('csv.delimiters_reversed');
|
|
$classicRoleNames = config('csv.classic_roles');
|
|
$object = new self();
|
|
$object->headers = $data['has-headers'] ?? false;
|
|
$object->date = $data['date-format'] ?? $object->date;
|
|
$object->delimiter = $delimiters[$data['delimiter']] ?? 'comma';
|
|
$object->defaultAccount = $data['import-account'] ?? $object->defaultAccount;
|
|
$object->rules = $data['apply-rules'] ?? true;
|
|
$object->flow = $data['flow'] ?? 'file';
|
|
$object->contentType = $data['content_type'] ?? 'csv';
|
|
$object->customTag = $data['custom_tag'] ?? '';
|
|
|
|
// camt settings
|
|
$object->groupedTransactionHandling = $data['grouped_transaction_handling'] ?? 'single';
|
|
$object->useEntireOpposingAddress = $data['use_entire_opposing_address'] ?? false;
|
|
|
|
// other settings (are not in v1 anyway)
|
|
$object->dateRange = $data['date_range'] ?? 'all';
|
|
$object->dateRangeNumber = $data['date_range_number'] ?? 30;
|
|
$object->dateRangeUnit = $data['date_range_unit'] ?? 'd';
|
|
$object->dateNotBefore = $data['date_not_before'] ?? '';
|
|
$object->dateNotAfter = $data['date_not_after'] ?? '';
|
|
|
|
// spectre settings (are not in v1 anyway)
|
|
$object->identifier = $data['identifier'] ?? '0';
|
|
$object->connection = $data['connection'] ?? '0';
|
|
$object->ignoreSpectreCategories = $data['ignore_spectre_categories'] ?? false;
|
|
|
|
// nordigen settings (are not in v1 anyway)
|
|
$object->nordigenCountry = $data['nordigen_country'] ?? '';
|
|
$object->nordigenBank = $data['nordigen_bank'] ?? '';
|
|
$object->nordigenRequisitions = $data['nordigen_requisitions'] ?? [];
|
|
$object->nordigenMaxDays = $data['nordigen_max_days'] ?? '90';
|
|
|
|
// settings for spectre + nordigen (are not in v1 anyway)
|
|
$object->mapAllData = $data['map_all_data'] ?? false;
|
|
$object->accounts = $data['accounts'] ?? [];
|
|
|
|
$object->ignoreDuplicateTransactions = $data['ignore_duplicate_transactions'] ?? true;
|
|
Log::debug(sprintf('Configuration fromClassicFile: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
|
|
if (isset($data['ignore_duplicates']) && true === $data['ignore_duplicates']) {
|
|
Log::debug('Will ignore duplicates.');
|
|
$object->ignoreDuplicateTransactions = true;
|
|
Log::debug(sprintf('Configuration fromClassicFile: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
$object->duplicateDetectionMethod = 'classic';
|
|
}
|
|
|
|
if (isset($data['ignore_duplicates']) && false === $data['ignore_duplicates']) {
|
|
Log::debug('Will NOT ignore duplicates.');
|
|
$object->ignoreDuplicateTransactions = false;
|
|
$object->duplicateDetectionMethod = 'none';
|
|
Log::debug(sprintf('Configuration fromClassicFile: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
}
|
|
|
|
if (isset($data['ignore_lines']) && true === $data['ignore_lines']) {
|
|
Log::debug('Will ignore duplicate lines.');
|
|
$object->ignoreDuplicateLines = true;
|
|
}
|
|
|
|
// array values
|
|
$object->specifics = [];
|
|
$object->roles = [];
|
|
$object->doMapping = [];
|
|
$object->mapping = [];
|
|
$object->accounts = [];
|
|
|
|
// utf8
|
|
$object->conversion = $data['conversion'] ?? false;
|
|
|
|
// loop roles from classic file:
|
|
$roles = $data['column-roles'] ?? [];
|
|
foreach ($roles as $index => $role) {
|
|
// some roles have been given a new name some time in the past.
|
|
$role = $classicRoleNames[$role] ?? $role;
|
|
$config = config(sprintf('csv.import_roles.%s', $role));
|
|
if (null !== $config) {
|
|
$object->roles[$index] = $role;
|
|
}
|
|
if (null === $config) {
|
|
Log::warn(sprintf('There is no config for "%s"!', $role));
|
|
}
|
|
}
|
|
ksort($object->roles);
|
|
|
|
// loop do mapping from classic file.
|
|
$doMapping = $data['column-do-mapping'] ?? [];
|
|
foreach ($doMapping as $index => $map) {
|
|
$index = (int) $index;
|
|
$object->doMapping[$index] = $map;
|
|
}
|
|
ksort($object->doMapping);
|
|
|
|
// loop mapping from classic file.
|
|
$mapping = $data['column-mapping-config'] ?? [];
|
|
foreach ($mapping as $index => $map) {
|
|
$index = (int) $index;
|
|
$object->mapping[$index] = $map;
|
|
}
|
|
ksort($object->mapping);
|
|
|
|
// set version to latest version and return.
|
|
$object->version = self::VERSION;
|
|
|
|
if ('csv' === $object->flow) {
|
|
$object->flow = 'file';
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @return static
|
|
*/
|
|
private static function fromVersionTwo(array $data): self
|
|
{
|
|
return self::fromArray($data);
|
|
}
|
|
|
|
/**
|
|
* @return static
|
|
*/
|
|
public static function fromArray(array $array): self
|
|
{
|
|
$delimiters = config('csv.delimiters_reversed');
|
|
$object = new self();
|
|
$object->headers = $array['headers'] ?? false;
|
|
$object->date = $array['date'] ?? '';
|
|
$object->defaultAccount = $array['default_account'] ?? 0;
|
|
$object->delimiter = $delimiters[$array['delimiter'] ?? ','] ?? 'comma';
|
|
$object->rules = $array['rules'] ?? true;
|
|
$object->skipForm = $array['skip_form'] ?? false;
|
|
$object->addImportTag = $array['add_import_tag'] ?? true;
|
|
$object->roles = $array['roles'] ?? [];
|
|
$object->mapping = $array['mapping'] ?? [];
|
|
$object->doMapping = $array['do_mapping'] ?? [];
|
|
$object->version = self::VERSION;
|
|
$object->flow = $array['flow'] ?? 'file';
|
|
$object->contentType = $array['content_type'] ?? 'csv';
|
|
$object->customTag = $array['custom_tag'] ?? '';
|
|
|
|
// sort
|
|
ksort($object->doMapping);
|
|
ksort($object->mapping);
|
|
ksort($object->roles);
|
|
|
|
// settings for spectre + nordigen
|
|
$object->mapAllData = $array['map_all_data'] ?? false;
|
|
$object->accounts = $array['accounts'] ?? [];
|
|
$object->newAccounts = $array['new_account'] ?? [];
|
|
|
|
// spectre
|
|
$object->identifier = $array['identifier'] ?? '0';
|
|
$object->connection = $array['connection'] ?? '0';
|
|
$object->ignoreSpectreCategories = $array['ignore_spectre_categories'] ?? false;
|
|
|
|
// date range settings
|
|
$object->dateRange = $array['date_range'] ?? 'all';
|
|
$object->dateRangeNumber = $array['date_range_number'] ?? 30;
|
|
$object->dateRangeUnit = $array['date_range_unit'] ?? 'd';
|
|
$object->dateNotBefore = $array['date_not_before'] ?? '';
|
|
$object->dateNotAfter = $array['date_not_after'] ?? '';
|
|
|
|
// camt
|
|
$object->groupedTransactionHandling = $array['grouped_transaction_handling'] ?? 'single';
|
|
$object->useEntireOpposingAddress = $array['use_entire_opposing_address'] ?? false;
|
|
|
|
// nordigen information:
|
|
$object->nordigenCountry = $array['nordigen_country'] ?? '';
|
|
$object->nordigenBank = $array['nordigen_bank'] ?? '';
|
|
$object->nordigenRequisitions = $array['nordigen_requisitions'] ?? [];
|
|
$object->nordigenMaxDays = $array['nordigen_max_days'] ?? '90';
|
|
|
|
// duplicate transaction detection
|
|
$object->duplicateDetectionMethod = $array['duplicate_detection_method'] ?? 'classic';
|
|
|
|
// config for "classic":
|
|
$object->ignoreDuplicateLines = $array['ignore_duplicate_lines'] ?? false;
|
|
$object->ignoreDuplicateTransactions = $array['ignore_duplicate_transactions'] ?? true;
|
|
Log::debug(sprintf('Configuration fromArray: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
|
|
if (!array_key_exists('duplicate_detection_method', $array)) {
|
|
if (false === $object->ignoreDuplicateTransactions) {
|
|
Log::debug('Set the duplicate method to "none".');
|
|
$object->duplicateDetectionMethod = 'none';
|
|
}
|
|
}
|
|
|
|
// overrule a setting:
|
|
if ('none' === $object->duplicateDetectionMethod) {
|
|
$object->ignoreDuplicateTransactions = false;
|
|
Log::debug(sprintf('Configuration fromClassicFile overruled: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
}
|
|
|
|
// config for "cell":
|
|
$object->uniqueColumnIndex = $array['unique_column_index'] ?? 0;
|
|
$object->uniqueColumnType = $array['unique_column_type'] ?? '';
|
|
|
|
// utf8
|
|
$object->conversion = $array['conversion'] ?? false;
|
|
|
|
// simplefin configuration
|
|
$object->pendingTransactions = $array['pending_transactions'] ?? true;
|
|
|
|
if ('csv' === $object->flow) {
|
|
$object->flow = 'file';
|
|
$object->contentType = 'csv';
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @return static
|
|
*/
|
|
private static function fromVersionThree(array $data): self
|
|
{
|
|
$object = self::fromArray($data);
|
|
$object->specifics = [];
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @return $this
|
|
*/
|
|
public static function fromRequest(array $array): self
|
|
{
|
|
$delimiters = config('csv.delimiters_reversed');
|
|
$object = new self();
|
|
$object->version = self::VERSION;
|
|
$object->headers = $array['headers'] ?? false;
|
|
$object->date = $array['date'];
|
|
$object->defaultAccount = $array['default_account'];
|
|
$object->delimiter = $delimiters[$array['delimiter']] ?? 'comma';
|
|
$object->rules = $array['rules'];
|
|
$object->skipForm = $array['skip_form'];
|
|
$object->addImportTag = $array['add_import_tag'] ?? true;
|
|
$object->roles = $array['roles'] ?? [];
|
|
$object->mapping = $array['mapping'] ?? [];
|
|
$object->doMapping = $array['do_mapping'] ?? [];
|
|
$object->contentType = $array['content_type'] ?? 'csv';
|
|
$object->customTag = $array['custom_tag'] ?? '';
|
|
|
|
// mapping for spectre + nordigen
|
|
$object->mapAllData = $array['map_all_data'] ?? false;
|
|
|
|
// spectre
|
|
$object->identifier = $array['identifier'] ?? '0';
|
|
$object->connection = $array['connection'] ?? '0';
|
|
$object->ignoreSpectreCategories = $array['ignore_spectre_categories'] ?? false;
|
|
|
|
// nordigen:
|
|
$object->nordigenCountry = $array['nordigen_country'] ?? '';
|
|
$object->nordigenBank = $array['nordigen_bank'] ?? '';
|
|
$object->nordigenRequisitions = $array['nordigen_requisitions'] ?? [];
|
|
$object->nordigenMaxDays = $array['nordigen_max_days'] ?? '90';
|
|
|
|
$object->groupedTransactionHandling = $array['grouped_transaction_handling'] ?? 'single';
|
|
$object->useEntireOpposingAddress = $array['use_entire_opposing_address'] ?? false;
|
|
|
|
// spectre + nordigen
|
|
$object->accounts = $array['accounts'] ?? [];
|
|
$object->newAccounts = $array['new_account'] ?? [];
|
|
|
|
// date range settings
|
|
$object->dateRange = $array['date_range'] ?? 'all';
|
|
$object->dateRangeNumber = $array['date_range_number'] ?? 30;
|
|
$object->dateRangeUnit = $array['date_range_unit'] ?? 'd';
|
|
|
|
// null or Carbon because fromRequest will give Carbon object.
|
|
$object->dateNotBefore = null === $array['date_not_before'] ? '' : $array['date_not_before']->format('Y-m-d');
|
|
$object->dateNotAfter = null === $array['date_not_after'] ? '' : $array['date_not_after']->format('Y-m-d');
|
|
|
|
// duplicate transaction detection
|
|
$object->duplicateDetectionMethod = $array['duplicate_detection_method'] ?? 'classic';
|
|
|
|
// config for "classic":
|
|
$object->ignoreDuplicateLines = $array['ignore_duplicate_lines'];
|
|
$object->ignoreDuplicateTransactions = true;
|
|
Log::debug(sprintf('Configuration fromRequest: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
|
|
// config for "cell":
|
|
$object->uniqueColumnIndex = $array['unique_column_index'] ?? 0;
|
|
$object->uniqueColumnType = $array['unique_column_type'] ?? '';
|
|
|
|
// utf8 conversion
|
|
$object->conversion = $array['conversion'] ?? false;
|
|
|
|
// simplefin configuration
|
|
$object->pendingTransactions = $array['pending_transactions'] ?? true;
|
|
|
|
// flow
|
|
$object->flow = $array['flow'] ?? 'file';
|
|
|
|
// overrule a setting:
|
|
if ('none' === $object->duplicateDetectionMethod) {
|
|
$object->ignoreDuplicateTransactions = false;
|
|
Log::debug(sprintf('Configuration overruled from none: ignoreDuplicateTransactions = %s', var_export($object->ignoreDuplicateTransactions, true)));
|
|
}
|
|
|
|
$object->specifics = [];
|
|
foreach ($array['specifics'] as $key => $enabled) {
|
|
if (true === $enabled) {
|
|
$object->specifics[] = $key;
|
|
}
|
|
}
|
|
if ('csv' === $object->flow) {
|
|
$object->flow = 'file';
|
|
$object->contentType = 'csv';
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* Create a standard empty configuration.
|
|
*/
|
|
public static function make(): self
|
|
{
|
|
return new self();
|
|
}
|
|
|
|
public function addRequisition(string $key, string $identifier): void
|
|
{
|
|
$this->nordigenRequisitions[$key] = $identifier;
|
|
}
|
|
|
|
public function clearRequisitions(): void
|
|
{
|
|
$this->nordigenRequisitions = [];
|
|
}
|
|
|
|
public function getAccounts(): array
|
|
{
|
|
return $this->accounts;
|
|
}
|
|
|
|
public function setAccounts(array $accounts): void
|
|
{
|
|
$this->accounts = $accounts;
|
|
}
|
|
|
|
public function getNewAccounts(): array
|
|
{
|
|
return $this->newAccounts;
|
|
}
|
|
|
|
public function setNewAccounts(array $newAccounts): void
|
|
{
|
|
$this->newAccounts = $newAccounts;
|
|
}
|
|
|
|
public function getConnection(): string
|
|
{
|
|
return $this->connection;
|
|
}
|
|
|
|
public function setConnection(string $connection): void
|
|
{
|
|
$this->connection = $connection;
|
|
}
|
|
|
|
public function getContentType(): string
|
|
{
|
|
return $this->contentType;
|
|
}
|
|
|
|
public function setContentType(string $contentType): void
|
|
{
|
|
$this->contentType = $contentType;
|
|
}
|
|
|
|
public function getCustomTag(): string
|
|
{
|
|
return $this->customTag;
|
|
}
|
|
|
|
public function getDate(): string
|
|
{
|
|
return $this->date;
|
|
}
|
|
|
|
public function getDateNotAfter(): string
|
|
{
|
|
return $this->dateNotAfter;
|
|
}
|
|
|
|
public function getDateNotBefore(): string
|
|
{
|
|
return $this->dateNotBefore;
|
|
}
|
|
|
|
public function getDateRange(): string
|
|
{
|
|
return $this->dateRange;
|
|
}
|
|
|
|
public function getDateRangeNumber(): int
|
|
{
|
|
return $this->dateRangeNumber;
|
|
}
|
|
|
|
public function getDateRangeUnit(): string
|
|
{
|
|
return $this->dateRangeUnit;
|
|
}
|
|
|
|
public function getDefaultAccount(): ?int
|
|
{
|
|
return $this->defaultAccount;
|
|
}
|
|
|
|
public function getDelimiter(): string
|
|
{
|
|
return $this->delimiter;
|
|
}
|
|
|
|
public function getDoMapping(): array
|
|
{
|
|
return $this->doMapping ?? [];
|
|
}
|
|
|
|
public function setDoMapping(array $doMapping): void
|
|
{
|
|
$this->doMapping = $doMapping;
|
|
}
|
|
|
|
public function getDuplicateDetectionMethod(): string
|
|
{
|
|
return $this->duplicateDetectionMethod;
|
|
}
|
|
|
|
public function getFlow(): string
|
|
{
|
|
return $this->flow;
|
|
}
|
|
|
|
public function setFlow(string $flow): void
|
|
{
|
|
$this->flow = $flow;
|
|
}
|
|
|
|
public function getGroupedTransactionHandling(): string
|
|
{
|
|
return $this->groupedTransactionHandling;
|
|
}
|
|
|
|
public function getIdentifier(): string
|
|
{
|
|
return $this->identifier;
|
|
}
|
|
|
|
public function setIdentifier(string $identifier): void
|
|
{
|
|
$this->identifier = $identifier;
|
|
}
|
|
|
|
public function getMapping(): array
|
|
{
|
|
return $this->mapping ?? [];
|
|
}
|
|
|
|
public function setMapping(array $mapping): void
|
|
{
|
|
$newMap = [];
|
|
foreach ($mapping as $column => $map) {
|
|
ksort($map);
|
|
$newMap[$column] = $map;
|
|
}
|
|
$this->mapping = $newMap;
|
|
}
|
|
|
|
public function getNordigenBank(): string
|
|
{
|
|
return $this->nordigenBank;
|
|
}
|
|
|
|
public function setNordigenBank(string $nordigenBank): void
|
|
{
|
|
$this->nordigenBank = $nordigenBank;
|
|
}
|
|
|
|
public function getNordigenCountry(): string
|
|
{
|
|
return $this->nordigenCountry;
|
|
}
|
|
|
|
public function setNordigenCountry(string $nordigenCountry): void
|
|
{
|
|
$this->nordigenCountry = $nordigenCountry;
|
|
}
|
|
|
|
public function getNordigenMaxDays(): string
|
|
{
|
|
return $this->nordigenMaxDays;
|
|
}
|
|
|
|
public function setNordigenMaxDays(string $nordigenMaxDays): void
|
|
{
|
|
$this->nordigenMaxDays = $nordigenMaxDays;
|
|
}
|
|
|
|
public function getNordigenRequisitions(): array
|
|
{
|
|
return $this->nordigenRequisitions;
|
|
}
|
|
|
|
public function getRequisition(string $key): ?string
|
|
{
|
|
return array_key_exists($key, $this->nordigenRequisitions) ? $this->nordigenRequisitions[$key] : null;
|
|
}
|
|
|
|
public function getRoles(): array
|
|
{
|
|
return $this->roles ?? [];
|
|
}
|
|
|
|
public function setRoles(array $roles): void
|
|
{
|
|
$this->roles = $roles;
|
|
}
|
|
|
|
public function setPendingTransactions(bool $pendingTransactions): void
|
|
{
|
|
$this->pendingTransactions = $pendingTransactions;
|
|
}
|
|
|
|
public function getSpecifics(): array
|
|
{
|
|
return $this->specifics;
|
|
}
|
|
|
|
public function getUniqueColumnIndex(): int
|
|
{
|
|
return $this->uniqueColumnIndex;
|
|
}
|
|
|
|
public function getUniqueColumnType(): string
|
|
{
|
|
return $this->uniqueColumnType;
|
|
}
|
|
|
|
public function getPendingTransactions(): bool
|
|
{
|
|
return $this->pendingTransactions;
|
|
}
|
|
|
|
public function hasSpecific(string $name): bool
|
|
{
|
|
return in_array($name, $this->specifics, true);
|
|
}
|
|
|
|
public function isAddImportTag(): bool
|
|
{
|
|
return $this->addImportTag;
|
|
}
|
|
|
|
public function isConversion(): bool
|
|
{
|
|
return $this->conversion;
|
|
}
|
|
|
|
public function isHeaders(): bool
|
|
{
|
|
return $this->headers;
|
|
}
|
|
|
|
public function isIgnoreDuplicateLines(): bool
|
|
{
|
|
return $this->ignoreDuplicateLines;
|
|
}
|
|
|
|
public function isIgnoreDuplicateTransactions(): bool
|
|
{
|
|
Log::debug(sprintf('isIgnoreDuplicateTransactions(%s)', var_export($this->ignoreDuplicateTransactions, true)));
|
|
|
|
return $this->ignoreDuplicateTransactions;
|
|
}
|
|
|
|
public function isIgnoreSpectreCategories(): bool
|
|
{
|
|
return $this->ignoreSpectreCategories;
|
|
}
|
|
|
|
public function isMapAllData(): bool
|
|
{
|
|
return $this->mapAllData;
|
|
}
|
|
|
|
public function isRules(): bool
|
|
{
|
|
return $this->rules;
|
|
}
|
|
|
|
public function isSkipForm(): bool
|
|
{
|
|
return $this->skipForm;
|
|
}
|
|
|
|
public function isUseEntireOpposingAddress(): bool
|
|
{
|
|
return $this->useEntireOpposingAddress;
|
|
}
|
|
|
|
/**
|
|
* Return the array but drop some potentially massive arrays.
|
|
*/
|
|
public function toSessionArray(): array
|
|
{
|
|
$array = $this->toArray();
|
|
unset($array['mapping'], $array['do_mapping'], $array['roles']);
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function toArray(): array
|
|
{
|
|
$array = [
|
|
'version' => $this->version,
|
|
'source' => sprintf('ff3-importer-%s', config('importer.version')),
|
|
'created_at' => date(\DateTimeInterface::W3C),
|
|
'date' => $this->date,
|
|
'default_account' => $this->defaultAccount,
|
|
'delimiter' => $this->delimiter,
|
|
'headers' => $this->headers,
|
|
'rules' => $this->rules,
|
|
'skip_form' => $this->skipForm,
|
|
'add_import_tag' => $this->addImportTag,
|
|
'roles' => $this->roles,
|
|
'do_mapping' => $this->doMapping,
|
|
'mapping' => $this->mapping,
|
|
'duplicate_detection_method' => $this->duplicateDetectionMethod,
|
|
'ignore_duplicate_lines' => $this->ignoreDuplicateLines,
|
|
'unique_column_index' => $this->uniqueColumnIndex,
|
|
'unique_column_type' => $this->uniqueColumnType,
|
|
'flow' => $this->flow,
|
|
'content_type' => $this->contentType,
|
|
'custom_tag' => $this->customTag,
|
|
|
|
// spectre
|
|
'identifier' => $this->identifier,
|
|
'connection' => $this->connection,
|
|
'ignore_spectre_categories' => $this->ignoreSpectreCategories,
|
|
|
|
// camt:
|
|
'grouped_transaction_handling' => $this->groupedTransactionHandling,
|
|
'use_entire_opposing_address' => $this->useEntireOpposingAddress,
|
|
|
|
// mapping for spectre + nordigen
|
|
'map_all_data' => $this->mapAllData,
|
|
|
|
// simplefin configuration
|
|
'pending_transactions' => $this->pendingTransactions,
|
|
|
|
// settings for spectre + nordigen
|
|
'accounts' => $this->accounts,
|
|
'new_account' => $this->newAccounts,
|
|
|
|
// date range settings:
|
|
'date_range' => $this->dateRange,
|
|
'date_range_number' => $this->dateRangeNumber,
|
|
'date_range_unit' => $this->dateRangeUnit,
|
|
'date_not_before' => $this->dateNotBefore,
|
|
'date_not_after' => $this->dateNotAfter,
|
|
|
|
// nordigen information:
|
|
'nordigen_country' => $this->nordigenCountry,
|
|
'nordigen_bank' => $this->nordigenBank,
|
|
'nordigen_requisitions' => $this->nordigenRequisitions,
|
|
'nordigen_max_days' => $this->nordigenMaxDays,
|
|
|
|
// utf8
|
|
'conversion' => $this->conversion,
|
|
];
|
|
|
|
// make sure that "ignore duplicate transactions" is turned off
|
|
// to deliver a consistent file.
|
|
$array['ignore_duplicate_transactions'] = false;
|
|
if ('classic' === $this->duplicateDetectionMethod) {
|
|
$array['ignore_duplicate_transactions'] = true;
|
|
}
|
|
|
|
return $array;
|
|
}
|
|
|
|
public function updateDateRange(): void
|
|
{
|
|
Log::debug('Now in updateDateRange()');
|
|
|
|
// set date and time:
|
|
switch ($this->dateRange) {
|
|
default:
|
|
case 'all':
|
|
Log::debug('Range is null, set all to NULL.');
|
|
$this->dateRangeUnit = 'd';
|
|
$this->dateRangeNumber = 30;
|
|
$this->dateNotBefore = '';
|
|
$this->dateNotAfter = '';
|
|
|
|
break;
|
|
|
|
case 'partial':
|
|
Log::debug('Range is partial, after is NULL, dateNotBefore will be calculated.');
|
|
$this->dateNotAfter = '';
|
|
$this->dateNotBefore = self::calcDateNotBefore($this->dateRangeUnit, $this->dateRangeNumber);
|
|
Log::debug(sprintf('dateNotBefore is now "%s"', $this->dateNotBefore));
|
|
|
|
break;
|
|
|
|
case 'range':
|
|
Log::debug('Range is "range", both will be created from a string.');
|
|
$before = trim($this->dateNotBefore); // string
|
|
$after = trim($this->dateNotAfter); // string
|
|
if ('' !== $before) {
|
|
$before = Carbon::createFromFormat('Y-m-d', $before);
|
|
}
|
|
if ('' !== $after) {
|
|
$after = Carbon::createFromFormat('Y-m-d', $after);
|
|
}
|
|
|
|
if ('' !== $before && '' !== $after && $before > $after) {
|
|
[$before, $after] = [$after, $before];
|
|
}
|
|
|
|
$this->dateNotBefore = '' === $before ? '' : $before->format('Y-m-d');
|
|
$this->dateNotAfter = '' === $after ? '' : $after->format('Y-m-d');
|
|
Log::debug(sprintf('dateNotBefore is now "%s", dateNotAfter is "%s"', $this->dateNotBefore, $this->dateNotAfter));
|
|
}
|
|
}
|
|
|
|
private static function calcDateNotBefore(string $unit, int $number): ?string
|
|
{
|
|
$functions = [
|
|
'd' => 'subDays',
|
|
'w' => 'subWeeks',
|
|
'm' => 'subMonths',
|
|
'y' => 'subYears',
|
|
];
|
|
if (isset($functions[$unit])) {
|
|
$today = Carbon::now();
|
|
$function = $functions[$unit];
|
|
$today->{$function}($number);
|
|
|
|
return $today->format('Y-m-d');
|
|
}
|
|
Log::error(sprintf('Could not parse date setting. Unknown key "%s"', $unit));
|
|
|
|
return null;
|
|
}
|
|
}
|