LifespansChartModule::subtitle() - Code Metrics - Inspection of "Set HTTP security headers" - fisharebest/webtrees - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cd51db...9c88b4 )

by Greg

created 2020-01-09 16:41 UTC

LifespansChartModule::subtitle() B

↳ Parent: LifespansChartModule::layoutIndividuals()

Complexity

Conditions	7
Paths	4

Size

Total Lines	36
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	25
nc	4
nop	4
dl	0
loc	36
rs	8.5866
c	0
b	0
f	0

<?php

/**
 * webtrees: online genealogy
 * Copyright (C) 2019 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 <http://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace Fisharebest\Webtrees\Module;

use Aura\Router\RouterContainer;
use Fig\Http\Message\RequestMethodInterface;
use Fisharebest\ExtCalendar\GregorianCalendar;
use Fisharebest\Webtrees\Auth;
use Fisharebest\Webtrees\ColorGenerator;
use Fisharebest\Webtrees\Date;
use Fisharebest\Webtrees\I18N;
use Fisharebest\Webtrees\Individual;
use Fisharebest\Webtrees\Place;
use Fisharebest\Webtrees\Tree;
use Illuminate\Database\Capsule\Manager as DB;
use Illuminate\Database\Query\JoinClause;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use stdClass;

use function app;
use function assert;

/**
 * Class LifespansChartModule
 */
class LifespansChartModule extends AbstractModule implements ModuleChartInterface, RequestHandlerInterface
{
    use ModuleChartTrait;

    private const ROUTE_NAME = 'lifespans-chart';
    private const ROUTE_URL  = '/tree/{tree}/lifespans';

    // Defaults
    protected const DEFAULT_PARAMETERS = [];

    // Parameters for generating colors
    protected const RANGE      = 120; // degrees
    protected const SATURATION = 100; // percent
    protected const LIGHTNESS  = 30; // percent
    protected const ALPHA      = 0.25;

    /**
     * Initialization.
     *
     * @return void
     */
    public function boot(): void
    {
        $router_container = app(RouterContainer::class);
        assert($router_container instanceof RouterContainer);

        $router_container->getMap()
            ->get(self::ROUTE_NAME, self::ROUTE_URL, $this)
            ->allows(RequestMethodInterface::METHOD_POST);
    }

    /**
     * How should this module be identified in the control panel, etc.?
     *
     * @return string
     */
    public function title(): string
    {
        /* I18N: Name of a module/chart */
        return I18N::translate('Lifespans');
    }

    /**
     * A sentence describing what this module does.
     *
     * @return string
     */
    public function description(): string
    {
        /* I18N: Description of the “LifespansChart” module */
        return I18N::translate('A chart of individuals’ lifespans.');
    }

    /**
     * CSS class for the URL.
     *
     * @return string
     */
    public function chartMenuClass(): string
    {
        return 'menu-chart-lifespan';
    }

    /**
     * The URL for this chart.
     *
     * @param Individual $individual
     * @param mixed[]    $parameters
     *
     * @return string
     */
    public function chartUrl(Individual $individual, array $parameters = []): string
    {
        return route(self::ROUTE_NAME, [
                'tree'  => $individual->tree()->name(),
                'xrefs' => [$individual->xref()],
            ] + $parameters + self::DEFAULT_PARAMETERS);
    }

    /**
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $tree = $request->getAttribute('tree');
        assert($tree instanceof Tree);

        $user      = $request->getAttribute('user');
        $xrefs     = $request->getQueryParams()['xrefs'] ?? [];
        $ajax      = $request->getQueryParams()['ajax'] ?? '';

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

        $addxref   = $params['addxref'] ?? '';
        $addfam    = (bool) ($params['addfam'] ?? false);
        $place_id  = (int) ($params['place_id'] ?? 0);
        $start     = $params['start'] ?? '';
        $end       = $params['end'] ?? '';

        $place      = Place::find($place_id, $tree);
        $start_date = new Date($start);
        $end_date   = new Date($end);

        $xrefs = array_unique($xrefs);

        // Add an individual, and family members
        $individual = Individual::getInstance($addxref, $tree);
        if ($individual !== null) {
            $xrefs[] = $addxref;
            if ($addfam) {
                $xrefs = array_merge($xrefs, $this->closeFamily($individual));
            }
        }

        // Select by date and/or place.
        if ($place_id !== 0 && $start_date->isOK() && $end_date->isOK()) {
            $date_xrefs  = $this->findIndividualsByDate($start_date, $end_date, $tree);
            $place_xrefs = $this->findIndividualsByPlace($place, $tree);
            $xrefs       = array_intersect($date_xrefs, $place_xrefs);
        } elseif ($start_date->isOK() && $end_date->isOK()) {
            $xrefs = $this->findIndividualsByDate($start_date, $end_date, $tree);
        } elseif ($place_id !== 0) {
            $xrefs = $this->findIndividualsByPlace($place, $tree);
        }

        // Filter duplicates and private individuals.
        $xrefs = array_unique($xrefs);
        $xrefs = array_filter($xrefs, static function (string $xref) use ($tree): bool {
            $individual = Individual::getInstance($xref, $tree);

            return $individual !== null && $individual->canShow();
        });

        // Convert POST requests into GET requests for pretty URLs.
        if ($request->getMethod() === RequestMethodInterface::METHOD_POST) {
            return redirect(route(self::ROUTE_NAME, [
                'tree'  => $tree->name(),
                'xrefs' => $xrefs,
            ]));
        }

        Auth::checkComponentAccess($this, 'chart', $tree, $user);

        if ($ajax === '1') {
            $this->layout = 'layouts/ajax';

            return $this->chart($tree, $xrefs);
        }

        $reset_url = route(self::ROUTE_NAME, ['tree' => $tree->name()]);

        $ajax_url = route(self::ROUTE_NAME, [
            'ajax'  => true,
            'tree'  => $tree->name(),
            'xrefs' => $xrefs,
        ]);

        return $this->viewResponse('modules/lifespans-chart/page', [
            'ajax_url'  => $ajax_url,
            'module'    => $this->name(),
            'reset_url' => $reset_url,
            'title'     => $this->title(),
            'tree'      => $tree,
            'xrefs'     => $xrefs,
        ]);
    }

    /**
     * @param Tree  $tree
     * @param array $xrefs
     *
     * @return ResponseInterface
     */
    protected function chart(Tree $tree, array $xrefs): ResponseInterface
    {
        /** @var Individual[] $individuals */
        $individuals = array_map(static function (string $xref) use ($tree): ?Individual {
            return Individual::getInstance($xref, $tree);
        }, $xrefs);

        $individuals = array_filter($individuals, static function (?Individual $individual): bool {
            return $individual instanceof Individual && $individual->canShow();
        });

        // Sort the array in order of birth year
        usort($individuals, Individual::birthDateComparator());

        // Round to whole decades
        $start_year = (int) floor($this->minYear($individuals) / 10) * 10;
        $end_year   = (int) ceil($this->maxYear($individuals) / 10) * 10;

        $lifespans = $this->layoutIndividuals($individuals);

        $max_rows = array_reduce($lifespans, static function ($carry, stdClass $item) {
            return max($carry, $item->row);
        }, 0);

        $count    = count($xrefs);
        $subtitle = I18N::plural('%s individual', '%s individuals', $count, I18N::number($count));
        
        $html = view('modules/lifespans-chart/chart', [
            'dir'        => I18N::direction(),
            'end_year'   => $end_year,
            'lifespans'  => $lifespans,
            'max_rows'   => $max_rows,
            'start_year' => $start_year,
            'subtitle'   => $subtitle,
        ]);

        return response($html);
    }

    /**
     * Find the latest event year for individuals
     *
     * @param array $individuals
     *
     * @return int
     */
    protected function maxYear(array $individuals): int
    {
        $jd = array_reduce($individuals, static function ($carry, Individual $item) {
            return max($carry, $item->getEstimatedDeathDate()->maximumJulianDay());
        }, 0);

        $year = $this->jdToYear($jd);

        // Don't show future dates
        return min($year, (int) date('Y'));
    }

    /**
     * Find the earliest event year for individuals
     *
     * @param array $individuals
     *
     * @return int
     */
    protected function minYear(array $individuals): int
    {
        $jd = array_reduce($individuals, static function ($carry, Individual $item) {
            return min($carry, $item->getEstimatedBirthDate()->minimumJulianDay());
        }, PHP_INT_MAX);

        return $this->jdToYear($jd);
    }

    /**
     * Convert a julian day to a gregorian year
     *
     * @param int $jd
     *
     * @return int
     */
    protected function jdToYear(int $jd): int
    {
        if ($jd === 0) {
            return 0;
        }

        $gregorian = new GregorianCalendar();
        [$y] = $gregorian->jdToYmd($jd);

        return $y;
    }

    /**
     * @param Date $start
     * @param Date $end
     * @param Tree $tree
     *
     * @return string[]
     */
    protected function findIndividualsByDate(Date $start, Date $end, Tree $tree): array
    {
        return DB::table('individuals')
            ->join('dates', static function (JoinClause $join): void {
                $join
                    ->on('d_file', '=', 'i_file')
                    ->on('d_gid', '=', 'i_id');
            })
            ->where('i_file', '=', $tree->id())
            ->where('d_julianday1', '<=', $end->maximumJulianDay())
            ->where('d_julianday2', '>=', $start->minimumJulianDay())
            ->whereNotIn('d_fact', ['BAPL', 'ENDL', 'SLGC', 'SLGS', '_TODO', 'CHAN'])
            ->pluck('i_id')
            ->all();
    }

    /**
     * @param Place $place
     * @param Tree  $tree
     *
     * @return string[]
     */
    protected function findIndividualsByPlace(Place $place, Tree $tree): array
    {
        return DB::table('individuals')
            ->join('placelinks', static function (JoinClause $join): void {
                $join
                    ->on('pl_file', '=', 'i_file')
                    ->on('pl_gid', '=', 'i_id');
            })
            ->where('i_file', '=', $tree->id())
            ->where('pl_p_id', '=', $place->id())
            ->pluck('i_id')
            ->all();
    }

    /**
     * Find the close family members of an individual.
     *
     * @param Individual $individual
     *
     * @return string[]
     */
    protected function closeFamily(Individual $individual): array
    {
        $xrefs = [];

        foreach ($individual->spouseFamilies() as $family) {
            foreach ($family->children() as $child) {
                $xrefs[] = $child->xref();
            }

            foreach ($family->spouses() as $spouse) {
                $xrefs[] = $spouse->xref();
            }
        }

        foreach ($individual->childFamilies() as $family) {
            foreach ($family->children() as $child) {
                $xrefs[] = $child->xref();
            }

            foreach ($family->spouses() as $spouse) {
                $xrefs[] = $spouse->xref();
            }
        }

        return $xrefs;
    }

    /**
     * @param Individual[] $individuals
     *
     * @return stdClass[]
     */
    private function layoutIndividuals(array $individuals): array
    {
        $colors = [
            'M' => new ColorGenerator(240, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE * -1),
            'F' => new ColorGenerator(000, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE),
            'U' => new ColorGenerator(120, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE),
        ];

        $current_year = (int) date('Y');

        // Latest year used in each row
        $rows = [];

        $lifespans = [];

        foreach ($individuals as $individual) {
            $birth_jd   = $individual->getEstimatedBirthDate()->minimumJulianDay();
            $birth_year = $this->jdToYear($birth_jd);
            $death_jd   = $individual->getEstimatedDeathDate()->maximumJulianDay();
            $death_year = $this->jdToYear($death_jd);

            // Died before they were born?  Swapping the dates allows them to be shown.
            if ($death_year < $birth_year) {
                $death_year = $birth_year;
            }

            // Don't show death dates in the future.
            $death_year = min($death_year, $current_year);

            // Add this individual to the next row in the chart...
            $next_row = count($rows);
            // ...unless we can find an existing row where it fits.
            foreach ($rows as $row => $year) {
                if ($year < $birth_year) {
                    $next_row = $row;
                    break;
                }
            }

            // Fill the row up to the year (leaving a small gap)
            $rows[$next_row] = $death_year;

            $lifespans[] = (object) [
                'background' => $colors[$individual->sex()]->getNextColor(),
                'birth_year' => $birth_year,
                'death_year' => $death_year,
                'id'         => 'individual-' . md5($individual->xref()),
                'individual' => $individual,
                'row'        => $next_row,
            ];
        }

        return $lifespans;
    }
}


1			<?php
2
3			/**
4			* webtrees: online genealogy
5			* Copyright (C) 2019 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 <http://www.gnu.org/licenses/>.
16			*/
17
18			declare(strict_types=1);
19
20			namespace Fisharebest\Webtrees\Module;
21
22			use Aura\Router\RouterContainer;
23			use Fig\Http\Message\RequestMethodInterface;
24			use Fisharebest\ExtCalendar\GregorianCalendar;
25			use Fisharebest\Webtrees\Auth;
26			use Fisharebest\Webtrees\ColorGenerator;
27			use Fisharebest\Webtrees\Date;
28			use Fisharebest\Webtrees\I18N;
29			use Fisharebest\Webtrees\Individual;
30			use Fisharebest\Webtrees\Place;
31			use Fisharebest\Webtrees\Tree;
32			use Illuminate\Database\Capsule\Manager as DB;
33			use Illuminate\Database\Query\JoinClause;
34			use Psr\Http\Message\ResponseInterface;
35			use Psr\Http\Message\ServerRequestInterface;
36			use Psr\Http\Server\RequestHandlerInterface;
37			use stdClass;
38
39			use function app;
40			use function assert;
41
42			/**
43			* Class LifespansChartModule
44			*/
45			class LifespansChartModule extends AbstractModule implements ModuleChartInterface, RequestHandlerInterface
46			{
47			use ModuleChartTrait;
48
49			private const ROUTE_NAME = 'lifespans-chart';
50			private const ROUTE_URL = '/tree/{tree}/lifespans';
51
52			// Defaults
53			protected const DEFAULT_PARAMETERS = [];
54
55			// Parameters for generating colors
56			protected const RANGE = 120; // degrees
57			protected const SATURATION = 100; // percent
58			protected const LIGHTNESS = 30; // percent
59			protected const ALPHA = 0.25;
60
61			/**
62			* Initialization.
63			*
64			* @return void
65			*/
66			public function boot(): void
67			{
68			$router_container = app(RouterContainer::class);
69			assert($router_container instanceof RouterContainer);
70
71			$router_container->getMap()
72			->get(self::ROUTE_NAME, self::ROUTE_URL, $this)
73			->allows(RequestMethodInterface::METHOD_POST);
74			}
75
76			/**
77			* How should this module be identified in the control panel, etc.?
78			*
79			* @return string
80			*/
81			public function title(): string
82			{
83			/* I18N: Name of a module/chart */
84			return I18N::translate('Lifespans');
85			}
86
87			/**
88			* A sentence describing what this module does.
89			*
90			* @return string
91			*/
92			public function description(): string
93			{
94			/* I18N: Description of the “LifespansChart” module */
95			return I18N::translate('A chart of individuals’ lifespans.');
96			}
97
98			/**
99			* CSS class for the URL.
100			*
101			* @return string
102			*/
103			public function chartMenuClass(): string
104			{
105			return 'menu-chart-lifespan';
106			}
107
108			/**
109			* The URL for this chart.
110			*
111			* @param Individual $individual
112			* @param mixed[] $parameters
113			*
114			* @return string
115			*/
116			public function chartUrl(Individual $individual, array $parameters = []): string
117			{
118			return route(self::ROUTE_NAME, [
119			'tree' => $individual->tree()->name(),
120			'xrefs' => [$individual->xref()],
121			] + $parameters + self::DEFAULT_PARAMETERS);
122			}
123
124			/**
125			* @param ServerRequestInterface $request
126			*
127			* @return ResponseInterface
128			*/
129			public function handle(ServerRequestInterface $request): ResponseInterface
130			{
131			$tree = $request->getAttribute('tree');
132			assert($tree instanceof Tree);
133
134			$user = $request->getAttribute('user');
135			$xrefs = $request->getQueryParams()['xrefs'] ?? [];
136			$ajax = $request->getQueryParams()['ajax'] ?? '';
137
138			$params = (array) $request->getParsedBody();
139
140			$addxref = $params['addxref'] ?? '';
141			$addfam = (bool) ($params['addfam'] ?? false);
142			$place_id = (int) ($params['place_id'] ?? 0);
143			$start = $params['start'] ?? '';
144			$end = $params['end'] ?? '';
145
146			$place = Place::find($place_id, $tree);
147			$start_date = new Date($start);
148			$end_date = new Date($end);
149
150			$xrefs = array_unique($xrefs);
151
152			// Add an individual, and family members
153			$individual = Individual::getInstance($addxref, $tree);
154			if ($individual !== null) {
155			$xrefs[] = $addxref;
156			if ($addfam) {
157			$xrefs = array_merge($xrefs, $this->closeFamily($individual));
158			}
159			}
160
161			// Select by date and/or place.
162			if ($place_id !== 0 && $start_date->isOK() && $end_date->isOK()) {
163			$date_xrefs = $this->findIndividualsByDate($start_date, $end_date, $tree);
164			$place_xrefs = $this->findIndividualsByPlace($place, $tree);
165			$xrefs = array_intersect($date_xrefs, $place_xrefs);
166			} elseif ($start_date->isOK() && $end_date->isOK()) {
167			$xrefs = $this->findIndividualsByDate($start_date, $end_date, $tree);
168			} elseif ($place_id !== 0) {
169			$xrefs = $this->findIndividualsByPlace($place, $tree);
170			}
171
172			// Filter duplicates and private individuals.
173			$xrefs = array_unique($xrefs);
174			$xrefs = array_filter($xrefs, static function (string $xref) use ($tree): bool {
175			$individual = Individual::getInstance($xref, $tree);
176
177			return $individual !== null && $individual->canShow();
178			});
179
180			// Convert POST requests into GET requests for pretty URLs.
181			if ($request->getMethod() === RequestMethodInterface::METHOD_POST) {
182			return redirect(route(self::ROUTE_NAME, [
183			'tree' => $tree->name(),
184			'xrefs' => $xrefs,
185			]));
186			}
187
188			Auth::checkComponentAccess($this, 'chart', $tree, $user);
189
190			if ($ajax === '1') {
191			$this->layout = 'layouts/ajax';
192
193			return $this->chart($tree, $xrefs);
194			}
195
196			$reset_url = route(self::ROUTE_NAME, ['tree' => $tree->name()]);
197
198			$ajax_url = route(self::ROUTE_NAME, [
199			'ajax' => true,
200			'tree' => $tree->name(),
201			'xrefs' => $xrefs,
202			]);
203
204			return $this->viewResponse('modules/lifespans-chart/page', [
205			'ajax_url' => $ajax_url,
206			'module' => $this->name(),
207			'reset_url' => $reset_url,
208			'title' => $this->title(),
209			'tree' => $tree,
210			'xrefs' => $xrefs,
211			]);
212			}
213
214			/**
215			* @param Tree $tree
216			* @param array $xrefs
217			*
218			* @return ResponseInterface
219			*/
220			protected function chart(Tree $tree, array $xrefs): ResponseInterface
221			{
222			/** @var Individual[] $individuals */
223			$individuals = array_map(static function (string $xref) use ($tree): ?Individual {
224			return Individual::getInstance($xref, $tree);
225			}, $xrefs);
226
227			$individuals = array_filter($individuals, static function (?Individual $individual): bool {
228			return $individual instanceof Individual && $individual->canShow();
229			});
230
231			// Sort the array in order of birth year
232			usort($individuals, Individual::birthDateComparator());
233
234			// Round to whole decades
235			$start_year = (int) floor($this->minYear($individuals) / 10) * 10;
236			$end_year = (int) ceil($this->maxYear($individuals) / 10) * 10;
237
238			$lifespans = $this->layoutIndividuals($individuals);
239
240			$max_rows = array_reduce($lifespans, static function ($carry, stdClass $item) {
241			return max($carry, $item->row);
242			}, 0);
243
244			$count = count($xrefs);
245			$subtitle = I18N::plural('%s individual', '%s individuals', $count, I18N::number($count));
246
247			$html = view('modules/lifespans-chart/chart', [
248			'dir' => I18N::direction(),
249			'end_year' => $end_year,
250			'lifespans' => $lifespans,
251			'max_rows' => $max_rows,
252			'start_year' => $start_year,
253			'subtitle' => $subtitle,
254			]);
255
256			return response($html);
257			}
258
259			/**
260			* Find the latest event year for individuals
261			*
262			* @param array $individuals
263			*
264			* @return int
265			*/
266			protected function maxYear(array $individuals): int
267			{
268			$jd = array_reduce($individuals, static function ($carry, Individual $item) {
269			return max($carry, $item->getEstimatedDeathDate()->maximumJulianDay());
270			}, 0);
271
272			$year = $this->jdToYear($jd);
273
274			// Don't show future dates
275			return min($year, (int) date('Y'));
276			}
277
278			/**
279			* Find the earliest event year for individuals
280			*
281			* @param array $individuals
282			*
283			* @return int
284			*/
285			protected function minYear(array $individuals): int
286			{
287			$jd = array_reduce($individuals, static function ($carry, Individual $item) {
288			return min($carry, $item->getEstimatedBirthDate()->minimumJulianDay());
289			}, PHP_INT_MAX);
290
291			return $this->jdToYear($jd);
292			}
293
294			/**
295			* Convert a julian day to a gregorian year
296			*
297			* @param int $jd
298			*
299			* @return int
300			*/
301			protected function jdToYear(int $jd): int
302			{
303			if ($jd === 0) {
304			return 0;
305			}
306
307			$gregorian = new GregorianCalendar();
308			[$y] = $gregorian->jdToYmd($jd);
309
310			return $y;
311			}
312
313			/**
314			* @param Date $start
315			* @param Date $end
316			* @param Tree $tree
317			*
318			* @return string[]
319			*/
320			protected function findIndividualsByDate(Date $start, Date $end, Tree $tree): array
321			{
322			return DB::table('individuals')
323			->join('dates', static function (JoinClause $join): void {
324			$join
325			->on('d_file', '=', 'i_file')
326			->on('d_gid', '=', 'i_id');
327			})
328			->where('i_file', '=', $tree->id())
329			->where('d_julianday1', '<=', $end->maximumJulianDay())
330			->where('d_julianday2', '>=', $start->minimumJulianDay())
331			->whereNotIn('d_fact', ['BAPL', 'ENDL', 'SLGC', 'SLGS', '_TODO', 'CHAN'])
332			->pluck('i_id')
333			->all();
334			}
335
336			/**
337			* @param Place $place
338			* @param Tree $tree
339			*
340			* @return string[]
341			*/
342			protected function findIndividualsByPlace(Place $place, Tree $tree): array
343			{
344			return DB::table('individuals')
345			->join('placelinks', static function (JoinClause $join): void {
346			$join
347			->on('pl_file', '=', 'i_file')
348			->on('pl_gid', '=', 'i_id');
349			})
350			->where('i_file', '=', $tree->id())
351			->where('pl_p_id', '=', $place->id())
352			->pluck('i_id')
353			->all();
354			}
355
356			/**
357			* Find the close family members of an individual.
358			*
359			* @param Individual $individual
360			*
361			* @return string[]
362			*/
363			protected function closeFamily(Individual $individual): array
364			{
365			$xrefs = [];
366
367			foreach ($individual->spouseFamilies() as $family) {
368			foreach ($family->children() as $child) {
369			$xrefs[] = $child->xref();
370			}
371
372			foreach ($family->spouses() as $spouse) {
373			$xrefs[] = $spouse->xref();
374			}
375			}
376
377			foreach ($individual->childFamilies() as $family) {
378			foreach ($family->children() as $child) {
379			$xrefs[] = $child->xref();
380			}
381
382			foreach ($family->spouses() as $spouse) {
383			$xrefs[] = $spouse->xref();
384			}
385			}
386
387			return $xrefs;
388			}
389
390			/**
391			* @param Individual[] $individuals
392			*
393			* @return stdClass[]
394			*/
395			private function layoutIndividuals(array $individuals): array
396			{
397			$colors = [
398			'M' => new ColorGenerator(240, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE * -1),
399			'F' => new ColorGenerator(000, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE),
400			'U' => new ColorGenerator(120, self::SATURATION, self::LIGHTNESS, self::ALPHA, self::RANGE),
401			];
402
403			$current_year = (int) date('Y');
404
405			// Latest year used in each row
406			$rows = [];
407
408			$lifespans = [];
409
410			foreach ($individuals as $individual) {
411			$birth_jd = $individual->getEstimatedBirthDate()->minimumJulianDay();
412			$birth_year = $this->jdToYear($birth_jd);
413			$death_jd = $individual->getEstimatedDeathDate()->maximumJulianDay();
414			$death_year = $this->jdToYear($death_jd);
415
416			// Died before they were born? Swapping the dates allows them to be shown.
417			if ($death_year < $birth_year) {
418			$death_year = $birth_year;
419			}
420
421			// Don't show death dates in the future.
422			$death_year = min($death_year, $current_year);
423
424			// Add this individual to the next row in the chart...
425			$next_row = count($rows);
426			// ...unless we can find an existing row where it fits.
427			foreach ($rows as $row => $year) {
428			if ($year < $birth_year) {
429			$next_row = $row;
430			break;
431			}
432			}
433
434			// Fill the row up to the year (leaving a small gap)
435			$rows[$next_row] = $death_year;
436
437			$lifespans[] = (object) [
438			'background' => $colors[$individual->sex()]->getNextColor(),
439			'birth_year' => $birth_year,
440			'death_year' => $death_year,
441			'id' => 'individual-' . md5($individual->xref()),
442			'individual' => $individual,
443			'row' => $next_row,
444			];
445			}
446
447			return $lifespans;
448			}
449			}
450

fisharebest / webtrees

Push — master ( cd51db...9c88b4 )

LifespansChartModule::subtitle() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like