2007-07-19 12:40:05 +02:00
< ? php
2016-06-16 06:57:19 +02:00
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 ;
2016-08-23 04:36:06 +02:00
use SilverStripe\Admin\AdminRootController ;
use SilverStripe\Admin\CMSBatchActionHandler ;
use SilverStripe\Admin\LeftAndMain ;
2017-08-21 02:45:56 +02:00
use SilverStripe\Admin\LeftAndMainFormRequestHandler ;
2016-10-25 02:22:31 +02:00
use SilverStripe\CMS\BatchActions\CMSBatchAction_Archive ;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Publish ;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Restore ;
use SilverStripe\CMS\BatchActions\CMSBatchAction_Unpublish ;
2016-08-23 04:36:06 +02:00
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 ;
2016-08-23 04:36:06 +02:00
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 ;
2016-08-23 04:36:06 +02:00
use SilverStripe\Core\Convert ;
2017-08-21 02:45:56 +02:00
use SilverStripe\Core\Environment ;
2016-08-23 04:36:06 +02:00
use SilverStripe\Core\Injector\Injector ;
2017-10-18 01:32:08 +02:00
use SilverStripe\Core\Manifest\ModuleResource ;
2017-10-10 06:03:22 +02:00
use SilverStripe\Core\Manifest\ModuleResourceLoader ;
2016-08-23 04:36:06 +02:00
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 ;
2016-08-23 04:36:06 +02:00
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 ;
2016-08-23 04:36:06 +02:00
use SilverStripe\Forms\TextField ;
2016-06-16 06:57:19 +02:00
use SilverStripe\ORM\ArrayList ;
2017-08-21 02:45:56 +02:00
use SilverStripe\ORM\CMSPreviewable ;
2016-06-16 06:57:19 +02:00
use SilverStripe\ORM\DataList ;
2016-08-23 04:36:06 +02:00
use SilverStripe\ORM\DataObject ;
2016-06-16 06:57:19 +02:00
use SilverStripe\ORM\DB ;
2016-10-21 05:15:34 +02:00
use SilverStripe\ORM\FieldType\DBHTMLText ;
2016-08-23 04:36:06 +02:00
use SilverStripe\ORM\HiddenClass ;
2017-04-06 07:38:15 +02:00
use SilverStripe\ORM\Hierarchy\MarkedSet ;
2016-08-23 04:36:06 +02:00
use SilverStripe\ORM\SS_List ;
2016-12-09 04:00:46 +01:00
use SilverStripe\ORM\ValidationResult ;
2017-05-12 02:47:46 +02:00
use SilverStripe\Security\InheritedPermissions ;
2016-06-23 01:51:20 +02:00
use SilverStripe\Security\Member ;
use SilverStripe\Security\Permission ;
use SilverStripe\Security\PermissionProvider ;
2016-08-23 04:36:06 +02:00
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 ;
2016-08-23 04:36:06 +02:00
use SilverStripe\View\ArrayData ;
use SilverStripe\View\Requirements ;
2016-07-22 01:32:32 +02:00
use Translatable ;
2016-08-23 04:36:06 +02:00
2007-07-19 12:40:05 +02:00
/**
* The main " content " area of the CMS .
2011-08-19 02:32:31 +02:00
*
2007-07-19 12:40:05 +02:00
* This class creates a 2 - frame layout - left - tree and right - form - to sit beneath the main
* admin menu .
2015-08-14 02:39:45 +02:00
*
2007-07-19 12:40:05 +02:00
* @ todo Create some base classes to contain the generic functionality that will be replicated .
2016-08-11 04:10:51 +02:00
*
* @ mixin LeftAndMainPageIconsExtension
2007-07-19 12:40:05 +02:00
*/
2017-01-25 21:59:25 +01:00
class CMSMain extends LeftAndMain implements CurrentPageIdentifier , PermissionProvider
{
2017-09-07 02:36:26 +02: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 ;
2017-03-29 06:19:57 +02:00
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' ,
2017-03-29 06:19:57 +02:00
'savetreenode' ,
'getsubtree' ,
'updatetreenodes' ,
2017-01-25 21:59:25 +01:00
'batchactions' ,
'treeview' ,
'listview' ,
'ListViewForm' ,
'childfilter' ,
);
2017-03-29 06:19:57 +02:00
private static $url_handlers = [
'EditForm/$ID' => 'EditForm' ,
2017-08-21 02:45:56 +02:00
'listview/$ParentID' => 'listview' ,
2017-03-29 06:19:57 +02:00
];
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' ,
);
protected function init ()
{
// set reading lang
if ( SiteTree :: has_extension ( 'Translatable' ) && ! $this -> getRequest () -> isAjax ()) {
2017-09-20 03:51:07 +02:00
Translatable :: choose_site_locale ( array_keys ( Translatable :: get_existing_content_languages ( SiteTree :: class )));
2017-01-25 21:59:25 +01:00
}
parent :: init ();
2017-06-28 00:17:09 +02:00
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' );
2017-09-07 02:36:26 +02:00
Requirements :: customCSS ( $this -> generatePageIconsCss (), self :: PAGE_ICONS_ID );
2017-06-28 00:17:09 +02:00
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 (),
2017-08-22 23:46:46 +02:00
$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)
2017-08-24 06:17:10 +02:00
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 )
{
return $this -> LinkWithSearch ( Controller :: join_links (
CMSMain :: singleton () -> Link ( 'listview' ),
$parentID
));
}
/**
* Link to lazy - load deferred tree view
*
* @ return string
*/
public function LinkTreeViewDeferred ()
{
2017-09-04 05:37:47 +02:00
return $this -> Link ( 'treeview' );
2017-08-21 02:45:56 +02:00
}
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 ;
}
}
2017-07-16 12:46:11 +02:00
/**
2017-07-18 03:19:04 +02:00
* 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 .
2017-07-16 12:46:11 +02:00
*
* @ return string
*/
2017-07-18 03:19:04 +02:00
public function getTabIdentifier ()
2017-07-16 12:46:11 +02:00
{
return 'edit' ;
}
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
2017-03-29 06:19:57 +02:00
Versioned :: prepopulate_versionnumber_cache ( SiteTree :: class , Versioned :: DRAFT );
Versioned :: prepopulate_versionnumber_cache ( SiteTree :: class , Versioned :: LIVE );
2017-08-22 23:46:46 +02:00
$html = $this -> getSiteTreeFor ( $this -> config () -> get ( 'tree_class' ));
2017-01-25 21:59:25 +01:00
$this -> extend ( 'updateSiteTreeAsUL' , $html );
return $html ;
}
2017-03-29 06:19:57 +02:00
/**
* 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 = 30
) {
2017-04-06 07:38:15 +02:00
// Provide better defaults from filter
2017-03-29 06:19:57 +02:00
$filter = $this -> getSearchFilter ();
2017-04-06 07:38:15 +02:00
if ( $filter ) {
2017-04-22 01:44:49 +02:00
if ( ! $childrenMethod ) {
2017-04-06 07:38:15 +02:00
$childrenMethod = $filter -> getChildrenMethod ();
2017-04-22 01:44:49 +02:00
}
if ( ! $numChildrenMethod ) {
2017-03-29 06:19:57 +02:00
$numChildrenMethod = $filter -> getNumChildrenMethod ();
}
2017-04-06 07:38:15 +02:00
if ( ! $filterFunction ) {
2017-04-22 01:44:49 +02:00
$filterFunction = function ( $node ) use ( $filter ) {
return $filter -> isPageIncluded ( $node );
};
}
2017-04-06 07:38:15 +02:00
}
2017-03-29 06:19:57 +02:00
2017-04-06 07:38:15 +02:00
// Build set from node and begin marking
2017-03-29 06:19:57 +02:00
$record = ( $rootID ) ? $this -> getRecord ( $rootID ) : null ;
2017-04-06 07:38:15 +02:00
$rootNode = $record ? $record : DataObject :: singleton ( $className );
$markingSet = MarkedSet :: create ( $rootNode , $childrenMethod , $numChildrenMethod , $nodeCountThreshold );
2017-03-29 06:19:57 +02:00
2017-04-06 07:38:15 +02:00
// Set filter function
2017-03-29 06:19:57 +02:00
if ( $filterFunction ) {
2017-04-06 07:38:15 +02:00
$markingSet -> setMarkingFilterFunction ( $filterFunction );
2017-03-29 06:19:57 +02:00
}
2017-04-06 07:38:15 +02:00
// Mark tree from this node
$markingSet -> markPartialTree ();
2017-03-29 06:19:57 +02:00
// Ensure current page is exposed
2017-04-06 07:38:15 +02:00
$currentPage = $this -> currentPage ();
2017-03-29 06:19:57 +02:00
if ( $currentPage ) {
2017-04-06 07:38:15 +02:00
$markingSet -> markToExpose ( $currentPage );
2017-03-29 06:19:57 +02:00
}
2017-04-06 07:38:15 +02:00
// Pre-cache permissions
2017-05-12 02:47:46 +02:00
$checker = SiteTree :: getPermissionChecker ();
if ( $checker instanceof InheritedPermissions ) {
$checker -> prePopulatePermissionCache (
InheritedPermissions :: EDIT ,
$markingSet -> markedNodeIDs ()
);
}
2017-03-29 06:19:57 +02:00
2017-04-06 07:38:15 +02:00
// 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 ) {
2017-04-06 07:38:15 +02:00
return [
2017-08-21 02:45:56 +02:00
'listViewLink' => $this -> LinkListViewChildren ( $node -> ID ),
2017-04-06 07:38:15 +02:00
'rootTitle' => $rootTitle ,
'extraClass' => $this -> getTreeNodeClasses ( $node ),
];
2017-04-22 01:44:49 +02:00
};
}
2017-03-29 06:19:57 +02:00
2017-04-06 07:38:15 +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 ;
2017-03-29 06:19:57 +02:00
}
2017-04-06 07:38:15 +02:00
}
2017-03-29 06:19:57 +02:00
2017-04-06 07:38:15 +02:00
// Get additional filter classes
$filter = $this -> getSearchFilter ();
if ( $filter && ( $filterClasses = $filter -> getPageClasses ( $node ))) {
if ( is_array ( $filterClasses )) {
$filterClasses = implode ( ' ' , $filterClasses );
}
$classes .= ' ' . $filterClasses ;
2017-03-29 06:19:57 +02:00
}
2017-04-06 07:38:15 +02:00
return trim ( $classes );
2017-03-29 06:19:57 +02:00
}
/**
* 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 (
2017-08-22 23:46:46 +02:00
$this -> config () -> get ( 'tree_class' ),
2017-03-29 06:19:57 +02:00
$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
}
2017-04-06 07:38:15 +02:00
// Create marking set with sole marked root
$markingSet = MarkedSet :: create ( $record );
$markingSet -> setMarkingFilterFunction ( function () {
return false ;
});
$markingSet -> markUnexpanded ( $record );
2017-03-29 06:19:57 +02:00
// 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 ;
2017-08-22 23:46:46 +02:00
$className = $this -> config () -> get ( 'tree_class' );
2017-03-29 06:19:57 +02:00
$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 ();
}
2017-04-06 07:38:15 +02:00
// Render using single node template
$html = $markingSet -> renderChildren (
[ self :: class . '_TreeNode' , 'type' => 'Includes' ],
$this -> getTreeNodeCustomisations ()
);
2017-03-29 06:19:57 +02:00
$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' ,
2017-03-29 06:19:57 +02:00
" You do not have permission to rearange the site tree. Your change was not saved. "
)
);
}
2017-08-22 23:46:46 +02:00
$className = $this -> config () -> get ( 'tree_class' );
2017-03-29 06:19:57 +02:00
$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' ,
2017-03-29 06:19:57 +02:00
" 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' ,
2017-03-29 06:19:57 +02:00
" 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.' ))
2017-03-29 06:19:57 +02:00
);
}
// 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.' ))
2017-03-29 06:19:57 +02:00
);
}
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' );
if ( ! $query || ( count ( $query ) === 1 && isset ( $query [ 'FilterClass' ]) && $query [ 'FilterClass' ] === 'SilverStripe\\CMS\\Controllers\\CMSSiteTreeFilter_Search' )) {
return false ;
}
return true ;
}
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
// view mode
2017-07-25 00:40:58 +02:00
$viewMode = HiddenField :: create ( 'view' , false , $this -> ViewState ( 'listview' ));
2017-01-25 21:59:25 +01:00
// Create the Field list
$fields = new FieldList (
$content ,
$pageFilter ,
$pageClasses ,
$dateGroup ,
$viewMode
);
// 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' ),
2017-05-09 01:11:08 +02:00
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' )
2017-08-23 05:09:21 +02:00
-> 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 ());
}
2017-08-24 07:09:34 +02:00
/**
* 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 )
{
2017-08-24 07:09:34 +02:00
$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 ()
)));
return $items ;
}
2017-01-25 21:59:25 +01:00
2017-08-24 07:09:34 +02: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
}
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 ();
$cacheCanCreate = array ();
foreach ( $classes as $class ) {
$cacheCanCreate [ $class ] = singleton ( $class ) -> canCreate ();
}
// Generate basic cache key. Too complex to encompass all variations
2017-02-22 02:34:07 +01:00
$cache = Injector :: inst () -> get ( CacheInterface :: class . '.CMSMain_SiteTreeHints' );
2017-05-21 05:15:00 +02:00
$cacheKey = md5 ( implode ( '_' , array ( Security :: getCurrentUser () -> ID , implode ( ',' , $cacheCanCreate ), implode ( ',' , $classes ))));
2017-01-25 21:59:25 +01:00
if ( $this -> getRequest () -> getVar ( 'flush' )) {
2017-02-22 02:34:07 +01:00
$cache -> clear ();
2017-01-25 21:59:25 +01:00
}
2017-02-22 02:34:07 +01:00
$json = $cache -> get ( $cacheKey );
2017-01-25 21:59:25 +01:00
if ( ! $json ) {
$def [ 'Root' ] = array ();
$def [ 'Root' ][ 'disallowedChildren' ] = array ();
// Contains all possible classes to support UI controls listing them all,
// such as the "add page here" context menu.
$def [ 'All' ] = array ();
// Identify disallows and set globals
foreach ( $classes as $class ) {
$obj = singleton ( $class );
if ( $obj instanceof HiddenClass ) {
continue ;
}
// Name item
$def [ 'All' ][ $class ] = array (
'title' => $obj -> i18n_singular_name ()
);
// Check if can be created at the root
2017-08-22 23:46:46 +02:00
$needsPerm = $obj -> config () -> get ( 'need_permission' );
if ( ! $obj -> config () -> get ( 'can_be_root' )
2017-01-25 21:59:25 +01:00
|| ( ! array_key_exists ( $class , $cacheCanCreate ) || ! $cacheCanCreate [ $class ])
|| ( $needsPerm && ! $this -> can ( $needsPerm ))
) {
$def [ 'Root' ][ 'disallowedChildren' ][] = $class ;
}
// Hint data specific to the class
$def [ $class ] = array ();
$defaultChild = $obj -> defaultChild ();
if ( $defaultChild !== 'Page' && $defaultChild !== null ) {
$def [ $class ][ 'defaultChild' ] = $defaultChild ;
}
$defaultParent = $obj -> defaultParent ();
if ( $defaultParent !== 1 && $defaultParent !== null ) {
$def [ $class ][ 'defaultParent' ] = $defaultParent ;
}
}
$this -> extend ( 'updateSiteTreeHints' , $def );
$json = Convert :: raw2json ( $def );
2017-02-22 02:34:07 +01:00
$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 )
{
2017-03-29 06:19:57 +02:00
if ( ! $id ) {
return null ;
}
2017-08-22 23:46:46 +02:00
$treeClass = $this -> config () -> get ( 'tree_class' );
2017-01-25 21:59:25 +01:00
if ( $id instanceof $treeClass ) {
return $id ;
2017-03-29 06:19:57 +02:00
}
if ( substr ( $id , 0 , 3 ) == 'new' ) {
return $this -> getNewItem ( $id );
}
if ( ! is_numeric ( $id )) {
return null ;
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02:00
$currentStage = Versioned :: get_reading_mode ();
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02:00
if ( $this -> getRequest () -> getVar ( 'Version' )) {
$versionID = ( int ) $this -> getRequest () -> getVar ( 'Version' );
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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
2017-03-29 06:19:57 +02: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
2017-03-29 06:19:57 +02:00
$record = DataObject :: get_by_id ( $treeClass , $id );
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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
}
2017-03-29 06:19:57 +02: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 )
{
2017-03-29 06:19:57 +02:00
// Get record
2017-01-25 21:59:25 +01:00
if ( ! $id ) {
$id = $this -> currentPageID ();
}
2017-03-29 06:19:57 +02:00
/** @var SiteTree $record */
2017-01-25 21:59:25 +01:00
$record = $this -> getRecord ( $id );
2017-03-29 06:19:57 +02:00
// 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 ();
}
2017-03-31 05:34:42 +02:00
2017-03-29 06:19:57 +02:00
// 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-03-29 06:19:57 +02:00
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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
2017-03-29 06:19:57 +02: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-03-29 06:19:57 +02:00
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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-03-29 06:19:57 +02:00
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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
2017-03-29 06:19:57 +02: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
2017-03-29 06:19:57 +02:00
if ( ! $record -> canEdit () || $deletedFromStage ) {
$readonlyFields = $form -> Fields () -> makeReadonly ();
$form -> setFields ( $readonlyFields );
}
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02:00
$form -> Fields () -> setForm ( $form );
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02:00
$this -> extend ( 'updateEditForm' , $form );
2017-01-25 21:59:25 +01:00
2017-03-29 06:19:57 +02: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
}
2017-03-29 06:19:57 +02: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 " ))
2017-03-29 06:19:57 +02:00
);
$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
*/
2017-04-04 01:44:41 +02:00
protected function getArchiveWarningMessage ( $record )
{
// Get all page's descendants
$record -> collateDescendants ( true , $descendants );
if ( ! $descendants ) {
$descendants = [];
}
// Get all campaigns that the page and its descendants belong to
$inChangeSetIDs = ChangeSetItem :: get_for_object ( $record ) -> column ( 'ChangeSetID' );
foreach ( $descendants as $page ) {
$inChangeSetIDs = array_merge ( $inChangeSetIDs , ChangeSetItem :: get_for_object ( $page ) -> column ( 'ChangeSetID' ));
}
if ( count ( $inChangeSetIDs ) > 0 ) {
$inChangeSets = ChangeSet :: get () -> filter ([ 'ID' => $inChangeSetIDs , 'State' => ChangeSet :: STATE_OPEN ]);
} else {
$inChangeSets = new ArrayList ();
}
$numCampaigns = ChangeSet :: singleton () -> i18n_pluralise ( $inChangeSets -> count ());
$numCampaigns = mb_strtolower ( $numCampaigns );
if ( count ( $descendants ) > 0 && $inChangeSets -> count () > 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 ]);
2017-04-04 01:44:41 +02:00
} 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?' );
2017-04-04 01:44:41 +02:00
} elseif ( $inChangeSets -> count () > 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 ]);
2017-04-04 01:44:41 +02:00
} 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?' );
2017-04-04 01:44:41 +02:00
}
return $archiveWarningMsg ;
}
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-01-25 21:59:25 +01:00
* @ return string HTML
*/
2017-09-04 05:37:47 +02: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-08-21 02:45:56 +02:00
* Note : This method exclusively handles top level view of list view
*
2017-01-25 21:59:25 +01:00
* @ param HTTPRequest $request
* @ return string HTML
*/
public function listview ( $request )
{
2017-08-21 02:45:56 +02:00
// Ensure selected page ID is highlighted
$pageID = $request -> param ( 'ParentID' ) ? : 0 ;
$this -> setCurrentPageID ( $pageID );
2017-01-25 21:59:25 +01:00
return $this -> getResponseNegotiator () -> respond ( $request );
}
/**
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
{
$mode = $this -> getRequest () -> requestVar ( 'view' )
? : $this -> getRequest () -> param ( 'Action' );
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' ];
2017-03-29 06:19:57 +02:00
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 {
2017-08-22 23:46:46 +02:00
$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-08-21 02:45:56 +02:00
$parentID = $this -> getRequest () -> param ( 'ParentID' );
$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 )
-> setAttributes ( array ( 'data-pjax' => 'ListViewForm,Breadcrumbs' ))
);
}
$gridField = new GridField ( 'Page' , 'Pages' , $list , $gridFieldConfig );
2017-08-24 06:17:10 +02:00
$gridField -> setAttribute ( 'cms-loading-ignore-url-params' , true );
2017-01-25 21:59:25 +01:00
/** @var GridFieldDataColumns $columns */
$columns = $gridField -> getConfig () -> getComponentByType ( 'SilverStripe\\Forms\\GridField\\GridFieldDataColumns' );
// 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 ( 'SilverStripe\\Forms\\GridField\\GridFieldSortableHeader' );
$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 ) {
2017-07-19 01:52:19 +02:00
$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
);
2017-07-19 01:52:19 +02:00
$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 )
{
2017-08-22 23:46:46 +02:00
$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 'Save & Publish' button was clicked, also publish the page
if ( $doPublish ) {
$record -> publishRecursive ();
$message = _t (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.PUBLISHED' ,
2017-01-25 21:59:25 +01:00
" Published ' { title}' successfully. " ,
[ 'title' => $record -> Title ]
);
} else {
$message = _t (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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 )
{
2017-08-22 23:46:46 +02:00
$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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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 */
2017-09-20 03:51:07 +02:00
$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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.RESTORED' ,
2017-01-25 21:59:25 +01:00
" Restored ' { title}' successfully " ,
2017-05-19 02:11:46 +02:00
'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' ,
2017-07-31 00:23:57 +02:00
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' ,
2017-07-31 00:23:57 +02:00
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 )
{
2017-08-22 23:46:46 +02:00
$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' ,
2017-04-20 03:15:29 +02:00
rawurlencode ( _t ( 'SilverStripe\\CMS\\Controllers\\CMSMain.REMOVEDPAGE' , " Removed ' { title}' from the published site " , array ( '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 )
{
2017-10-19 22:26:35 +02:00
$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 */
2017-10-19 22:26:35 +02:00
$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 (
2017-05-19 02:11:46 +02:00
__CLASS__ . '.ROLLEDBACKVERSIONv2' ,
" Rolled back to version # { version}. " ,
2017-01-25 21:59:25 +01:00
array ( 'version' => $data [ 'Version' ])
);
} else {
$record -> doRevertToLive ();
$message = _t (
2017-05-19 02:11:46 +02:00
__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 ;
}
}
2017-04-20 03:15:29 +02:00
$response .= _t ( 'SilverStripe\\CMS\\Controllers\\CMSMain.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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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.'
);
2017-04-20 03:15:29 +02:00
$response .= '<h1>' . _t ( 'SilverStripe\\CMS\\Controllers\\CMSMain.PUBALLFUN' , '"Publish All" functionality' ) . ' </ h1 >
2016-12-05 22:58:26 +01:00
< p > ' . $publishAllDescription . ' </ p >
2007-07-19 12:40:05 +02:00
< form method = " post " action = " publishall " >
2007-09-15 23:54:24 +02:00
< input type = " submit " name = " confirm " value = " '
2017-04-20 03:15:29 +02:00
. _t ( 'SilverStripe\\CMS\\Controllers\\CMSMain.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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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 (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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 (
2017-04-20 03:15:29 +02:00
'name' => _t ( 'SilverStripe\\CMS\\Controllers\\CMSMain.ACCESS' , " Access to ' { title}' section " , array ( 'title' => $title )),
'category' => _t ( 'SilverStripe\\Security\\Permission.CMS_ACCESS_CATEGORY' , 'CMS Access' ),
2017-01-25 21:59:25 +01:00
'help' => _t (
2017-04-20 03:15:29 +02:00
'SilverStripe\\CMS\\Controllers\\CMSMain.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
)
);
}
2017-04-06 07:38:15 +02:00
/**
* Get title for root CMS node
*
* @ return string
*/
protected function getCMSTreeTitle ()
{
$rootTitle = SiteConfig :: current_site_config () -> Title ;
$this -> extend ( 'updateCMSTreeTitle' , $rootTitle );
return $rootTitle ;
}
2007-07-19 12:40:05 +02:00
}