mirror of
https://github.com/silverstripe/silverstripe-cms
synced 2024-10-22 08:05:56 +02:00
1354 lines
42 KiB
PHP
1354 lines
42 KiB
PHP
<?php
|
|
/**
|
|
* 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.
|
|
*
|
|
* @package cms
|
|
* @subpackage controller
|
|
* @todo Create some base classes to contain the generic functionality that will be replicated.
|
|
*/
|
|
class CMSMain extends LeftAndMain implements CurrentPageIdentifier, PermissionProvider {
|
|
|
|
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_priority = 10;
|
|
|
|
private static $tree_class = "SiteTree";
|
|
|
|
private static $subitem_class = "Member";
|
|
|
|
private static $allowed_actions = array(
|
|
'buildbrokenlinks',
|
|
'deleteitems',
|
|
'DeleteItemsForm',
|
|
'dialog',
|
|
'duplicate',
|
|
'duplicatewithchildren',
|
|
'publishall',
|
|
'publishitems',
|
|
'PublishItemsForm',
|
|
'submit',
|
|
'EditForm',
|
|
'SearchForm',
|
|
'SiteTreeAsUL',
|
|
'getshowdeletedsubtree',
|
|
'batchactions',
|
|
'treeview',
|
|
'listview',
|
|
'ListViewForm',
|
|
);
|
|
|
|
public function init() {
|
|
// set reading lang
|
|
if(SiteTree::has_extension('Translatable') && !$this->request->isAjax()) {
|
|
Translatable::choose_site_locale(array_keys(Translatable::get_existing_content_languages('SiteTree')));
|
|
}
|
|
|
|
parent::init();
|
|
|
|
Versioned::reading_stage("Stage");
|
|
|
|
Requirements::css(CMS_DIR . '/css/screen.css');
|
|
Requirements::customCSS($this->generatePageIconsCss());
|
|
|
|
Requirements::combine_files(
|
|
'cmsmain.js',
|
|
array_merge(
|
|
array(
|
|
CMS_DIR . '/javascript/CMSMain.js',
|
|
CMS_DIR . '/javascript/CMSMain.EditForm.js',
|
|
CMS_DIR . '/javascript/CMSMain.AddForm.js',
|
|
CMS_DIR . '/javascript/CMSPageHistoryController.js',
|
|
CMS_DIR . '/javascript/CMSMain.Tree.js',
|
|
CMS_DIR . '/javascript/SilverStripeNavigator.js',
|
|
CMS_DIR . '/javascript/SiteTreeURLSegmentField.js'
|
|
),
|
|
Requirements::add_i18n_javascript(CMS_DIR . '/javascript/lang', true, true)
|
|
)
|
|
);
|
|
|
|
CMSBatchActionHandler::register('publish', 'CMSBatchAction_Publish');
|
|
CMSBatchActionHandler::register('unpublish', 'CMSBatchAction_Unpublish');
|
|
CMSBatchActionHandler::register('delete', 'CMSBatchAction_Delete');
|
|
CMSBatchActionHandler::register('deletefromlive', 'CMSBatchAction_DeleteFromLive');
|
|
}
|
|
|
|
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();
|
|
$controller = $this;
|
|
$negotiator->setCallback('ListViewForm', function() use(&$controller) {
|
|
return $controller->ListViewForm()->forTemplate();
|
|
});
|
|
return $negotiator;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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(
|
|
$this->stat('url_base', true),
|
|
$this->stat('url_segment', true), // in case we want to change the segment
|
|
'/', // trailing slash needed if $action is null!
|
|
"$action"
|
|
);
|
|
$this->extend('updateLink', $link);
|
|
return $link;
|
|
}
|
|
|
|
public function LinkPages() {
|
|
return singleton('CMSPagesController')->Link();
|
|
}
|
|
|
|
public function LinkPagesWithSearch() {
|
|
return $this->LinkWithSearch($this->LinkPages());
|
|
}
|
|
|
|
public function LinkTreeView() {
|
|
return $this->LinkWithSearch(singleton('CMSMain')->Link('treeview'));
|
|
}
|
|
|
|
public function LinkListView() {
|
|
return $this->LinkWithSearch(singleton('CMSMain')->Link('listview'));
|
|
}
|
|
|
|
public function LinkGalleryView() {
|
|
return $this->LinkWithSearch(singleton('CMSMain')->Link('galleryview'));
|
|
}
|
|
|
|
public function LinkPageEdit($id = null) {
|
|
if(!$id) $id = $this->currentPageID();
|
|
return $this->LinkWithSearch(
|
|
Controller::join_links(singleton('CMSPageEditController')->Link('show'), $id)
|
|
);
|
|
}
|
|
|
|
public function LinkPageSettings() {
|
|
if($id = $this->currentPageID()) {
|
|
return $this->LinkWithSearch(
|
|
Controller::join_links(singleton('CMSPageSettingsController')->Link('show'), $id)
|
|
);
|
|
}
|
|
}
|
|
|
|
public function LinkPageHistory() {
|
|
if($id = $this->currentPageID()) {
|
|
return $this->LinkWithSearch(
|
|
Controller::join_links(singleton('CMSPageHistoryController')->Link('show'), $id)
|
|
);
|
|
}
|
|
}
|
|
|
|
public function LinkWithSearch($link) {
|
|
// Whitelist to avoid side effects
|
|
$params = array(
|
|
'q' => (array)$this->request->getVar('q'),
|
|
'ParentID' => $this->request->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 = singleton("CMSPageAddController")->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 = ($record && $record instanceof Page) ? $record->Link('?stage=Stage') : Director::absoluteBaseURL();
|
|
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", "Stage");
|
|
Versioned::prepopulate_versionnumber_cache("SiteTree", "Live");
|
|
$html = $this->getSiteTreeFor($this->stat('tree_class'));
|
|
|
|
$this->extend('updateSiteTreeAsUL', $html);
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* @return boolean
|
|
*/
|
|
public function TreeIsFiltered() {
|
|
return $this->request->getVar('q');
|
|
}
|
|
|
|
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
|
|
$content = new TextField('q[Term]', _t('CMSSearch.FILTERLABELTEXT', 'Content'));
|
|
$dateHeader = new HeaderField('q[Date]', _t('CMSSearch.FILTERDATEHEADING', 'Date'), 4);
|
|
$dateFrom = new DateField(
|
|
'q[LastEditedFrom]',
|
|
_t('CMSSearch.FILTERDATEFROM', 'From')
|
|
);
|
|
$dateFrom->setConfig('showcalendar', true);
|
|
$dateTo = new DateField(
|
|
'q[LastEditedTo]',
|
|
_t('CMSSearch.FILTERDATETO', 'To')
|
|
);
|
|
$dateTo->setConfig('showcalendar', true);
|
|
$pageFilter = new DropdownField(
|
|
'q[FilterClass]',
|
|
_t('CMSMain.PAGES', 'Pages'),
|
|
CMSSiteTreeFilter::get_all_filters()
|
|
);
|
|
$pageClasses = new DropdownField(
|
|
'q[ClassName]',
|
|
_t('CMSMain.PAGETYPEOPT', 'Page Type', 'Dropdown for limiting search to a page type'),
|
|
$this->getPageTypes()
|
|
);
|
|
$pageClasses->setEmptyString(_t('CMSMain.PAGETYPEANYOPT','Any'));
|
|
|
|
// Group the Datefields
|
|
$dateGroup = new FieldGroup(
|
|
$dateHeader,
|
|
$dateFrom,
|
|
$dateTo
|
|
);
|
|
$dateGroup->setFieldHolderTemplate('FieldGroup_DefaultFieldHolder')->addExtraClass('stacked');
|
|
|
|
// Create the Field list
|
|
$fields = new FieldList(
|
|
$content,
|
|
$dateGroup,
|
|
$pageFilter,
|
|
$pageClasses
|
|
);
|
|
|
|
// Create the Search and Reset action
|
|
$actions = new FieldList(
|
|
FormAction::create('doSearch', _t('CMSMain_left_ss.APPLY_FILTER', 'Apply Filter'))
|
|
->addExtraClass('ss-ui-action-constructive'),
|
|
Object::create('ResetFormAction', 'clear', _t('CMSMain_left_ss.RESET', 'Reset'))
|
|
);
|
|
|
|
// Use <button> to allow full jQuery UI styling on the all of the Actions
|
|
foreach($actions->dataFields() as $action) {
|
|
$action->setUseButtonTag(true);
|
|
}
|
|
|
|
// Create the form
|
|
$form = Form::create($this, 'SearchForm', $fields, $actions)
|
|
->addExtraClass('cms-search-form')
|
|
->setFormMethod('GET')
|
|
->setFormAction($this->Link())
|
|
->disableSecurityToken()
|
|
->unsetValidator();
|
|
|
|
// Load the form with previously sent search data
|
|
$form->loadDataFrom($this->request->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] = _t($pageTypeClass.'.SINGULARNAME', $pageTypeClass);
|
|
}
|
|
asort($pageTypes);
|
|
return $pageTypes;
|
|
}
|
|
|
|
public function doSearch($data, $form) {
|
|
return $this->getsubtree($this->request);
|
|
}
|
|
|
|
/**
|
|
* @param bool $unlinked
|
|
* @return ArrayList
|
|
*/
|
|
public function Breadcrumbs($unlinked = false) {
|
|
$items = parent::Breadcrumbs($unlinked);
|
|
|
|
// The root element should point to the pages tree view,
|
|
// rather than the actual controller (which would just show an empty edit form)
|
|
$defaultTitle = self::menu_title_for_class('CMSPagesController');
|
|
$items[0]->Title = _t("{$this->class}.MENUTITLE", $defaultTitle);
|
|
$items[0]->Link = singleton('CMSPagesController')->Link();
|
|
|
|
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() {
|
|
$json = '';
|
|
$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
|
|
$cache = SS_Cache::factory('CMSMain_SiteTreeHints');
|
|
$cacheKey = md5(implode('_', array(Member::currentUserID(), implode(',', $cacheCanCreate), implode(',', $classes))));
|
|
if($this->request->getVar('flush')) $cache->clean(Zend_Cache::CLEANING_MODE_ALL);
|
|
$json = $cache->load($cacheKey);
|
|
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
|
|
$globalDisallowed = array();
|
|
foreach($classes as $class) {
|
|
$obj = singleton($class);
|
|
$needsPerm = $obj->stat('need_permission');
|
|
|
|
if(!($obj instanceof HiddenClass)) {
|
|
$def['All'][$class] = array(
|
|
'title' => $obj->i18n_singular_name()
|
|
);
|
|
}
|
|
|
|
if(!$obj->stat('can_be_root')) {
|
|
$def['Root']['disallowedChildren'][] = $class;
|
|
}
|
|
|
|
if(
|
|
($obj instanceof HiddenClass)
|
|
|| (!array_key_exists($class, $cacheCanCreate) || !$cacheCanCreate[$class])
|
|
|| ($needsPerm && !$this->can($needsPerm))
|
|
) {
|
|
$globalDisallowed[] = $class;
|
|
$def['Root']['disallowedChildren'][] = $class;
|
|
}
|
|
}
|
|
|
|
// Set disallows by class
|
|
foreach($classes as $class) {
|
|
$obj = singleton($class);
|
|
if($obj instanceof HiddenClass) continue;
|
|
|
|
$def[$class] = array();
|
|
|
|
$allowed = $obj->allowedChildren();
|
|
if($pos = array_search('SiteTree', $allowed)) unset($allowed[$pos]);
|
|
|
|
// Start by disallowing all classes which aren't specifically allowed,
|
|
// then add the ones which are globally disallowed.
|
|
$disallowed = array_diff($classes, (array)$allowed);
|
|
$disallowed = array_unique(array_merge($disallowed, $globalDisallowed));
|
|
// Re-index the array for JSON non sequential key issue
|
|
if($disallowed) $def[$class]['disallowedChildren'] = array_values($disallowed);
|
|
|
|
$defaultChild = $obj->defaultChild();
|
|
if($defaultChild != 'Page' && $defaultChild != null) {
|
|
$def[$class]['defaultChild'] = $defaultChild;
|
|
}
|
|
|
|
$defaultParent = $obj->defaultParent();
|
|
$parent = SiteTree::get_by_link($defaultParent);
|
|
$id = $parent ? $parent->id : null;
|
|
if ($defaultParent != 1 && $defaultParent != null) {
|
|
$def[$class]['defaultParent'] = $defaultParent;
|
|
}
|
|
}
|
|
|
|
$this->extend('updateSiteTreeHints', $def);
|
|
|
|
$json = Convert::raw2json($def);
|
|
$cache->save($json, $cacheKey);
|
|
}
|
|
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) {
|
|
$instance = singleton($class);
|
|
|
|
if($instance instanceof HiddenClass) continue;
|
|
|
|
if(!$instance->canCreate()) continue;
|
|
|
|
// skip this type if it is restricted
|
|
if($instance->stat('need_permission') && !$this->can(singleton($class)->stat('need_permission'))) continue;
|
|
|
|
$addAction = $instance->i18n_singular_name();
|
|
|
|
// Get description (convert 'Page' to 'SiteTree' for correct localization lookups)
|
|
$description = _t((($class == 'Page') ? 'SiteTree' : $class) . '.DESCRIPTION');
|
|
|
|
if(!$description) {
|
|
$description = $instance->uninherited('description');
|
|
}
|
|
|
|
if($class == 'Page' && !$description) {
|
|
$description = singleton('SiteTree')->uninherited('description');
|
|
}
|
|
|
|
$result->push(new ArrayData(array(
|
|
'ClassName' => $class,
|
|
'AddAction' => $addAction,
|
|
'Description' => $description,
|
|
// TODO Sprite support
|
|
'IconURL' => $instance->stat('icon'),
|
|
'Title' => singleton($class)->i18n_singular_name(),
|
|
)));
|
|
}
|
|
|
|
$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 DataObject
|
|
*/
|
|
public function getRecord($id, $versionID = null) {
|
|
$treeClass = $this->stat('tree_class');
|
|
|
|
if($id instanceof $treeClass) {
|
|
return $id;
|
|
}
|
|
else if($id && is_numeric($id)) {
|
|
if($this->request->getVar('Version')) {
|
|
$versionID = (int) $this->request->getVar('Version');
|
|
}
|
|
|
|
if($versionID) {
|
|
$record = Versioned::get_version($treeClass, $id, $versionID);
|
|
} else {
|
|
$record = DataObject::get_one($treeClass, "\"$treeClass\".\"ID\" = $id");
|
|
}
|
|
|
|
// Then, try getting a record from the live site
|
|
if(!$record) {
|
|
// $record = Versioned::get_one_by_stage($treeClass, "Live", "\"$treeClass\".\"ID\" = $id");
|
|
Versioned::reading_stage('Live');
|
|
singleton($treeClass)->flushCache();
|
|
|
|
$record = DataObject::get_one( $treeClass, "\"$treeClass\".\"ID\" = $id");
|
|
if($record) Versioned::set_reading_mode('');
|
|
}
|
|
|
|
// Then, try getting a deleted record
|
|
if(!$record) {
|
|
$record = Versioned::get_latest_version($treeClass, $id);
|
|
}
|
|
|
|
// Don't open a page from a different locale
|
|
/** The record's Locale is saved in database in 2.4, and not related with Session,
|
|
* we should not check their locale matches the Translatable::get_current_locale,
|
|
* here as long as we all the HTTPRequest is init with right locale.
|
|
* This bit breaks the all FileIFrameField functions if the field is used in CMS
|
|
* and its relevent ajax calles, like loading the tree dropdown for TreeSelectorField.
|
|
*/
|
|
/* if($record && SiteTree::has_extension('Translatable') && $record->Locale && $record->Locale != Translatable::get_current_locale()) {
|
|
$record = null;
|
|
}*/
|
|
|
|
return $record;
|
|
|
|
} else if(substr($id,0,3) == 'new') {
|
|
return $this->getNewItem($id);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param Int $id
|
|
* @param FieldList $fields
|
|
* @return Form
|
|
*/
|
|
public function getEditForm($id = null, $fields = null) {
|
|
|
|
if(!$id) $id = $this->currentPageID();
|
|
$form = parent::getEditForm($id);
|
|
|
|
// TODO Duplicate record fetching (see parent implementation)
|
|
$record = $this->getRecord($id);
|
|
if($record && !$record->canView()) return Security::permissionFailure($this);
|
|
|
|
if(!$fields) $fields = $form->Fields();
|
|
$actions = $form->Actions();
|
|
|
|
if($record) {
|
|
$deletedFromStage = $record->IsDeletedFromStage;
|
|
$deleteFromLive = !$record->ExistsOnLive;
|
|
|
|
$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(new HiddenField("TreeTitle", false, $record->TreeTitle));
|
|
|
|
if($record->ID && is_numeric( $record->ID ) ) {
|
|
$liveLink = $record->getAbsoluteLiveLink();
|
|
if($liveLink) $liveLinkField->setValue($liveLink);
|
|
if(!$deletedFromStage) {
|
|
$stageLink = Controller::join_links($record->AbsoluteLink(), '?stage=Stage');
|
|
if($stageLink) $stageLinkField->setValue($stageLink);
|
|
}
|
|
}
|
|
|
|
// Added in-line to the form, but plucked into different view by LeftAndMain.Preview.js upon load
|
|
if(in_array('CMSPreviewable', class_implements($record)) && !$fields->fieldByName('SilverStripeNavigator')) {
|
|
$navField = new LiteralField('SilverStripeNavigator', $this->getSilverStripeNavigator());
|
|
$navField->setAllowHTML(true);
|
|
$fields->push($navField);
|
|
}
|
|
|
|
// 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()) {
|
|
$tabset = $actions->fieldByName('ActionMenus');
|
|
if ($tabset) {
|
|
foreach ($tabset->getChildren() as $tab) {
|
|
if (!$tab->getChildren()->count()) {
|
|
$tabset->removeByName($tab->getName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Use <button> to allow full jQuery UI styling
|
|
$actionsFlattened = $actions->dataFields();
|
|
if($actionsFlattened) foreach($actionsFlattened as $action) $action->setUseButtonTag(true);
|
|
|
|
if($record->hasMethod('getCMSValidator')) {
|
|
$validator = $record->getCMSValidator();
|
|
} else {
|
|
$validator = new RequiredFields();
|
|
}
|
|
|
|
$form = CMSForm::create(
|
|
$this, "EditForm", $fields, $actions, $validator
|
|
)->setHTMLID('Form_EditForm');
|
|
$form->setResponseNegotiator($this->getResponseNegotiator());
|
|
$form->loadDataFrom($record);
|
|
$form->disableDefaultAction();
|
|
$form->addExtraClass('cms-edit-form');
|
|
$form->setTemplate($this->getTemplatesWithSuffix('_EditForm'));
|
|
// TODO Can't merge $FormAttributes in template at the moment
|
|
$form->addExtraClass('center ' . $this->BaseCSSClasses());
|
|
// if($form->Fields()->hasTabset()) $form->Fields()->findOrMakeTab('Root')->setTemplate('CMSTabSet');
|
|
$form->setAttribute('data-pjax-fragment', 'CurrentForm');
|
|
// Set validation exemptions for specific actions
|
|
$form->setValidationExemptActions(array('restore', 'revert', 'deletefromlive', 'rollback'));
|
|
|
|
// Announce the capability so the frontend can decide whether to allow preview or not.
|
|
if(in_array('CMSPreviewable', class_implements($record))) {
|
|
$form->addExtraClass('cms-previewable');
|
|
}
|
|
|
|
if(!$record->canEdit() || $deletedFromStage) {
|
|
$readonlyFields = $form->Fields()->makeReadonly();
|
|
$form->setFields($readonlyFields);
|
|
}
|
|
|
|
$this->extend('updateEditForm', $form);
|
|
return $form;
|
|
} else if($id) {
|
|
$form = CMSForm::create( $this, "EditForm", new FieldList(
|
|
new LabelField('PageDoesntExistLabel',_t('CMSMain.PAGENOTEXISTS',"This page doesn't exist"))), new FieldList()
|
|
)->setHTMLID('Form_EditForm');
|
|
$form->setResponseNegotiator($this->getResponseNegotiator());
|
|
return $form;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param SS_HTTPRequest $request
|
|
* @return String HTML
|
|
*/
|
|
public function treeview($request) {
|
|
return $this->renderWith($this->getTemplatesWithSuffix('_TreeView'));
|
|
}
|
|
|
|
/**
|
|
* @param SS_HTTPRequest $request
|
|
* @return String HTML
|
|
*/
|
|
public function listview($request) {
|
|
return $this->renderWith($this->getTemplatesWithSuffix('_ListView'));
|
|
}
|
|
|
|
/**
|
|
* 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 Exception if invalid filter class is passed.
|
|
*/
|
|
public function getList($params, $parentID = 0) {
|
|
$list = new DataList($this->stat('tree_class'));
|
|
$filter = null;
|
|
$ids = array();
|
|
if(isset($params['FilterClass']) && $filterClass = $params['FilterClass']){
|
|
if(!is_subclass_of($filterClass, 'CMSSiteTreeFilter')) {
|
|
throw new Exception(sprintf('Invalid filter class passed: %s', $filterClass));
|
|
}
|
|
$filter = new $filterClass($params);
|
|
$filterOn = true;
|
|
foreach($pages=$filter->pagesIncluded() as $pageMap){
|
|
$ids[] = $pageMap['ID'];
|
|
}
|
|
if(count($ids)) $list = $list->where('"'.$this->stat('tree_class').'"."ID" IN ('.implode(",", $ids).')');
|
|
} else {
|
|
$list = $list->filter("ParentID", is_numeric($parentID) ? $parentID : 0);
|
|
}
|
|
|
|
return $list;
|
|
}
|
|
|
|
public function ListViewForm() {
|
|
$params = $this->request->requestVar('q');
|
|
$list = $this->getList($params, $parentID = $this->request->requestVar('ParentID'));
|
|
$gridFieldConfig = GridFieldConfig::create()->addComponents(
|
|
new GridFieldSortableHeader(),
|
|
new GridFieldDataColumns(),
|
|
new GridFieldPaginator(15)
|
|
);
|
|
if($parentID){
|
|
$gridFieldConfig->addComponent(
|
|
GridFieldLevelup::create($parentID)
|
|
->setLinkSpec('?ParentID=%d&view=list')
|
|
->setAttributes(array('data-pjax' => 'ListViewForm,Breadcrumbs'))
|
|
);
|
|
}
|
|
$gridField = new GridField('Page','Pages', $list, $gridFieldConfig);
|
|
$columns = $gridField->getConfig()->getComponentByType('GridFieldDataColumns');
|
|
|
|
// Don't allow navigating into children nodes on filtered lists
|
|
$fields = array(
|
|
'getTreeTitle' => _t('SiteTree.PAGETITLE', 'Page Title'),
|
|
'singular_name' => _t('SiteTree.PAGETYPE'),
|
|
'LastEdited' => _t('SiteTree.LASTUPDATED', 'Last Updated'),
|
|
);
|
|
$gridField->getConfig()->getComponentByType('GridFieldSortableHeader')->setFieldSorting(array('getTreeTitle' => 'Title'));
|
|
$gridField->getState()->ParentID = $parentID;
|
|
|
|
if(!$params) {
|
|
$fields = array_merge(array('listChildrenLink' => ''), $fields);
|
|
}
|
|
|
|
$columns->setDisplayFields($fields);
|
|
$columns->setFieldCasting(array(
|
|
'Created' => 'Datetime->Ago',
|
|
'LastEdited' => 'Datetime->FormatFromSettings',
|
|
'getTreeTitle' => 'HTMLText'
|
|
));
|
|
|
|
$controller = $this;
|
|
$columns->setFieldFormatting(array(
|
|
'listChildrenLink' => function($value, &$item) use($controller) {
|
|
$num = $item ? $item->numChildren() : null;
|
|
if($num) {
|
|
return sprintf(
|
|
'<a class="cms-panel-link list-children-link" data-pjax-target="ListViewForm,Breadcrumbs" href="%s">%s</a>',
|
|
Controller::join_links(
|
|
$controller->Link(),
|
|
sprintf("?ParentID=%d&view=list", (int)$item->ID)
|
|
),
|
|
$num
|
|
);
|
|
}
|
|
},
|
|
'getTreeTitle' => function($value, &$item) use($controller) {
|
|
return sprintf(
|
|
'<a class="action-detail" href="%s">%s</a>',
|
|
Controller::join_links(
|
|
singleton('CMSPageEditController')->Link('show'),
|
|
(int)$item->ID
|
|
),
|
|
$item->TreeTitle // returns HTML, does its own escaping
|
|
);
|
|
}
|
|
));
|
|
|
|
$listview = CMSForm::create(
|
|
$this,
|
|
'ListViewForm',
|
|
new FieldList($gridField),
|
|
new FieldList()
|
|
)->setHTMLID('Form_ListViewForm');
|
|
$listview->setAttribute('data-pjax-fragment', 'ListViewForm');
|
|
$listview->setResponseNegotiator($this->getResponseNegotiator());
|
|
|
|
$this->extend('updateListView', $listview);
|
|
|
|
$listview->disableSecurityToken();
|
|
return $listview;
|
|
}
|
|
|
|
public function currentPageID() {
|
|
$id = parent::currentPageID();
|
|
|
|
$this->extend('updateCurrentPageID', $id);
|
|
|
|
// Fall back to homepage record
|
|
if(!$id) {
|
|
$homepageSegment = RootURLController::get_homepage_link();
|
|
$homepageRecord = DataObject::get_one('SiteTree', sprintf(
|
|
'"SiteTree"."URLSegment" = \'%s\'',
|
|
Convert::raw2sql($homepageSegment)
|
|
));
|
|
if($homepageRecord) $id = $homepageRecord->ID;
|
|
}
|
|
|
|
return $id;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------//
|
|
// Data saving handlers
|
|
|
|
/**
|
|
* Save and Publish page handler
|
|
*/
|
|
public function save($data, $form) {
|
|
$className = $this->stat('tree_class');
|
|
|
|
// Existing or new record?
|
|
$SQL_id = Convert::raw2sql($data['ID']);
|
|
if(substr($SQL_id,0,3) != 'new') {
|
|
$record = DataObject::get_by_id($className, $SQL_id);
|
|
if($record && !$record->canEdit()) return Security::permissionFailure($this);
|
|
if(!$record || !$record->ID) throw new SS_HTTPResponse_Exception("Bad record ID #$SQL_id", 404);
|
|
} else {
|
|
if(!singleton($this->stat('tree_class'))->canCreate()) return Security::permissionFailure($this);
|
|
$record = $this->getNewItem($SQL_id, false);
|
|
}
|
|
|
|
// 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) {
|
|
$newClassName = $record->ClassName;
|
|
// The records originally saved attribute was overwritten by $form->saveInto($record) before.
|
|
// This is necessary for newClassInstance() to work as expected, and trigger change detection
|
|
// on the ClassName attribute
|
|
$record->setClassName($data['ClassName']);
|
|
// Replace $record with a new instance
|
|
$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 (isset($data['publish']) && $data['publish'] == 1) {
|
|
$record->doPublish();
|
|
}
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
/**
|
|
* @uses LeftAndMainExtension->augmentNewSiteTreeItem()
|
|
*/
|
|
public function getNewItem($id, $setID = true) {
|
|
list($dummy, $className, $parentID, $suffix) = array_pad(explode('-',$id),4,null);
|
|
|
|
$newItem = new $className();
|
|
|
|
if( !$suffix ) {
|
|
$sessionTag = "NewItems." . $parentID . "." . $className;
|
|
if(Session::get($sessionTag)) {
|
|
$suffix = '-' . Session::get($sessionTag);
|
|
Session::set($sessionTag, Session::get($sessionTag) + 1);
|
|
}
|
|
else
|
|
Session::set($sessionTag, 1);
|
|
|
|
$id = $id . $suffix;
|
|
}
|
|
|
|
$newItem->Title = _t(
|
|
'CMSMain.NEWPAGE',
|
|
"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')) {
|
|
$newItem->Sort = DB::query("SELECT MAX(\"Sort\") FROM \"SiteTree\" WHERE \"ParentID\" = '" . Convert::raw2sql($parentID) . "'")->value() + 1;
|
|
}
|
|
|
|
if($setID) $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;
|
|
}
|
|
|
|
/**
|
|
* Delete the page from live. This means a page in draft mode might still exist.
|
|
*
|
|
* @see delete()
|
|
*/
|
|
public function deletefromlive($data, $form) {
|
|
Versioned::reading_stage('Live');
|
|
$record = DataObject::get_by_id("SiteTree", $data['ID']);
|
|
if($record && !($record->canDelete() && $record->canDeleteFromLive())) return Security::permissionFailure($this);
|
|
|
|
$descRemoved = '';
|
|
$descendantsRemoved = 0;
|
|
$recordTitle = $record->Title;
|
|
$recordID = $record->ID;
|
|
|
|
// before deleting the records, get the descendants of this tree
|
|
if($record) {
|
|
$descendantIDs = $record->getDescendantIDList();
|
|
|
|
// then delete them from the live site too
|
|
$descendantsRemoved = 0;
|
|
foreach( $descendantIDs as $descID )
|
|
if( $descendant = DataObject::get_by_id('SiteTree', $descID) ) {
|
|
$descendant->doDeleteFromLive();
|
|
$descendantsRemoved++;
|
|
}
|
|
|
|
// delete the record
|
|
$record->doDeleteFromLive();
|
|
}
|
|
|
|
Versioned::reading_stage('Stage');
|
|
|
|
if(isset($descendantsRemoved)) {
|
|
$descRemoved = ' ' . _t(
|
|
'CMSMain.DESCREMOVED',
|
|
'and {count} descendants',
|
|
array('count' => $descendantsRemoved)
|
|
);
|
|
} else {
|
|
$descRemoved = '';
|
|
}
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(
|
|
_t(
|
|
'CMSMain.REMOVED',
|
|
'Deleted \'{title}\'{description} from live site',
|
|
array('title' => $recordTitle, 'description' => $descRemoved)
|
|
)
|
|
)
|
|
);
|
|
|
|
// Even if the record has been deleted from stage and live, it can be viewed in "archive mode"
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
/**
|
|
* Actually perform the publication step
|
|
*/
|
|
public function performPublish($record) {
|
|
if($record && !$record->canPublish()) return Security::permissionFailure($this);
|
|
|
|
$record->doPublish();
|
|
}
|
|
|
|
/**
|
|
* 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()
|
|
*/
|
|
public function revert($data, $form) {
|
|
if(!isset($data['ID'])) return new SS_HTTPResponse("Please pass an ID in the form content", 400);
|
|
|
|
$id = (int) $data['ID'];
|
|
$restoredPage = Versioned::get_latest_version("SiteTree", $id);
|
|
if(!$restoredPage) return new SS_HTTPResponse("SiteTree #$id not found", 400);
|
|
|
|
$record = Versioned::get_one_by_stage(
|
|
'SiteTree',
|
|
'Live',
|
|
sprintf("\"SiteTree_Live\".\"ID\" = '%d'", (int)$data['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 SS_HTTPResponse_Exception("Bad record ID #$id", 404);
|
|
|
|
$record->doRevertToLive();
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(_t(
|
|
'CMSMain.RESTORED',
|
|
"Restored '{title}' successfully",
|
|
'Param %s is a title',
|
|
array('title' => $record->Title)
|
|
))
|
|
);
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
/**
|
|
* Delete the current page from draft stage.
|
|
* @see deletefromlive()
|
|
*/
|
|
public function delete($data, $form) {
|
|
$id = Convert::raw2sql($data['ID']);
|
|
$record = DataObject::get_one(
|
|
"SiteTree",
|
|
sprintf("\"SiteTree\".\"ID\" = %d", $id)
|
|
);
|
|
if($record && !$record->canDelete()) return Security::permissionFailure();
|
|
if(!$record || !$record->ID) throw new SS_HTTPResponse_Exception("Bad record ID #$id", 404);
|
|
|
|
// save ID and delete record
|
|
$recordID = $record->ID;
|
|
$record->delete();
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(sprintf(_t('CMSMain.REMOVEDPAGEFROMDRAFT',"Removed '%s' from the draft site"), $record->Title))
|
|
);
|
|
|
|
// Even if the record has been deleted from stage and live, it can be viewed in "archive mode"
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
public function publish($data, $form) {
|
|
$data['publish'] = '1';
|
|
|
|
return $this->save($data, $form);
|
|
}
|
|
|
|
public function unpublish($data, $form) {
|
|
$className = $this->stat('tree_class');
|
|
$record = DataObject::get_by_id($className, $data['ID']);
|
|
|
|
if($record && !$record->canDeleteFromLive()) return Security::permissionFailure($this);
|
|
if(!$record || !$record->ID) throw new SS_HTTPResponse_Exception("Bad record ID #" . (int)$data['ID'], 404);
|
|
|
|
$record->doUnpublish();
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(_t('CMSMain.REMOVEDPAGE',"Removed '{title}' from the published site", array('title' => $record->Title)))
|
|
);
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function rollback() {
|
|
return $this->doRollback(array(
|
|
'ID' => $this->currentPageID(),
|
|
'Version' => $this->request->param('VersionID')
|
|
), null);
|
|
}
|
|
|
|
/**
|
|
* Rolls a site back to a given version ID
|
|
*
|
|
* @param array
|
|
* @param Form
|
|
*
|
|
* @return html
|
|
*/
|
|
public function doRollback($data, $form) {
|
|
$this->extend('onBeforeRollback', $data['ID']);
|
|
|
|
$id = (isset($data['ID'])) ? (int) $data['ID'] : null;
|
|
$version = (isset($data['Version'])) ? (int) $data['Version'] : null;
|
|
|
|
$record = DataObject::get_by_id($this->stat('tree_class'), $id);
|
|
if($record && !$record->canEdit()) return Security::permissionFailure($this);
|
|
|
|
if($version) {
|
|
$record->doRollbackTo($version);
|
|
$message = _t(
|
|
'CMSMain.ROLLEDBACKVERSIONv2',
|
|
"Rolled back to version #%d.",
|
|
array('version' => $data['Version'])
|
|
);
|
|
} else {
|
|
$record->doRollbackTo('Live');
|
|
$message = _t(
|
|
'CMSMain.ROLLEDBACKPUBv2',"Rolled back to published version."
|
|
);
|
|
}
|
|
|
|
$this->response->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(singleton('CMSPageEditController')->Link('show'), $record->ID);
|
|
$this->response->addHeader('X-ControllerURL', $url);
|
|
$this->request->addHeader('X-Pjax', 'Content');
|
|
$this->response->addHeader('X-Pjax', 'Content');
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
/**
|
|
* 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 = '';
|
|
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 buildbrokenlinks($request) {
|
|
// Protect against CSRF on destructive action
|
|
if(!SecurityToken::inst()->checkRequest($request)) return $this->httpError(400);
|
|
|
|
increase_time_limit_to();
|
|
increase_memory_limit_to();
|
|
|
|
if($this->urlParams['ID']) {
|
|
$newPageSet[] = DataObject::get_by_id("Page", $this->urlParams['ID']);
|
|
} else {
|
|
$pages = DataObject::get("Page");
|
|
foreach($pages as $page) $newPageSet[] = $page;
|
|
$pages = null;
|
|
}
|
|
|
|
$content = new HtmlEditorField('Content');
|
|
$download = new HtmlEditorField('Download');
|
|
|
|
foreach($newPageSet as $i => $page) {
|
|
$page->HasBrokenLink = 0;
|
|
$page->HasBrokenFile = 0;
|
|
|
|
$content->setValue($page->Content);
|
|
$content->saveInto($page);
|
|
|
|
$download->setValue($page->Download);
|
|
$download->saveInto($page);
|
|
|
|
echo "<li>$page->Title (link:$page->HasBrokenLink, file:$page->HasBrokenFile)";
|
|
|
|
$page->writeWithoutVersion();
|
|
$page->destroy();
|
|
$newPageSet[$i] = null;
|
|
}
|
|
}
|
|
|
|
public function publishall($request) {
|
|
if(!Permission::check('ADMIN')) return Security::permissionFailure($this);
|
|
|
|
increase_time_limit_to();
|
|
increase_memory_limit_to();
|
|
|
|
$response = "";
|
|
|
|
if(isset($this->requestParams['confirm'])) {
|
|
// Protect against CSRF on destructive action
|
|
if(!SecurityToken::inst()->checkRequest($request)) return $this->httpError(400);
|
|
|
|
$start = 0;
|
|
$pages = DataObject::get("SiteTree", "", "", "", "$start,30");
|
|
$count = 0;
|
|
while($pages) {
|
|
foreach($pages as $page) {
|
|
if($page && !$page->canPublish()) return Security::permissionFailure($this);
|
|
|
|
$page->doPublish();
|
|
$page->destroy();
|
|
unset($page);
|
|
$count++;
|
|
$response .= "<li>$count</li>";
|
|
}
|
|
if($pages->Count() > 29) {
|
|
$start += 30;
|
|
$pages = DataObject::get("SiteTree", "", "", "", "$start,30");
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
$response .= _t('CMSMain.PUBPAGES',"Done: Published {count} pages", array('count' => $count));
|
|
|
|
} else {
|
|
$token = SecurityToken::inst();
|
|
$fields = new FieldList();
|
|
$token->updateFieldSet($fields);
|
|
$tokenField = $fields->First();
|
|
$tokenHtml = ($tokenField) ? $tokenField->FieldHolder() : '';
|
|
$response .= '<h1>' . _t('CMSMain.PUBALLFUN','"Publish All" functionality') . '</h1>
|
|
<p>' . _t('CMSMain.PUBALLFUN2', '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.') . '</p>
|
|
<form method="post" action="publishall">
|
|
<input type="submit" name="confirm" value="'
|
|
. _t('CMSMain.PUBALLCONFIRM',"Please publish every page in the site, copying content stage to live",'Confirmation button') .'" />'
|
|
. $tokenHtml .
|
|
'</form>';
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Restore a completely deleted page from the SiteTree_versions table.
|
|
*/
|
|
public function restore($data, $form) {
|
|
if(!isset($data['ID']) || !is_numeric($data['ID'])) {
|
|
return new SS_HTTPResponse("Please pass an ID in the form content", 400);
|
|
}
|
|
|
|
$id = (int)$data['ID'];
|
|
$restoredPage = Versioned::get_latest_version("SiteTree", $id);
|
|
if(!$restoredPage) return new SS_HTTPResponse("SiteTree #$id not found", 400);
|
|
|
|
$restoredPage = $restoredPage->doRestoreToStage();
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(_t(
|
|
'CMSMain.RESTORED',
|
|
"Restored '{title}' successfully",
|
|
array('title' => $restoredPage->Title)
|
|
))
|
|
);
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
}
|
|
|
|
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)) {
|
|
$page = DataObject::get_by_id("SiteTree", $id);
|
|
if($page && (!$page->canEdit() || !$page->canCreate())) return Security::permissionFailure($this);
|
|
if(!$page || !$page->ID) throw new SS_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->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(_t(
|
|
'CMSMain.DUPLICATED',
|
|
"Duplicated '{title}' successfully",
|
|
array('title' => $newPage->Title)
|
|
))
|
|
);
|
|
$url = Controller::join_links(singleton('CMSPageEditController')->Link('show'), $newPage->ID);
|
|
$this->response->addHeader('X-ControllerURL', $url);
|
|
$this->request->addHeader('X-Pjax', 'Content');
|
|
$this->response->addHeader('X-Pjax', 'Content');
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
} else {
|
|
return new SS_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);
|
|
increase_time_limit_to();
|
|
if(($id = $this->urlParams['ID']) && is_numeric($id)) {
|
|
$page = DataObject::get_by_id("SiteTree", $id);
|
|
if($page && (!$page->canEdit() || !$page->canCreate())) return Security::permissionFailure($this);
|
|
if(!$page || !$page->ID) throw new SS_HTTPResponse_Exception("Bad record ID #$id", 404);
|
|
|
|
$newPage = $page->duplicateWithChildren();
|
|
|
|
$this->response->addHeader(
|
|
'X-Status',
|
|
rawurlencode(_t(
|
|
'CMSMain.DUPLICATEDWITHCHILDREN',
|
|
"Duplicated '{title}' and children successfully",
|
|
array('title' => $newPage->Title)
|
|
))
|
|
);
|
|
$url = Controller::join_links(singleton('CMSPageEditController')->Link('show'), $newPage->ID);
|
|
$this->response->addHeader('X-ControllerURL', $url);
|
|
$this->request->addHeader('X-Pjax', 'Content');
|
|
$this->response->addHeader('X-Pjax', 'Content');
|
|
|
|
return $this->getResponseNegotiator()->respond($this->request);
|
|
} else {
|
|
return new SS_HTTPResponse("CMSMain::duplicatewithchildren() Bad ID: '$id'", 400);
|
|
}
|
|
}
|
|
|
|
public function providePermissions() {
|
|
$title = _t("CMSPagesController.MENUTITLE", LeftAndMain::menu_title_for_class('CMSPagesController'));
|
|
return array(
|
|
"CMS_ACCESS_CMSMain" => array(
|
|
'name' => _t('CMSMain.ACCESS', "Access to '{title}' section", array('title' => $title)),
|
|
'category' => _t('Permission.CMS_ACCESS_CATEGORY', 'CMS Access'),
|
|
'help' => _t(
|
|
'CMSMain.ACCESS_HELP',
|
|
'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
|
|
)
|
|
);
|
|
}
|
|
|
|
}
|