Icybee\Modules\Files\Operation\SaveOperation

Complexity

Total Complexity

26

Size/Duplication

Total Lines	212
Duplicated Lines	7.55 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	get_file()	0	4	1
A	lazy_get_properties()	0	19	2
A	action()	0	6	1
C	control()	0	38	7
C	validate()	16	45	8
A	process()	0	19	4
A	resolve_request_file_from_pathname()	0	19	3

<?php

/*
 * This file is part of the Icybee package.
 *
 * (c) Olivier Laviale <olivier.laviale@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Icybee\Modules\Files\Operation;

use ICanBoogie\ErrorCollection;
use ICanBoogie\HTTP\Request;
use ICanBoogie\HTTP\File as HTTPFile;

use Icybee\Modules\Files\File;
use Icybee\Modules\Files\Module;

/**
 * Save a file.
 *
 * @property-read HTTPFile|null $file The file associated with the request.
 * @property Module $module
 * @property File $record
 */
class SaveOperation extends \Icybee\Modules\Nodes\Operation\SaveOperation
{
	/**
	 * Name of the _user-file_ slot.
	 *
	 * @var string
	 */
	const USERFILE = File::HTTP_FILE;

	/**
	 * @var HTTPFile|bool The optional file to save with the record.
	 */
	protected $file;

	protected function get_file()
	{
		return $this->file;
	}

	/**
	 * @var array Accepted file types.
	 */
	protected $accept;

	/**
	 * Unset {@link File::MIME}, {@link File::SIZE}, and {@link File::EXTENSION} properties because
	 * they can only be set from a HTTP file. {@link File::DESCRIPTION} is set to and empty
	 * string if it is not defined.
	 *
	 * {@inheritdoc}
	 */
	protected function lazy_get_properties()
	{
		$properties = parent::lazy_get_properties() + [

			'description' => ''

		];

		unset($properties[File::MIME]);
		unset($properties[File::SIZE]);
		unset($properties[File::EXTENSION]);

		if ($this->file)
		{
			$properties[File::HTTP_FILE] = $this->file;
		}

		return $properties;
	}

	/**
	 * {@inheritdoc}
	 *
	 * The temporary files stored in the repository are cleaned before the operation is processed.
	 */
	public function action(Request $request)
	{
		$this->module->clean_temporary_files();

		return parent::action($request);
	}

	/**
	 * If PATH is not defined, we check for a file upload, which is required if the operation key
	 * is empty. If a file upload is found, the Uploaded object is set as the operation `file`
	 * property, and the PATH parameter of the operation is set to the file location.
	 *
	 * Note that if the upload is not required - because the operation key is defined for updating
	 * an entry - the PATH parameter of the operation is set to TRUE to avoid error reporting from
	 * the form validation.
	 *
	 * TODO: maybe this is not ideal, since the file upload should be made optional when the form
	 * is generated to edit existing entries.
	 *
	 * @inheritdoc
	 */
	protected function control(array $controls)
	{
		$request = $this->request;
		$path = $request[File::HTTP_FILE];
		$file = $request->files[self::USERFILE];

		if ($file && $file->is_valid)
		{
			$filename = \ICanBoogie\generate_v4_uuid();
			$pathname = \ICanBoogie\REPOSITORY . 'tmp' . DIRECTORY_SEPARATOR . $filename;

			$file->move($pathname);
		}
		else if ($path && strpos($path, \ICanBoogie\strip_root(\ICanBoogie\REPOSITORY . "files")) !== 0)
		{
			$file = $this->resolve_request_file_from_pathname($path);

			if (!$file)
			{
				$this->response->errors->add(File::HTTP_FILE, "Invalid or deleted file: %pathname", [ 'pathname' => $path ]);
			}
		}

		unset($request[File::HTTP_FILE]);

		$this->file = $file;

		if ($file)
		{
			#
			# This is used during form validation.
			#

			$request[File::HTTP_FILE] = $file->pathname;
		}

		return parent::control($controls);
	}

	/**
	 * The method validates unless there was an error during the file upload.
	 *
	 * @inheritdoc
	 */
	protected function validate(ErrorCollection $errors)
	{
		$file = $this->file;

		if ($file)
		{
			$error_message = $file->error_message;

			$max_file_size = $this->app->registry["{$this->module->flat_id}.max_file_size"] * 1024;

			if ($max_file_size && $max_file_size < $file->size)

This code seems to be duplicated across your project.

			{
				$error_message = $errors->add(
					File::HTTP_FILE,
					"Maximum file size is :size Mb",
					[ ':size' => round($max_file_size / 1024) ]
				);
			}

			if ($this->accept && !$file->match($this->accept))

The expression $this->accept of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

This code seems to be duplicated across your project.

			{
				$error_message = $errors->add(
					File::HTTP_FILE,
					"Only the following file types are accepted: %accepted.",
					[ '%accepted' => implode(', ', $this->accept)
				]);
			}

			if ($error_message)
			{
				$errors->add(File::HTTP_FILE, "Unable to upload file %file: :message.", [

					'%file' => $file->name,
					':message' => $error_message

				]);
			}
		}
		else if (!$this->key)
		{
			$errors->add(File::HTTP_FILE, "File is required.");
		}

		return parent::validate($errors);
	}

	/**
	 * Trigger a {@link File\MoveEvent} when the path of the updated record is updated.
	 *
	 * @inheritdoc
	 */
	protected function process()
	{
		$record = $this->record;
		$oldpath = $record ? $record->pathname->relative : null;

		$rc = parent::process();

		if ($oldpath)

The expression $oldpath of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

		{
			$newpath = $this->record->pathname->relative;

			if ($oldpath != $newpath)
			{
				new File\MoveEvent($record, $oldpath, $newpath);
			}
		}

		return $rc;
	}

	protected function resolve_request_file_from_pathname($pathname)
	{
		$filename = basename($pathname);
		$info_pathname = \ICanBoogie\REPOSITORY . 'tmp' . DIRECTORY_SEPARATOR . $filename . '.info';

		if (!file_exists($info_pathname))
		{
			return null;
		}

		$properties = json_decode(file_get_contents($info_pathname), true);

		if (!$properties)
		{
			return null;
		}

		return HTTPFile::from($properties);
	}
}