alphaz\Files\Files

Complexity

Total Complexity

70

Size/Duplication

Total Lines	609
Duplicated Lines	0 %

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	recursiveCreateDir()	0	3	2
A	moveDir()	0	7	3
A	systemDirs()	0	8	1
A	moveFile()	0	4	2
A	__construct()	0	4	1
A	moveDirs()	0	4	2
A	copyDir()	0	7	3
A	copyDirs()	0	4	2
A	addExt()	0	3	1
A	deleteFile()	0	4	2
A	touch()	0	7	5
B	fileUpload()	0	64	7
A	permission()	0	7	3
A	moveFiles()	0	4	2
A	deleteDirs()	0	4	2
A	copyFiles()	0	4	2
A	copyFile()	0	5	2
A	deleteFiles()	0	4	2
A	chown()	0	6	4
A	mkDir()	0	11	5
A	deleteDir()	0	19	6
A	changeDefaultChmod()	0	3	2
A	addMineTypes()	0	3	1
B	filesUpload()	0	71	8

<?php

/**
 * This file is part of the alphaz Framework.
 *
 * @author Muhammad Umer Farooq (Malik) <mumerfarooqlablnet01@gmail.com>
 *
 * @link https://github.com/alphazframework/framework
 *
 * For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 * @since 1.0.0
 *
 * @license MIT
 */

namespace alphaz\Files;

class Files
{
    /**
     * Mine Types of files.
     *
     * @since 1.0.0
     *
     * @var array
     */
    private $mineTypes = [];

    /**
     * Types.
     *
     * @since 1.0.0
     *
     * @var array
     */
    private $types = [];

    /**
     * The default value for recursive create dirs.
     *
     * @since 1.0.0
     *
     * @var bool
     */
    private $recursiveDirectories = true;

    /**
     * Default chmod.
     *
     * @since 1.0.0
     *
     * @var int
     */
    private $defCHMOD = 0755;

    /**
     * __construct.
     *
     * @param array $mines
     * @param array $extensions
     *
     * @since 1.0.0
     */
    public function __construct($mines, $extensions)
    {
        $this->mineTypes = $mines;
        $this->types = $extensions;
    }

    /**
     * Create alphaz system dir.
     *
     * @since 1.0.0
     * @deprecated 3.0.0
     *
     * @return bool
     */
    public function systemDirs()
    {
        $this->mkDir('../Storage');
        $this->mkDir('../Storage/Data');
        $this->mkDir('../Storage/Logs');
        $this->mkDir('../Storage/Session');
        $this->mkDir('../Storage/Backup');
        $this->mkDIr('../Storage/Cache');
    }

    /**
     * Change the default chmod.
     *
     * @param mixed $chomd Valid chmod
     *
     * @since 1.0.0
     *
     * @return int
     */
    public function changeDefaultChmod($chmod)
    {
        return ($chmod === null) ? $this->defCHMOD : $this->defCHMOD = $chmod;
    }

    /**
     * Create recurisve dir.
     *
     * @param mixed $value recursive status true|false.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function recursiveCreateDir($value = null)
    {
        return ($value === null) ? $this->recursiveDirectories : $this->recursiveDirectories = $value;
    }

    /**
     * Add the mine type.
     *
     * @param (string) $type Correct mine type.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function addMineTypes($type)
    {
        array_push($this->mineTypes, $type);
    }

    /**
     * Add the extemsio.
     *
     * @param (string) $type Correct type.
     * @param (string) $sub  Extensions/
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function addExt($type, $ext)
    {
        array_push($this->types[$type], $ext);
    }

    /**
     * Make the dir.
     *
     * @param (string) $name      Name of dir with path.
     * @param (string) $recursive Recursive mode create: null|true|false.
     * @param (string) $chmod     Directory permission on create: default 0755.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function mkDir($name, $recursive = null, $chmod = null)
    {
        // test the recursive mode with default value
        $recursive = ($recursive === null) ? $this->recursiveDirectories : $recursive;

The assignment to $recursive is dead and can be removed.

        // test the chmod with default value
        $chmod = ($chmod === null) ? $this->defCHMOD : $chmod;

The assignment to $chmod is dead and can be removed.

        if (!is_dir($name)) {
            return (mkdir($name)) ? true : false;
        }

        return false;
    }

    /**
     * Change the permission.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (mixed)  $pre    Valid permission.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function permission($source, $pre)
    {
        if (!is_dir($source)) {
            return (file_exists($source)) ? chmod($source, $pre) : false;
        }

        return false;
    }

    /**
     * Change the owner of an array of files.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (array)  $files  Files to be copy.
     * @param (mixed)  $user   The new owner user name.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function chown($source, $files, $user)
    {
        foreach ($files as $file => $value) {
            if (file_exists($source.$value)) {
                if (@chown($file, $user) === false) {
                    throw new \RuntimeException("The ownership of {$file} can not change", 500);
                }
            }
        }
    }

    /**
     * Sets access and modification time of file.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (array)  $files  Files to be copy.
     * @param (int)    $time   The touch time as a Unix timestamp.
     * @param (int)    $atime  The access time as a Unix timestamp.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function touch($source, $files, $time = null, $atime = null)
    {
        foreach ($files as $file => $value) {
            if (file_exists($source.$value)) {
                $touch = $time ? @touch($file, $time, $atime) : @touch($file);
                if ($touch !== true) {
                    return false;
                }
            }
        }
    }

    /**
     * Copy file.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (string) $target Target directory.
     * @param (string) $files  Files to be copy.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function copyFile($source, $target, $file)
    {
        $this->mkDir($target);
        if (file_exists($source.$file)) {
            copy($source.$file, $target.$file);
        }
    }

    /**
     * Copy files.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (string) $target Target directory.
     * @param (array)  $files  Files to be copy.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function copyFiles($source, $target, $files)
    {
        foreach ($files as $file) {
            $this->copyFile($source, $target, $file);
        }
    }

    /**
     * Move file.
     *
     * @param (string) $source Name of file or directory with path.
     * @param (string) $target Target directory.
     * @param (string) $file   Files to be moved.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function moveFile($source, $target, $file)
    {
        if (file_exists($source.$file)) {
            rename($source.$file, $target.$file);
        }
    }

    /**
     * Move files.
     *
     * @param (string)       $source Name of file or directory with path.
     * @param (string)       $target Target directory.
     * @param (array|string) $files  Files to be moved.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function moveFiles($source, $target, $files)
    {
        foreach ($files as $file) {
            $this->moveFile($source, $target, $files);

$files of type array is incompatible with the type string expected by parameter $file of alphaz\Files\Files::moveFile().

        }
    }

    /**
     * Delete file.
     *
     * @param (string) $file Name of file with path.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function deleteFile($file)
    {
        if (file_exists($file)) {
            unlink($file);
        }
    }

    /**
     * Delete files.
     *
     * @param (array) $file Name of file with path.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function deleteFiles($files)
    {
        foreach ($files as $file) {
            $this->deleteFile($file);
        }
    }

    /**
     * Copy dir.
     *
     * @param (string) $source Directory with path.
     * @param (string) $target Target directory.
     * @param (string) $dir    Directory to be copied.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function copyDir($source, $target, $dir)
    {
        $this->mkDir($target);
        $serverOs = (new \alphaz\Common\OperatingSystem())->get();
        $command = ($serverOs === 'Windows') ? 'xcopy ' : 'cp -r ';
        if (is_dir($source.$dir)) {
            shell_exec($command.$source.$dir.' '.$target);
        }
    }

    /**
     * Copy dirs.
     *
     * @param (string) $source Directory with path.
     * @param (string) $target Target directory.
     * @param (array)  $dirs   Directories to be copied.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function copyDirs($source, $target, $dirs)
    {
        foreach ($dirs as $dir) {
            $this->copyDir($source, $target, $dir);
        }
    }

    /**
     * Move dir.
     *
     * @param (string) $source Directory with path.
     * @param (string) $target Target directory.
     * @param (string) $dir    Directory to be copied.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function moveDir($source, $target, $dir)
    {
        $this->mkDir($target);
        $serverOs = (new \alphaz\Common\OperatingSystem())->get();
        $command = ($serverOs === 'Windows') ? 'move ' : 'mv ';
        if (is_dir($source.$dir)) {
            shell_exec($command.$source.$dir.' '.$target);
        }
    }

    /**
     * Move dirs.
     *
     * @param (string) $source Directory with path.
     * @param (string) $target Target directory.
     * @param (array)  $dirs   Dirs to be copy.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function moveDirs($source, $target, $dirs)
    {
        foreach ($dirs as $dir) {
            $this->moveDir($source, $target, $dir);
        }
    }

    /**
     * Delete dir.
     *
     * @param (string) $dir Directory with path.
     *
     * @since 1.0.0
     *
     * @return bool
     */
    public function deleteDir($dir)
    {
        if (!file_exists($dir)) {
            return true;
        }

        if (!is_dir($dir)) {
            return unlink($dir);
        }
        foreach (scandir($dir) as $item) {
            if ($item == '.' || $item == '..') {
                continue;
            }
            $this->deleteDir($dir.DIRECTORY_SEPARATOR.$item);

            return true;
        }

        return rmdir($dir);
    }

    /**
     * Delete dirs.
     *
     * @param (array) $dirs Directory with path.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function deleteDirs($dirs)
    {
        foreach ($dirs as $dir) {
            $this->deleteDir($dir);
        }
    }

    /**
     * Upload file.
     *
     * @param (string) $file     File to be uploaded.
     * @param (string) $target   Target where file should be uploaded.
     * @param (string) $fileType Supported => image,media,docs,zip.
     * @param (int)    $maxSize  File size to be allowed.
     *
     * @since 1.0.0
     *
     * @return mixed
     */
    public function fileUpload($file, $target, $fileType, $maxSize = 7992000000)
    {
        $exactName = basename($file['name']);
        $fileTmp = $file['tmp_name'];
        $fileSize = $file['size'];
        $error = $file['error'];
        $type = $file['type'];
        $ext = pathinfo($file['name'], PATHINFO_EXTENSION);
        $newName = \alphaz\Site\Site::salts(30);
        $fileNewName = $newName.'.'.$ext;

Are you sure $ext of type array|string can be used in concatenation?

        $allowerd_ext = $this->types[$fileType];
        if (in_array($type, $this->mineTypes) === false) {
            return [
                'status'  => 'error',
                'code'    => 'mineType',
                'message' => sprintf(printl('z:files:error:mine:type'), $type),
            ];
        }
        if (in_array($ext, $allowerd_ext) === true) {
            if ($error === 0) {
                if ($fileSize <= $maxSize) {
                    $this->mkdir($target);
                    $fileRoot = $target.$fileNewName;
                    if (is_uploaded_file($fileTmp)) {
                        if (move_uploaded_file($fileTmp, $fileRoot)) {
                            return [
                                'status'  => 'success',
                                'code'    => $fileNewName,
                                'message' => printl('z:files:success'),
                                'name'    => $exactName,
                            ];
                        } else {
                            return [
                                'status'  => 'error',
                                'code'    => 'somethingwrong',
                                'message' => printl('z:files:error:somethingwrong'),
                            ];
                        }
                    } else {
                        return [
                            'status'  => 'error',
                            'code'    => 'invilidfile',
                            'message' => printl('z:files:error:invilid:file'),
                        ];
                    }
                } else {
                    return [
                        'status'  => 'error',
                        'code'    => 'exceedlimit',
                        'message' => sprintf(printl('z:files:error:exceed:limit'), $maxSize),
                    ];
                }
            } else {
                return [
                    'status'  => 'error',
                    'code'    => $error,
                    'message' => $error,
                ];
            }
        } else {
            return [
                'status'  => 'error',
                'code'    => 'extension',
                'message' => sprintf(printl('z:files:error:extension'), $ext),

It seems like $ext can also be of type array; however, parameter $values of sprintf() does only seem to accept double|integer|string, maybe add an additional type check?

            ];
        }
    }

    /**
     * Upload files.
     *
     * @param (array)  $files    Files to be uploaded.
     * @param (string) $target   Target where file should be upload.
     * @param (string) $fileType Supported => image,media,docs,zip.
     * @param (int)    $count    Number of file count.
     * @param (int)    $maxSize  File size to be allowed.
     *
     * @since 1.0.0
     *
     * @return void
     */
    public function filesUpload($files, $target, $fileType, $count, $maxSize = 7992000000)
    {
        $status = [];
        for ($i = 0; $i <= $count; $i++) {
            $exactName = basename($files['name'][$i]);
            $fileTmp = $files['tmp_name'][$i];
            $fileSize = $files['size'][$i];
            $error = $files['error'][$i];
            $type = $files['type'][$i];
            $ext = pathinfo($files['name'][$i], PATHINFO_EXTENSION);
            $newName = \alphaz\Site\Site::salts(30);
            $fileNewName = $newName.'.'.$ext;

Are you sure $ext of type array|string can be used in concatenation?

            $allowerd_ext = $this->types[$fileType];
            if (in_array($type, $this->mineTypes) === false) {
                $status[$i] = [
                    'status'  => 'error',
                    'code'    => 'mineType',
                    'message' => sprintf(printl('z:files:error:mine:type'), $type),
                ];
            }
            if (in_array($ext, $allowerd_ext) === true) {
                if ($error === 0) {
                    if ($fileSize <= $maxSize) {
                        $this->mkdir($target);
                        $fileRoot = $target.$fileNewName;
                        if (is_uploaded_file($fileTmp)) {
                            if (move_uploaded_file($fileTmp, $fileRoot)) {
                                $status[$i] = [
                                    'status'  => 'success',
                                    'code'    => $fileNewName,
                                    'message' => printl('z:files:success'),
                                    'name'    => $exactName,
                                ];
                            } else {
                                $status[$i] = [
                                    'status'  => 'error',
                                    'code'    => 'somethingwrong',
                                    'message' => printl('z:files:error:somethingwrong'),
                                ];
                            }
                        } else {
                            return [

The expression return array('status' => 'error', 'code' => 'invilidfile', 'message' => printl('z:files:error:invilid:file')) returns the type array<string,string> which is incompatible with the documented return type void.

                                'status'  => 'error',
                                'code'    => 'invilidfile',
                                'message' => printl('z:files:error:invilid:file'),
                            ];
                        }
                    } else {
                        $status[$i] = [
                            'status'  => 'error',
                            'code'    => 'exceedlimit',
                            'message' => sprintf(printl('z:files:error:exceed:limit'), $maxSize),
                        ];
                    }
                } else {
                    $status[$i] = [
                        'status'  => 'error',
                        'code'    => $error,
                        'message' => $error,
                    ];
                }
            } else {
                $status[$i] = [
                    'status'  => 'error',
                    'code'    => 'extension',
                    'message' => sprintf(printl('z:files:error:extension'), $ext),

It seems like $ext can also be of type array; however, parameter $values of sprintf() does only seem to accept double|integer|string, maybe add an additional type check?

                ];
            }
        }

        return $status;

The expression return $status returns the type array which is incompatible with the documented return type void.

    }
}