mirror of
https://github.com/firefly-iii/firefly-iii.git
synced 2025-01-22 22:43:20 -06:00
319 lines
10 KiB
PHP
319 lines
10 KiB
PHP
<?php
|
|
/**
|
|
* Map.php
|
|
* Copyright (c) 2017 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/>.
|
|
*/
|
|
declare(strict_types=1);
|
|
|
|
namespace FireflyIII\Support\Import\Configuration\File;
|
|
|
|
use FireflyIII\Exceptions\FireflyException;
|
|
use FireflyIII\Import\Mapper\MapperInterface;
|
|
use FireflyIII\Import\MapperPreProcess\PreProcessorInterface;
|
|
use FireflyIII\Import\Specifics\SpecificInterface;
|
|
use FireflyIII\Models\ImportJob;
|
|
use FireflyIII\Repositories\ImportJob\ImportJobRepositoryInterface;
|
|
use FireflyIII\Support\Import\Configuration\ConfigurationInterface;
|
|
use League\Csv\Reader;
|
|
use League\Csv\Statement;
|
|
use Log;
|
|
|
|
/**
|
|
* Class Mapping.
|
|
*/
|
|
class Map implements ConfigurationInterface
|
|
{
|
|
/** @var array that holds each column to be mapped by the user */
|
|
private $data = [];
|
|
/** @var ImportJob */
|
|
private $job;
|
|
/** @var ImportJobRepositoryInterface */
|
|
private $repository;
|
|
/** @var array */
|
|
private $validSpecifics = [];
|
|
|
|
/**
|
|
* @return array
|
|
*
|
|
* @throws FireflyException
|
|
* @throws \League\Csv\Exception
|
|
*/
|
|
public function getData(): array
|
|
{
|
|
$this->getMappableColumns();
|
|
|
|
// in order to actually map we also need all possible values from the CSV file.
|
|
$config = $this->getConfig();
|
|
$content = $this->repository->uploadFileContents($this->job);
|
|
$offset = 0;
|
|
/** @var Reader $reader */
|
|
$reader = Reader::createFromString($content);
|
|
$reader->setDelimiter($config['delimiter']);
|
|
if ($config['has-headers']) {
|
|
$offset = 1;
|
|
}
|
|
$stmt = (new Statement)->offset($offset);
|
|
$results = $stmt->process($reader);
|
|
$this->validSpecifics = array_keys(config('csv.import_specifics'));
|
|
$indexes = array_keys($this->data);
|
|
$rowIndex = 0;
|
|
foreach ($results as $rowIndex => $row) {
|
|
$row = $this->runSpecifics($row);
|
|
|
|
//do something here
|
|
foreach ($indexes as $index) { // this is simply 1, 2, 3, etc.
|
|
if (!isset($row[$index])) {
|
|
// don't really know how to handle this. Just skip, for now.
|
|
continue;
|
|
}
|
|
$value = trim($row[$index]);
|
|
if (strlen($value) > 0) {
|
|
// we can do some preprocessing here,
|
|
// which is exclusively to fix the tags:
|
|
if (null !== $this->data[$index]['preProcessMap'] && strlen($this->data[$index]['preProcessMap']) > 0) {
|
|
/** @var PreProcessorInterface $preProcessor */
|
|
$preProcessor = app($this->data[$index]['preProcessMap']);
|
|
$result = $preProcessor->run($value);
|
|
$this->data[$index]['values'] = array_merge($this->data[$index]['values'], $result);
|
|
|
|
Log::debug($rowIndex . ':' . $index . 'Value before preprocessor', ['value' => $value]);
|
|
Log::debug($rowIndex . ':' . $index . 'Value after preprocessor', ['value-new' => $result]);
|
|
Log::debug($rowIndex . ':' . $index . 'Value after joining', ['value-complete' => $this->data[$index]['values']]);
|
|
|
|
continue;
|
|
}
|
|
|
|
$this->data[$index]['values'][] = $value;
|
|
}
|
|
}
|
|
}
|
|
$setIndexes = array_keys($this->data);
|
|
foreach ($setIndexes as $index) {
|
|
$this->data[$index]['values'] = array_unique($this->data[$index]['values']);
|
|
asort($this->data[$index]['values']);
|
|
// if the count of this array is zero, there is nothing to map.
|
|
if (count($this->data[$index]['values']) === 0) {
|
|
unset($this->data[$index]);
|
|
}
|
|
}
|
|
unset($setIndexes);
|
|
|
|
// save number of rows, thus number of steps, in job:
|
|
$steps = $rowIndex * 5;
|
|
$extended = $this->job->extended_status;
|
|
$extended['steps'] = $steps;
|
|
$this->job->extended_status = $extended;
|
|
$this->job->save();
|
|
|
|
return $this->data;
|
|
}
|
|
|
|
/**
|
|
* Return possible warning to user.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getWarningMessage(): string
|
|
{
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* @param ImportJob $job
|
|
*
|
|
* @return ConfigurationInterface
|
|
*/
|
|
public function setJob(ImportJob $job): ConfigurationInterface
|
|
{
|
|
$this->job = $job;
|
|
$this->repository = app(ImportJobRepositoryInterface::class);
|
|
$this->repository->setUser($job->user);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Store the result.
|
|
*
|
|
* @param array $data
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function storeConfiguration(array $data): bool
|
|
{
|
|
$config = $this->getConfig();
|
|
|
|
if (isset($data['mapping'])) {
|
|
foreach ($data['mapping'] as $index => $array) {
|
|
$config['column-mapping-config'][$index] = [];
|
|
foreach ($array as $value => $mapId) {
|
|
$mapId = (int)$mapId;
|
|
if (0 !== $mapId) {
|
|
$config['column-mapping-config'][$index][$value] = $mapId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// set thing to be completed.
|
|
$config['stage'] = 'ready';
|
|
$this->saveConfig($config);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param string $column
|
|
*
|
|
* @return MapperInterface
|
|
*/
|
|
private function createMapper(string $column): MapperInterface
|
|
{
|
|
$mapperClass = config('csv.import_roles.' . $column . '.mapper');
|
|
$mapperName = sprintf('\\FireflyIII\\Import\Mapper\\%s', $mapperClass);
|
|
|
|
return app($mapperName);
|
|
}
|
|
|
|
/**
|
|
* Short hand method.
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getConfig(): array
|
|
{
|
|
return $this->repository->getConfiguration($this->job);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*
|
|
* @throws FireflyException
|
|
*/
|
|
private function getMappableColumns(): bool
|
|
{
|
|
$config = $this->getConfig();
|
|
/**
|
|
* @var int
|
|
* @var bool $mustBeMapped
|
|
*/
|
|
foreach ($config['column-do-mapping'] as $index => $mustBeMapped) {
|
|
$column = $this->validateColumnName($config['column-roles'][$index] ?? '_ignore');
|
|
$shouldMap = $this->shouldMapColumn($column, $mustBeMapped);
|
|
if ($shouldMap) {
|
|
// create configuration entry for this specific column and add column to $this->data array for later processing.
|
|
$this->data[$index] = [
|
|
'name' => $column,
|
|
'index' => $index,
|
|
'options' => $this->createMapper($column)->getMap(),
|
|
'preProcessMap' => $this->getPreProcessorName($column),
|
|
'values' => [],
|
|
];
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param string $column
|
|
*
|
|
* @return string
|
|
*/
|
|
private function getPreProcessorName(string $column): string
|
|
{
|
|
$name = '';
|
|
$hasPreProcess = config('csv.import_roles.' . $column . '.pre-process-map');
|
|
$preProcessClass = config('csv.import_roles.' . $column . '.pre-process-mapper');
|
|
|
|
if (null !== $hasPreProcess && true === $hasPreProcess && null !== $preProcessClass) {
|
|
$name = sprintf('\\FireflyIII\\Import\\MapperPreProcess\\%s', $preProcessClass);
|
|
}
|
|
|
|
return $name;
|
|
}
|
|
|
|
/**
|
|
* @param array $row
|
|
*
|
|
* @return array
|
|
*
|
|
* @throws FireflyException
|
|
*/
|
|
private function runSpecifics(array $row): array
|
|
{
|
|
// run specifics here:
|
|
// and this is the point where the specifix go to work.
|
|
$config = $this->getConfig();
|
|
$specifics = $config['specifics'] ?? [];
|
|
$names = array_keys($specifics);
|
|
foreach ($names as $name) {
|
|
if (!in_array($name, $this->validSpecifics)) {
|
|
throw new FireflyException(sprintf('"%s" is not a valid class name', $name));
|
|
}
|
|
$class = config('csv.import_specifics.' . $name);
|
|
/** @var SpecificInterface $specific */
|
|
$specific = app($class);
|
|
|
|
// it returns the row, possibly modified:
|
|
$row = $specific->run($row);
|
|
}
|
|
|
|
return $row;
|
|
}
|
|
|
|
/**
|
|
* @param array $array
|
|
*/
|
|
private function saveConfig(array $array)
|
|
{
|
|
$this->repository->setConfiguration($this->job, $array);
|
|
}
|
|
|
|
/**
|
|
* @param string $column
|
|
* @param bool $mustBeMapped
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function shouldMapColumn(string $column, bool $mustBeMapped): bool
|
|
{
|
|
$canBeMapped = config('csv.import_roles.' . $column . '.mappable');
|
|
|
|
return $canBeMapped && $mustBeMapped;
|
|
}
|
|
|
|
/**
|
|
* @param string $column
|
|
*
|
|
* @return string
|
|
*
|
|
* @throws FireflyException
|
|
*/
|
|
private function validateColumnName(string $column): string
|
|
{
|
|
// is valid column?
|
|
$validColumns = array_keys(config('csv.import_roles'));
|
|
if (!in_array($column, $validColumns)) {
|
|
throw new FireflyException(sprintf('"%s" is not a valid column.', $column));
|
|
}
|
|
|
|
return $column;
|
|
}
|
|
}
|