ldc-portsalaries/app/Imports/EmployeeImport.php

<?php

namespace App\Imports;

use App\Jobs\SendEmployeeCreatedAccountMail;
use App\Models\Employee;
use App\Models\EmployeeMailToken;
use App\Models\Site;
use Exception;
use Illuminate\Support\Carbon;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Maatwebsite\Excel\Concerns\ToCollection;
use Maatwebsite\Excel\Concerns\Importable;
use Maatwebsite\Excel\Concerns\SkipsEmptyRows;
use Maatwebsite\Excel\Concerns\WithCustomCsvSettings;

class EmployeeImport implements
    ToCollection,
    WithCustomCsvSettings,
    SkipsEmptyRows
{
    use Importable;

    /** @var \App\Models\Site */
    private $site;

    /** @var array */
    private $headers;

    public $updatedCount = 0;

    public $importedCount = 0;

    public $errorMessages = [];

    public $importedFailed = [];

    public function __construct(Site $site)
    {
        $this->site = $site;
    }

    public function collection(Collection $rows)
    {
        /** @var \App\Models\User */
        $user = auth()->user();
        /** @var \App\Models\Site */
        $site = Site::where('id', $user->selected_site_id)->firstOrFail();
        $cMAT = 0;
        $cNOM = 1;
        $cPRENOM = 2;
        $cMAIL = 3;

        foreach ($rows as $k => $row) {
            $employee = Employee::where('matricule', $row[$cMAT])->firstOrNew();

            if (!$this->validateRow($k, $row, $employee)) {
                $this->importedFailed[$k] = $row;
                continue;
            }
            $createdAccount = false;

            // If employee exists but is in a different Site
            if (!is_null($employee->site) and $employee->site_id !== $site->id) {
                $this->setErrorMessages($k, [sprintf(
                    'Le salariée %s %s %s existe déjà dans le site %s',
                    $row[$cMAT],
                    $row[$cNOM],
                    $row[$cPRENOM],
                    $site->name
                )]);
                $this->importedFailed[$k] = $row;
            }

            // set fields
            $employee->fill([
                'matricule' => $row[$cMAT],
                'firstname' => $row[$cPRENOM],
                'lastname' => $row[$cNOM],
                'site_id' => $site->id,
            ]);

            if (!$employee->exists) {
                $createdAccount = true;
            }

            $employee->email = $row[$cMAIL];
            // Anti date mdp
            $employee->password_date = Carbon::now()->subDay();
            $employee->password_attempts = 0;

            try {
                $employee->saveOrFail();
            } catch (Exception $e) {
                $this->setErrorMessages($k, [sprintf(
                    'Erreur %s',
                    $e->getMessage()
                )]);
                $this->importedFailed[$k] = $row;
                continue;
            }

            if ($createdAccount) {
                $this->importedCount += 1;
                if ($employee->hashcode) {
                    $employee->hashcode->delete();
                }
                $employee->hashcode = new EmployeeMailToken([
                    'email' => $employee->email,
                    'employee_id' => $employee->id
                ]);
                $employee->hashcode->saveOrFail();
                dispatch(new SendEmployeeCreatedAccountMail($employee))
                    ->onConnection('database');
            } else {
                $this->updatedCount += 1;
            }
        }
    }

    public function getCsvSettings(): array
    {
        return [
            'input_encoding' => 'UTF-8',
            'delimiter' => ';'
        ];
    }

    /**
     * Validate row
     *
     * @param \Illuminate\Support\Collection $key
     * @param array $row
     * @return boolean
     */
    private function validateRow(int $key, Collection $row, Employee $employee = null): bool
    {
        try {
            $unique = 'unique:employees,email';
            if ($employee->id) {
                $unique .= ",$employee->id";
            }
            Validator::make($row->all(), [
                '0' => 'required|digits_between:7,8',
                '1' => 'required|string',
                '2' => 'required|string',
                '3' => "required|$unique|email:rfc"
            ], [], ['matricule', 'prénom', 'nom', 'email'])->validate();
        } catch (ValidationException $e) {
            $this->setErrorMessages($key, $e->errors());
            return false;
        }
        return true;
    }

    /**
     * Set import error messages
     *
     * @param integer $row
     * @param array $messages
     * @return void
     */
    public function setErrorMessages(int $row, array $messages): void
    {
        if (!isset($this->errorMessages[$row])) {
            $this->errorMessages[$row] = [];
        }
        $m1 = $this->errorMessages[$row];
        $m2 = collect($messages)->flatten()->all();
        array_merge_recursive_distinct($m1, $m2);
        $this->errorMessages[$row] = array_merge_recursive_distinct($m1, $m2);
    }
}