silverstripe-cms/code/Controllers/CMSMain.php

2306 lines
75 KiB
PHP
Raw Normal View History

<?php
2016-07-22 01:32:32 +02:00
namespace SilverStripe\CMS\Controllers;
2017-08-21 02:45:56 +02:00
use InvalidArgumentException;
use Psr\SimpleCache\CacheInterface;
use SilverStripe\Admin\AdminRootController;
use SilverStripe\Admin\CMSBatchActionHandler;
use SilverStripe\Admin\LeftAndMain;
2017-08-21 02:45:56 +02:00
use SilverStripe\Admin\LeftAndMainFormRequestHandler;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Archive;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Publish;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Restore;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Unpublish;
use SilverStripe\CMS\Model\CurrentPageIdentifier;
use SilverStripe\CMS\Model\RedirectorPage;
use SilverStripe\CMS\Model\SiteTree;
2017-08-21 02:45:56 +02:00
use SilverStripe\CMS\Model\VirtualPage;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
2016-09-09 01:26:24 +02:00
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Control\HTTPResponse_Exception;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Convert;
2017-08-21 02:45:56 +02:00
use SilverStripe\Core\Environment;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Forms\DateField;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Forms\FieldGroup;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\FormAction;
2016-09-08 09:33:32 +02:00
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Forms\GridField\GridFieldConfig;
use SilverStripe\Forms\GridField\GridFieldDataColumns;
use SilverStripe\Forms\GridField\GridFieldLevelup;
use SilverStripe\Forms\GridField\GridFieldPaginator;
use SilverStripe\Forms\GridField\GridFieldSortableHeader;
use SilverStripe\Forms\HiddenField;
use SilverStripe\Forms\LabelField;
use SilverStripe\Forms\LiteralField;
2017-08-21 02:45:56 +02:00
use SilverStripe\Forms\Tab;
2016-09-08 09:33:32 +02:00
use SilverStripe\Forms\TabSet;
use SilverStripe\Forms\TextField;
use SilverStripe\ORM\ArrayList;
2017-08-21 02:45:56 +02:00
use SilverStripe\ORM\CMSPreviewable;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\FieldType\DBHTMLText;
use SilverStripe\ORM\HiddenClass;
use SilverStripe\ORM\Hierarchy\MarkedSet;
use SilverStripe\ORM\SS_List;
use SilverStripe\ORM\ValidationResult;
use SilverStripe\Security\InheritedPermissions;
use SilverStripe\Security\Member;
use SilverStripe\Security\Permission;
use SilverStripe\Security\PermissionProvider;
use SilverStripe\Security\Security;
use SilverStripe\Security\SecurityToken;
2017-08-21 02:45:56 +02:00
use SilverStripe\SiteConfig\SiteConfig;
use SilverStripe\Versioned\ChangeSet;
use SilverStripe\Versioned\ChangeSetItem;
use SilverStripe\Versioned\Versioned;
use SilverStripe\View\ArrayData;
use SilverStripe\View\Requirements;
2017-11-30 03:56:16 +01:00
use SilverStripe\Core\Flushable;
use SilverStripe\Core\Cache\MemberCacheFlusher;
2016-07-22 01:32:32 +02:00
use Translatable;
/**
* The main "content" area of the CMS.
*
* This class creates a 2-frame layout - left-tree and right-form - to sit beneath the main
* admin menu.
*
* @todo Create some base classes to contain the generic functionality that will be replicated.
*
* @mixin LeftAndMainPageIconsExtension
*/
2017-11-30 03:56:16 +01:00
class CMSMain extends LeftAndMain implements CurrentPageIdentifier, PermissionProvider, Flushable, MemberCacheFlusher
2017-01-25 21:59:25 +01:00
{
/**
* Unique ID for page icons CSS block
*/
const PAGE_ICONS_ID = 'PageIcons';
2017-01-25 21:59:25 +01:00
private static $url_segment = 'pages';
private static $url_rule = '/$Action/$ID/$OtherID';
// Maintain a lower priority than other administration sections
// so that Director does not think they are actions of CMSMain
private static $url_priority = 39;
private static $menu_title = 'Edit Page';
private static $menu_icon_class = 'font-icon-sitemap';
private static $menu_priority = 10;
private static $tree_class = SiteTree::class;
private static $subitem_class = Member::class;
private static $session_namespace = self::class;
2017-01-25 21:59:25 +01:00
private static $required_permission_codes = 'CMS_ACCESS_CMSMain';
/**
* Amount of results showing on a single page.
*
* @config
* @var int
*/
private static $page_length = 15;
private static $allowed_actions = array(
'archive',
'deleteitems',
'DeleteItemsForm',
'dialog',
'duplicate',
'duplicatewithchildren',
'publishall',
'publishitems',
'PublishItemsForm',
'submit',
'EditForm',
'SearchForm',
'SiteTreeAsUL',
'getshowdeletedsubtree',
'savetreenode',
'getsubtree',
'updatetreenodes',
2017-01-25 21:59:25 +01:00
'batchactions',
'treeview',
'listview',
'ListViewForm',
'childfilter',
);
private static $url_handlers = [
2017-12-13 02:35:21 +01:00
'EditForm/$ID' => 'EditForm',
];
2017-01-25 21:59:25 +01:00
private static $casting = array(
'TreeIsFiltered' => 'Boolean',
'AddForm' => 'HTMLFragment',
'LinkPages' => 'Text',
'Link' => 'Text',
'ListViewForm' => 'HTMLFragment',
'ExtraTreeTools' => 'HTMLFragment',
'PageList' => 'HTMLFragment',
'PageListSidebar' => 'HTMLFragment',
'SiteTreeHints' => 'HTMLFragment',
'SecurityID' => 'Text',
'SiteTreeAsUL' => 'HTMLFragment',
);
2017-11-30 03:56:16 +01:00
private static $dependencies = [
'HintsCache' => '%$' . CacheInterface::class . '.CMSMain_SiteTreeHints',
];
/**
* @var CacheInterface
*/
protected $hintsCache;
2017-01-25 21:59:25 +01:00
protected function init()
{
// set reading lang
if (SiteTree::has_extension('Translatable') && !$this->getRequest()->isAjax()) {
Translatable::choose_site_locale(array_keys(Translatable::get_existing_content_languages(SiteTree::class)));
2017-01-25 21:59:25 +01:00
}
parent::init();
Requirements::javascript('silverstripe/cms: client/dist/js/bundle.js');
Requirements::javascript('silverstripe/cms: client/dist/js/SilverStripeNavigator.js');
Requirements::css('silverstripe/cms: client/dist/styles/bundle.css');
Requirements::customCSS($this->generatePageIconsCss(), self::PAGE_ICONS_ID);
2017-10-10 06:03:22 +02:00
Requirements::add_i18n_javascript('silverstripe/cms: client/lang', false, true);
2017-01-25 21:59:25 +01:00
CMSBatchActionHandler::register('restore', CMSBatchAction_Restore::class);
CMSBatchActionHandler::register('archive', CMSBatchAction_Archive::class);
CMSBatchActionHandler::register('unpublish', CMSBatchAction_Unpublish::class);
CMSBatchActionHandler::register('publish', CMSBatchAction_Publish::class);
}
public function index($request)
{
// In case we're not showing a specific record, explicitly remove any session state,
// to avoid it being highlighted in the tree, and causing an edit form to show.
if (!$request->param('Action')) {
$this->setCurrentPageID(null);
}
return parent::index($request);
}
public function getResponseNegotiator()
{
$negotiator = parent::getResponseNegotiator();
// ListViewForm
$negotiator->setCallback('ListViewForm', function () {
return $this->ListViewForm()->forTemplate();
});
return $negotiator;
}
/**
* Get pages listing area
*
* @return DBHTMLText
*/
public function PageList()
{
return $this->renderWith($this->getTemplatesWithSuffix('_PageList'));
}
/**
* Page list view for edit-form
*
* @return DBHTMLText
*/
public function PageListSidebar()
{
return $this->renderWith($this->getTemplatesWithSuffix('_PageList_Sidebar'));
}
/**
* If this is set to true, the "switchView" context in the
* template is shown, with links to the staging and publish site.
*
* @return boolean
*/
public function ShowSwitchView()
{
return true;
}
/**
* Overloads the LeftAndMain::ShowView. Allows to pass a page as a parameter, so we are able
* to switch view also for archived versions.
*
* @param SiteTree $page
* @return array
*/
public function SwitchView($page = null)
{
if (!$page) {
$page = $this->currentPage();
}
if ($page) {
$nav = SilverStripeNavigator::get_for_record($page);
return $nav['items'];
}
}
//------------------------------------------------------------------------------------------//
// Main controllers
//------------------------------------------------------------------------------------------//
// Main UI components
/**
* Override {@link LeftAndMain} Link to allow blank URL segment for CMSMain.
*
* @param string|null $action Action to link to.
* @return string
*/
public function Link($action = null)
{
$link = Controller::join_links(
AdminRootController::admin_url(),
$this->config()->get('url_segment'), // in case we want to change the segment
2017-01-25 21:59:25 +01:00
'/', // trailing slash needed if $action is null!
"$action"
);
$this->extend('updateLink', $link);
return $link;
}
public function LinkPages()
{
return CMSPagesController::singleton()->Link();
}
public function LinkPagesWithSearch()
{
return $this->LinkWithSearch($this->LinkPages());
}
/**
* Get link to tree view
*
* @return string
*/
public function LinkTreeView()
{
// Tree view is just default link to main pages section (no /treeview suffix)
return CMSMain::singleton()->Link();
2017-01-25 21:59:25 +01:00
}
/**
* Get link to list view
*
* @return string
*/
public function LinkListView()
{
2017-08-21 02:45:56 +02:00
// Note : Force redirect to top level page controller (no parentid)
2017-01-25 21:59:25 +01:00
return $this->LinkWithSearch(CMSMain::singleton()->Link('listview'));
}
2017-08-21 02:45:56 +02:00
/**
* Link to list view for children of a parent page
*
* @param int|string $parentID Literal parentID, or placeholder (e.g. '%d') for
* client side substitution
* @return string
*/
public function LinkListViewChildren($parentID)
{
2017-12-12 03:04:21 +01:00
return sprintf(
'%s?ParentID=%s',
CMSMain::singleton()->Link(),
2017-08-21 02:45:56 +02:00
$parentID
2017-12-12 03:04:21 +01:00
);
2017-08-21 02:45:56 +02:00
}
2017-12-07 04:24:01 +01:00
/**
* @return string
*/
public function LinkListViewRoot()
{
return $this->LinkListViewChildren(0);
}
2017-08-21 02:45:56 +02:00
/**
* Link to lazy-load deferred tree view
*
* @return string
*/
public function LinkTreeViewDeferred()
{
return $this->Link('treeview');
2017-08-21 02:45:56 +02:00
}
2017-12-06 05:06:15 +01:00
/**
* Link to lazy-load deferred list view
*
* @return string
*/
public function LinkListViewDeferred()
{
return $this->Link('listview');
}
2017-01-25 21:59:25 +01:00
public function LinkPageEdit($id = null)
{
if (!$id) {
$id = $this->currentPageID();
}
return $this->LinkWithSearch(
Controller::join_links(CMSPageEditController::singleton()->Link('show'), $id)
);
}
public function LinkPageSettings()
{
if ($id = $this->currentPageID()) {
return $this->LinkWithSearch(
Controller::join_links(CMSPageSettingsController::singleton()->Link('show'), $id)
);
} else {
return null;
}
}
public function LinkPageHistory()
{
if ($id = $this->currentPageID()) {
return $this->LinkWithSearch(
Controller::join_links(CMSPageHistoryController::singleton()->Link('show'), $id)
);
} else {
return null;
}
}
/**
* Return the active tab identifier for the CMS. Used by templates to decide which tab to give the active state.
* The default value is "edit", as the primary content tab. Child controllers will override this.
*
* @return string
*/
public function getTabIdentifier()
{
return 'edit';
}
2017-11-30 03:56:16 +01:00
/**
* @param CacheInterface $cache
* @return $this
*/
public function setHintsCache(CacheInterface $cache)
{
$this->hintsCache = $cache;
return $this;
}
/**
* @return CacheInterface $cache
*/
public function getHintsCache()
{
return $this->hintsCache;
}
/**
* Clears all dependent cache backends
*/
public function clearCache()
{
$this->getHintsCache()->clear();
}
2017-01-25 21:59:25 +01:00
public function LinkWithSearch($link)
{
// Whitelist to avoid side effects
$params = array(
'q' => (array)$this->getRequest()->getVar('q'),
'ParentID' => $this->getRequest()->getVar('ParentID')
);
$link = Controller::join_links(
$link,
array_filter(array_values($params)) ? '?' . http_build_query($params) : null
);
$this->extend('updateLinkWithSearch', $link);
return $link;
}
public function LinkPageAdd($extra = null, $placeholders = null)
{
$link = CMSPageAddController::singleton()->Link();
$this->extend('updateLinkPageAdd', $link);
if ($extra) {
$link = Controller::join_links($link, $extra);
}
if ($placeholders) {
$link .= (strpos($link, '?') === false ? "?$placeholders" : "&$placeholders");
}
return $link;
}
/**
* @return string
*/
public function LinkPreview()
{
$record = $this->getRecord($this->currentPageID());
$baseLink = Director::absoluteBaseURL();
if ($record && $record instanceof SiteTree) {
// if we are an external redirector don't show a link
if ($record instanceof RedirectorPage && $record->RedirectionType == 'External') {
$baseLink = false;
} else {
$baseLink = $record->Link('?stage=Stage');
}
}
return $baseLink;
}
/**
* Return the entire site tree as a nested set of ULs
*/
public function SiteTreeAsUL()
{
// Pre-cache sitetree version numbers for querying efficiency
Versioned::prepopulate_versionnumber_cache(SiteTree::class, Versioned::DRAFT);
Versioned::prepopulate_versionnumber_cache(SiteTree::class, Versioned::LIVE);
$html = $this->getSiteTreeFor($this->config()->get('tree_class'));
2017-01-25 21:59:25 +01:00
$this->extend('updateSiteTreeAsUL', $html);
return $html;
}
/**
* Get a site tree HTML listing which displays the nodes under the given criteria.
*
* @param string $className The class of the root object
* @param string $rootID The ID of the root object. If this is null then a complete tree will be
* shown
* @param string $childrenMethod The method to call to get the children of the tree. For example,
* Children, AllChildrenIncludingDeleted, or AllHistoricalChildren
* @param string $numChildrenMethod
* @param callable $filterFunction
* @param int $nodeCountThreshold
* @return string Nested unordered list with links to each page
*/
public function getSiteTreeFor(
$className,
$rootID = null,
$childrenMethod = null,
$numChildrenMethod = null,
$filterFunction = null,
$nodeCountThreshold = null
) {
$nodeCountThreshold = is_null($nodeCountThreshold) ? Config::inst()->get($className, 'node_threshold_total') : $nodeCountThreshold;
// Provide better defaults from filter
$filter = $this->getSearchFilter();
if ($filter) {
2017-04-22 01:44:49 +02:00
if (!$childrenMethod) {
$childrenMethod = $filter->getChildrenMethod();
2017-04-22 01:44:49 +02:00
}
if (!$numChildrenMethod) {
$numChildrenMethod = $filter->getNumChildrenMethod();
}
if (!$filterFunction) {
2017-04-22 01:44:49 +02:00
$filterFunction = function ($node) use ($filter) {
return $filter->isPageIncluded($node);
};
}
}
// Build set from node and begin marking
$record = ($rootID) ? $this->getRecord($rootID) : null;
$rootNode = $record ? $record : DataObject::singleton($className);
$markingSet = MarkedSet::create($rootNode, $childrenMethod, $numChildrenMethod, $nodeCountThreshold);
// Set filter function
if ($filterFunction) {
$markingSet->setMarkingFilterFunction($filterFunction);
}
// Mark tree from this node
$markingSet->markPartialTree();
// Ensure current page is exposed
$currentPage = $this->currentPage();
if ($currentPage) {
$markingSet->markToExpose($currentPage);
}
// Pre-cache permissions
$checker = SiteTree::getPermissionChecker();
if ($checker instanceof InheritedPermissions) {
$checker->prePopulatePermissionCache(
InheritedPermissions::EDIT,
$markingSet->markedNodeIDs()
);
}
// Render using full-subtree template
return $markingSet->renderChildren(
[ self::class . '_SubTree', 'type' => 'Includes' ],
$this->getTreeNodeCustomisations()
);
}
/**
* Get callback to determine template customisations for nodes
*
* @return callable
*/
protected function getTreeNodeCustomisations()
{
$rootTitle = $this->getCMSTreeTitle();
2017-08-21 02:45:56 +02:00
return function (SiteTree $node) use ($rootTitle) {
return [
2017-08-21 02:45:56 +02:00
'listViewLink' => $this->LinkListViewChildren($node->ID),
'rootTitle' => $rootTitle,
'extraClass' => $this->getTreeNodeClasses($node),
'Title' => _t(
self::class . '.PAGETYPE_TITLE',
'(Page type: {type}) {title}',
[
'type' => $node->i18n_singular_name(),
'title' => $node->Title,
]
)
];
2017-04-22 01:44:49 +02:00
};
}
/**
* Get extra CSS classes for a page's tree node
*
* @param SiteTree $node
* @return string
*/
public function getTreeNodeClasses(SiteTree $node)
{
// Get classes from object
$classes = $node->CMSTreeClasses();
// Get status flag classes
$flags = $node->getStatusFlags();
if ($flags) {
$statuses = array_keys($flags);
foreach ($statuses as $s) {
$classes .= ' status-' . $s;
}
}
// Get additional filter classes
$filter = $this->getSearchFilter();
if ($filter && ($filterClasses = $filter->getPageClasses($node))) {
if (is_array($filterClasses)) {
$filterClasses = implode(' ', $filterClasses);
}
$classes .= ' ' . $filterClasses;
}
return trim($classes);
}
/**
* Get a subtree underneath the request param 'ID'.
* If ID = 0, then get the whole tree.
*
* @param HTTPRequest $request
* @return string
*/
public function getsubtree($request)
{
$html = $this->getSiteTreeFor(
$this->config()->get('tree_class'),
$request->getVar('ID'),
null,
null,
null,
$request->getVar('minNodeCount')
);
// Trim off the outer tag
$html = preg_replace('/^[\s\t\r\n]*<ul[^>]*>/', '', $html);
$html = preg_replace('/<\/ul[^>]*>[\s\t\r\n]*$/', '', $html);
return $html;
}
/**
* Allows requesting a view update on specific tree nodes.
* Similar to {@link getsubtree()}, but doesn't enforce loading
* all children with the node. Useful to refresh views after
* state modifications, e.g. saving a form.
*
* @param HTTPRequest $request
* @return HTTPResponse
*/
public function updatetreenodes($request)
{
$data = array();
$ids = explode(',', $request->getVar('ids'));
foreach ($ids as $id) {
if ($id === "") {
continue; // $id may be a blank string, which is invalid and should be skipped over
}
$record = $this->getRecord($id);
if (!$record) {
continue; // In case a page is no longer available
}
// Create marking set with sole marked root
$markingSet = MarkedSet::create($record);
$markingSet->setMarkingFilterFunction(function () {
return false;
});
$markingSet->markUnexpanded($record);
// Find the next & previous nodes, for proper positioning (Sort isn't good enough - it's not a raw offset)
// TODO: These methods should really be in hierarchy - for a start it assumes Sort exists
$prev = null;
$className = $this->config()->get('tree_class');
$next = DataObject::get($className)
->filter('ParentID', $record->ParentID)
->filter('Sort:GreaterThan', $record->Sort)
->first();
if (!$next) {
$prev = DataObject::get($className)
->filter('ParentID', $record->ParentID)
->filter('Sort:LessThan', $record->Sort)
->reverse()
->first();
}
// Render using single node template
$html = $markingSet->renderChildren(
[ self::class . '_TreeNode', 'type' => 'Includes'],
$this->getTreeNodeCustomisations()
);
$data[$id] = array(
'html' => $html,
'ParentID' => $record->ParentID,
'NextID' => $next ? $next->ID : null,
'PrevID' => $prev ? $prev->ID : null
);
}
return $this
->getResponse()
->addHeader('Content-Type', 'application/json')
->setBody(Convert::raw2json($data));
}
/**
* Update the position and parent of a tree node.
* Only saves the node if changes were made.
*
* Required data:
* - 'ID': The moved node
* - 'ParentID': New parent relation of the moved node (0 for root)
* - 'SiblingIDs': Array of all sibling nodes to the moved node (incl. the node itself).
* In case of a 'ParentID' change, relates to the new siblings under the new parent.
*
* @param HTTPRequest $request
* @return HTTPResponse JSON string with a
* @throws HTTPResponse_Exception
*/
public function savetreenode($request)
{
if (!SecurityToken::inst()->checkRequest($request)) {
return $this->httpError(400);
}
if (!Permission::check('SITETREE_REORGANISE') && !Permission::check('ADMIN')) {
return $this->httpError(
403,
_t(
2017-05-08 07:57:24 +02:00
__CLASS__.'.CANT_REORGANISE',
"You do not have permission to rearange the site tree. Your change was not saved."
)
);
}
$className = $this->config()->get('tree_class');
$id = $request->requestVar('ID');
$parentID = $request->requestVar('ParentID');
if (!is_numeric($id) || !is_numeric($parentID)) {
return $this->httpError(400);
}
// Check record exists in the DB
/** @var SiteTree $node */
$node = DataObject::get_by_id($className, $id);
if (!$node) {
return $this->httpError(
500,
_t(
2017-05-08 07:57:24 +02:00
__CLASS__.'.PLEASESAVE',
"Please Save Page: This page could not be updated because it hasn't been saved yet."
)
);
}
// Check top level permissions
$root = $node->getParentType();
if (($parentID == '0' || $root == 'root') && !SiteConfig::current_site_config()->canCreateTopLevel()) {
return $this->httpError(
403,
_t(
2017-05-08 07:57:24 +02:00
__CLASS__.'.CANT_REORGANISE',
"You do not have permission to alter Top level pages. Your change was not saved."
)
);
}
$siblingIDs = $request->requestVar('SiblingIDs');
$statusUpdates = array('modified'=>array());
if (!$node->canEdit()) {
return Security::permissionFailure($this);
}
// Update hierarchy (only if ParentID changed)
if ($node->ParentID != $parentID) {
$node->ParentID = (int)$parentID;
$node->write();
$statusUpdates['modified'][$node->ID] = array(
'TreeTitle' => $node->TreeTitle
);
// Update all dependent pages
$virtualPages = VirtualPage::get()->filter("CopyContentFromID", $node->ID);
foreach ($virtualPages as $virtualPage) {
$statusUpdates['modified'][$virtualPage->ID] = array(
'TreeTitle' => $virtualPage->TreeTitle()
);
}
$this->getResponse()->addHeader(
'X-Status',
2017-05-08 07:57:24 +02:00
rawurlencode(_t(__CLASS__.'.REORGANISATIONSUCCESSFUL', 'Reorganised the site tree successfully.'))
);
}
// Update sorting
if (is_array($siblingIDs)) {
$counter = 0;
foreach ($siblingIDs as $id) {
if ($id == $node->ID) {
$node->Sort = ++$counter;
$node->write();
$statusUpdates['modified'][$node->ID] = array(
'TreeTitle' => $node->TreeTitle
);
} elseif (is_numeric($id)) {
// Nodes that weren't "actually moved" shouldn't be registered as
// having been edited; do a direct SQL update instead
++$counter;
$table = DataObject::getSchema()->baseDataTable($className);
DB::prepared_query(
"UPDATE \"$table\" SET \"Sort\" = ? WHERE \"ID\" = ?",
array($counter, $id)
);
}
}
$this->getResponse()->addHeader(
'X-Status',
2017-05-08 07:57:24 +02:00
rawurlencode(_t(__CLASS__.'.REORGANISATIONSUCCESSFUL', 'Reorganised the site tree successfully.'))
);
}
return $this
->getResponse()
->addHeader('Content-Type', 'application/json')
->setBody(Convert::raw2json($statusUpdates));
}
public function CanOrganiseSitetree()
{
return !Permission::check('SITETREE_REORGANISE') && !Permission::check('ADMIN') ? false : true;
}
2017-01-25 21:59:25 +01:00
/**
* @return boolean
*/
public function TreeIsFiltered()
{
$query = $this->getRequest()->getVar('q');
2017-12-13 06:16:34 +01:00
return !empty($query);
2017-01-25 21:59:25 +01:00
}
public function ExtraTreeTools()
{
$html = '';
$this->extend('updateExtraTreeTools', $html);
return $html;
}
/**
* Returns a Form for page searching for use in templates.
*
* Can be modified from a decorator by a 'updateSearchForm' method
*
* @return Form
*/
public function SearchForm()
{
// Create the fields
2017-04-20 03:45:23 +02:00
$content = new TextField('q[Term]', _t('SilverStripe\\CMS\\Search\\SearchForm.FILTERLABELTEXT', 'Search'));
2017-01-25 21:59:25 +01:00
$dateFrom = new DateField(
'q[LastEditedFrom]',
2017-04-20 03:45:23 +02:00
_t('SilverStripe\\CMS\\Search\\SearchForm.FILTERDATEFROM', 'From')
2017-01-25 21:59:25 +01:00
);
$dateTo = new DateField(
'q[LastEditedTo]',
2017-04-20 03:45:23 +02:00
_t('SilverStripe\\CMS\\Search\\SearchForm.FILTERDATETO', 'To')
2017-01-25 21:59:25 +01:00
);
$pageFilter = new DropdownField(
'q[FilterClass]',
2017-04-20 03:15:29 +02:00
_t('SilverStripe\\CMS\\Controllers\\CMSMain.PAGES', 'Page status'),
2017-01-25 21:59:25 +01:00
CMSSiteTreeFilter::get_all_filters()
);
$pageClasses = new DropdownField(
'q[ClassName]',
2017-04-20 03:15:29 +02:00
_t('SilverStripe\\CMS\\Controllers\\CMSMain.PAGETYPEOPT', 'Page type', 'Dropdown for limiting search to a page type'),
2017-01-25 21:59:25 +01:00
$this->getPageTypes()
);
2017-04-20 03:15:29 +02:00
$pageClasses->setEmptyString(_t('SilverStripe\\CMS\\Controllers\\CMSMain.PAGETYPEANYOPT', 'Any'));
2017-01-25 21:59:25 +01:00
// Group the Datefields
$dateGroup = new FieldGroup(
$dateFrom,
$dateTo
);
2017-04-20 03:45:23 +02:00
$dateGroup->setTitle(_t('SilverStripe\\CMS\\Search\\SearchForm.PAGEFILTERDATEHEADING', 'Last edited'));
2017-01-25 21:59:25 +01:00
// Create the Field list
$fields = new FieldList(
$content,
$pageFilter,
$pageClasses,
2017-12-13 02:35:21 +01:00
$dateGroup
2017-01-25 21:59:25 +01:00
);
// Create the Search and Reset action
$actions = new FieldList(
2017-04-20 03:45:23 +02:00
FormAction::create('doSearch', _t('SilverStripe\\CMS\\Controllers\\CMSMain.APPLY_FILTER', 'Search'))
2017-01-25 21:59:25 +01:00
->addExtraClass('btn btn-primary'),
FormAction::create('clear', _t('SilverStripe\\CMS\\Controllers\\CMSMain.CLEAR_FILTER', 'Clear'))
->setAttribute('type', 'reset')
2017-01-25 21:59:25 +01:00
->addExtraClass('btn btn-secondary')
);
// Use <button> to allow full jQuery UI styling on the all of the Actions
/** @var FormAction $action */
foreach ($actions->dataFields() as $action) {
/** @var FormAction $action */
$action->setUseButtonTag(true);
}
// Create the form
/** @skipUpgrade */
$form = Form::create($this, 'SearchForm', $fields, $actions)
->addExtraClass('cms-search-form')
->setFormMethod('GET')
->setFormAction(CMSMain::singleton()->Link())
2017-01-25 21:59:25 +01:00
->disableSecurityToken()
->unsetValidator();
// Load the form with previously sent search data
$form->loadDataFrom($this->getRequest()->getVars());
// Allow decorators to modify the form
$this->extend('updateSearchForm', $form);
return $form;
}
/**
* Returns a sorted array suitable for a dropdown with pagetypes and their translated name
*
* @return array
*/
protected function getPageTypes()
{
$pageTypes = array();
foreach (SiteTree::page_type_classes() as $pageTypeClass) {
$pageTypes[$pageTypeClass] = SiteTree::singleton($pageTypeClass)->i18n_singular_name();
}
asort($pageTypes);
return $pageTypes;
}
public function doSearch($data, $form)
{
return $this->getsubtree($this->getRequest());
}
/**
* Get "back" url for breadcrumbs
*
* @return string
*/
public function getBreadcrumbsBackLink()
{
$breadcrumbs = $this->Breadcrumbs();
if ($breadcrumbs->count() < 2) {
return $this->LinkPages();
}
// Get second from end breadcrumb
return $breadcrumbs
->offsetGet($breadcrumbs->count() - 2)
->Link;
}
2017-01-25 21:59:25 +01:00
/**
* @param bool $unlinked
* @return ArrayList
*/
public function Breadcrumbs($unlinked = false)
{
$items = new ArrayList();
// Check if we are editing a page
/** @var SiteTree $record */
$record = $this->currentPage();
if (!$record) {
$items->push(new ArrayData(array(
'Title' => CMSPagesController::menu_title(),
'Link' => ($unlinked) ? false : $this->LinkPages()
)));
$this->extend('updateBreadcrumbs', $items);
return $items;
}
2017-01-25 21:59:25 +01:00
// Add all ancestors
$ancestors = $record->getAncestors();
$ancestors = new ArrayList(array_reverse($ancestors->toArray()));
$ancestors->push($record);
/** @var SiteTree $ancestor */
foreach ($ancestors as $ancestor) {
$items->push(new ArrayData(array(
'Title' => $ancestor->getMenuTitle(),
'Link' => ($unlinked)
? false
: $ancestor->CMSEditLink()
)));
2017-01-25 21:59:25 +01:00
}
$this->extend('updateBreadcrumbs', $items);
2017-01-25 21:59:25 +01:00
return $items;
}
/**
* Create serialized JSON string with site tree hints data to be injected into
* 'data-hints' attribute of root node of jsTree.
*
* @return string Serialized JSON
*/
public function SiteTreeHints()
{
$classes = SiteTree::page_type_classes();
2017-11-30 03:56:16 +01:00
$memberID = Security::getCurrentUser() ? Security::getCurrentUser()->ID : 0;
$cache = $this->getHintsCache();
$cacheKey = $this->generateHintsCacheKey($memberID);
$json = $cache->get($cacheKey);
2017-01-25 21:59:25 +01:00
if ($json) {
return $json;
}
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
$canCreate = [];
foreach ($classes as $class) {
$canCreate[$class] = singleton($class)->canCreate();
2017-01-25 21:59:25 +01:00
}
2017-11-30 03:56:16 +01:00
$def['Root'] = [];
$def['Root']['disallowedChildren'] = [];
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
// Contains all possible classes to support UI controls listing them all,
// such as the "add page here" context menu.
$def['All'] = [];
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
// Identify disallows and set globals
foreach ($classes as $class) {
$obj = singleton($class);
if ($obj instanceof HiddenClass) {
continue;
}
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
// Name item
$def['All'][$class] = [
'title' => $obj->i18n_singular_name()
];
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
// Check if can be created at the root
$needsPerm = $obj->config()->get('need_permission');
if (!$obj->config()->get('can_be_root')
|| (!array_key_exists($class, $canCreate) || !$canCreate[$class])
|| ($needsPerm && !$this->can($needsPerm))
) {
$def['Root']['disallowedChildren'][] = $class;
2017-01-25 21:59:25 +01:00
}
2017-11-30 03:56:16 +01:00
// Hint data specific to the class
$def[$class] = [];
$defaultChild = $obj->defaultChild();
if ($defaultChild !== 'Page' && $defaultChild !== null) {
$def[$class]['defaultChild'] = $defaultChild;
}
2017-01-25 21:59:25 +01:00
2017-11-30 03:56:16 +01:00
$defaultParent = $obj->defaultParent();
if ($defaultParent !== 1 && $defaultParent !== null) {
$def[$class]['defaultParent'] = $defaultParent;
}
2017-01-25 21:59:25 +01:00
}
2017-11-30 03:56:16 +01:00
$this->extend('updateSiteTreeHints', $def);
$json = Convert::raw2json($def);
$cache->set($cacheKey, $json);
2017-01-25 21:59:25 +01:00
return $json;
}
/**
* Populates an array of classes in the CMS
* which allows the user to change the page type.
*
* @return SS_List
*/
public function PageTypes()
{
$classes = SiteTree::page_type_classes();
$result = new ArrayList();
foreach ($classes as $class) {
2017-01-23 03:11:49 +01:00
$instance = SiteTree::singleton($class);
2017-01-25 21:59:25 +01:00
if ($instance instanceof HiddenClass) {
continue;
}
// skip this type if it is restricted
2017-10-18 01:32:08 +02:00
$needPermissions = $instance->config()->get('need_permission');
if ($needPermissions && !$this->can($needPermissions)) {
2017-01-25 21:59:25 +01:00
continue;
}
$result->push(new ArrayData(array(
'ClassName' => $class,
2017-10-18 01:32:08 +02:00
'AddAction' => $instance->i18n_singular_name(),
'Description' => $instance->i18n_classDescription(),
'IconURL' => $instance->getPageIconURL(),
'Title' => $instance->i18n_singular_name(),
2017-01-25 21:59:25 +01:00
)));
}
$result = $result->sort('AddAction');
return $result;
}
/**
* Get a database record to be managed by the CMS.
*
* @param int $id Record ID
* @param int $versionID optional Version id of the given record
* @return SiteTree
*/
public function getRecord($id, $versionID = null)
{
if (!$id) {
return null;
}
$treeClass = $this->config()->get('tree_class');
2017-01-25 21:59:25 +01:00
if ($id instanceof $treeClass) {
return $id;
}
if (substr($id, 0, 3) == 'new') {
return $this->getNewItem($id);
}
if (!is_numeric($id)) {
return null;
}
2017-01-25 21:59:25 +01:00
$currentStage = Versioned::get_reading_mode();
2017-01-25 21:59:25 +01:00
if ($this->getRequest()->getVar('Version')) {
$versionID = (int) $this->getRequest()->getVar('Version');
}
2017-01-25 21:59:25 +01:00
/** @var SiteTree $record */
if ($versionID) {
$record = Versioned::get_version($treeClass, $id, $versionID);
} else {
$record = DataObject::get_by_id($treeClass, $id);
}
2017-01-25 21:59:25 +01:00
// Then, try getting a record from the live site
if (!$record) {
// $record = Versioned::get_one_by_stage($treeClass, "Live", "\"$treeClass\".\"ID\" = $id");
Versioned::set_stage(Versioned::LIVE);
singleton($treeClass)->flushCache();
2017-01-25 21:59:25 +01:00
$record = DataObject::get_by_id($treeClass, $id);
}
2017-01-25 21:59:25 +01:00
// Then, try getting a deleted record
if (!$record) {
$record = Versioned::get_latest_version($treeClass, $id);
}
// Set the reading mode back to what it was.
Versioned::set_reading_mode($currentStage);
return $record;
}
/**
* {@inheritdoc}
*
* @param HTTPRequest $request
* @return Form
*/
public function EditForm($request = null)
{
// set page ID from request
if ($request) {
// Validate id is present
$id = $request->param('ID');
if (!isset($id)) {
$this->httpError(400);
return null;
}
$this->setCurrentPageID($id);
2017-01-25 21:59:25 +01:00
}
return $this->getEditForm();
2017-01-25 21:59:25 +01:00
}
/**
* @param int $id
* @param FieldList $fields
* @return Form
*/
public function getEditForm($id = null, $fields = null)
{
// Get record
2017-01-25 21:59:25 +01:00
if (!$id) {
$id = $this->currentPageID();
}
/** @var SiteTree $record */
2017-01-25 21:59:25 +01:00
$record = $this->getRecord($id);
// Check parent form can be generated
$form = parent::getEditForm($record, $fields);
if (!$form || !$record) {
return $form;
2017-01-25 21:59:25 +01:00
}
if (!$fields) {
$fields = $form->Fields();
}
// Add extra fields
$deletedFromStage = !$record->isOnDraft();
$fields->push($idField = new HiddenField("ID", false, $id));
// Necessary for different subsites
$fields->push($liveLinkField = new HiddenField("AbsoluteLink", false, $record->AbsoluteLink()));
$fields->push($liveLinkField = new HiddenField("LiveLink"));
$fields->push($stageLinkField = new HiddenField("StageLink"));
$fields->push($archiveWarningMsgField = new HiddenField("ArchiveWarningMessage"));
$fields->push(new HiddenField("TreeTitle", false, $record->getTreeTitle()));
$archiveWarningMsgField->setValue($this->getArchiveWarningMessage($record));
// Build preview / live links
$liveLink = $record->getAbsoluteLiveLink();
if ($liveLink) {
$liveLinkField->setValue($liveLink);
}
if (!$deletedFromStage) {
$stageLink = Controller::join_links($record->AbsoluteLink(), '?stage=Stage');
if ($stageLink) {
$stageLinkField->setValue($stageLink);
2017-01-25 21:59:25 +01:00
}
}
2017-01-25 21:59:25 +01:00
// Added in-line to the form, but plucked into different view by LeftAndMain.Preview.js upon load
/** @skipUpgrade */
if ($record instanceof CMSPreviewable && !$fields->fieldByName('SilverStripeNavigator')) {
$navField = new LiteralField('SilverStripeNavigator', $this->getSilverStripeNavigator());
$navField->setAllowHTML(true);
$fields->push($navField);
}
2017-01-25 21:59:25 +01:00
// getAllCMSActions can be used to completely redefine the action list
if ($record->hasMethod('getAllCMSActions')) {
$actions = $record->getAllCMSActions();
} else {
$actions = $record->getCMSActions();
// Find and remove action menus that have no actions.
if ($actions && $actions->count()) {
/** @var TabSet $tabset */
$tabset = $actions->fieldByName('ActionMenus');
if ($tabset) {
/** @var Tab $tab */
foreach ($tabset->getChildren() as $tab) {
if (!$tab->getChildren()->count()) {
$tabset->removeByName($tab->getName());
2017-01-25 21:59:25 +01:00
}
}
}
}
}
2017-01-25 21:59:25 +01:00
// Use <button> to allow full jQuery UI styling
$actionsFlattened = $actions->dataFields();
if ($actionsFlattened) {
/** @var FormAction $action */
foreach ($actionsFlattened as $action) {
$action->setUseButtonTag(true);
2017-01-25 21:59:25 +01:00
}
}
2017-01-25 21:59:25 +01:00
// TODO Can't merge $FormAttributes in template at the moment
$form->addExtraClass('center ' . $this->BaseCSSClasses());
// Set validation exemptions for specific actions
2017-07-15 17:21:51 +02:00
$form->setValidationExemptActions(array(
'restore',
'revert',
'deletefromlive',
'delete',
'unpublish',
'rollback',
'doRollback',
'archive',
));
2017-01-25 21:59:25 +01:00
// Announce the capability so the frontend can decide whether to allow preview or not.
if ($record instanceof CMSPreviewable) {
$form->addExtraClass('cms-previewable');
}
$form->addExtraClass('fill-height flexbox-area-grow');
2017-01-25 21:59:25 +01:00
if (!$record->canEdit() || $deletedFromStage) {
$readonlyFields = $form->Fields()->makeReadonly();
$form->setFields($readonlyFields);
}
2017-01-25 21:59:25 +01:00
$form->Fields()->setForm($form);
2017-01-25 21:59:25 +01:00
$this->extend('updateEditForm', $form);
2017-01-25 21:59:25 +01:00
// Use custom reqest handler for LeftAndMain requests;
// CMS Forms cannot be identified solely by name, but also need ID (and sometimes OtherID)
$form->setRequestHandler(
LeftAndMainFormRequestHandler::create($form, [$id])
);
return $form;
2017-01-25 21:59:25 +01:00
}
public function EmptyForm()
{
$fields = new FieldList(
2017-04-20 03:15:29 +02:00
new LabelField('PageDoesntExistLabel', _t('SilverStripe\\CMS\\Controllers\\CMSMain.PAGENOTEXISTS', "This page doesn't exist"))
);
$form = parent::EmptyForm();
$form->setFields($fields);
$fields->setForm($form);
return $form;
}
/**
* Build an archive warning message based on the page's children
*
* @param SiteTree $record
* @return string
*/
/**
* Build an archive warning message based on the page's children
*
* @param SiteTree $record
* @return string
*/
protected function getArchiveWarningMessage($record)
{
// Get all page's descendants
$descendants = [];
$this->collateDescendants([$record->ID], $descendants);
if (!$descendants) {
$descendants = [];
}
// Get the IDs of all changeset including at least one of the pages.
$descendants[] = $record->ID;
$inChangeSetIDs = ChangeSetItem::get()->filter([
'ObjectID' => $descendants,
'ObjectClass' => SiteTree::class
])->column('ChangeSetID');
// Count number of affected change set
$affectedChangeSetCount = 0;
if (count($inChangeSetIDs) > 0) {
$affectedChangeSetCount = ChangeSet::get()
->filter(['ID' => $inChangeSetIDs, 'State' => ChangeSet::STATE_OPEN])
->count();
}
$numCampaigns = ChangeSet::singleton()->i18n_pluralise($affectedChangeSetCount);
$numCampaigns = mb_strtolower($numCampaigns);
if (count($descendants) > 0 && $affectedChangeSetCount > 0) {
2017-04-20 03:15:29 +02:00
$archiveWarningMsg = _t('SilverStripe\\CMS\\Controllers\\CMSMain.ArchiveWarningWithChildrenAndCampaigns', 'Warning: This page and all of its child pages will be unpublished and automatically removed from their associated {NumCampaigns} before being sent to the archive.\n\nAre you sure you want to proceed?', [ 'NumCampaigns' => $numCampaigns ]);
} elseif (count($descendants) > 0) {
2017-04-20 03:15:29 +02:00
$archiveWarningMsg = _t('SilverStripe\\CMS\\Controllers\\CMSMain.ArchiveWarningWithChildren', 'Warning: This page and all of its child pages will be unpublished before being sent to the archive.\n\nAre you sure you want to proceed?');
} elseif ($affectedChangeSetCount > 0) {
2017-04-20 03:15:29 +02:00
$archiveWarningMsg = _t('SilverStripe\\CMS\\Controllers\\CMSMain.ArchiveWarningWithCampaigns', 'Warning: This page will be unpublished and automatically removed from their associated {NumCampaigns} before being sent to the archive.\n\nAre you sure you want to proceed?', [ 'NumCampaigns' => $numCampaigns ]);
} else {
2017-04-20 03:15:29 +02:00
$archiveWarningMsg = _t('SilverStripe\\CMS\\Controllers\\CMSMain.ArchiveWarning', 'Warning: This page will be unpublished before being sent to the archive.\n\nAre you sure you want to proceed?');
}
return $archiveWarningMsg;
}
/**
* Find IDs of all descendant pages for the provided ID lists.
* @param int[] $recordIDs
* @param array $collator
* @return bool
*/
protected function collateDescendants($recordIDs, &$collator)
{
$children = SiteTree::get()->filter(['ParentID' => $recordIDs])->column();
if ($children) {
foreach ($children as $item) {
$collator[] = $item;
}
$this->collateDescendants($children, $collator);
return true;
}
return false;
}
2017-01-25 21:59:25 +01:00
/**
2017-08-21 02:45:56 +02:00
* This method exclusively handles deferred ajax requests to render the
* pages tree deferred handler (no pjax-fragment)
*
2017-12-13 02:35:21 +01:00
* @return DBHTMLText HTML response with the rendered treeview
2017-01-25 21:59:25 +01:00
*/
public function treeview()
2017-01-25 21:59:25 +01:00
{
2017-08-21 02:45:56 +02:00
return $this->renderWith($this->getTemplatesWithSuffix('_TreeView'));
2017-01-25 21:59:25 +01:00
}
2017-12-13 02:35:21 +01:00
/**
* Returns deferred listview for the current level
*
* @return DBHTMLText HTML response with the rendered listview
*/
public function listview()
2017-12-06 05:06:15 +01:00
{
return $this->renderWith($this->getTemplatesWithSuffix('_ListView'));
}
2017-01-25 21:59:25 +01:00
/**
2017-12-13 02:35:21 +01:00
* Get view state based on the current action
*
2017-07-25 00:40:58 +02:00
* @param string $default
2017-01-25 21:59:25 +01:00
* @return string
*/
2017-07-25 00:40:58 +02:00
public function ViewState($default = 'treeview')
2017-01-25 21:59:25 +01:00
{
2017-12-13 02:35:21 +01:00
$mode = $this->getRequest()->param('Action');
2017-01-25 21:59:25 +01:00
switch ($mode) {
case 'listview':
case 'treeview':
return $mode;
default:
2017-07-25 00:40:58 +02:00
return $default;
2017-01-25 21:59:25 +01:00
}
}
/**
* Callback to request the list of page types allowed under a given page instance.
* Provides a slower but more precise response over SiteTreeHints
*
* @param HTTPRequest $request
* @return HTTPResponse
*/
public function childfilter($request)
{
// Check valid parent specified
$parentID = $request->requestVar('ParentID');
$parent = SiteTree::get()->byID($parentID);
if (!$parent || !$parent->exists()) {
return $this->httpError(404);
}
// Build hints specific to this class
// Identify disallows and set globals
$classes = SiteTree::page_type_classes();
$disallowedChildren = array();
foreach ($classes as $class) {
$obj = singleton($class);
if ($obj instanceof HiddenClass) {
continue;
}
if (!$obj->canCreate(null, array('Parent' => $parent))) {
$disallowedChildren[] = $class;
}
}
$this->extend('updateChildFilter', $disallowedChildren, $parentID);
return $this
->getResponse()
->addHeader('Content-Type', 'application/json; charset=utf-8')
->setBody(Convert::raw2json($disallowedChildren));
}
/**
* Safely reconstruct a selected filter from a given set of query parameters
*
* @param array $params Query parameters to use
* @return CMSSiteTreeFilter The filter class, or null if none present
* @throws InvalidArgumentException if invalid filter class is passed.
*/
protected function getQueryFilter($params)
{
if (empty($params['FilterClass'])) {
return null;
}
$filterClass = $params['FilterClass'];
if (!is_subclass_of($filterClass, CMSSiteTreeFilter::class)) {
2017-01-25 21:59:25 +01:00
throw new InvalidArgumentException("Invalid filter class passed: {$filterClass}");
}
return $filterClass::create($params);
}
/**
* Returns the pages meet a certain criteria as {@see CMSSiteTreeFilter} or the subpages of a parent page
* defaulting to no filter and show all pages in first level.
* Doubles as search results, if any search parameters are set through {@link SearchForm()}.
*
* @param array $params Search filter criteria
* @param int $parentID Optional parent node to filter on (can't be combined with other search criteria)
* @return SS_List
* @throws InvalidArgumentException if invalid filter class is passed.
*/
public function getList($params = array(), $parentID = 0)
{
if ($filter = $this->getQueryFilter($params)) {
return $filter->getFilteredPages();
} else {
$list = DataList::create($this->config()->get('tree_class'));
2017-01-25 21:59:25 +01:00
$parentID = is_numeric($parentID) ? $parentID : 0;
return $list->filter("ParentID", $parentID);
}
}
/**
* @return Form
*/
public function ListViewForm()
{
$params = $this->getRequest()->requestVar('q');
2017-12-12 03:04:21 +01:00
$parentID = $this->getRequest()->requestVar('ParentID');
2017-08-21 02:45:56 +02:00
$list = $this->getList($params, $parentID);
2017-01-25 21:59:25 +01:00
$gridFieldConfig = GridFieldConfig::create()->addComponents(
new GridFieldSortableHeader(),
new GridFieldDataColumns(),
2017-02-16 05:51:54 +01:00
new GridFieldPaginator($this->config()->get('page_length'))
2017-01-25 21:59:25 +01:00
);
if ($parentID) {
2017-08-21 02:45:56 +02:00
$linkSpec = $this->LinkListViewChildren('%d');
2017-01-25 21:59:25 +01:00
$gridFieldConfig->addComponent(
GridFieldLevelup::create($parentID)
->setLinkSpec($linkSpec)
2017-12-06 05:06:15 +01:00
->setAttributes(array('data-pjax-target' => 'ListViewForm,Breadcrumbs'))
2017-01-25 21:59:25 +01:00
);
2017-12-12 03:04:21 +01:00
$this->setCurrentPageID($parentID);
2017-01-25 21:59:25 +01:00
}
$gridField = new GridField('Page', 'Pages', $list, $gridFieldConfig);
$gridField->setAttribute('cms-loading-ignore-url-params', true);
2017-01-25 21:59:25 +01:00
/** @var GridFieldDataColumns $columns */
$columns = $gridField->getConfig()->getComponentByType(GridFieldDataColumns::class);
2017-01-25 21:59:25 +01:00
// Don't allow navigating into children nodes on filtered lists
$fields = array(
2017-04-20 03:15:29 +02:00
'getTreeTitle' => _t('SilverStripe\\CMS\\Model\\SiteTree.PAGETITLE', 'Page Title'),
'singular_name' => _t('SilverStripe\\CMS\\Model\\SiteTree.PAGETYPE', 'Page Type'),
'LastEdited' => _t('SilverStripe\\CMS\\Model\\SiteTree.LASTUPDATED', 'Last Updated'),
2017-01-25 21:59:25 +01:00
);
/** @var GridFieldSortableHeader $sortableHeader */
$sortableHeader = $gridField->getConfig()->getComponentByType(GridFieldSortableHeader::class);
2017-01-25 21:59:25 +01:00
$sortableHeader->setFieldSorting(array('getTreeTitle' => 'Title'));
$gridField->getState()->ParentID = $parentID;
if (!$params) {
$fields = array_merge(array('listChildrenLink' => ''), $fields);
}
$columns->setDisplayFields($fields);
$columns->setFieldCasting(array(
'Created' => 'DBDatetime->Ago',
'LastEdited' => 'DBDatetime->FormatFromSettings',
'getTreeTitle' => 'HTMLFragment'
));
$controller = $this;
$columns->setFieldFormatting(array(
'listChildrenLink' => function ($value, &$item) use ($controller) {
/** @var SiteTree $item */
$num = $item ? $item->numChildren() : null;
if ($num) {
return sprintf(
'<a class="btn btn-secondary btn--no-text btn--icon-large font-icon-right-dir cms-panel-link list-children-link" data-pjax-target="ListViewForm,Breadcrumbs" href="%s"><span class="sr-only">%s child pages</span></a>',
2017-08-21 02:45:56 +02:00
$this->LinkListViewChildren((int)$item->ID),
2017-01-25 21:59:25 +01:00
$num
);
}
},
'getTreeTitle' => function ($value, &$item) use ($controller) {
$title = sprintf(
2017-01-25 21:59:25 +01:00
'<a class="action-detail" href="%s">%s</a>',
Controller::join_links(
CMSPageEditController::singleton()->Link('show'),
(int)$item->ID
),
$item->TreeTitle // returns HTML, does its own escaping
);
$breadcrumbs = $item->Breadcrumbs(20, true, false, true, '/');
// Remove item's tile
$breadcrumbs = preg_replace('/[^\/]+$/', '', trim($breadcrumbs));
// Trim spaces around delimiters
$breadcrumbs = preg_replace('/\s?\/\s?/', '/', trim($breadcrumbs));
return $title . sprintf('<p class="small cms-list__item-breadcrumbs">%s</p>', $breadcrumbs);
2017-01-25 21:59:25 +01:00
}
));
$negotiator = $this->getResponseNegotiator();
$listview = Form::create(
$this,
'ListViewForm',
new FieldList($gridField),
new FieldList()
)->setHTMLID('Form_ListViewForm');
$listview->setAttribute('data-pjax-fragment', 'ListViewForm');
$listview->setValidationResponseCallback(function (ValidationResult $errors) use ($negotiator, $listview) {
$request = $this->getRequest();
if ($request->isAjax() && $negotiator) {
$result = $listview->forTemplate();
return $negotiator->respond($request, array(
'CurrentForm' => function () use ($result) {
return $result;
}
));
}
});
$this->extend('updateListView', $listview);
$listview->disableSecurityToken();
return $listview;
}
public function currentPageID()
{
$id = parent::currentPageID();
$this->extend('updateCurrentPageID', $id);
return $id;
}
//------------------------------------------------------------------------------------------//
// Data saving handlers
/**
* Save and Publish page handler
*
* @param array $data
* @param Form $form
* @return HTTPResponse
* @throws HTTPResponse_Exception
*/
public function save($data, $form)
{
$className = $this->config()->get('tree_class');
2017-01-25 21:59:25 +01:00
// Existing or new record?
$id = $data['ID'];
if (substr($id, 0, 3) != 'new') {
/** @var SiteTree $record */
$record = DataObject::get_by_id($className, $id);
// Check edit permissions
if ($record && !$record->canEdit()) {
return Security::permissionFailure($this);
}
if (!$record || !$record->ID) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
} else {
if (!$className::singleton()->canCreate()) {
return Security::permissionFailure($this);
}
$record = $this->getNewItem($id, false);
}
// Check publishing permissions
$doPublish = !empty($data['publish']);
if ($record && $doPublish && !$record->canPublish()) {
return Security::permissionFailure($this);
}
// TODO Coupling to SiteTree
$record->HasBrokenLink = 0;
$record->HasBrokenFile = 0;
if (!$record->ObsoleteClassName) {
$record->writeWithoutVersion();
}
// Update the class instance if necessary
if (isset($data['ClassName']) && $data['ClassName'] != $record->ClassName) {
// Replace $record with a new instance of the new class
$newClassName = $data['ClassName'];
$record = $record->newClassInstance($newClassName);
}
// save form data into record
$form->saveInto($record);
$record->write();
// If the 'Publish' button was clicked, also publish the page
2017-01-25 21:59:25 +01:00
if ($doPublish) {
$record->publishRecursive();
$message = _t(
__CLASS__ . '.PUBLISHED',
2017-01-25 21:59:25 +01:00
"Published '{title}' successfully.",
['title' => $record->Title]
);
} else {
$message = _t(
__CLASS__ . '.SAVED',
2017-01-25 21:59:25 +01:00
"Saved '{title}' successfully.",
['title' => $record->Title]
);
}
$this->getResponse()->addHeader('X-Status', rawurlencode($message));
return $this->getResponseNegotiator()->respond($this->getRequest());
}
/**
* @uses LeftAndMainExtension->augmentNewSiteTreeItem()
*
* @param int|string $id
* @param bool $setID
* @return mixed|DataObject
* @throws HTTPResponse_Exception
*/
public function getNewItem($id, $setID = true)
{
$parentClass = $this->config()->get('tree_class');
2017-06-08 08:02:18 +02:00
list(, $className, $parentID) = array_pad(explode('-', $id), 3, null);
2017-01-25 21:59:25 +01:00
if (!is_a($className, $parentClass, true)) {
$response = Security::permissionFailure($this);
if (!$response) {
$response = $this->getResponse();
}
throw new HTTPResponse_Exception($response);
}
/** @var SiteTree $newItem */
$newItem = Injector::inst()->create($className);
$newItem->Title = _t(
__CLASS__ . '.NEWPAGE',
2017-01-25 21:59:25 +01:00
"New {pagetype}",
'followed by a page type title',
array('pagetype' => singleton($className)->i18n_singular_name())
);
$newItem->ClassName = $className;
$newItem->ParentID = $parentID;
// DataObject::fieldExists only checks the current class, not the hierarchy
// This allows the CMS to set the correct sort value
if ($newItem->castingHelper('Sort')) {
2017-06-08 08:02:18 +02:00
$maxSort = DB::prepared_query(
'SELECT MAX("Sort") FROM "SiteTree" WHERE "ParentID" = ?',
array($parentID)
)->value();
$newItem->Sort = (int)$maxSort + 1;
2017-01-25 21:59:25 +01:00
}
2017-06-08 08:02:18 +02:00
if ($setID && $id) {
2017-01-25 21:59:25 +01:00
$newItem->ID = $id;
}
# Some modules like subsites add extra fields that need to be set when the new item is created
$this->extend('augmentNewSiteTreeItem', $newItem);
return $newItem;
}
/**
* Actually perform the publication step
*
* @param Versioned|DataObject $record
* @return mixed
*/
public function performPublish($record)
{
if ($record && !$record->canPublish()) {
return Security::permissionFailure($this);
}
$record->publishRecursive();
}
/**
* Reverts a page by publishing it to live.
* Use {@link restorepage()} if you want to restore a page
* which was deleted from draft without publishing.
*
* @uses SiteTree->doRevertToLive()
*
* @param array $data
* @param Form $form
* @return HTTPResponse
* @throws HTTPResponse_Exception
*/
public function revert($data, $form)
{
if (!isset($data['ID'])) {
throw new HTTPResponse_Exception("Please pass an ID in the form content", 400);
}
$id = (int) $data['ID'];
$restoredPage = Versioned::get_latest_version(SiteTree::class, $id);
if (!$restoredPage) {
throw new HTTPResponse_Exception("SiteTree #$id not found", 400);
}
/** @var SiteTree $record */
$record = Versioned::get_one_by_stage(SiteTree::class, Versioned::LIVE, array(
2017-01-25 21:59:25 +01:00
'"SiteTree_Live"."ID"' => $id
));
// a user can restore a page without publication rights, as it just adds a new draft state
// (this action should just be available when page has been "deleted from draft")
if ($record && !$record->canEdit()) {
return Security::permissionFailure($this);
}
if (!$record || !$record->ID) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
$record->doRevertToLive();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.RESTORED',
2017-01-25 21:59:25 +01:00
"Restored '{title}' successfully",
'Param {title} is a title',
2017-01-25 21:59:25 +01:00
array('title' => $record->Title)
))
);
return $this->getResponseNegotiator()->respond($this->getRequest());
}
/**
* Delete the current page from draft stage.
*
* @see deletefromlive()
*
* @param array $data
* @param Form $form
* @return HTTPResponse
* @throws HTTPResponse_Exception
*/
public function delete($data, $form)
{
$id = $data['ID'];
$record = SiteTree::get()->byID($id);
if ($record && !$record->canDelete()) {
return Security::permissionFailure();
}
if (!$record || !$record->ID) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
// Delete record
$record->delete();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.REMOVEDPAGEFROMDRAFT',
"Removed '{title}' from the draft site",
['title' => $record->Title]
))
2017-01-25 21:59:25 +01:00
);
// Even if the record has been deleted from stage and live, it can be viewed in "archive mode"
return $this->getResponseNegotiator()->respond($this->getRequest());
}
/**
* Delete this page from both live and stage
*
* @param array $data
* @param Form $form
* @return HTTPResponse
* @throws HTTPResponse_Exception
*/
public function archive($data, $form)
{
$id = $data['ID'];
/** @var SiteTree $record */
$record = SiteTree::get()->byID($id);
if (!$record || !$record->exists()) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
if (!$record->canArchive()) {
return Security::permissionFailure();
}
// Archive record
$record->doArchive();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.ARCHIVEDPAGE',
"Archived page '{title}'",
['title' => $record->Title]
))
2017-01-25 21:59:25 +01:00
);
// Even if the record has been deleted from stage and live, it can be viewed in "archive mode"
return $this->getResponseNegotiator()->respond($this->getRequest());
}
public function publish($data, $form)
{
$data['publish'] = '1';
return $this->save($data, $form);
}
public function unpublish($data, $form)
{
$className = $this->config()->get('tree_class');
2017-01-25 21:59:25 +01:00
/** @var SiteTree $record */
$record = DataObject::get_by_id($className, $data['ID']);
if ($record && !$record->canUnpublish()) {
return Security::permissionFailure($this);
}
if (!$record || !$record->ID) {
throw new HTTPResponse_Exception("Bad record ID #" . (int)$data['ID'], 404);
}
$record->doUnpublish();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.REMOVEDPAGE',
"Removed '{title}' from the published site",
['title' => $record->Title]
))
2017-01-25 21:59:25 +01:00
);
return $this->getResponseNegotiator()->respond($this->getRequest());
}
/**
* @return HTTPResponse
*/
public function rollback()
{
return $this->doRollback(array(
'ID' => $this->currentPageID(),
'Version' => $this->getRequest()->param('VersionID')
), null);
}
/**
* Rolls a site back to a given version ID
*
* @param array $data
* @param Form $form
* @return HTTPResponse
*/
public function doRollback($data, $form)
{
$this->extend('onBeforeRollback', $data['ID'], $data['Version']);
2017-01-25 21:59:25 +01:00
$id = (isset($data['ID'])) ? (int) $data['ID'] : null;
$version = (isset($data['Version'])) ? (int) $data['Version'] : null;
/** @var DataObject|Versioned $record */
$record = Versioned::get_latest_version($this->config()->get('tree_class'), $id);
2017-01-25 21:59:25 +01:00
if ($record && !$record->canEdit()) {
return Security::permissionFailure($this);
}
if ($version) {
$record->doRollbackTo($version);
$message = _t(
__CLASS__ . '.ROLLEDBACKVERSIONv2',
"Rolled back to version #{version}.",
2017-01-25 21:59:25 +01:00
array('version' => $data['Version'])
);
} else {
$record->doRevertToLive();
$message = _t(
__CLASS__ . '.ROLLEDBACKPUBv2',
2017-01-25 21:59:25 +01:00
"Rolled back to published version."
);
}
$this->getResponse()->addHeader('X-Status', rawurlencode($message));
// Can be used in different contexts: In normal page edit view, in which case the redirect won't have any effect.
// Or in history view, in which case a revert causes the CMS to re-load the edit view.
// The X-Pjax header forces a "full" content refresh on redirect.
$url = Controller::join_links(CMSPageEditController::singleton()->Link('show'), $record->ID);
$this->getResponse()->addHeader('X-ControllerURL', $url);
$this->getRequest()->addHeader('X-Pjax', 'Content');
$this->getResponse()->addHeader('X-Pjax', 'Content');
return $this->getResponseNegotiator()->respond($this->getRequest());
}
/**
* Batch Actions Handler
*/
public function batchactions()
{
return new CMSBatchActionHandler($this, 'batchactions');
}
public function BatchActionParameters()
{
$batchActions = CMSBatchActionHandler::config()->batch_actions;
$forms = array();
foreach ($batchActions as $urlSegment => $batchAction) {
$SNG_action = singleton($batchAction);
if ($SNG_action->canView() && $fieldset = $SNG_action->getParameterFields()) {
$formHtml = '';
/** @var FormField $field */
foreach ($fieldset as $field) {
$formHtml .= $field->Field();
}
$forms[$urlSegment] = $formHtml;
}
}
$pageHtml = '';
foreach ($forms as $urlSegment => $html) {
$pageHtml .= "<div class=\"params\" id=\"BatchActionParameters_$urlSegment\">$html</div>\n\n";
}
return new LiteralField("BatchActionParameters", '<div id="BatchActionParameters" style="display:none">'.$pageHtml.'</div>');
}
/**
* Returns a list of batch actions
*/
public function BatchActionList()
{
return $this->batchactions()->batchActionList();
}
public function publishall($request)
{
if (!Permission::check('ADMIN')) {
return Security::permissionFailure($this);
}
2017-06-20 07:12:07 +02:00
Environment::increaseTimeLimitTo();
Environment::increaseMemoryLimitTo();
2017-01-25 21:59:25 +01:00
$response = "";
if (isset($this->requestParams['confirm'])) {
// Protect against CSRF on destructive action
if (!SecurityToken::inst()->checkRequest($request)) {
return $this->httpError(400);
}
$start = 0;
$pages = SiteTree::get()->limit("$start,30");
$count = 0;
while ($pages) {
/** @var SiteTree $page */
foreach ($pages as $page) {
if ($page && !$page->canPublish()) {
return Security::permissionFailure($this);
}
$page->publishRecursive();
$page->destroy();
unset($page);
$count++;
$response .= "<li>$count</li>";
}
if ($pages->count() > 29) {
$start += 30;
$pages = SiteTree::get()->limit("$start,30");
} else {
break;
}
}
$response .= _t(__CLASS__ . '.PUBPAGES', "Done: Published {count} pages", array('count' => $count));
2017-01-25 21:59:25 +01:00
} else {
$token = SecurityToken::inst();
$fields = new FieldList();
$token->updateFieldSet($fields);
$tokenField = $fields->first();
$tokenHtml = ($tokenField) ? $tokenField->FieldHolder() : '';
$publishAllDescription = _t(
__CLASS__ . '.PUBALLFUN2',
2017-01-25 21:59:25 +01:00
'Pressing this button will do the equivalent of going to every page and pressing "publish". '
. 'It\'s intended to be used after there have been massive edits of the content, such as when '
. 'the site was first built.'
);
$response .= '<h1>' . _t(__CLASS__ . '.PUBALLFUN', '"Publish All" functionality') . '</h1>
2016-12-05 22:58:26 +01:00
<p>' . $publishAllDescription . '</p>
<form method="post" action="publishall">
<input type="submit" name="confirm" value="'
. _t(__CLASS__ . '.PUBALLCONFIRM', "Please publish every page in the site, copying content stage to live", 'Confirmation button') .'" />'
2017-01-25 21:59:25 +01:00
. $tokenHtml .
'</form>';
}
return $response;
}
/**
* Restore a completely deleted page from the SiteTree_versions table.
*
* @param array $data
* @param Form $form
* @return HTTPResponse
*/
public function restore($data, $form)
{
if (!isset($data['ID']) || !is_numeric($data['ID'])) {
return new HTTPResponse("Please pass an ID in the form content", 400);
}
$id = (int)$data['ID'];
/** @var SiteTree $restoredPage */
$restoredPage = Versioned::get_latest_version(SiteTree::class, $id);
if (!$restoredPage) {
return new HTTPResponse("SiteTree #$id not found", 400);
}
$restoredPage = $restoredPage->doRestoreToStage();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.RESTORED',
2017-01-25 21:59:25 +01:00
"Restored '{title}' successfully",
array('title' => $restoredPage->Title)
))
);
return $this->getResponseNegotiator()->respond($this->getRequest());
}
public function duplicate($request)
{
// Protect against CSRF on destructive action
if (!SecurityToken::inst()->checkRequest($request)) {
return $this->httpError(400);
}
if (($id = $this->urlParams['ID']) && is_numeric($id)) {
/** @var SiteTree $page */
$page = SiteTree::get()->byID($id);
if ($page && (!$page->canEdit() || !$page->canCreate(null, array('Parent' => $page->Parent())))) {
return Security::permissionFailure($this);
}
if (!$page || !$page->ID) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
$newPage = $page->duplicate();
// ParentID can be hard-set in the URL. This is useful for pages with multiple parents
if (isset($_GET['parentID']) && is_numeric($_GET['parentID'])) {
$newPage->ParentID = $_GET['parentID'];
$newPage->write();
}
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.DUPLICATED',
2017-01-25 21:59:25 +01:00
"Duplicated '{title}' successfully",
array('title' => $newPage->Title)
))
);
$url = Controller::join_links(CMSPageEditController::singleton()->Link('show'), $newPage->ID);
$this->getResponse()->addHeader('X-ControllerURL', $url);
$this->getRequest()->addHeader('X-Pjax', 'Content');
$this->getResponse()->addHeader('X-Pjax', 'Content');
return $this->getResponseNegotiator()->respond($this->getRequest());
} else {
return new HTTPResponse("CMSMain::duplicate() Bad ID: '$id'", 400);
}
}
public function duplicatewithchildren($request)
{
// Protect against CSRF on destructive action
if (!SecurityToken::inst()->checkRequest($request)) {
return $this->httpError(400);
}
2017-06-20 07:12:07 +02:00
Environment::increaseTimeLimitTo();
2017-01-25 21:59:25 +01:00
if (($id = $this->urlParams['ID']) && is_numeric($id)) {
/** @var SiteTree $page */
$page = SiteTree::get()->byID($id);
if ($page && (!$page->canEdit() || !$page->canCreate(null, array('Parent' => $page->Parent())))) {
return Security::permissionFailure($this);
}
if (!$page || !$page->ID) {
throw new HTTPResponse_Exception("Bad record ID #$id", 404);
}
$newPage = $page->duplicateWithChildren();
$this->getResponse()->addHeader(
'X-Status',
rawurlencode(_t(
__CLASS__ . '.DUPLICATEDWITHCHILDREN',
2017-01-25 21:59:25 +01:00
"Duplicated '{title}' and children successfully",
array('title' => $newPage->Title)
))
);
$url = Controller::join_links(CMSPageEditController::singleton()->Link('show'), $newPage->ID);
$this->getResponse()->addHeader('X-ControllerURL', $url);
$this->getRequest()->addHeader('X-Pjax', 'Content');
$this->getResponse()->addHeader('X-Pjax', 'Content');
return $this->getResponseNegotiator()->respond($this->getRequest());
} else {
return new HTTPResponse("CMSMain::duplicatewithchildren() Bad ID: '$id'", 400);
}
}
public function providePermissions()
{
$title = CMSPagesController::menu_title();
return array(
"CMS_ACCESS_CMSMain" => array(
'name' => _t(__CLASS__ . '.ACCESS', "Access to '{title}' section", array('title' => $title)),
2017-04-20 03:15:29 +02:00
'category' => _t('SilverStripe\\Security\\Permission.CMS_ACCESS_CATEGORY', 'CMS Access'),
2017-01-25 21:59:25 +01:00
'help' => _t(
__CLASS__ . '.ACCESS_HELP',
2017-01-25 21:59:25 +01:00
'Allow viewing of the section containing page tree and content. View and edit permissions can be handled through page specific dropdowns, as well as the separate "Content permissions".'
),
'sort' => -99 // below "CMS_ACCESS_LeftAndMain", but above everything else
)
);
}
/**
* Get title for root CMS node
*
* @return string
*/
protected function getCMSTreeTitle()
{
$rootTitle = SiteConfig::current_site_config()->Title;
$this->extend('updateCMSTreeTitle', $rootTitle);
return $rootTitle;
}
2017-11-30 03:56:16 +01:00
/**
* Cache key for SiteTreeHints() method
*
* @param $memberID
* @return string
*/
2017-11-30 03:56:16 +01:00
protected function generateHintsCacheKey($memberID)
{
return md5($memberID . '_' . __CLASS__);
2017-11-30 03:56:16 +01:00
}
/**
* Clear the cache on ?flush
*/
public static function flush()
{
CMSMain::singleton()->clearCache();
2017-11-30 03:56:16 +01:00
}
/**
* Flush the hints cache for a specific member
*
* @param array $memberIDs
2017-11-30 03:56:16 +01:00
*/
public function flushMemberCache($memberIDs = null)
{
$cache = $this->getHintsCache();
if (!$memberIDs) {
$cache->clear();
return;
2017-11-30 03:56:16 +01:00
}
foreach ($memberIDs as $memberID) {
$key = $this->generateHintsCacheKey($memberID);
$cache->delete($key);
}
2017-11-30 03:56:16 +01:00
}
}