Class luya\admin\helpers\Storage

                public static function extractFilesDataFromFilesArray(array $file)
{
    if (!isset($file['tmp_name'])) {
        return [];
    }
    $files = [];
    if (is_array($file['tmp_name'])) {
        foreach ($file['tmp_name'] as $index => $value) {
            // skip empty or none exsting tmp file names
            if (!isset($file['tmp_name'][$index]) || empty($file['tmp_name'][$index])) {
                continue;
            }
            // create files structure array
            $files[] = [
                'name' => $file['name'][$index],
                'type' => $file['type'][$index],
                'tmp_name' => $file['tmp_name'][$index],
                'error' => $file['error'][$index],
                'size' => $file['size'][$index],
            ];
        }
    } elseif (isset($file['tmp_name']) && !empty($file['tmp_name'])) {
        $files[] = [
            'name' => $file['name'],
            'type' => $file['type'],
            'tmp_name' => $file['tmp_name'],
            'error' => $file['error'],
            'size' => $file['size'],
        ];
    }
    return $files;
}

            

                public static function extractFilesDataFromMultipleFiles(array $files)
{
    $data = [];
    $i=0;
    foreach ($files as $type => $field) {
        foreach ($field as $fieldName => $values) {
            if (is_array($values)) {
                foreach ($values as $key => $value) {
                    $data[$key][$type] = $value;
                }
            } else {
                $data[$i][$type] = $values;
            }
        }
    }
    return $data;
}

            

                public static function getImageResolution($filePath, $throwException = false)
{
    $dimensions = @getimagesize(Yii::getAlias($filePath));
    $width = 0;
    $height = 0;
    if (isset($dimensions[0]) && isset($dimensions[1])) {
        $width = (int)$dimensions[0];
        $height = (int)$dimensions[1];
    } elseif ($throwException) {
        throw new Exception("Unable to determine the resolutions of the file $filePath.");
    }
    return [
        'width' => $width,
        'height' => $height,
    ];
}

            

                public static function getUploadErrorMessage($errorId)
{
    $messagesArray = self::getUploadErrorMessages();
    return $messagesArray[$errorId] ?? 'Unknown upload error.';
}

            

                public static function getUploadErrorMessages()
{
    return [
        UPLOAD_ERR_OK => Module::t('upload_err_message_0'),
        UPLOAD_ERR_INI_SIZE => Module::t('upload_err_message_1'),
        UPLOAD_ERR_FORM_SIZE =>  Module::t('upload_err_message_2'),
        UPLOAD_ERR_PARTIAL =>  Module::t('upload_err_message_3'),
        UPLOAD_ERR_NO_FILE =>  Module::t('upload_err_message_4'),
        UPLOAD_ERR_NO_TMP_DIR =>  Module::t('upload_err_message_6'),
        UPLOAD_ERR_CANT_WRITE =>  Module::t('upload_err_message_7'),
        UPLOAD_ERR_EXTENSION =>  Module::t('upload_err_message_8'),
    ];
}

            

                public static function moveFileToFolder($fileId, $folderId)
{
    $file = StorageFile::findOne($fileId);
    if ($file) {
        $file->updateAttributes(['folder_id' => $folderId]);
        Yii::$app->storage->flushArrays();
        return true;
    }
    return false;
}

            

                public static function moveFilesToFolder(array $fileIds, $folderId)
{
    foreach ($fileIds as $fileId) {
        static::moveFileToFolder($fileId, $folderId);
    }
}

            

                public static function refreshFile($fileId, $filePath)
{
    foreach (StorageImage::find()->where(['file_id' => $fileId])->all() as $img) {
        // remove the source
        if ($img->deleteSource()) {
            // recreate image filters
            $img->imageFilter($img->filter_id, false);
        }
    }
    $file = StorageFile::findOne($fileId);
    if (!$file) {
        throw new InvalidArgumentException("Unable to find the given file.");
    }
    $fileHash = FileHelper::md5sum($filePath);
    $fileSize = @filesize($filePath);
    $file->updateAttributes([
        'hash_file' => $fileHash,
        'file_size' => $fileSize,
        'upload_timestamp' => time(),
    ]);
    return true;
}

            

                public static function removeFile($fileId, $cleanup = false)
{
    $model = StorageFile::find()->where(['id' => $fileId, 'is_deleted' => false])->one();
    if ($model) {
        if ($cleanup) {
            foreach (Yii::$app->storage->findImages(['file_id' => $fileId]) as $imageItem) {
                StorageImage::findOne($imageItem->id)->delete();
            }
        }
        $response = $model->delete();
        Yii::$app->storage->flushArrays();
        return $response;
    }
    return true;
}

            

                public static function removeImage($imageId, $cleanup = false)
{
    Yii::$app->storage->flushArrays();
    $image = Yii::$app->storage->getImage($imageId);
    if ($cleanup && $image) {
        $fileId = $image->fileId;
        foreach (Yii::$app->storage->findImages(['file_id' => $fileId]) as $imageItem) {
            $storageImage = StorageImage::findOne($imageItem->id);
            if ($storageImage) {
                $storageImage->delete();
            }
        }
    }
    $file = StorageImage::findOne($imageId);
    if ($file) {
        return $file->delete();
    }
    return false;
}

            

                public static function replaceFile($fileName, $newFileSource, $newFileName)
{
    try {
        Yii::$app->storage->ensureFileUpload($newFileSource, $newFileName);
    } catch (\Exception $e) {
        return false;
    }
    return Yii::$app->storage->fileSystemReplaceFile($fileName, $newFileSource);
}

            

                public static function replaceFileFromContent($fileName, $newFileContent)
{
    $newFileSource = @tempnam(sys_get_temp_dir(), 'replaceFromFromContent');
    FileHelper::writeFile($newFileSource, $newFileContent);
    try {
        Yii::$app->storage->ensureFileUpload($newFileSource, $fileName);
    } catch (\Exception $e) {
        return false;
    }
    return Yii::$app->storage->fileSystemReplaceFile($fileName, $newFileSource);
}

            

                public static function uploadFromContent($content, $fileName, $folderId = 0, $isHidden = false)
{
    $fromTempFile = @tempnam(sys_get_temp_dir(), 'uploadFromContent');
    FileHelper::writeFile($fromTempFile, $content);
    return Yii::$app->storage->addFile($fromTempFile, $fileName, $folderId, $isHidden);
}

            

                public static function uploadFromFileArray(array $fileArray, $toFolder = 0, $isHidden = false)
{
    $files = self::extractFilesDataFromFilesArray($fileArray);
    if (count($files) !== 1) {
        return ['upload' => false, 'message' => 'no image found', 'file_id' => 0];
    }
    return self::verifyAndSaveFile($files[0], $toFolder, $isHidden);
}

            

                public static function uploadFromFiles(array $filesArray, $toFolder = 0, $isHidden = false)
{
    $files = [];
    foreach ($filesArray as $fileArrayKey => $file) {
        $files = array_merge($files, self::extractFilesDataFromFilesArray($file));
    }
    foreach ($files as $file) {
        return self::verifyAndSaveFile($file, $toFolder, $isHidden);
    }
    return ['upload' => false, 'message' => 'no files selected or empty files list.', 'file_id' => 0];
}

            

                protected static function verifyAndSaveFile(array $file, $toFolder = 0, $isHidden = false)
{
    try {
        if ($file['error'] !== UPLOAD_ERR_OK) {
            return ['upload' => false, 'message' => static::getUploadErrorMessage($file['error']), 'file_id' => 0];
        }
        $file = Yii::$app->storage->addFile($file['tmp_name'], $file['name'], $toFolder, $isHidden);
        if ($file) {
            return ['upload' => true, 'message' => 'file uploaded succesfully', 'file_id' => $file->id];
        }
    } catch (Exception $err) {
        return ['upload' => false, 'message' => $err->getMessage(), 'file_id' => 0];
    }
    return ['upload' => false, 'message' => 'no files selected or empty files list.', 'file_id' => 0];
}