MapDataImportAction::__construct() - Code Metrics - Inspection of "Working on GEDCOM elements" - fisharebest/webtrees - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( f72123...a47531 )

by Greg

created 2021-04-05 13:36 UTC

MapDataImportAction::__construct() A

↳ Parent: MapDataImportAction

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	2
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?php

/**
 * webtrees: online genealogy
 * Copyright (C) 2021 webtrees development team
 * This program 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.
 * 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 General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace Fisharebest\Webtrees\Http\RequestHandlers;

use Exception;
use Fisharebest\Webtrees\FlashMessages;
use Fisharebest\Webtrees\Gedcom;
use Fisharebest\Webtrees\I18N;
use Fisharebest\Webtrees\PlaceLocation;
use Fisharebest\Webtrees\Registry;
use Fisharebest\Webtrees\Services\MapDataService;
use Illuminate\Database\Capsule\Manager as DB;
use League\Flysystem\FilesystemException;
use League\Flysystem\UnableToCheckFileExistence;
use League\Flysystem\UnableToReadFile;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\UploadedFileInterface;
use Psr\Http\Server\RequestHandlerInterface;

use function array_filter;
use function array_reverse;
use function array_slice;
use function count;
use function fclose;
use function fgetcsv;
use function implode;
use function is_numeric;
use function json_decode;
use function redirect;
use function rewind;
use function route;
use function str_contains;
use function stream_get_contents;

use const JSON_THROW_ON_ERROR;
use const UPLOAD_ERR_OK;

/**
 * Import geographic data.
 */
class MapDataImportAction implements RequestHandlerInterface
{
    private MapDataService $map_data_service;

    /**
     * MapDataImportAction constructor.
     *
     * @param MapDataService $map_data_service
     */
    public function __construct(MapDataService $map_data_service)
    {
        $this->map_data_service = $map_data_service;
    }

    /**
     * This function assumes the input file layout is
     * level followed by a variable number of placename fields
     * followed by Longitude, Latitude, Zoom & Icon
     *
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     * @throws Exception
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $data_filesystem = Registry::filesystem()->data();

        $params = (array) $request->getParsedBody();

        $serverfile     = $params['serverfile'] ?? '';
        $options        = $params['import-options'] ?? '';
        $clear_database = (bool) ($params['cleardatabase'] ?? false);
        $local_file     = $request->getUploadedFiles()['localfile'] ?? null;

        $places = [];

        $url = route(MapDataList::class, ['parent_id' => 0]);

        $fp = false;

        try {
            $file_exists = $data_filesystem->fileExists(MapDataService::PLACES_FOLDER . $serverfile);
        } catch (FilesystemException | UnableToCheckFileExistence $ex) {
            $file_exists = false;
        }


        if ($serverfile !== '' && $file_exists) {
            // first choice is file on server
            try {
                $fp = $data_filesystem->readStream(MapDataService::PLACES_FOLDER . $serverfile);
            } catch (FilesystemException | UnableToReadFile $ex) {
                $fp = false;
            }
        } elseif ($local_file instanceof UploadedFileInterface && $local_file->getError() === UPLOAD_ERR_OK) {
            // 2nd choice is local file
            $fp = $local_file->getStream()->detach();
        }

        if ($fp === false || $fp === null) {
            return redirect($url);
        }

        $string = stream_get_contents($fp);

        // Check the file type
        if (str_contains($string, 'FeatureCollection')) {
            $input_array = json_decode($string, false, 512, JSON_THROW_ON_ERROR);

            foreach ($input_array->features as $feature) {
                $places[] = [
                    'latitude'  => $feature->geometry->coordinates[1],
                    'longitude' => $feature->geometry->coordinates[0],
                    'name'      => $feature->properties->name,
                ];
            }
        } else {
            rewind($fp);
            while (($row = fgetcsv($fp, 0, MapDataService::CSV_SEPARATOR)) !== false) {
                // Skip the header
                if (!is_numeric($row[0])) {
                    continue;
                }

                $level = (int) $row[0];
                $count = count($row);
                $name  = implode(Gedcom::PLACE_SEPARATOR, array_reverse(array_slice($row, 1, 1 + $level)));

                $places[] = [
                    'latitude'  => (float) strtr($row[$count - 3], ['N' => '', 'S' => '-', ',' => '.']),
                    'longitude' => (float) strtr($row[$count - 4], ['E' => '', 'W' => '-', ',' => '.']),
                    'name'      => $name
                ];
            }
        }

        fclose($fp);

        if ($clear_database) {
            // Child places are deleted via on-delete-cascade...
            DB::table('place_location')
                ->whereNull('parent_id')
                ->delete();

            // Automatically import any new/missing places.
            $this->map_data_service->importMissingLocations();
        }

        $added   = 0;
        $updated = 0;

        // Remove places with 0,0 coordinates at lower levels.
        $places = array_filter($places, static function ($place) {
            return !str_contains($place['name'], ',') || $place['longitude'] !== 0.0 || $place['latitude'] !== 0.0;
        });

        foreach ($places as $place) {
            $location = new PlaceLocation($place['name']);
            $exists   = $location->exists();

            // Only update existing records
            if ($options === 'update' && !$exists) {
                continue;
            }

            // Only add new records
            if ($options === 'add' && $exists) {
                continue;
            }

            if (!$exists) {
                $added++;
            }

            $updated += DB::table('place_location')
                ->where('id', '=', $location->id())
                ->update([
                    'latitude'  => $place['latitude'],
                    'longitude' => $place['longitude'],
                ]);
        }

        FlashMessages::addMessage(
            I18N::translate('locations updated: %s, locations added: %s', I18N::number($updated), I18N::number($added)),
            'info'
        );

        return redirect($url);
    }
}


1			<?php
2
3			/**
4			* webtrees: online genealogy
5			* Copyright (C) 2021 webtrees development team
6			* This program is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			* You should have received a copy of the GNU General Public License
15			* along with this program. If not, see <https://www.gnu.org/licenses/>.
16			*/
17
18			declare(strict_types=1);
19
20			namespace Fisharebest\Webtrees\Http\RequestHandlers;
21
22			use Exception;
23			use Fisharebest\Webtrees\FlashMessages;
24			use Fisharebest\Webtrees\Gedcom;
25			use Fisharebest\Webtrees\I18N;
26			use Fisharebest\Webtrees\PlaceLocation;
27			use Fisharebest\Webtrees\Registry;
28			use Fisharebest\Webtrees\Services\MapDataService;
29			use Illuminate\Database\Capsule\Manager as DB;
30			use League\Flysystem\FilesystemException;
31			use League\Flysystem\UnableToCheckFileExistence;
32			use League\Flysystem\UnableToReadFile;
33			use Psr\Http\Message\ResponseInterface;
34			use Psr\Http\Message\ServerRequestInterface;
35			use Psr\Http\Message\UploadedFileInterface;
36			use Psr\Http\Server\RequestHandlerInterface;
37
38			use function array_filter;
39			use function array_reverse;
40			use function array_slice;
41			use function count;
42			use function fclose;
43			use function fgetcsv;
44			use function implode;
45			use function is_numeric;
46			use function json_decode;
47			use function redirect;
48			use function rewind;
49			use function route;
50			use function str_contains;
51			use function stream_get_contents;
52
53			use const JSON_THROW_ON_ERROR;
54			use const UPLOAD_ERR_OK;
55
56			/**
57			* Import geographic data.
58			*/
59			class MapDataImportAction implements RequestHandlerInterface
60			{
61			private MapDataService $map_data_service;
62
63			/**
64			* MapDataImportAction constructor.
65			*
66			* @param MapDataService $map_data_service
67			*/
68			public function __construct(MapDataService $map_data_service)
69			{
70			$this->map_data_service = $map_data_service;
71			}
72
73			/**
74			* This function assumes the input file layout is
75			* level followed by a variable number of placename fields
76			* followed by Longitude, Latitude, Zoom & Icon
77			*
78			* @param ServerRequestInterface $request
79			*
80			* @return ResponseInterface
81			* @throws Exception
82			*/
83			public function handle(ServerRequestInterface $request): ResponseInterface
84			{
85			$data_filesystem = Registry::filesystem()->data();
86
87			$params = (array) $request->getParsedBody();
88
89			$serverfile = $params['serverfile'] ?? '';
90			$options = $params['import-options'] ?? '';
91			$clear_database = (bool) ($params['cleardatabase'] ?? false);
92			$local_file = $request->getUploadedFiles()['localfile'] ?? null;
93
94			$places = [];
95
96			$url = route(MapDataList::class, ['parent_id' => 0]);
97
98			$fp = false;
99
100			try {
101			$file_exists = $data_filesystem->fileExists(MapDataService::PLACES_FOLDER . $serverfile);
102			} catch (FilesystemException \| UnableToCheckFileExistence $ex) {
103			$file_exists = false;
104			}
105
106
107			if ($serverfile !== '' && $file_exists) {
108			// first choice is file on server
109			try {
110			$fp = $data_filesystem->readStream(MapDataService::PLACES_FOLDER . $serverfile);
111			} catch (FilesystemException \| UnableToReadFile $ex) {
112			$fp = false;
113			}
114			} elseif ($local_file instanceof UploadedFileInterface && $local_file->getError() === UPLOAD_ERR_OK) {
115			// 2nd choice is local file
116			$fp = $local_file->getStream()->detach();
117			}
118
119			if ($fp === false \|\| $fp === null) {
120			return redirect($url);
121			}
122
123			$string = stream_get_contents($fp);
124
125			// Check the file type
126			if (str_contains($string, 'FeatureCollection')) {
127			$input_array = json_decode($string, false, 512, JSON_THROW_ON_ERROR);
128
129			foreach ($input_array->features as $feature) {
130			$places[] = [
131			'latitude' => $feature->geometry->coordinates[1],
132			'longitude' => $feature->geometry->coordinates[0],
133			'name' => $feature->properties->name,
134			];
135			}
136			} else {
137			rewind($fp);
138			while (($row = fgetcsv($fp, 0, MapDataService::CSV_SEPARATOR)) !== false) {
139			// Skip the header
140			if (!is_numeric($row[0])) {
141			continue;
142			}
143
144			$level = (int) $row[0];
145			$count = count($row);
146			$name = implode(Gedcom::PLACE_SEPARATOR, array_reverse(array_slice($row, 1, 1 + $level)));
147
148			$places[] = [
149			'latitude' => (float) strtr($row[$count - 3], ['N' => '', 'S' => '-', ',' => '.']),
150			'longitude' => (float) strtr($row[$count - 4], ['E' => '', 'W' => '-', ',' => '.']),
151			'name' => $name
152			];
153			}
154			}
155
156			fclose($fp);
157
158			if ($clear_database) {
159			// Child places are deleted via on-delete-cascade...
160			DB::table('place_location')
161			->whereNull('parent_id')
162			->delete();
163
164			// Automatically import any new/missing places.
165			$this->map_data_service->importMissingLocations();
166			}
167
168			$added = 0;
169			$updated = 0;
170
171			// Remove places with 0,0 coordinates at lower levels.
172			$places = array_filter($places, static function ($place) {
173			return !str_contains($place['name'], ',') \|\| $place['longitude'] !== 0.0 \|\| $place['latitude'] !== 0.0;
174			});
175
176			foreach ($places as $place) {
177			$location = new PlaceLocation($place['name']);
178			$exists = $location->exists();
179
180			// Only update existing records
181			if ($options === 'update' && !$exists) {
182			continue;
183			}
184
185			// Only add new records
186			if ($options === 'add' && $exists) {
187			continue;
188			}
189
190			if (!$exists) {
191			$added++;
192			}
193
194			$updated += DB::table('place_location')
195			->where('id', '=', $location->id())
196			->update([
197			'latitude' => $place['latitude'],
198			'longitude' => $place['longitude'],
199			]);
200			}
201
202			FlashMessages::addMessage(
203			I18N::translate('locations updated: %s, locations added: %s', I18N::number($updated), I18N::number($added)),
204			'info'
205			);
206
207			return redirect($url);
208			}
209			}
210

fisharebest / webtrees

Push — develop ( f72123...a47531 )

MapDataImportAction::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like