1<?php 2 3/** 4 * webtrees: online genealogy 5 * Copyright (C) 2022 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 18declare(strict_types=1); 19 20namespace Fisharebest\Webtrees; 21 22use Closure; 23use Exception; 24use Fisharebest\Webtrees\Contracts\TimestampInterface; 25use Fisharebest\Webtrees\Contracts\UserInterface; 26use Fisharebest\Webtrees\Http\RequestHandlers\GedcomRecordPage; 27use Fisharebest\Webtrees\Services\PendingChangesService; 28use Illuminate\Database\Capsule\Manager as DB; 29use Illuminate\Database\Query\Builder; 30use Illuminate\Database\Query\Expression; 31use Illuminate\Database\Query\JoinClause; 32use Illuminate\Support\Collection; 33 34use function addcslashes; 35use function app; 36use function array_combine; 37use function array_keys; 38use function array_map; 39use function array_search; 40use function array_shift; 41use function assert; 42use function count; 43use function date; 44use function e; 45use function explode; 46use function in_array; 47use function md5; 48use function preg_match; 49use function preg_match_all; 50use function preg_replace; 51use function preg_replace_callback; 52use function preg_split; 53use function range; 54use function route; 55use function str_contains; 56use function str_ends_with; 57use function str_pad; 58use function strtoupper; 59use function trim; 60use function view; 61 62use const PHP_INT_MAX; 63use const PREG_SET_ORDER; 64use const STR_PAD_LEFT; 65 66/** 67 * A GEDCOM object. 68 */ 69class GedcomRecord 70{ 71 public const RECORD_TYPE = 'UNKNOWN'; 72 73 protected const ROUTE_NAME = GedcomRecordPage::class; 74 75 protected string $xref; 76 77 protected Tree $tree; 78 79 // GEDCOM data (before any pending edits) 80 protected string $gedcom; 81 82 // GEDCOM data (after any pending edits) 83 protected ?string $pending; 84 85 /** @var array<Fact> Facts extracted from $gedcom/$pending */ 86 protected array $facts; 87 88 /** @var array<array<string>> All the names of this individual */ 89 protected array $getAllNames = []; 90 91 /** @var int|null Cached result */ 92 private ?int $getPrimaryName = null; 93 94 /** @var int|null Cached result */ 95 private ?int $getSecondaryName = null; 96 97 /** 98 * Create a GedcomRecord object from raw GEDCOM data. 99 * 100 * @param string $xref 101 * @param string $gedcom an empty string for new/pending records 102 * @param string|null $pending null for a record with no pending edits, 103 * empty string for records with pending deletions 104 * @param Tree $tree 105 */ 106 public function __construct(string $xref, string $gedcom, ?string $pending, Tree $tree) 107 { 108 $this->xref = $xref; 109 $this->gedcom = $gedcom; 110 $this->pending = $pending; 111 $this->tree = $tree; 112 $this->facts = $this->parseFacts(); 113 } 114 115 /** 116 * A closure which will filter out private records. 117 * 118 * @return Closure 119 */ 120 public static function accessFilter(): Closure 121 { 122 return static function (GedcomRecord $record): bool { 123 return $record->canShow(); 124 }; 125 } 126 127 /** 128 * A closure which will compare records by name. 129 * 130 * @return Closure 131 */ 132 public static function nameComparator(): Closure 133 { 134 return static function (GedcomRecord $x, GedcomRecord $y): int { 135 if ($x->canShowName()) { 136 if ($y->canShowName()) { 137 return I18N::comparator()($x->sortName(), $y->sortName()); 138 } 139 140 return -1; // only $y is private 141 } 142 143 if ($y->canShowName()) { 144 return 1; // only $x is private 145 } 146 147 return 0; // both $x and $y private 148 }; 149 } 150 151 /** 152 * A closure which will compare records by change time. 153 * 154 * @param int $direction +1 to sort ascending, -1 to sort descending 155 * 156 * @return Closure 157 */ 158 public static function lastChangeComparator(int $direction = 1): Closure 159 { 160 return static function (GedcomRecord $x, GedcomRecord $y) use ($direction): int { 161 return $direction * ($x->lastChangeTimestamp() <=> $y->lastChangeTimestamp()); 162 }; 163 } 164 165 /** 166 * Get the GEDCOM tag for this record. 167 * 168 * @return string 169 */ 170 public function tag(): string 171 { 172 preg_match('/^0 @[^@]*@ (\w+)/', $this->gedcom(), $match); 173 174 return $match[1] ?? static::RECORD_TYPE; 175 } 176 177 /** 178 * Get the XREF for this record 179 * 180 * @return string 181 */ 182 public function xref(): string 183 { 184 return $this->xref; 185 } 186 187 /** 188 * Get the tree to which this record belongs 189 * 190 * @return Tree 191 */ 192 public function tree(): Tree 193 { 194 return $this->tree; 195 } 196 197 /** 198 * Application code should access data via Fact objects. 199 * This function exists to support old code. 200 * 201 * @return string 202 */ 203 public function gedcom(): string 204 { 205 return $this->pending ?? $this->gedcom; 206 } 207 208 /** 209 * Does this record have a pending change? 210 * 211 * @return bool 212 */ 213 public function isPendingAddition(): bool 214 { 215 return $this->pending !== null; 216 } 217 218 /** 219 * Does this record have a pending deletion? 220 * 221 * @return bool 222 */ 223 public function isPendingDeletion(): bool 224 { 225 return $this->pending === ''; 226 } 227 228 /** 229 * Generate a URL to this record. 230 * 231 * @return string 232 */ 233 public function url(): string 234 { 235 return route(static::ROUTE_NAME, [ 236 'xref' => $this->xref(), 237 'tree' => $this->tree->name(), 238 'slug' => Registry::slugFactory()->make($this), 239 ]); 240 } 241 242 /** 243 * Can the details of this record be shown? 244 * 245 * @param int|null $access_level 246 * 247 * @return bool 248 */ 249 public function canShow(int $access_level = null): bool 250 { 251 $access_level = $access_level ?? Auth::accessLevel($this->tree); 252 253 // We use this value to bypass privacy checks. For example, 254 // when downloading data or when calculating privacy itself. 255 if ($access_level === Auth::PRIV_HIDE) { 256 return true; 257 } 258 259 $cache_key = 'show-' . $this->xref . '-' . $this->tree->id() . '-' . $access_level; 260 261 return Registry::cache()->array()->remember($cache_key, function () use ($access_level) { 262 return $this->canShowRecord($access_level); 263 }); 264 } 265 266 /** 267 * Can the name of this record be shown? 268 * 269 * @param int|null $access_level 270 * 271 * @return bool 272 */ 273 public function canShowName(int $access_level = null): bool 274 { 275 return $this->canShow($access_level); 276 } 277 278 /** 279 * Can we edit this record? 280 * 281 * @return bool 282 */ 283 public function canEdit(): bool 284 { 285 if ($this->isPendingDeletion()) { 286 return false; 287 } 288 289 if (Auth::isManager($this->tree)) { 290 return true; 291 } 292 293 return Auth::isEditor($this->tree) && !str_contains($this->gedcom, "\n1 RESN locked"); 294 } 295 296 /** 297 * Remove private data from the raw gedcom record. 298 * Return both the visible and invisible data. We need the invisible data when editing. 299 * 300 * @param int $access_level 301 * 302 * @return string 303 */ 304 public function privatizeGedcom(int $access_level): string 305 { 306 if ($access_level === Auth::PRIV_HIDE) { 307 // We may need the original record, for example when downloading a GEDCOM or clippings cart 308 return $this->gedcom; 309 } 310 311 if ($this->canShow($access_level)) { 312 // The record is not private, but the individual facts may be. 313 314 // Include the entire first line (for NOTE records) 315 [$gedrec] = explode("\n", $this->gedcom . $this->pending, 2); 316 317 // Check each of the facts for access 318 foreach ($this->facts([], false, $access_level) as $fact) { 319 $gedrec .= "\n" . $fact->gedcom(); 320 } 321 322 return $gedrec; 323 } 324 325 // We cannot display the details, but we may be able to display 326 // limited data, such as links to other records. 327 return $this->createPrivateGedcomRecord($access_level); 328 } 329 330 /** 331 * Default for "other" object types 332 * 333 * @return void 334 */ 335 public function extractNames(): void 336 { 337 $this->addName(static::RECORD_TYPE, $this->getFallBackName(), ''); 338 } 339 340 /** 341 * Derived classes should redefine this function, otherwise the object will have no name 342 * 343 * @return array<int,array<string,string>> 344 */ 345 public function getAllNames(): array 346 { 347 if ($this->getAllNames === []) { 348 if ($this->canShowName()) { 349 // Ask the record to extract its names 350 $this->extractNames(); 351 // No name found? Use a fallback. 352 if ($this->getAllNames === []) { 353 $this->addName(static::RECORD_TYPE, $this->getFallBackName(), ''); 354 } 355 } else { 356 $this->addName(static::RECORD_TYPE, I18N::translate('Private'), ''); 357 } 358 } 359 360 return $this->getAllNames; 361 } 362 363 /** 364 * If this object has no name, what do we call it? 365 * 366 * @return string 367 */ 368 public function getFallBackName(): string 369 { 370 return e($this->xref()); 371 } 372 373 /** 374 * Which of the (possibly several) names of this record is the primary one. 375 * 376 * @return int 377 */ 378 public function getPrimaryName(): int 379 { 380 static $language_script; 381 382 $language_script ??= I18N::locale()->script()->code(); 383 384 if ($this->getPrimaryName === null) { 385 // Generally, the first name is the primary one.... 386 $this->getPrimaryName = 0; 387 // ...except when the language/name use different character sets 388 foreach ($this->getAllNames() as $n => $name) { 389 if (I18N::textScript($name['sort']) === $language_script) { 390 $this->getPrimaryName = $n; 391 break; 392 } 393 } 394 } 395 396 return $this->getPrimaryName; 397 } 398 399 /** 400 * Which of the (possibly several) names of this record is the secondary one. 401 * 402 * @return int 403 */ 404 public function getSecondaryName(): int 405 { 406 if ($this->getSecondaryName === null) { 407 // Generally, the primary and secondary names are the same 408 $this->getSecondaryName = $this->getPrimaryName(); 409 // ....except when there are names with different character sets 410 $all_names = $this->getAllNames(); 411 if (count($all_names) > 1) { 412 $primary_script = I18N::textScript($all_names[$this->getPrimaryName()]['sort']); 413 foreach ($all_names as $n => $name) { 414 if ($n !== $this->getPrimaryName() && $name['type'] !== '_MARNM' && I18N::textScript($name['sort']) !== $primary_script) { 415 $this->getSecondaryName = $n; 416 break; 417 } 418 } 419 } 420 } 421 422 return $this->getSecondaryName; 423 } 424 425 /** 426 * Allow the choice of primary name to be overidden, e.g. in a search result 427 * 428 * @param int|null $n 429 * 430 * @return void 431 */ 432 public function setPrimaryName(int $n = null): void 433 { 434 $this->getPrimaryName = $n; 435 $this->getSecondaryName = null; 436 } 437 438 /** 439 * Allow native PHP functions such as array_unique() to work with objects 440 * 441 * @return string 442 */ 443 public function __toString(): string 444 { 445 return $this->xref . '@' . $this->tree->id(); 446 } 447 448 /** 449 * /** 450 * Get variants of the name 451 * 452 * @return string 453 */ 454 public function fullName(): string 455 { 456 if ($this->canShowName()) { 457 $tmp = $this->getAllNames(); 458 459 return $tmp[$this->getPrimaryName()]['full']; 460 } 461 462 return I18N::translate('Private'); 463 } 464 465 /** 466 * Get a sortable version of the name. Do not display this! 467 * 468 * @return string 469 */ 470 public function sortName(): string 471 { 472 // The sortable name is never displayed, no need to call canShowName() 473 $tmp = $this->getAllNames(); 474 475 return $tmp[$this->getPrimaryName()]['sort']; 476 } 477 478 /** 479 * Get the full name in an alternative character set 480 * 481 * @return string|null 482 */ 483 public function alternateName(): ?string 484 { 485 if ($this->canShowName() && $this->getPrimaryName() !== $this->getSecondaryName()) { 486 $all_names = $this->getAllNames(); 487 488 return $all_names[$this->getSecondaryName()]['full']; 489 } 490 491 return null; 492 } 493 494 /** 495 * Format this object for display in a list 496 * 497 * @return string 498 */ 499 public function formatList(): string 500 { 501 $html = '<a href="' . e($this->url()) . '" class="list_item">'; 502 $html .= '<b>' . $this->fullName() . '</b>'; 503 $html .= $this->formatListDetails(); 504 $html .= '</a>'; 505 506 return $html; 507 } 508 509 /** 510 * This function should be redefined in derived classes to show any major 511 * identifying characteristics of this record. 512 * 513 * @return string 514 */ 515 public function formatListDetails(): string 516 { 517 return ''; 518 } 519 520 /** 521 * Extract/format the first fact from a list of facts. 522 * 523 * @param array<string> $facts 524 * @param int $style 525 * 526 * @return string 527 */ 528 public function formatFirstMajorFact(array $facts, int $style): string 529 { 530 foreach ($this->facts($facts, true) as $event) { 531 // Only display if it has a date or place (or both) 532 if ($event->date()->isOK() && $event->place()->gedcomName() !== '') { 533 $joiner = ' — '; 534 } else { 535 $joiner = ''; 536 } 537 if ($event->date()->isOK() || $event->place()->gedcomName() !== '') { 538 switch ($style) { 539 case 1: 540 return '<br><em>' . $event->label() . ' ' . view('fact-date', ['cal_link' => 'false', 'fact' => $event, 'record' => $event->record(), 'time' => false]) . '</em>'; 541 case 2: 542 return '<dl><dt class="label">' . $event->label() . '</dt><dd class="field">' . view('fact-date', ['cal_link' => 'false', 'fact' => $event, 'record' => $event->record(), 'time' => false]) . $joiner . $event->place()->shortName() . '</dd></dl>'; 543 } 544 } 545 } 546 547 return ''; 548 } 549 550 /** 551 * Get all attributes (e.g. DATE or PLAC) from an event (e.g. BIRT or MARR). 552 * This is used to display multiple events on the individual/family lists. 553 * Multiple events can exist because of uncertainty in dates, dates in different 554 * calendars, place-names in both latin and hebrew character sets, etc. 555 * It also allows us to combine dates/places from different events in the summaries. 556 * 557 * @param array<string> $events 558 * 559 * @return array<Date> 560 */ 561 public function getAllEventDates(array $events): array 562 { 563 $dates = []; 564 foreach ($this->facts($events, false, null, true) as $event) { 565 if ($event->date()->isOK()) { 566 $dates[] = $event->date(); 567 } 568 } 569 570 return $dates; 571 } 572 573 /** 574 * Get all the places for a particular type of event 575 * 576 * @param array<string> $events 577 * 578 * @return array<Place> 579 */ 580 public function getAllEventPlaces(array $events): array 581 { 582 $places = []; 583 foreach ($this->facts($events) as $event) { 584 if (preg_match_all('/\n(?:2 PLAC|3 (?:ROMN|FONE|_HEB)) +(.+)/', $event->gedcom(), $ged_places)) { 585 foreach ($ged_places[1] as $ged_place) { 586 $places[] = new Place($ged_place, $this->tree); 587 } 588 } 589 } 590 591 return $places; 592 } 593 594 /** 595 * The facts and events for this record. 596 * 597 * @param array<string> $filter 598 * @param bool $sort 599 * @param int|null $access_level 600 * @param bool $ignore_deleted 601 * 602 * @return Collection<int,Fact> 603 */ 604 public function facts( 605 array $filter = [], 606 bool $sort = false, 607 int $access_level = null, 608 bool $ignore_deleted = false 609 ): Collection { 610 $access_level = $access_level ?? Auth::accessLevel($this->tree); 611 612 // Convert BIRT into INDI:BIRT, etc. 613 $filter = array_map(fn (string $tag): string => $this->tag() . ':' . $tag, $filter); 614 615 $facts = new Collection(); 616 if ($this->canShow($access_level)) { 617 foreach ($this->facts as $fact) { 618 if (($filter === [] || in_array($fact->tag(), $filter, true)) && $fact->canShow($access_level)) { 619 $facts->push($fact); 620 } 621 } 622 } 623 624 if ($sort) { 625 switch ($this->tag()) { 626 case Family::RECORD_TYPE: 627 case Individual::RECORD_TYPE: 628 $facts = Fact::sortFacts($facts); 629 break; 630 631 default: 632 $subtags = Registry::elementFactory()->make($this->tag())->subtags(); 633 $subtags = array_map(fn (string $tag): string => $this->tag() . ':' . $tag, array_keys($subtags)); 634 $subtags = array_combine(range(1, count($subtags)), $subtags); 635 636 $facts = $facts 637 ->sort(static function (Fact $x, Fact $y) use ($subtags): int { 638 $sort_x = array_search($x->tag(), $subtags, true) ?: PHP_INT_MAX; 639 $sort_y = array_search($y->tag(), $subtags, true) ?: PHP_INT_MAX; 640 641 return $sort_x <=> $sort_y; 642 }); 643 break; 644 } 645 } 646 647 if ($ignore_deleted) { 648 $facts = $facts->filter(static function (Fact $fact): bool { 649 return !$fact->isPendingDeletion(); 650 }); 651 } 652 653 return $facts; 654 } 655 656 /** 657 * @return array<string,string> 658 */ 659 public function missingFacts(): array 660 { 661 $missing_facts = []; 662 663 foreach (Registry::elementFactory()->make($this->tag())->subtags() as $subtag => $repeat) { 664 [, $max] = explode(':', $repeat); 665 $max = $max === 'M' ? PHP_INT_MAX : (int) $max; 666 667 if ($this->facts([$subtag], false, null, true)->count() < $max) { 668 $missing_facts[$subtag] = $subtag; 669 $missing_facts[$subtag] = Registry::elementFactory()->make($this->tag() . ':' . $subtag)->label(); 670 } 671 } 672 673 uasort($missing_facts, I18N::comparator()); 674 675 if (!Auth::canUploadMedia($this->tree, Auth::user())) { 676 unset($missing_facts['OBJE']); 677 } 678 679 // We have special code for this. 680 unset($missing_facts['FILE']); 681 682 return $missing_facts; 683 } 684 685 /** 686 * Get the last-change timestamp for this record 687 * 688 * @return TimestampInterface 689 */ 690 public function lastChangeTimestamp(): TimestampInterface 691 { 692 /** @var Fact|null $chan */ 693 $chan = $this->facts(['CHAN'])->first(); 694 695 if ($chan instanceof Fact) { 696 // The record has a CHAN event. 697 $d = $chan->date()->minimumDate()->format('%Y-%m-%d'); 698 699 if ($d !== '') { 700 // The CHAN event has a valid DATE. 701 if (preg_match('/\n3 TIME (([01]\d|2[0-3]):([0-5]\d):([0-5]\d))/', $chan->gedcom(), $match)) { 702 return Registry::timestampFactory()->fromString($d . $match[1], 'Y-m-d H:i:s'); 703 } 704 705 if (preg_match('/\n3 TIME (([01]\d|2[0-3]):([0-5]\d))/', $chan->gedcom(), $match)) { 706 return Registry::timestampFactory()->fromString($d . $match[1], 'Y-m-d H:i'); 707 } 708 709 return Registry::timestampFactory()->fromString($d, 'Y-m-d'); 710 } 711 } 712 713 // The record does not have a CHAN event 714 return Registry::timestampFactory()->make(0); 715 } 716 717 /** 718 * Get the last-change user for this record 719 * 720 * @return string 721 */ 722 public function lastChangeUser(): string 723 { 724 $chan = $this->facts(['CHAN'])->first(); 725 726 if ($chan === null) { 727 return I18N::translate('Unknown'); 728 } 729 730 $chan_user = $chan->attribute('_WT_USER'); 731 if ($chan_user === '') { 732 return I18N::translate('Unknown'); 733 } 734 735 return $chan_user; 736 } 737 738 /** 739 * Add a new fact to this record 740 * 741 * @param string $gedcom 742 * @param bool $update_chan 743 * 744 * @return void 745 */ 746 public function createFact(string $gedcom, bool $update_chan): void 747 { 748 $this->updateFact('', $gedcom, $update_chan); 749 } 750 751 /** 752 * Delete a fact from this record 753 * 754 * @param string $fact_id 755 * @param bool $update_chan 756 * 757 * @return void 758 */ 759 public function deleteFact(string $fact_id, bool $update_chan): void 760 { 761 $this->updateFact($fact_id, '', $update_chan); 762 } 763 764 /** 765 * Replace a fact with a new gedcom data. 766 * 767 * @param string $fact_id 768 * @param string $gedcom 769 * @param bool $update_chan 770 * 771 * @return void 772 * @throws Exception 773 */ 774 public function updateFact(string $fact_id, string $gedcom, bool $update_chan): void 775 { 776 // Not all record types allow a CHAN event. 777 $update_chan = $update_chan && in_array(static::RECORD_TYPE, Gedcom::RECORDS_WITH_CHAN, true); 778 779 // MSDOS line endings will break things in horrible ways 780 $gedcom = preg_replace('/[\r\n]+/', "\n", $gedcom); 781 $gedcom = trim($gedcom); 782 783 if ($this->pending === '') { 784 throw new Exception('Cannot edit a deleted record'); 785 } 786 if ($gedcom !== '' && !preg_match('/^1 ' . Gedcom::REGEX_TAG . '/', $gedcom)) { 787 throw new Exception('Invalid GEDCOM data passed to GedcomRecord::updateFact(' . $gedcom . ')'); 788 } 789 790 if ($this->pending) { 791 $old_gedcom = $this->pending; 792 } else { 793 $old_gedcom = $this->gedcom; 794 } 795 796 // First line of record may contain data - e.g. NOTE records. 797 [$new_gedcom] = explode("\n", $old_gedcom, 2); 798 799 // Replacing (or deleting) an existing fact 800 foreach ($this->facts([], false, Auth::PRIV_HIDE, true) as $fact) { 801 if ($fact->id() === $fact_id) { 802 if ($gedcom !== '') { 803 $new_gedcom .= "\n" . $gedcom; 804 } 805 $fact_id = 'NOT A VALID FACT ID'; // Only replace/delete one copy of a duplicate fact 806 } elseif (!str_ends_with($fact->tag(), ':CHAN') || !$update_chan) { 807 $new_gedcom .= "\n" . $fact->gedcom(); 808 } 809 } 810 811 // Adding a new fact 812 if ($fact_id === '') { 813 $new_gedcom .= "\n" . $gedcom; 814 } 815 816 if ($update_chan && !str_contains($new_gedcom, "\n1 CHAN")) { 817 $today = strtoupper(date('d M Y')); 818 $now = date('H:i:s'); 819 $new_gedcom .= "\n1 CHAN\n2 DATE " . $today . "\n3 TIME " . $now . "\n2 _WT_USER " . Auth::user()->userName(); 820 } 821 822 if ($new_gedcom !== $old_gedcom) { 823 // Save the changes 824 DB::table('change')->insert([ 825 'gedcom_id' => $this->tree->id(), 826 'xref' => $this->xref, 827 'old_gedcom' => $old_gedcom, 828 'new_gedcom' => $new_gedcom, 829 'user_id' => Auth::id(), 830 ]); 831 832 $this->pending = $new_gedcom; 833 834 if (Auth::user()->getPreference(UserInterface::PREF_AUTO_ACCEPT_EDITS) === '1') { 835 $pending_changes_service = app(PendingChangesService::class); 836 assert($pending_changes_service instanceof PendingChangesService); 837 838 $pending_changes_service->acceptRecord($this); 839 $this->gedcom = $new_gedcom; 840 $this->pending = null; 841 } 842 } 843 844 $this->facts = $this->parseFacts(); 845 } 846 847 /** 848 * Update this record 849 * 850 * @param string $gedcom 851 * @param bool $update_chan 852 * 853 * @return void 854 */ 855 public function updateRecord(string $gedcom, bool $update_chan): void 856 { 857 // Not all record types allow a CHAN event. 858 $update_chan = $update_chan && in_array(static::RECORD_TYPE, Gedcom::RECORDS_WITH_CHAN, true); 859 860 // MSDOS line endings will break things in horrible ways 861 $gedcom = preg_replace('/[\r\n]+/', "\n", $gedcom); 862 $gedcom = trim($gedcom); 863 864 // Update the CHAN record 865 if ($update_chan) { 866 $gedcom = preg_replace('/\n1 CHAN(\n[2-9].*)*/', '', $gedcom); 867 $today = strtoupper(date('d M Y')); 868 $now = date('H:i:s'); 869 $gedcom .= "\n1 CHAN\n2 DATE " . $today . "\n3 TIME " . $now . "\n2 _WT_USER " . Auth::user()->userName(); 870 } 871 872 // Create a pending change 873 DB::table('change')->insert([ 874 'gedcom_id' => $this->tree->id(), 875 'xref' => $this->xref, 876 'old_gedcom' => $this->gedcom(), 877 'new_gedcom' => $gedcom, 878 'user_id' => Auth::id(), 879 ]); 880 881 // Clear the cache 882 $this->pending = $gedcom; 883 884 // Accept this pending change 885 if (Auth::user()->getPreference(UserInterface::PREF_AUTO_ACCEPT_EDITS) === '1') { 886 $pending_changes_service = app(PendingChangesService::class); 887 assert($pending_changes_service instanceof PendingChangesService); 888 889 $pending_changes_service->acceptRecord($this); 890 $this->gedcom = $gedcom; 891 $this->pending = null; 892 } 893 894 $this->facts = $this->parseFacts(); 895 896 Log::addEditLog('Update: ' . static::RECORD_TYPE . ' ' . $this->xref, $this->tree); 897 } 898 899 /** 900 * Delete this record 901 * 902 * @return void 903 */ 904 public function deleteRecord(): void 905 { 906 // Create a pending change 907 if (!$this->isPendingDeletion()) { 908 DB::table('change')->insert([ 909 'gedcom_id' => $this->tree->id(), 910 'xref' => $this->xref, 911 'old_gedcom' => $this->gedcom(), 912 'new_gedcom' => '', 913 'user_id' => Auth::id(), 914 ]); 915 } 916 917 // Auto-accept this pending change 918 if (Auth::user()->getPreference(UserInterface::PREF_AUTO_ACCEPT_EDITS) === '1') { 919 $pending_changes_service = app(PendingChangesService::class); 920 assert($pending_changes_service instanceof PendingChangesService); 921 922 $pending_changes_service->acceptRecord($this); 923 } 924 925 Log::addEditLog('Delete: ' . static::RECORD_TYPE . ' ' . $this->xref, $this->tree); 926 } 927 928 /** 929 * Remove all links from this record to $xref 930 * 931 * @param string $xref 932 * @param bool $update_chan 933 * 934 * @return void 935 */ 936 public function removeLinks(string $xref, bool $update_chan): void 937 { 938 $value = '@' . $xref . '@'; 939 940 foreach ($this->facts() as $fact) { 941 if ($fact->value() === $value) { 942 $this->deleteFact($fact->id(), $update_chan); 943 } elseif (preg_match_all('/\n(\d) ' . Gedcom::REGEX_TAG . ' ' . $value . '/', $fact->gedcom(), $matches, PREG_SET_ORDER)) { 944 $gedcom = $fact->gedcom(); 945 foreach ($matches as $match) { 946 $next_level = $match[1] + 1; 947 $next_levels = '[' . $next_level . '-9]'; 948 $gedcom = preg_replace('/' . $match[0] . '(\n' . $next_levels . '.*)*/', '', $gedcom); 949 } 950 $this->updateFact($fact->id(), $gedcom, $update_chan); 951 } 952 } 953 } 954 955 /** 956 * Each object type may have its own special rules, and re-implement this function. 957 * 958 * @param int $access_level 959 * 960 * @return bool 961 */ 962 protected function canShowByType(int $access_level): bool 963 { 964 $fact_privacy = $this->tree->getFactPrivacy(); 965 966 if (isset($fact_privacy[static::RECORD_TYPE])) { 967 // Restriction found 968 return $fact_privacy[static::RECORD_TYPE] >= $access_level; 969 } 970 971 // No restriction found - must be public: 972 return true; 973 } 974 975 /** 976 * Generate a private version of this record 977 * 978 * @param int $access_level 979 * 980 * @return string 981 */ 982 protected function createPrivateGedcomRecord(int $access_level): string 983 { 984 return '0 @' . $this->xref . '@ ' . static::RECORD_TYPE; 985 } 986 987 /** 988 * Convert a name record into sortable and full/display versions. This default 989 * should be OK for simple record types. INDI/FAM records will need to redefine it. 990 * 991 * @param string $type 992 * @param string $value 993 * @param string $gedcom 994 * 995 * @return void 996 */ 997 protected function addName(string $type, string $value, string $gedcom): void 998 { 999 $this->getAllNames[] = [ 1000 'type' => $type, 1001 'sort' => preg_replace_callback('/(\d+)/', static function (array $matches): string { 1002 return str_pad($matches[0], 10, '0', STR_PAD_LEFT); 1003 }, $value), 1004 'full' => '<bdi>' . e($value) . '</bdi>', 1005 // This is used for display 1006 'fullNN' => $value, 1007 // This goes into the database 1008 ]; 1009 } 1010 1011 /** 1012 * Get all the names of a record, including ROMN, FONE and _HEB alternatives. 1013 * Records without a name (e.g. FAM) will need to redefine this function. 1014 * Parameters: the level 1 fact containing the name. 1015 * Return value: an array of name structures, each containing 1016 * ['type'] = the gedcom fact, e.g. NAME, TITL, FONE, _HEB, etc. 1017 * ['full'] = the name as specified in the record, e.g. 'Vincent van Gogh' or 'John Unknown' 1018 * ['sort'] = a sortable version of the name (not for display), e.g. 'Gogh, Vincent' or '@N.N., John' 1019 * 1020 * @param int $level 1021 * @param string $fact_type 1022 * @param Collection<int,Fact> $facts 1023 * 1024 * @return void 1025 */ 1026 protected function extractNamesFromFacts(int $level, string $fact_type, Collection $facts): void 1027 { 1028 $sublevel = $level + 1; 1029 $subsublevel = $sublevel + 1; 1030 foreach ($facts as $fact) { 1031 if (preg_match_all('/^' . $level . ' (' . $fact_type . ') (.+)((\n[' . $sublevel . '-9].+)*)/m', $fact->gedcom(), $matches, PREG_SET_ORDER)) { 1032 foreach ($matches as $match) { 1033 // Treat 1 NAME / 2 TYPE married the same as _MARNM 1034 if ($match[1] === 'NAME' && str_contains($match[3], "\n2 TYPE married")) { 1035 $this->addName('_MARNM', $match[2], $fact->gedcom()); 1036 } else { 1037 $this->addName($match[1], $match[2], $fact->gedcom()); 1038 } 1039 if ($match[3] && preg_match_all('/^' . $sublevel . ' (ROMN|FONE|_\w+) (.+)((\n[' . $subsublevel . '-9].+)*)/m', $match[3], $submatches, PREG_SET_ORDER)) { 1040 foreach ($submatches as $submatch) { 1041 $this->addName($submatch[1], $submatch[2], $match[3]); 1042 } 1043 } 1044 } 1045 } 1046 } 1047 } 1048 1049 /** 1050 * Split the record into facts 1051 * 1052 * @return array<Fact> 1053 */ 1054 private function parseFacts(): array 1055 { 1056 // Split the record into facts 1057 if ($this->gedcom) { 1058 $gedcom_facts = preg_split('/\n(?=1)/', $this->gedcom); 1059 array_shift($gedcom_facts); 1060 } else { 1061 $gedcom_facts = []; 1062 } 1063 if ($this->pending) { 1064 $pending_facts = preg_split('/\n(?=1)/', $this->pending); 1065 array_shift($pending_facts); 1066 } else { 1067 $pending_facts = []; 1068 } 1069 1070 $facts = []; 1071 1072 foreach ($gedcom_facts as $gedcom_fact) { 1073 $fact = new Fact($gedcom_fact, $this, md5($gedcom_fact)); 1074 if ($this->pending !== null && !in_array($gedcom_fact, $pending_facts, true)) { 1075 $fact->setPendingDeletion(); 1076 } 1077 $facts[] = $fact; 1078 } 1079 foreach ($pending_facts as $pending_fact) { 1080 if (!in_array($pending_fact, $gedcom_facts, true)) { 1081 $fact = new Fact($pending_fact, $this, md5($pending_fact)); 1082 $fact->setPendingAddition(); 1083 $facts[] = $fact; 1084 } 1085 } 1086 1087 return $facts; 1088 } 1089 1090 /** 1091 * Work out whether this record can be shown to a user with a given access level 1092 * 1093 * @param int $access_level 1094 * 1095 * @return bool 1096 */ 1097 private function canShowRecord(int $access_level): bool 1098 { 1099 // This setting would better be called "$ENABLE_PRIVACY" 1100 if (!$this->tree->getPreference('HIDE_LIVE_PEOPLE')) { 1101 return true; 1102 } 1103 1104 // We should always be able to see our own record (unless an admin is applying download restrictions) 1105 if ($this->xref() === $this->tree->getUserPreference(Auth::user(), UserInterface::PREF_TREE_ACCOUNT_XREF) && $access_level === Auth::accessLevel($this->tree)) { 1106 return true; 1107 } 1108 1109 // Does this record have a RESN? 1110 if (str_contains($this->gedcom, "\n1 RESN confidential")) { 1111 return Auth::PRIV_NONE >= $access_level; 1112 } 1113 if (str_contains($this->gedcom, "\n1 RESN privacy")) { 1114 return Auth::PRIV_USER >= $access_level; 1115 } 1116 if (str_contains($this->gedcom, "\n1 RESN none")) { 1117 return true; 1118 } 1119 1120 // Does this record have a default RESN? 1121 $individual_privacy = $this->tree->getIndividualPrivacy(); 1122 if (isset($individual_privacy[$this->xref()])) { 1123 return $individual_privacy[$this->xref()] >= $access_level; 1124 } 1125 1126 // Privacy rules do not apply to admins 1127 if (Auth::PRIV_NONE >= $access_level) { 1128 return true; 1129 } 1130 1131 // Different types of record have different privacy rules 1132 return $this->canShowByType($access_level); 1133 } 1134 1135 /** 1136 * Lock the database row, to prevent concurrent edits. 1137 */ 1138 public function lock(): void 1139 { 1140 DB::table('other') 1141 ->where('o_file', '=', $this->tree->id()) 1142 ->where('o_id', '=', $this->xref()) 1143 ->lockForUpdate() 1144 ->get(); 1145 } 1146} 1147