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.
914 lines
26 KiB
914 lines
26 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\CSV\Configuration;
|
|
|
|
use Carbon\Carbon;
|
|
use Log;
|
|
use UnexpectedValueException;
|
|
|
|
/**
|
|
* Class Configuration
|
|
* TODO move me to a shared directory
|
|
*/
|
|
class Configuration
|
|
{
|
|
/** @var int */
|
|
public const VERSION = 3;
|
|
private string $date;
|
|
private int $defaultAccount;
|
|
private string $delimiter;
|
|
private bool $headers;
|
|
private bool $rules;
|
|
private bool $skipForm;
|
|
private array $specifics;
|
|
private array $roles;
|
|
private int $version;
|
|
private array $doMapping;
|
|
private bool $mapAllData;
|
|
private bool $addImportTag;
|
|
|
|
// nordigen configuration
|
|
private string $nordigenCountry;
|
|
private string $nordigenBank;
|
|
private array $nordigenRequisitions;
|
|
|
|
// spectre + nordigen configuration
|
|
private array $accounts;
|
|
|
|
// spectre configuration
|
|
private string $identifier;
|
|
private string $connection;
|
|
|
|
// date range settings
|
|
private string $dateRange;
|
|
private int $dateRangeNumber;
|
|
private string $dateRangeUnit;
|
|
private string $dateNotBefore;
|
|
private string $dateNotAfter;
|
|
|
|
// what type of import?
|
|
private string $flow;
|
|
|
|
// how to do double transaction detection?
|
|
private array $mapping; // 'classic' or 'cell'
|
|
|
|
// configuration for "classic" method:
|
|
private string $duplicateDetectionMethod;
|
|
private bool $ignoreDuplicateTransactions;
|
|
|
|
// configuration for "cell" method:
|
|
private bool $ignoreDuplicateLines;
|
|
private int $uniqueColumnIndex;
|
|
private string $uniqueColumnType;
|
|
|
|
// configuration for utf-8
|
|
private bool $conversion;
|
|
|
|
/**
|
|
* 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->flow = 'csv';
|
|
|
|
// date range settings
|
|
$this->dateRange = 'all';
|
|
$this->dateRangeNumber = 30;
|
|
$this->dateRangeUnit = 'd';
|
|
$this->dateNotBefore = '';
|
|
$this->dateNotAfter = '';
|
|
|
|
// nordigen configuration
|
|
$this->nordigenCountry = '';
|
|
$this->nordigenBank = '';
|
|
$this->nordigenRequisitions = [];
|
|
|
|
// spectre + nordigen configuration
|
|
$this->accounts = [];
|
|
|
|
// spectre
|
|
$this->identifier = '0';
|
|
$this->connection = '0';
|
|
|
|
// mapping for spectre + nordigen
|
|
$this->mapAllData = false;
|
|
|
|
// double transaction detection:
|
|
$this->duplicateDetectionMethod = 'classic';
|
|
|
|
// config for "classic":
|
|
$this->ignoreDuplicateTransactions = true;
|
|
$this->ignoreDuplicateLines = true;
|
|
|
|
// config for "cell":
|
|
$this->uniqueColumnIndex = 0;
|
|
$this->uniqueColumnType = 'internal_reference';
|
|
|
|
// utf8
|
|
$this->conversion = false;
|
|
|
|
$this->version = self::VERSION;
|
|
}
|
|
|
|
/**
|
|
* Create a standard empty configuration.
|
|
*
|
|
* @return static
|
|
*/
|
|
public static function make(): self
|
|
{
|
|
return new self;
|
|
}
|
|
|
|
/**
|
|
* @param array $array
|
|
*
|
|
* @return $this
|
|
*/
|
|
public static function fromRequest(array $array): self
|
|
{
|
|
$delimiters = config('csv_importer.delimiters_reversed');
|
|
$object = new self;
|
|
$object->version = self::VERSION;
|
|
$object->headers = $array['headers'];
|
|
$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'] ?? [];
|
|
|
|
// mapping for spectre + nordigen
|
|
$object->mapAllData = $array['map_all_data'] ?? false;
|
|
|
|
// spectre
|
|
$object->identifier = $array['identifier'] ?? '0';
|
|
$object->connection = $array['connection'] ?? '0';
|
|
|
|
// nordigen:
|
|
$object->nordigenCountry = $array['nordigen_country'] ?? '';
|
|
$object->nordigenBank = $array['nordigen_bank'] ?? '';
|
|
$object->nordigenRequisitions = $array['nordigen_requisitions'] ?? [];
|
|
|
|
// spectre + nordigen
|
|
$object->accounts = $array['accounts'] ?? [];
|
|
|
|
// 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'] ?? '';
|
|
|
|
// duplicate transaction detection
|
|
$object->duplicateDetectionMethod = $array['duplicate_detection_method'] ?? 'classic';
|
|
|
|
// config for "classic":
|
|
$object->ignoreDuplicateLines = $array['ignore_duplicate_lines'];
|
|
$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;
|
|
|
|
// flow
|
|
$object->flow = $array['flow'] ?? 'csv';
|
|
|
|
// overrule a setting:
|
|
if ('none' === $object->duplicateDetectionMethod) {
|
|
$object->ignoreDuplicateTransactions = false;
|
|
}
|
|
|
|
$object->specifics = [];
|
|
foreach ($array['specifics'] as $key => $enabled) {
|
|
if (true === $enabled) {
|
|
$object->specifics[] = $key;
|
|
}
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @param array $data
|
|
*
|
|
* @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));
|
|
}
|
|
|
|
/**
|
|
* @param array $data
|
|
*
|
|
* @return static
|
|
*/
|
|
private static function fromClassicFile(array $data): self
|
|
{
|
|
$delimiters = config('csv_importer.delimiters_reversed');
|
|
$classicRoleNames = config('csv_importer.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'] ?? 'csv';
|
|
|
|
// other settings
|
|
$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
|
|
$object->identifier = $data['identifier'] ?? '0';
|
|
$object->connection = $data['connection'] ?? '0';
|
|
|
|
// settings for spectre + nordigen
|
|
$object->mapAllData = $data['map_all_data'] ?? false;
|
|
$object->accounts = $data['accounts'] ?? [];
|
|
|
|
$object->ignoreDuplicateTransactions = $data['ignore_duplicate_transactions'] ?? true;
|
|
|
|
if (isset($data['ignore_duplicates']) && true === $data['ignore_duplicates']) {
|
|
Log::debug('Will ignore duplicates.');
|
|
$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';
|
|
}
|
|
|
|
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 $role) {
|
|
// some roles have been given a new name some time in the past.
|
|
$role = $classicRoleNames[$role] ?? $role;
|
|
|
|
$config = config(sprintf('csv_importer.import_roles.%s', $role));
|
|
if (null !== $config) {
|
|
$object->roles[] = $role;
|
|
}
|
|
}
|
|
|
|
// loop do mapping from classic file.
|
|
$doMapping = $data['column-do-mapping'] ?? [];
|
|
foreach ($doMapping as $index => $map) {
|
|
$index = (int) $index;
|
|
$object->doMapping[$index] = $map;
|
|
}
|
|
|
|
// loop mapping from classic file.
|
|
$mapping = $data['column-mapping-config'] ?? [];
|
|
foreach ($mapping as $index => $map) {
|
|
$index = (int) $index;
|
|
$object->mapping[$index] = $map;
|
|
}
|
|
// set version to "2" and return.
|
|
$object->version = 2;
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @param array $data
|
|
*
|
|
* @return static
|
|
*/
|
|
private static function fromVersionTwo(array $data): self
|
|
{
|
|
return self::fromArray($data);
|
|
}
|
|
|
|
/**
|
|
* @param array $data
|
|
*
|
|
* @return static
|
|
*/
|
|
private static function fromVersionThree(array $data): self
|
|
{
|
|
$object = self::fromArray($data);
|
|
$object->specifics = [];
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @param array $array
|
|
*
|
|
* @return static
|
|
*/
|
|
public static function fromArray(array $array): self
|
|
{
|
|
$version = $array['version'] ?? 1;
|
|
$delimiters = config('csv_importer.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 = $version;
|
|
$object->flow = $array['flow'] ?? 'csv';
|
|
|
|
// settings for spectre + nordigen
|
|
$object->mapAllData = $array['map_all_data'] ?? false;
|
|
$object->accounts = $array['accounts'] ?? [];
|
|
|
|
|
|
// spectre
|
|
$object->identifier = $array['identifier'] ?? '0';
|
|
$object->connection = $array['connection'] ?? '0';
|
|
|
|
// 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'] ?? '';
|
|
|
|
// nordigen information:
|
|
$object->nordigenCountry = $array['nordigen_country'] ?? '';
|
|
$object->nordigenBank = $array['nordigen_bank'] ?? '';
|
|
$object->nordigenRequisitions = $array['nordigen_requisitions'] ?? [];
|
|
|
|
// 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;
|
|
|
|
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;
|
|
}
|
|
|
|
// config for "cell":
|
|
$object->uniqueColumnIndex = $array['unique_column_index'] ?? 0;
|
|
$object->uniqueColumnType = $array['unique_column_type'] ?? '';
|
|
|
|
// utf8
|
|
$object->conversion = $array['conversion'] ?? false;
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isSkipForm(): bool
|
|
{
|
|
return $this->skipForm;
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function hasSpecific(string $name): bool
|
|
{
|
|
return in_array($name, $this->specifics, true);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isAddImportTag(): bool
|
|
{
|
|
return $this->addImportTag;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getRoles(): array
|
|
{
|
|
return $this->roles ?? [];
|
|
}
|
|
|
|
/**
|
|
* @param array $roles
|
|
*/
|
|
public function setRoles(array $roles): void
|
|
{
|
|
$this->roles = $roles;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isIgnoreDuplicateLines(): bool
|
|
{
|
|
return $this->ignoreDuplicateLines;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isIgnoreDuplicateTransactions(): bool
|
|
{
|
|
return $this->ignoreDuplicateTransactions;
|
|
}
|
|
|
|
/**
|
|
* Return the array but drop some potentially massive arrays.
|
|
* @return array
|
|
*/
|
|
public function toSessionArray(): array
|
|
{
|
|
$array = $this->toArray();
|
|
unset($array['mapping'], $array['do_mapping'], $array['roles']);
|
|
return $array;
|
|
}
|
|
|
|
/**
|
|
* @param string $identifier
|
|
*/
|
|
public function setIdentifier(string $identifier): void
|
|
{
|
|
$this->identifier = $identifier;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function toArray(): array
|
|
{
|
|
$array = [
|
|
'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,
|
|
'ignore_duplicate_transactions' => $this->ignoreDuplicateTransactions,
|
|
'unique_column_index' => $this->uniqueColumnIndex,
|
|
'unique_column_type' => $this->uniqueColumnType,
|
|
'version' => $this->version,
|
|
'flow' => $this->flow,
|
|
|
|
// spectre
|
|
'identifier' => $this->identifier,
|
|
'connection' => $this->connection,
|
|
|
|
// mapping for spectre + nordigen
|
|
'map_all_data' => $this->mapAllData,
|
|
|
|
// settings for spectre + nordigen
|
|
'accounts' => $this->accounts,
|
|
|
|
// 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,
|
|
|
|
// 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;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDate(): string
|
|
{
|
|
return $this->date;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getDefaultAccount(): ?int
|
|
{
|
|
return $this->defaultAccount;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDelimiter(): string
|
|
{
|
|
return $this->delimiter;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isHeaders(): bool
|
|
{
|
|
return $this->headers;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getConnection(): string
|
|
{
|
|
return $this->connection;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getIdentifier(): string
|
|
{
|
|
return $this->identifier;
|
|
}
|
|
|
|
/**
|
|
* @param string $connection
|
|
*/
|
|
public function setConnection(string $connection): void
|
|
{
|
|
$this->connection = $connection;
|
|
}
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isRules(): bool
|
|
{
|
|
return $this->rules;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getDoMapping(): array
|
|
{
|
|
return $this->doMapping ?? [];
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isMapAllData(): bool
|
|
{
|
|
return $this->mapAllData;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param array $doMapping
|
|
*/
|
|
public function setDoMapping(array $doMapping): void
|
|
{
|
|
$this->doMapping = $doMapping;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getMapping(): array
|
|
{
|
|
return $this->mapping ?? [];
|
|
}
|
|
|
|
/**
|
|
* @param array $mapping
|
|
*/
|
|
public function setMapping(array $mapping): void
|
|
{
|
|
$newMap = [];
|
|
foreach ($mapping as $column => $map) {
|
|
ksort($map);
|
|
$newMap[$column] = $map;
|
|
}
|
|
$this->mapping = $newMap;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getSpecifics(): array
|
|
{
|
|
return $this->specifics;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDuplicateDetectionMethod(): string
|
|
{
|
|
return $this->duplicateDetectionMethod;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getUniqueColumnIndex(): int
|
|
{
|
|
return $this->uniqueColumnIndex;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getUniqueColumnType(): string
|
|
{
|
|
return $this->uniqueColumnType;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getFlow(): string
|
|
{
|
|
return $this->flow;
|
|
}
|
|
|
|
/**
|
|
* @param string $flow
|
|
*/
|
|
public function setFlow(string $flow): void
|
|
{
|
|
$this->flow = $flow;
|
|
}
|
|
|
|
/**
|
|
* @param string $nordigenCountry
|
|
*/
|
|
public function setNordigenCountry(string $nordigenCountry): void
|
|
{
|
|
$this->nordigenCountry = $nordigenCountry;
|
|
}
|
|
|
|
/**
|
|
* @param string $nordigenBank
|
|
*/
|
|
public function setNordigenBank(string $nordigenBank): void
|
|
{
|
|
$this->nordigenBank = $nordigenBank;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getNordigenCountry(): string
|
|
{
|
|
return $this->nordigenCountry;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getNordigenBank(): string
|
|
{
|
|
return $this->nordigenBank;
|
|
}
|
|
|
|
/**
|
|
* @param string $identifier
|
|
*/
|
|
public function addRequisition(string $key, string $identifier)
|
|
{
|
|
$this->nordigenRequisitions[$key] = $identifier;
|
|
}
|
|
|
|
/**
|
|
* @param string $key
|
|
* @return string|null
|
|
*/
|
|
public function getRequisition(string $key): ?string
|
|
{
|
|
return array_key_exists($key, $this->nordigenRequisitions) ? $this->nordigenRequisitions[$key] : null;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDateRange(): string
|
|
{
|
|
return $this->dateRange;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getDateRangeNumber(): int
|
|
{
|
|
return $this->dateRangeNumber;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDateRangeUnit(): string
|
|
{
|
|
return $this->dateRangeUnit;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDateNotBefore(): string
|
|
{
|
|
return $this->dateNotBefore;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDateNotAfter(): string
|
|
{
|
|
return $this->dateNotAfter;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getAccounts(): array
|
|
{
|
|
return $this->accounts;
|
|
}
|
|
|
|
/**
|
|
* @param array $accounts
|
|
*/
|
|
public function setAccounts(array $accounts): void
|
|
{
|
|
$this->accounts = $accounts;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function updateDateRange(): void
|
|
{
|
|
Log::debug('Now in updateDateRange()');
|
|
// set date and time:
|
|
switch ($this->dateRange) {
|
|
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 = $this->dateNotBefore; // string
|
|
$after = $this->dateNotAfter; // string
|
|
if (null !== $before) {
|
|
$before = Carbon::createFromFormat('Y-m-d', $before);
|
|
}
|
|
if (null !== $after) {
|
|
$after = Carbon::createFromFormat('Y-m-d', $after);
|
|
}
|
|
|
|
if (null !== $before && null !== $after && $before > $after) {
|
|
[$before, $after] = [$after, $before];
|
|
}
|
|
|
|
$this->dateNotBefore = null === $before ? '' : $before->format('Y-m-d');
|
|
$this->dateNotAfter = null === $after ? '' : $after->format('Y-m-d');
|
|
Log::debug(sprintf('dateNotBefore is now "%s", dateNotAfter is "%s"', $this->dateNotBefore, $this->dateNotAfter));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $unit
|
|
* @param int $number
|
|
*
|
|
* @return string|null
|
|
*/
|
|
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');
|
|
}
|
|
app('log')->error(sprintf('Could not parse date setting. Unknown key "%s"', $unit));
|
|
|
|
return null;
|
|
}
|
|
}
|