francescozanoni / clqei

app/Services/ImportService.php

<?php
declare(strict_types = 1);

namespace App\Services;

use Illuminate\Filesystem\Filesystem;

class ImportService
{

    /**
     * Validate files to import
     *
     * @param string|array $filePaths paths to text files to import
     * @return array validation errors
     *
     * @todo adapt validation error output in case of multiple file paths
     */
    public function validate($filePaths) : array
    {

        if (is_array($filePaths) === false) {
            $filePaths = [$filePaths];
        }
        
        foreach ($filePaths as $filePath) {
        
            if (is_string($filePath) === false ||
                file_exists($filePath) === false ||

$filePath of type array is incompatible with the type string expected by parameter $filename of file_exists().

                is_readable($filePath) === false ||

$filePath of type array is incompatible with the type string expected by parameter $filename of is_readable().

                is_file($filePath) === false

$filePath of type array is incompatible with the type string expected by parameter $filename of is_file().

            ) {
                return ["Invalid file path"];
            }

            $fileSystem = new Filesystem;
            $fileMimeType = $fileSystem->mimeType($filePath);

$filePath of type array is incompatible with the type string expected by parameter $path of Illuminate\Filesystem\Filesystem::mimeType().

            if ($fileMimeType !== "text/plain") {
                return ["Invalid file type"];
            }

            if (file($filePath) === false ||

$filePath of type array is incompatible with the type string expected by parameter $filename of file().

                count(file($filePath)) === 0) {

It seems like file($filePath) can also be of type false; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

                return ["Empty file"];
            }
        
        }

        return [];

    }

    /**
     * Import files
     *
     * @param string|array $filePaths paths to text files to import
     * @param string $class class of models to import
     */
    public function import($filePaths, string $class)
    {

        if (in_array("App\Models\Interfaces\Importable", class_implements($class)) === false) {
            throw new \InvalidArgumentException("Invalid import model class");
        }

        if (is_array($filePaths) === false) {
            $filePaths = [$filePaths];
        }

        $records = file(implode(PHP_EOL, $filePaths));

It seems like $filePaths can also be of type string; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

        // @todo add character check
        // @todo add uniqueness check
        // @todo add return of number of records imported

        // Data is cleaned.
        $records = array_unique(array_map("trim", $records));

It seems like $records can also be of type false; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        foreach ($records as $record) {
            $model = new $class();
            $model->name = $record;
            $model->save();
        }

    }

}