AssetAdmin::breadcrumbs() - Code Metrics - Inspection of "WIP AssetGalleryField -> AssetAdmin API refactor" - silverstripe/silverstripe-asset-admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#202)

by Ingo
created 2016-06-29 22:35 UTC
AssetAdmin::breadcrumbs() A

↳ Parent: AssetAdmin
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
c	2
b	1
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1
<?php

namespace SilverStripe\AssetAdmin\Controller;

use SilverStripe\Filesystem\Storage\AssetNameGenerator;
use LeftAndMain;
use PermissionProvider;
use DateField;
use DropdownField;
use Controller;
use FieldList;
use Form;
use CheckboxField;
use File;
use Requirements;
use CMSBatchActionHandler;
use DataObject;
use Injector;
use Folder;
use CMSForm;
use SS_List;
use SSViewer;
use HeaderField;
use FieldGroup;
use SecurityToken;
use SS_HTTPRequest;
use SS_HTTPResponse;
use Upload;
use Config;

/**
 * AssetAdmin is the 'file store' section of the CMS.
 * It provides an interface for manipulating the File and Folder objects in the system.
 *
 * @package cms
 * @subpackage assets
 */
class AssetAdmin extends LeftAndMain implements PermissionProvider
{
    private static $url_segment = 'assets';


    private static $url_rule = '/$Action/$ID';


    private static $menu_title = 'Files';


    private static $tree_class = 'Folder';


    private static $url_handlers = [

        // Legacy redirect for SS3-style detail view
        'EditForm/field/File/item/$FileID/$Action' => 'legacyRedirectForEditView',
        // Pass all URLs to the index, for React to unpack
        'show/$FolderID/edit/$FileID' => 'index',
        // API access points with structured data
        'POST api/createFolder' => 'apiCreateFolder',
        'POST api/createFile' => 'apiCreateFile',
        'GET api/readFolder' => 'apiReadFolder',
        'PUT api/updateFolder' => 'apiUpdateFolder',
        'PUT api/updateFile' => 'apiUpdateFile',
        'DELETE api/delete' => 'apiDelete',
        'GET api/search' => 'apiSearch',
    ];

    /**
     * Amount of results showing on a single page.
     *
     * @config
     * @var int
     */
    private static $page_length = 15;


    /**
     * @config
     * @see Upload->allowedMaxFileSize
     * @var int
     */
    private static $allowed_max_file_size;


    /**
     * @var array
     */
    private static $allowed_actions = array(

        'legacyRedirectForEditView',
        'apiCreateFolder',
        'apiCreateFile',
        'apiReadFolder',
        'apiUpdateFolder',
        'apiUpdateFile',
        'apiDelete',
        'apiSearch',
    );

    /**
     * Set up the controller
     */
    public function init()
    {
        parent::init();

        Requirements::javascript(FRAMEWORK_DIR . "/admin/client/dist/js/bundle-lib.js");
        Requirements::add_i18n_javascript(ASSET_ADMIN_DIR . '/client/lang', false, true);
        Requirements::javascript(ASSET_ADMIN_DIR . "/client/dist/js/bundle.js");
        Requirements::css(ASSET_ADMIN_DIR . "/client/dist/styles/bundle.css");

        CMSBatchActionHandler::register('delete', 'SilverStripe\AssetAdmin\BatchAction\DeleteAssets', 'Folder');
    }

	public function getClientConfig() {
        $baseLink = $this->Link();
		return array_merge( parent::getClientConfig(), [
            'assetsRoute' => $this->Link() . ':folderAction?/:folderId?/:fileAction?/:fileId?',
            'assetsRouteHome' => $this->Link() . 'show/0',
            'createFileEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/createFile'),
                'method' => 'post',
                'payloadFormat' => 'urlencoded',
            ],
            'createFolderEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/createFolder'),
                'method' => 'post',
                'payloadFormat' => 'urlencoded',
            ],
            'readFolderEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/readFolder'),
                'method' => 'get',
                'responseFormat' => 'json',
            ],
            'searchEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/search'),
                'method' => 'get',
                'responseFormat' => 'json',
            ],
            'updateFileEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/updateFile'),
                'method' => 'put',
                'payloadFormat' => 'urlencoded',
            ],
            'updateFolderEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/updateFolder'),
                'method' => 'put',
                'payloadFormat' => 'urlencoded',
            ],
            'deleteEndpoint' => [
                'url' => Controller::join_links($baseLink, 'api/delete'),
                'method' => 'delete',
                'payloadFormat' => 'urlencoded',
            ],
            'limit' => $this->config()->page_length,
        ]);
	}

    /**
     * Fetches a collection of files by ParentID.
     *
     * @param SS_HTTPRequest $request
     * @return SS_HTTPResponse
     */
    public function apiReadFolder(SS_HTTPRequest $request)
    {
        $params = $request->requestVars();
        $items = array();
        $parentId = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $folderID = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if (!isset($params['id']) && !strlen($params['id'])) {
            $this->httpError(400);
        }

        $folderID = (int)$params['id'];
        if ($folderID === 0) {
            $folder = new Folder();
        } else {
            $folder = Folder::get()->byID($folderID);
        }

        // TODO Limit results to avoid running out of memory (implement client-side pagination)
        $files = $this->getList()->filter('ParentID', $folderID);

        if ($files) {
            foreach ($files as $file) {
                if (!$file->canView()) {
                    continue;
                }

                $items[] = $this->getObjectFromData($file);
            }
        }

        $response = new SS_HTTPResponse();
        $response->addHeader('Content-Type', 'application/json');
        $response->setBody(json_encode([
            'files' => $items,
            'count' => count($items),
            'parent' => $folder->ParentID, // grandparent
            'folderID' => $folderID,
            'canEdit' => $folder ? $folder->canEdit() : false,
            'canDelete' => $folder ? $folder->canDelete() : false
        ]));

        return $response;
    }

    /**
     * @param SS_HTTPRequest $request
     *
     * @return SS_HTTPResponse
     */
    public function apiSearch(SS_HTTPRequest $request)
    {
        $params = $request->getVars();
        $list = $this->getList($params);

        $response = new SS_HTTPResponse();
        $response->addHeader('Content-Type', 'application/json');
        $response->setBody(json_encode([
            // Serialisation
            "files" => array_map(function($file) {
                return $this->getObjectFromData($file);
            }, $list->toArray()),
            "count" => $list->count(),
        ]));

        return $response;
    }

    /**
     * @param SS_HTTPRequest $request
     *
     * @return SS_HTTPResponse
     */
    public function apiUpdateFile(SS_HTTPRequest $request)
    {
        parse_str($request->getBody(), $data);

        // CSRF check
        $token = SecurityToken::inst();
        if (empty($data[$token->getName()]) || !$token->check($data[$token->getName()])) {

            return new SS_HTTPResponse(null, 400);
        }

        if (!isset($data['id']) || !is_numeric($data['id'])) {

            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 400))
                ->addHeader('Content-Type', 'application/json');
        }

        $id = $data['id'];
        $record = $this->getList()->filter('ID', (int) $id)->first();

        if (!$record) {

            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 404))
                ->addHeader('Content-Type', 'application/json');
        }

        if (!$record->canEdit()) {

            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 401))
                ->addHeader('Content-Type', 'application/json');
        }

        // TODO Use same property names and capitalisation as DataObject
        if (!empty($data['title'])) {
            $record->Title = $data['title'];
        }

        // TODO Use same property names and capitalisation as DataObject
        if (!empty($data['basename'])) {
            $record->Name = $data['basename'];
        }

        $record->write();

        return (new SS_HTTPResponse(json_encode(['status' => 'ok']), 200))
            ->addHeader('Content-Type', 'application/json');
    }

    /**
     * @param SS_HTTPRequest $request
     *
     * @return SS_HTTPResponse
     */
    public function apiDelete(SS_HTTPRequest $request)
    {
        parse_str($request->getBody(), $vars);

        // CSRF check
        $token = SecurityToken::inst();
        if (empty($vars[$token->getName()]) || !$token->check($vars[$token->getName()])) {

            return new SS_HTTPResponse(null, 400);
        }

        if (!isset($vars['ids']) || !$vars['ids']) {

            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 400))
                ->addHeader('Content-Type', 'application/json');
        }

        $fileIds = $vars['ids'];
        $files = $this->getList()->filter("ID", $fileIds)->toArray();

        if (!count($files)) {

            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 404))
                ->addHeader('Content-Type', 'application/json');
        }

        if (!min(array_map(function ($file) {
            return $file->canDelete();
        }, $files))) {
            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 401))
                ->addHeader('Content-Type', 'application/json');
        }

        foreach ($files as $file) {
            $file->delete();
        }

        return (new SS_HTTPResponse(json_encode(['status' => 'file was deleted'])))
            ->addHeader('Content-Type', 'application/json');
    }

    public function apiCreateFile(SS_HTTPRequest $request)
    {
        $class = 'File';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $data = $request->postVars();
        $upload = $this->getUpload();

        // CSRF check
        $token = SecurityToken::inst();
        if (empty($data[$token->getName()]) || !$token->check($data[$token->getName()])) {

            return new SS_HTTPResponse(null, 400);
        }

        // check canAddChildren permissions
        if (!empty($data['ParentID']) && is_numeric($data['ParentID'])) {
            $parentRecord = Folder::get()->byID($data['ParentID']);
            if ($parentRecord->hasMethod('canAddChildren') && !$parentRecord->canAddChildren()) {

                return (new SS_HTTPResponse(json_encode(['status' => 'error']), 403))
                    ->addHeader('Content-Type', 'application/json');
            }
        } else {
            $parentRecord = singleton('Folder');
        }

        // check create permissions
        if (!$parentRecord->canCreate()) {
            return (new SS_HTTPResponse(json_encode(['status' => 'error']), 403))
                ->addHeader('Content-Type', 'application/json');
        }

        $tmpFile = $request->postVar('Upload');
        if(!$upload->validate($tmpFile)) {
            $result = ['error' => $upload->getErrors()];
            return (new SS_HTTPResponse(json_encode($result), 400))
                ->addHeader('Content-Type', 'application/json');
        }

        // TODO Allow batch uploads

        $file = File::create();
        $uploadResult = $upload->loadIntoFile($tmpFile, $file, $parentRecord ? $parentRecord->getFilename() : '/');
        if(!$uploadResult) {

            $result = ['error' => 'unknown'];
            return (new SS_HTTPResponse(json_encode($result), 400))
                ->addHeader('Content-Type', 'application/json');
        }

        $file->ParentID = $parentRecord->ID;
        $file->write();

        $result = [$this->getObjectFromData($file)];

        return (new SS_HTTPResponse(json_encode($result)))
            ->addHeader('Content-Type', 'application/json');
    }

    public function apiCreateFolder(SS_HTTPRequest $request)
    {
        $data = $request->postVars();

        $class = 'Folder';

        // CSRF check
        $token = SecurityToken::inst();
        if (empty($data[$token->getName()]) || !$token->check($data[$token->getName()])) {

            return new SS_HTTPResponse(null, 400);
        }

        // check addchildren permissions
        if (!empty($data['ParentID']) && is_numeric($data['ParentID'])) {
            $parentRecord = \DataObject::get_by_id($class, $data['ParentID']);
            if ($parentRecord->hasMethod('canAddChildren') && !$parentRecord->canAddChildren()) {

                return (new SS_HTTPResponse(null, 403))
                    ->addHeader('Content-Type', 'application/json');
            }
        } else {
            $parentRecord = singleton($class);
        }
        $data['ParentID'] = ($parentRecord->exists()) ? (int)$parentRecord->ID : 0;

        // check create permissions
        if (!$parentRecord->canCreate()) {
            return (new SS_HTTPResponse(null, 403))
                ->addHeader('Content-Type', 'application/json');
        }

        // Build filename
        $baseFilename = isset($data['Name'])
            ? basename($data['Name'])
            : _t('AssetAdmin.NEWFOLDER', "NewFolder");

        if ($parentRecord && $parentRecord->ID) {
            $baseFilename = $parentRecord->getFilename() . '/' . $baseFilename;
        }

        // Ensure name is unique
        $nameGenerator = $this->getNameGenerator($baseFilename);
        foreach ($nameGenerator as $filename) {
            if (! File::find($filename)) {
                break;
            }
        }
        $data['Name'] = basename($filename);
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.

        // Create record
        $record = $class::create();
        $record->ParentID = $data['ParentID'];
        $record->Name = $record->Title = basename($data['Name']);
        $record->write();

        $result = [
            "ParentID" => $record->ParentID,
            "ID" => $record->ID,
            "Filename" => $record->Filename,
        ];

        return (new SS_HTTPResponse(json_encode($result)))->addHeader('Content-Type', 'application/json');
    }

    public function legacyRedirectForEditView($request)
    {
        $fileID = $request->param('FileID');
        $file = File::get()->byID($fileID);
        $link = $this->getFileEditLink($file) ?: $this->Link();
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->redirect($link);
    }

    /**
     * Given a file return the CMS link to edit it
     *
     * @param File $file
     * @return string
     */
    public function getFileEditLink($file) {
        if(!$file || !$file->isInDB()) {
            return null;
        }

        return Controller::join_links(
            $this->Link('show'),
            $file->ParentID,
            'edit',
            $file->ID
        );
    }

    /**
     * Get the search context from {@link File}, used to create the search form
     * as well as power the /search API endpoint.
     *
     * @return SearchContext
     */
    public function getSearchContext()
    {
        $context = singleton('File')->getDefaultSearchContext();

        // Customize fields
        $dateHeader = HeaderField::create('Date', _t('CMSSearch.FILTERDATEHEADING', 'Date'), 4);
        $dateFrom = DateField::create('CreatedFrom', _t('CMSSearch.FILTERDATEFROM', 'From'))
        ->setConfig('showcalendar', true);
        $dateTo = DateField::create('CreatedTo', _t('CMSSearch.FILTERDATETO', 'To'))
        ->setConfig('showcalendar', true);
        $dateGroup = FieldGroup::create(
            $dateHeader,
            $dateFrom,
            $dateTo
        );
        $context->addField($dateGroup);
        $appCategories = array(
            'archive' => _t('AssetAdmin.AppCategoryArchive', 'Archive', 'A collection of files'),
            'audio' => _t('AssetAdmin.AppCategoryAudio', 'Audio'),
            'document' => _t('AssetAdmin.AppCategoryDocument', 'Document'),
            'flash' => _t('AssetAdmin.AppCategoryFlash', 'Flash', 'The fileformat'),
            'image' => _t('AssetAdmin.AppCategoryImage', 'Image'),
            'video' => _t('AssetAdmin.AppCategoryVideo', 'Video'),
        );
        $context->addField(
            $typeDropdown = new DropdownField(
                'AppCategory',
                _t('AssetAdmin.Filetype', 'File type'),
                $appCategories
            )
        );

        $typeDropdown->setEmptyString(' ');

        $context->addField(
            new CheckboxField('CurrentFolderOnly', _t('AssetAdmin.CurrentFolderOnly', 'Limit to current folder?'))
        );
        $context->getFields()->removeByName('Title');

        return $context;
    }

    /**
     * Get an asset renamer for the given filename.
     *
     * @param  string             $filename Path name
     * @return AssetNameGenerator
     */
    protected function getNameGenerator($filename)
    {
        return Injector::inst()
            ->createWithArgs('AssetNameGenerator', array($filename));
    }

    /**
     * @todo Implement on client
     */
    public function breadcrumbs($unlinked = false)
    {
        return null;
    }


    /**
     * Don't include class namespace in auto-generated CSS class
     */
    public function baseCSSClasses()
    {
        return 'AssetAdmin LeftAndMain';
    }

    /**
     * Don't include class namespace in template names
     * @todo Make code in framework more namespace-savvy so that we don't need this duplication
     */
    public function getTemplatesWithSuffix($suffix)
    {
        $className = get_class($this);
        $baseClass = 'LeftandMain';

        $templates = array();
        $classes = array_reverse(\ClassInfo::ancestry($className));
        foreach ($classes as $class) {
            $template = (new \ReflectionClass($class))->getShortName() . $suffix;
            if (\SSViewer::hasTemplate($template)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $templates[] = $template;
            }

            // If the class is "Page_Controller", look for Page.ss
            if (stripos($class, '_controller') !== false) {
                $template = str_ireplace('_controller', '', $class) . $suffix;
                if (\SSViewer::hasTemplate($template)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $templates[] = $template;
                }
            }

            if ($baseClass && $class == $baseClass) {
                break;
            }
        }

        return $templates;
    }

    public function providePermissions()
    {
        $title = _t("AssetAdmin.MENUTITLE", LeftAndMain::menu_title_for_class($this->class));


        return array(
            "CMS_ACCESS_AssetAdmin" => array(
                'name' => _t('CMSMain.ACCESS', "Access to '{title}' section", array('title' => $title)),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                'category' => _t('Permission.CMS_ACCESS_CATEGORY', 'CMS Access')
            )
        );
    }

    /**
     * The form is used to generate a form schema,
     * as well as an intermediary object to process data through API endpoints.
     * Since it's used directly on API endpoints, it does not have any form actions.
     *
     * @param Folder
     * @return Form
     */
    protected function getFolderEditForm(Folder $folder)
    {
        $form = Form::create(
            $this,
            'FolderEditForm',
            $folder->getCMSFields(),
            FieldList::create()
        );

        return $form;
    }

    /**
     * See {@link getFolderEditForm()} for details.
     *
     * @param File $file
     * @return Form
     */
    protected function getFileEditForm(File $file)
    {
        $form = Form::create(
            $this,
            'FileEditForm',
            $file->getCMSFields(),
            FieldList::create()
        );

        return $form;
    }

    /**
     * @param File $file
     *
     * @return array
     */
    protected function getObjectFromData(File $file)
    {
        $object = array(
            'id' => $file->ID,
            'created' => $file->Created,
            'lastUpdated' => $file->LastEdited,
            'owner' => null,
            'parent' => null,
            'attributes' => array(
                'dimensions' => array(),
            ),
            'title' => $file->Title,
            'type' => $file->is_a('Folder') ? 'folder' : $file->FileType,
            'category' => $file->is_a('Folder') ? 'folder' : $file->appCategory(),
            'name' => $file->Name,
            'filename' => $file->Filename,
            'extension' => $file->Extension,

            'size' => $file->Size,
            'url' => $file->AbsoluteURL,
            'canEdit' => $file->canEdit(),
            'canDelete' => $file->canDelete()
        );

        /** @var Member $owner */
        $owner = $file->Owner();

        if ($owner) {
            $object['owner'] = array(
                'id' => $owner->ID,
                'title' => trim($owner->FirstName . ' ' . $owner->Surname),
            );
        }

        /** @var Folder $parent */
        $parent = $file->Parent();

        if ($parent) {
            $object['parent'] = array(
                'id' => $parent->ID,
                'title' => $parent->Title,
                'filename' => $parent->Filename,
            );
        }

        /** @var File $file */
        if ($file->hasMethod('getWidth') && $file->hasMethod('getHeight')) {
            $object['attributes']['dimensions']['width'] = $file->Width;
            $object['attributes']['dimensions']['height'] = $file->Height;

        }

        return $object;
    }


    /**
     * Returns the files and subfolders contained in the currently selected folder,
     * defaulting to the root node. Doubles as search results, if any search parameters
     * are set through {@link SearchForm()}.
     *
     * @param array $params Unsanitised request parameters
     * @return SS_List
     */
    protected function getList($params = array())
    {
        $context = $this->getSearchContext();

        // Overwrite name filter to search both Name and Title attributes
        $context->removeFilterByName('Name');

        // Lazy loaded list. Allows adding new filters through SearchContext.
        $list = $context->getResults($params);

        // Re-add previously removed "Name" filter as combined filter
        // TODO Replace with composite SearchFilter once that API exists
        if(!empty($params['Name'])) {
            $list = $list->filterAny(array(
                'Name:PartialMatch' => $params['Name'],
                'Title:PartialMatch' => $params['Name']
            ));
        }

        // Optionally limit search to a folder (non-recursive)
        if(!empty($params['ParentID']) && is_numeric($params['ParentID'])) {
            $list = $list->filter('ParentID', $params['ParentID']);
        }

        // Date filtering
        if (!empty($params['CreatedFrom'])) {
            $fromDate = new DateField(null, null, $params['CreatedFrom']);
            $list = $list->filter("Created:GreaterThanOrEqual", $fromDate->dataValue().' 00:00:00');
        }
        if (!empty($params['CreatedTo'])) {
            $toDate = new DateField(null, null, $params['CreatedTo']);
            $list = $list->filter("Created:LessThanOrEqual", $toDate->dataValue().' 23:59:59');
        }

        // Categories
        if (!empty($filters['AppCategory']) && !empty(File::config()->app_categories[$filters['AppCategory']])) {

            $extensions = File::config()->app_categories[$filters['AppCategory']];
            $list = $list->filter('Name:PartialMatch', $extensions);
        }

        // Sort folders first
        $list = $list->sort(
            '(CASE WHEN "File"."ClassName" = \'Folder\' THEN 0 ELSE 1 END), "Name"'
        );

        // Pagination
        if (isset($filters['page']) && isset($filters['limit'])) {
            $page = $filters['page'];
            $limit = $filters['limit'];
            $offset = ($page - 1) * $limit;
            $list = $list->limit($limit, $offset);
        }

        // Access checks
        $list = $list->filterByCallback(function($file) {return $file->canView();});

        return $list;
    }

    /**
     * @return Upload
     */
    protected function getUpload()
    {
        $upload = Upload::create();
        $upload->getValidator()->setAllowedExtensions(
            // filter out '' since this would be a regex problem on JS end
            array_filter(Config::inst()->get('File', 'allowed_extensions'))
        );

        return $upload;
    }
}

1			<?php
2
3			namespace SilverStripe\AssetAdmin\Controller;
4
5			use SilverStripe\Filesystem\Storage\AssetNameGenerator;
6			use LeftAndMain;
7			use PermissionProvider;
8			use DateField;
9			use DropdownField;
10			use Controller;
11			use FieldList;
12			use Form;
13			use CheckboxField;
14			use File;
15			use Requirements;
16			use CMSBatchActionHandler;
17			use DataObject;
18			use Injector;
19			use Folder;
20			use CMSForm;
21			use SS_List;
22			use SSViewer;
23			use HeaderField;
24			use FieldGroup;
25			use SecurityToken;
26			use SS_HTTPRequest;
27			use SS_HTTPResponse;
28			use Upload;
29			use Config;
30
31			/**
32			* AssetAdmin is the 'file store' section of the CMS.
33			* It provides an interface for manipulating the File and Folder objects in the system.
34			*
35			* @package cms
36			* @subpackage assets
37			*/
38			class AssetAdmin extends LeftAndMain implements PermissionProvider
39			{
40			private static $url_segment = 'assets';
silverstripe / silverstripe-asset-admin

Pull Request — master (#202)

AssetAdmin::breadcrumbs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
