DBFile

Complexity

Total Complexity

71

Size/Duplication

Total Lines	454
Duplicated Lines	16.08 %

Coupling/Cohesion

Components	1
Dependencies	9

36 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getIsImage()	0	5	2
A	getStore()	0	3	1
A	scaffoldFormField()	0	3	1
A	forTemplate()	0	3	2
A	getTag()	0	7	2
A	getFrontendTemplate()	0	15	3
A	getBasename()	0	5	2
A	getExtension()	0	5	2
A	getTitle()	0	8	3
A	setFromLocalFile()	11	11	3
A	setFromStream()	11	11	2
A	setFromString()	11	11	2
A	getStream()	8	8	2
A	getString()	8	8	2
A	getURL()	0	9	2
A	getSourceURL()	0	5	1
A	getAbsoluteURL()	0	6	2
A	getMetaData()	8	8	2
A	getMimeType()	8	8	2
A	getValue()	0	9	2
A	exists()	8	8	2
A	get_shortcodes()	0	3	1
A	handle_shortcode()	0	3	1
A	getFilename()	0	3	1
A	getHash()	0	3	1
A	getVariant()	0	3	1
A	getAbsoluteSize()	0	6	2
A	setOriginal()	0	4	1
A	getAllowedCategories()	0	3	1
A	setAllowedCategories()	0	7	2
A	getAllowedExtensions()	0	4	1
A	isValidFilename()	0	18	4
A	assertFilenameValid()	0	7	2
B	validate()	0	23	5
A	setField()	0	8	3

<?php

namespace SilverStripe\Model\FieldType;

use SilverStripe\Filesystem\ImageManipulation;
use SilverStripe\Filesystem\Storage\AssetContainer;
use SilverStripe\Filesystem\Storage\AssetStore;

use Injector;
use AssetField;
use File;
use Director;
use Permission;
use ShortcodeHandler;
use ValidationResult;
use ValidationException;

// Un-comment once https://github.com/silverstripe/silverstripe-framework/pull/4551/ is merged
// namespace SilverStripe\Filesystem\Storage;

/**
 * Represents a file reference stored in a database
 *
 * @property string $Hash SHA of the file
 * @property string $Filename Name of the file, including directory
 * @property string $Variant Variant of the file
 *
 * @package framework
 * @subpackage filesystem
 */
class DBFile extends DBComposite implements AssetContainer, ShortcodeHandler {

	use ImageManipulation;

	/**
	 * List of allowed file categories.
	 *
	 * {@see File::$app_categories}
	 *
	 * @var array
	 */
	protected $allowedCategories = array();

	/**
	 * List of image mime types supported by the image manipulations API
	 *
	 * {@see File::app_categories} for matching extensions.
	 *
	 * @config
	 * @var array
	 */
	private static $supported_images = array(
		'image/jpeg',
		'image/gif',
		'image/png'
	);

	/**
	 * Create a new image manipulation
	 *
	 * @param string $name
	 * @param array|string $allowed List of allowed file categories (not extensions), as per File::$app_categories
	 */
	public function __construct($name = null, $allowed = array()) {
		parent::__construct($name);
		$this->setAllowedCategories($allowed);
	}

	/**
	 * Determine if a valid non-empty image exists behind this asset, which is a format
	 * compatible with image manipulations
	 *
	 * @return boolean
	 */
	public function getIsImage() {
		// Check file type
		$mime = $this->getMimeType();
		return $mime && in_array($mime, $this->config()->supported_images);

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

	}

	/**
	 * @return AssetStore
	 */
	protected function getStore() {
		return Injector::inst()->get('AssetStore');
	}

	private static $composite_db = array(

Consider using a different property name as you override a private property of the parent class.

		"Hash" => "Varchar(255)", // SHA of the base content
		"Filename" => "Varchar(255)", // Path identifier of the base content
		"Variant" => "Varchar(255)", // Identifier of the variant to the base, if given
	);

	private static $casting = array(

Consider using a different property name as you override a private property of the parent class.

		'URL' => 'Varchar',
		'AbsoluteURL' => 'Varchar',
		'Basename' => 'Varchar',
		'Title' => 'Varchar',
		'MimeType' => 'Varchar',
		'String' => 'Text',
		'Tag' => 'HTMLText',
		'Size' => 'Varchar'
	);

	public function scaffoldFormField($title = null, $params = null) {
		return AssetField::create($this->getName(), $title);

Consider using $this->name. There is an issue with getName() and APC-enabled PHP versions.

	}

	/**
	 * Return a html5 tag of the appropriate for this file (normally img or a)
	 *
	 * @return string
	 */
	public function forTemplate() {
		return $this->getTag() ?: '';
	}

	/**
	 * Return a html5 tag of the appropriate for this file (normally img or a)
	 *
	 * @return string
	 */
	public function getTag() {
		$template = $this->getFrontendTemplate();
		if(empty($template)) {
			return '';
		}
		return (string)$this->renderWith($template);
	}

	/**
	 * Determine the template to render as on the frontend
	 *
	 * @return string Name of template
	 */
	public function getFrontendTemplate() {
		// Check that path is available
		$url = $this->getURL();
		if(empty($url)) {
			return null;
		}

		// Image template for supported images
		if($this->getIsImage()) {
			return 'DBFile_image';
		}

		// Default download
		return 'DBFile_download';
	}

	/**
	 * Get trailing part of filename
	 *
	 * @return string
	 */
	public function getBasename() {
		if($this->exists()) {
			return basename($this->getSourceURL());
		}
	}

	/**
	 * Get file extension
	 *
	 * @return string
	 */
	public function getExtension() {
		if($this->exists()) {
			return pathinfo($this->Filename, PATHINFO_EXTENSION);
		}
	}

	/**
	 * Alt title for this
	 *
	 * @return string
	 */
	public function getTitle() {
		// If customised, use the customised title
		if($this->failover && ($title = $this->failover->Title)) {

The property Title does not exist on object<ViewableData>. Since you implemented __set, maybe consider adding a @property annotation.

			return $title;
		}
		// fallback to using base name
		return $this->getBasename();
	}

	public function setFromLocalFile($path, $filename = null, $hash = null, $variant = null, $conflictResolution = null) {

This method seems to be duplicated in your project.

		$this->assertFilenameValid($filename ?: $path);
		$result = $this
			->getStore()
			->setFromLocalFile($path, $filename, $hash, $variant, $conflictResolution);
		// Update from result
		if($result) {

The expression $result 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->setValue($result);
		}
		return $result;
	}

	public function setFromStream($stream, $filename, $hash = null, $variant = null, $conflictResolution = null) {

This method seems to be duplicated in your project.

		$this->assertFilenameValid($filename);
		$result = $this
			->getStore()
			->setFromStream($stream, $filename, $hash, $variant, $conflictResolution);
		// Update from result
		if($result) {

The expression $result 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->setValue($result);
		}
		return $result;
	}

	public function setFromString($data, $filename, $hash = null, $variant = null, $conflictResolution = null) {

This method seems to be duplicated in your project.

		$this->assertFilenameValid($filename);
		$result = $this
			->getStore()
			->setFromString($data, $filename, $hash, $variant, $conflictResolution);
		// Update from result
		if($result) {

The expression $result 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->setValue($result);
		}
		return $result;
	}

	public function getStream() {

This method seems to be duplicated in your project.

		if(!$this->exists()) {
			return null;
		}
		return $this
			->getStore()
			->getAsStream($this->Filename, $this->Hash, $this->Variant);
	}

	public function getString() {

This method seems to be duplicated in your project.

		if(!$this->exists()) {
			return null;
		}
		return $this
			->getStore()
			->getAsString($this->Filename, $this->Hash, $this->Variant);
	}

	public function getURL() {
		if(!$this->exists()) {
			return null;
		}
		$url = $this->getSourceURL();
		$this->updateURL($url);
		$this->extend('updateURL', $url);
		return $url;
	}

	/**
	 * Get URL, but without resampling.
	 * Note that this will return the url even if the file does not exist.
	 *
	 * @return string
	 */
	public function getSourceURL() {
		return $this
			->getStore()
			->getAsURL($this->Filename, $this->Hash, $this->Variant);
	}

	/**
	 * Get the absolute URL to this resource
	 *
	 * @return type
	 */
	public function getAbsoluteURL() {
		if(!$this->exists()) {
			return null;
		}
		return Director::absoluteURL($this->getURL());

The expression \Director::absoluteURL($this->getURL()); of type string|false adds false to the return on line 273 which is incompatible with the return type declared by the interface SilverStripe\Filesystem\Storage\AssetContainer::getAbsoluteURL of type string. It seems like you forgot to handle an error condition.

	}

	public function getMetaData() {

This method seems to be duplicated in your project.

		if(!$this->exists()) {
			return null;
		}
		return $this
			->getStore()
			->getMetadata($this->Filename, $this->Hash, $this->Variant);
	}

	public function getMimeType() {

This method seems to be duplicated in your project.

		if(!$this->exists()) {
			return null;
		}
		return $this
			->getStore()
			->getMimeType($this->Filename, $this->Hash, $this->Variant);
	}
	
	public function getValue() {
		if($this->exists()) {
			return array(
				'Filename' => $this->Filename,
				'Hash' => $this->Hash,
				'Variant' => $this->Variant
			);
		}
	}

	public function exists() {

This method seems to be duplicated in your project.

		if(empty($this->Filename)) {
			return false;
		}
		return $this
			->getStore()
			->exists($this->Filename, $this->Hash, $this->Variant);
	}

	public static function get_shortcodes() {
		return 'dbfile_link';
	}

	public static function handle_shortcode($arguments, $content, $parser, $shortcode, $extra = array()) {
		// @todo
	}
	
	public function getFilename() {
		return $this->getField('Filename');
	}

	public function getHash() {
		return $this->getField('Hash');
	}

	public function getVariant() {
		return $this->getField('Variant');
	}

	/**
	 * Return file size in bytes.
	 *
	 * @return int
	 */
	public function getAbsoluteSize() {
		$metadata = $this->getMetaData();
		if(isset($metadata['size'])) {
			return $metadata['size'];
		}
	}

	/**
	 * Customise this object with an "original" record for getting other customised fields
	 *
	 * @param AssetContainer $original
	 * @return $this
	 */
	public function setOriginal($original) {
		$this->failover = $original;

It seems like $original of type object<SilverStripe\Filesystem\Storage\AssetContainer> is incompatible with the declared type object<ViewableData> of property $failover.

		return $this;
	}

	/**
	 * Get list of allowed file categories
	 *
	 * @return array
	 */
	public function getAllowedCategories() {
		return $this->allowedCategories;
	}

	/**
	 * Assign allowed categories
	 *
	 * @param array|string $categories
	 * @return $this
	 */
	public function setAllowedCategories($categories) {
		if(is_string($categories)) {
			$categories = preg_split('/\s*,\s*/', $categories);
		}
		$this->allowedCategories = (array)$categories;
		return $this;
	}

	/**
	 * Gets the list of extensions (if limited) for this field. Empty list
	 * means there is no restriction on allowed types.
	 *
	 * @return array
	 */
	protected function getAllowedExtensions() {
		$categories = $this->getAllowedCategories();
		return File::get_category_extensions($categories);
	}

	/**
	 * Validate that this DBFile accepts this filename as valid
	 *
	 * @param string $filename
	 * @throws ValidationException
	 * @return bool
	 */
	protected function isValidFilename($filename) {
		$extension = strtolower(File::get_file_extension($filename));

		// Validate true if within the list of allowed extensions
		$allowed = $this->getAllowedExtensions();
		if($allowed) {

The expression $allowed 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.

			return in_array($extension, $allowed);
		}
		
		// If no extensions are configured, fallback to global list
		$globalList = File::config()->allowed_extensions;

The property allowed_extensions does not exist on object<Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

		if(in_array($extension, $globalList)) {
			return true;
		}

		// Only admins can bypass global rules
		return !File::config()->apply_restrictions_to_admin && Permission::check('ADMIN');
	}

	/**
	 * Check filename, and raise a ValidationException if invalid
	 *
	 * @param string $filename
	 * @throws ValidationException
	 */
	protected function assertFilenameValid($filename) {
		$result = new ValidationResult();
		$this->validate($result, $filename);
		if(!$result->valid()) {
			throw new ValidationException($result);
		}
	}


	/**
	 * Hook to validate this record against a validation result
	 *
	 * @param ValidationResult $result
	 * @param string $filename Optional filename to validate. If omitted, the current value is validated.
	 * @return bool Valid flag
	 */
	public function validate(ValidationResult $result, $filename = null) {
		if(empty($filename)) {
			$filename = $this->getFilename();
		}
		if(empty($filename) || $this->isValidFilename($filename)) {
			return true;
		}

		// Check allowed extensions
		$extensions = $this->getAllowedExtensions();
		if(empty($extensions)) {
			$extensions = File::config()->allowed_extensions;

The property allowed_extensions does not exist on object<Config_ForClass>. Since you implemented __set, maybe consider adding a @property annotation.

		}
		sort($extensions);
		$message = _t(
			'File.INVALIDEXTENSION',
			'Extension is not allowed (valid: {extensions})',
			'Argument 1: Comma-separated list of valid extensions',
			array('extensions' => wordwrap(implode(', ',$extensions)))

array('extensions' => wordwrap(implode(', ', $extensions))) is of type array<string,string,{"extensions":"string"}>, but the function expects a string.

		);
		$result->error($message);
		return false;
	}

	public function setField($field, $value, $markChanged = true) {
		// Catch filename validation on direct assignment
		if($field === 'Filename' && $value) {
			$this->assertFilenameValid($value);
		}
		
		return parent::setField($field, $value, $markChanged);
	}


	/**
	 * Returns the size of the file type in an appropriate format.
	 *
	 * @return string|false String value, or false if doesn't exist
	 */
	public function getSize() {
		$size = $this->getAbsoluteSize();
		if($size) {
			return \File::format_size($size);
		}
		return false;
	}
}