SilverStripe\Assets\Folder

Complexity

Total Complexity

35

Size/Duplication

Total Lines	321
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	16

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	exists()	0	4	1
B	find_or_make()	0	35	4
A	onBeforeDelete()	0	8	2
A	getIcon()	0	4	1
A	setTitle()	0	7	1
A	getTitle()	0	4	1
A	getSize()	0	4	1
A	myChildren()	0	4	1
A	hasChildren()	0	4	1
A	hasChildFolders()	0	4	1
B	getCMSFields()	0	31	1
A	ChildFolders()	0	4	1
A	numChildFolders()	0	4	1
A	CMSTreeClasses()	0	16	3
A	getTreeTitle()	0	7	1
A	getFilename()	0	4	1
A	getURL()	0	4	1
A	getAbsoluteURL()	0	4	1
A	onAfterWrite()	0	12	2
A	onAfterDelete()	0	9	2
A	updateFilesystem()	0	4	1
A	onAfterSkippedWrite()	0	4	1
A	updateChildFilesystem()	0	13	3
A	StripThumbnail()	0	4	1
A	validate()	0	6	1

<?php

namespace SilverStripe\Assets;

use SilverStripe\Core\Convert;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\HeaderField;
use SilverStripe\Forms\HiddenField;
use SilverStripe\Forms\LiteralField;
use SilverStripe\Forms\TextField;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\ValidationResult;
use SilverStripe\ORM\Versioning\Versioned;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\TabSet;

/**
 * Represents a logical folder, which may be used to organise assets
 * stored in the configured backend.
 *
 * Unlike {@see File} dataobjects, there is not necessarily a physical filesystem entite which
 * represents a Folder, and it may be purely logical. However, a physical folder may exist
 * if the backend creates one.
 *
 * Additionally, folders do not have URLs (relative or absolute), nor do they have paths.
 *
 * When a folder is moved or renamed, records within it will automatically be copied to the updated
 * location.
 *
 * Deleting a folder will remove all child records, but not any physical files.
 *
 * See {@link File} documentation for more details about the
 * relationship between the database and filesystem in the SilverStripe file APIs.
 */
class Folder extends File
{

    private static $singular_name = "Folder";

    private static $plural_name = "Folders";

    private static $table_name = 'Folder';

    public function exists()
    {
        return $this->isInDB();
    }

    /**
     * Find the given folder or create it as a database record
     *
     * @param string $folderPath Directory path relative to assets root
     * @return Folder|null
     */
    public static function find_or_make($folderPath)
    {
        // replace leading and trailing slashes
        $folderPath = preg_replace('/^\/?(.*)\/?$/', '$1', trim($folderPath));
        $parts = explode("/", $folderPath);

        $parentID = 0;
        $item = null;
        $filter = FileNameFilter::create();
        foreach ($parts as $part) {
            if (!$part) {
                continue; // happens for paths with a trailing slash
            }

            // Ensure search includes folders with illegal characters removed, but
            // err in favour of matching existing folders if $folderPath
            // includes illegal characters itself.
            $partSafe = $filter->filter($part);
            $item = Folder::get()->filter(array(

As per coding style, self should be used for accessing local static members.

                'ParentID' => $parentID,
                'Name' => array($partSafe, $part)
            ))->first();

            if (!$item) {
                $item = new Folder();
                $item->ParentID = $parentID;
                $item->Name = $partSafe;
                $item->Title = $part;
                $item->write();
            }
            $parentID = $item->ID;
        }

        return $item;
    }

    public function onBeforeDelete()
    {
        foreach ($this->AllChildren() as $child) {
            $child->delete();
        }

        parent::onBeforeDelete();
    }

    /**
     * Return the relative URL of an icon for this file type
     *
     * @return string
     */
    public function getIcon()
    {
        return FRAMEWORK_DIR . "/client/dist/images/app_icons/folder_icon_large.png";
    }

    /**
     * Override setting the Title of Folders to that Name and Title are always in sync.
     * Note that this is not appropriate for files, because someone might want to create a human-readable name
     * of a file that is different from its name on disk. But folders should always match their name on disk.
     *
     * @param string $title
     * @return $this
     */
    public function setTitle($title)
    {
        $this->setField('Title', $title);
        $this->setField('Name', $title);

        return $this;
    }

    /**
     * Get the folder title
     *
     * @return string
     */
    public function getTitle()
    {
        return $this->Name;
    }

    /**
     * A folder doesn't have a (meaningful) file size.
     *
     * @return null
     */
    public function getSize()
    {
        return null;
    }

    /**
     * Returns all children of this folder
     *
     * @return DataList
     */
    public function myChildren()
    {
        return File::get()->filter("ParentID", $this->ID);
    }

    /**
     * Returns true if this folder has children
     *
     * @return bool
     */
    public function hasChildren()
    {
        return $this->myChildren()->exists();
    }

    /**
     * Returns true if this folder has children
     *
     * @return bool
     */
    public function hasChildFolders()
    {
        return $this->ChildFolders()->exists();
    }

    /**
     * Return the FieldList used to edit this folder in the CMS.
     * You can modify this FieldList by subclassing folder, or by creating a {@link DataExtension}
     * and implemeting updateCMSFields(FieldList $fields) on that extension.
     *
     * @return FieldList
     */
    public function getCMSFields()
    {
        // Don't show readonly path until we can implement parent folder selection,
        // it's too confusing when readonly (makes sense for files only).

        $width = (int)Image::config()->get('asset_preview_width');
        $previewLink = Convert::raw2att($this->ScaleMaxWidth($width)->getIcon());
        $image = "<img src=\"{$previewLink}\" class=\"editor__thumbnail\" />";

        $content = Tab::create(
            'Main',
            HeaderField::create('TitleHeader', $this->Title, 1)
                ->addExtraClass('editor__heading'),
            LiteralField::create("IconFull", $image)
                ->addExtraClass('editor__file-preview'),
            TabSet::create(
                'Editor',
                Tab::create(
                    'Details',
                    TextField::create("Name", $this->fieldLabel('Filename'))
                )
            ),
            HiddenField::create('ID', $this->ID)
        );

        $fields = FieldList::create(TabSet::create('Root', $content));

        $this->extend('updateCMSFields', $fields);

        return $fields;
    }

    /**
     * Get the children of this folder that are also folders.
     *
     * @return DataList
     */
    public function ChildFolders()
    {
        return Folder::get()->filter('ParentID', $this->ID);

As per coding style, self should be used for accessing local static members.

    }

    /**
     * Get the number of children of this folder that are also folders.
     *
     * @return int
     */
    public function numChildFolders()
    {
        return $this->ChildFolders()->count();
    }
    /**
     * @return string
     */
    public function CMSTreeClasses()
    {
        $classes = sprintf('class-%s', $this->class);

        if (!$this->canDelete()) {
            $classes .= " nodelete";
        }

        if (!$this->canEdit()) {
            $classes .= " disabled";
        }

        $classes .= $this->markingClasses('numChildFolders');

        return $classes;
    }

    /**
     * @return string
     */
    public function getTreeTitle()
    {
        return sprintf(
            "<span class=\"jstree-foldericon\"></span><span class=\"item\">%s</span>",
            Convert::raw2att(preg_replace('~\R~u', ' ', $this->Title))
        );
    }

    public function getFilename()
    {
        return parent::generateFilename() . '/';

It seems like you call parent on a different method (generateFilename() instead of getFilename()). Are you sure this is correct? If so, you might want to change this to $this->generateFilename().

    }

    /**
     * Folders do not have public URLs
     *
     * @param bool $grant
     * @return null|string
     */
    public function getURL($grant = true)
    {
        return null;
    }

    /**
     * Folders do not have public URLs
     *
     * @return string
     */
    public function getAbsoluteURL()
    {
        return null;
    }

    public function onAfterWrite()
    {
        parent::onAfterWrite();

        // No publishing UX for folders, so just cascade changes live
        if (Versioned::get_stage() === Versioned::DRAFT) {
            $this->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);
        }

        // Update draft version of all child records
        $this->updateChildFilesystem();
    }

    public function onAfterDelete()
    {
        parent::onAfterDelete();

        // Cascade deletions to live
        if (Versioned::get_stage() === Versioned::DRAFT) {
            $this->deleteFromStage(Versioned::LIVE);
        }
    }

    public function updateFilesystem()
    {
        // No filesystem changes to update
    }

    /**
     * If a write is skipped due to no changes, ensure that nested records still get asked to update
     */
    public function onAfterSkippedWrite()
    {
        $this->updateChildFilesystem();
    }

    /**
     * Update filesystem of all children
     */
    public function updateChildFilesystem()
    {
        // Don't synchronise on live (rely on publishing instead)
        if (Versioned::get_stage() === Versioned::LIVE) {
            return;
        }

        $this->flushCache();
        // Writing this record should trigger a write (and potential updateFilesystem) on each child
        foreach ($this->AllChildren() as $child) {
            $child->write();
        }
    }

    public function StripThumbnail()
    {
        return null;
    }

    public function validate()
    {
        $result = ValidationResult::create();
        $this->extend('validate', $result);
        return $result;
    }
}