154 lines
4.6 KiB
PHP
154 lines
4.6 KiB
PHP
<?php
|
|
|
|
namespace App\Services\Import\Handlers;
|
|
|
|
use App\Models\Import;
|
|
use App\Models\Person\PersonPhone;
|
|
use App\Services\Import\BaseEntityHandler;
|
|
|
|
class PhoneHandler extends BaseEntityHandler
|
|
{
|
|
public function getEntityClass(): string
|
|
{
|
|
return PersonPhone::class;
|
|
}
|
|
|
|
/**
|
|
* Override validate to skip validation if phone is empty.
|
|
* Handles both single values and arrays.
|
|
*/
|
|
public function validate(array $mapped): array
|
|
{
|
|
$phone = $mapped['nu'] ?? null;
|
|
|
|
// If array, check if all values are empty/invalid
|
|
if (is_array($phone)) {
|
|
$hasValue = false;
|
|
foreach ($phone as $ph) {
|
|
if (!empty($ph) && trim((string)$ph) !== '' && $ph !== '0') {
|
|
$hasValue = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!$hasValue) {
|
|
return ['valid' => true, 'errors' => []];
|
|
}
|
|
// Skip parent validation for arrays - we'll validate in process()
|
|
return ['valid' => true, 'errors' => []];
|
|
}
|
|
|
|
// Single value - check if empty or invalid
|
|
if (empty($phone) || trim((string)$phone) === '' || $phone === '0') {
|
|
return ['valid' => true, 'errors' => []];
|
|
}
|
|
|
|
return parent::validate($mapped);
|
|
}
|
|
|
|
public function resolve(array $mapped, array $context = []): mixed
|
|
{
|
|
$nu = $mapped['nu'] ?? null;
|
|
$personId = $mapped['person_id']
|
|
?? ($context['person']['entity']->id ?? null)
|
|
?? ($context['person']?->entity?->id ?? null);
|
|
|
|
if (! $nu || ! $personId) {
|
|
return null;
|
|
}
|
|
|
|
// Normalize phone number for comparison
|
|
$normalizedNu = $this->normalizePhoneNumber($nu);
|
|
|
|
// Find existing phone by normalized number for this person
|
|
return PersonPhone::where('person_id', $personId)
|
|
->where('nu', $normalizedNu)
|
|
->first();
|
|
}
|
|
|
|
public function process(Import $import, array $mapped, array $raw, array $context = []): array
|
|
{
|
|
// Handle multiple phones if nu is an array
|
|
$phones = $mapped['nu'] ?? null;
|
|
|
|
// If single value, convert to array for uniform processing
|
|
if (!is_array($phones)) {
|
|
$phones = [$phones];
|
|
}
|
|
|
|
$results = [];
|
|
$insertedCount = 0;
|
|
$skippedCount = 0;
|
|
|
|
foreach ($phones as $phone) {
|
|
// Skip if phone number is empty or blank or '0'
|
|
if (empty($phone) || trim((string)$phone) === '' || $phone === '0') {
|
|
$skippedCount++;
|
|
continue;
|
|
}
|
|
|
|
// Resolve person_id from context
|
|
$personId = $mapped['person_id'] ?? $context['person']['entity']?->id ?? null;
|
|
|
|
if (! $personId) {
|
|
$skippedCount++;
|
|
continue;
|
|
}
|
|
|
|
// Normalize phone number
|
|
$normalizedPhone = $this->normalizePhoneNumber($phone);
|
|
|
|
$existing = $this->resolvePhone($normalizedPhone, $personId);
|
|
|
|
// Check for duplicates if configured
|
|
if ($this->getOption('deduplicate', true) && $existing) {
|
|
$skippedCount++;
|
|
continue;
|
|
}
|
|
|
|
// Create new phone
|
|
$payload = [
|
|
'nu' => $normalizedPhone,
|
|
'person_id' => $personId,
|
|
'type_id' => 1, // Default to mobile
|
|
];
|
|
|
|
$phoneEntity = new PersonPhone;
|
|
$phoneEntity->fill($payload);
|
|
$phoneEntity->save();
|
|
|
|
$results[] = $phoneEntity;
|
|
$insertedCount++;
|
|
}
|
|
|
|
if ($insertedCount === 0 && $skippedCount > 0) {
|
|
return [
|
|
'action' => 'skipped',
|
|
'message' => 'All phones empty, invalid or duplicates',
|
|
];
|
|
}
|
|
|
|
return [
|
|
'action' => 'inserted',
|
|
'entity' => $results[0] ?? null,
|
|
'entities' => $results,
|
|
'applied_fields' => ['nu', 'person_id'],
|
|
'count' => $insertedCount,
|
|
];
|
|
}
|
|
|
|
protected function resolvePhone(string $normalizedPhone, int $personId): mixed
|
|
{
|
|
return PersonPhone::where('person_id', $personId)
|
|
->where('nu', $normalizedPhone)
|
|
->first();
|
|
}
|
|
|
|
/**
|
|
* Normalize phone number by removing spaces, dashes, and parentheses.
|
|
*/
|
|
protected function normalizePhoneNumber(string $phone): string
|
|
{
|
|
return preg_replace('/[\s\-\(\)]/', '', $phone);
|
|
}
|
|
}
|