function getSource()
{
if ($this->includeBaseClass) {
$classes[] = $this->sourceClass;
} else {
$classes = array();
}
$classes = $classes + ClassInfo::subclassesFor($this->sourceClass);
if (!count($this->availableClasses)) {
$this->availableClasses = $classes;
} elseif ($this->includeBaseClass) {
$this->availableClasses[] = $this->sourceClass;
}
$dropdownArray = array();
if ($this->getHasEmptyDefault()) {
$dropdownArray[""] = $this->emptyString;
}
if ($classes) {
foreach ($classes as $key => $className) {
if (class_exists($key)) {
if (in_array($className, $this->availableClasses)) {
$obj = singleton($className);
if ($obj) {
$dropdownArray[$className] = $obj->i18n_singular_name();
}
}
}
}
}
if (!count($dropdownArray)) {
$dropdownArray = array($this->sourceClass => _t("EcommerceClassNameOrTypeDropdownField.CAN_NOT_CREATE", "Can't create.") . $title);
}
return $dropdownArray;
}
/**
* Gets the classes that can be created using this button, defaulting to the model class and
* its subclasses.
*
* @param GridField $grid
* @return array a map of class name to title
*/
public function getClasses(GridField $grid)
{
$result = array();
if (is_null($this->classes)) {
$classes = array_values(ClassInfo::subclassesFor($grid->getModelClass()));
sort($classes);
} else {
$classes = $this->classes;
}
$kill_ancestors = array();
foreach ($classes as $class => $title) {
if (!is_string($class)) {
$class = $title;
$is_abstract = ($reflection = new ReflectionClass($class)) && $reflection->isAbstract();
if (!$is_abstract) {
$title = singleton($class)->i18n_singular_name();
}
} else {
$is_abstract = ($reflection = new ReflectionClass($class)) && $reflection->isAbstract();
}
if ($ancestor_to_hide = Config::inst()->get($class, 'hide_ancestor', Config::FIRST_SET)) {
$kill_ancestors[$ancestor_to_hide] = true;
}
if ($is_abstract || !singleton($class)->canCreate()) {
continue;
}
$result[$class] = $title;
}
if ($kill_ancestors) {
foreach ($kill_ancestors as $class => $bool) {
unset($result[$class]);
}
}
return $result;
}
function getModularCMSFields($relationName = 'Modules', $title = 'Content Modules')
{
$fields = array();
$GLOBALS['_CONTENT_MODULE_PARENT_PAGEID'] = $this->owner->ID;
$area = $this->owner->obj($relationName);
if ($area && $area->exists()) {
$fields[] = HeaderField::create($relationName . 'Header', $title, 2);
$fields[] = GridField::create($relationName, $title, $area->Modules(), GridFieldConfig_RecordEditor::create()->addComponent(new GridFieldOrderableRows('SortOrder'))->removeComponentsByType('GridFieldAddNewButton')->addComponent($add = new GridFieldAddNewMultiClass()));
if (($allowed_modules = $this->owner->Config()->get('allowed_modules')) && is_array($allowed_modules) && count($allowed_modules)) {
if (isset($allowed_modules[$relationName])) {
$add->setClasses($allowed_modules[$relationName]);
} else {
$add->setClasses($allowed_modules);
}
} else {
// Remove the base "ContentModule" from allowed modules.
$classes = array_values(ClassInfo::subclassesFor('ContentModule'));
sort($classes);
if (($key = array_search('ContentModule', $classes)) !== false) {
unset($classes[$key]);
}
$add->setClasses($classes);
}
} else {
$fields[] = LiteralField::create('SaveFirstToAddModules', '<div class="message">You must save first before you can add modules.</div>');
}
return $fields;
}
/**
* Add an option to include in the comment
*/
public function updateFieldConfiguration(FieldList $fields)
{
if (in_array($this->owner->Parent()->Classname, ClassInfo::subclassesFor('Consultation'))) {
$comment = CheckboxField::create($this->owner->getSettingName('CommentField'), _t('CONSULTATION.INCLUDEINCOMMENT', 'Include this field in comment post'), $this->owner->getSetting('CommentField'));
$fields->push($comment);
}
}
/**
* Returns true if the folder contains files
* @return boolean
*/
public function containsFiles()
{
if (!$this->owner instanceof Folder) {
return false;
}
return (bool) DB::query("SELECT COUNT(*) FROM File WHERE ParentID = " . (int) $this->owner->ID . " AND ClassName NOT IN ('" . implode("','", array_values(ClassInfo::subclassesFor('Folder'))) . "')")->value();
}
function updateCMSFields(FieldList $fields)
{
if ($attributes = $fields->fieldByName("ProductAttributeType")) {
$attributes->getConfig()->removeComponentsByType("GridFieldAddNewButton")->addComponent($multiclass = new GridFieldAddNewMultiClass());
$multiclass->setClasses(array_values(ClassInfo::subclassesFor("ProductAttributeType")));
}
}
/**
* @return Array
*/
public static function get_all_tests()
{
ManifestBuilder::load_test_manifest();
$tests = ClassInfo::subclassesFor('SapphireTest');
array_shift($tests);
return $tests;
}
public function testEveryFieldTransformsDisabledAsClone()
{
$fieldClasses = ClassInfo::subclassesFor('FormField');
foreach ($fieldClasses as $fieldClass) {
$reflectionClass = new ReflectionClass($fieldClass);
if (!$reflectionClass->isInstantiable()) {
continue;
}
$constructor = $reflectionClass->getMethod('__construct');
if ($constructor->getNumberOfRequiredParameters() > 1) {
continue;
}
if ($fieldClass == 'CompositeField' || is_subclass_of($fieldClass, 'CompositeField')) {
continue;
}
if ($fieldClass = 'NullableField') {
$instance = new $fieldClass(new TextField("{$fieldClass}_instance"));
} else {
$instance = new $fieldClass("{$fieldClass}_instance");
}
$isDisabledBefore = $instance->isDisabled();
$disabledInstance = $instance->performDisabledTransformation();
$this->assertEquals($isDisabledBefore, $instance->isDisabled(), "FormField class {$fieldClass} retains its disabled state after calling performDisabledTransformation()");
$this->assertTrue($disabledInstance->isDisabled(), "FormField class {$fieldClass} returns a valid disabled representation as of isDisabled()");
$this->assertNotSame($disabledInstance, $instance, "FormField class {$fieldClass} returns a valid cloned disabled representation");
}
}
/**
* @return SS_List of SilverStripeNavigatorItem
*/
function getItems() {
$items = array();
$classes = ClassInfo::subclassesFor('SilverStripeNavigatorItem');
array_shift($classes);
// Sort menu items according to priority
$i = 0;
foreach($classes as $class) {
// Skip base class
if($class == 'SilverStripeNavigatorItem') continue;
$i++;
$item = new $class($this->record);
if(!$item->canView()) continue;
// This funny litle formula ensures that the first item added with the same priority will be left-most.
$priority = $item->getPriority() * 100 - 1;
// Ensure that we can have duplicates with the same (default) priority
while(isset($items[$priority])) $priority++;
$items[$priority] = $item;
}
ksort($items);
return new ArrayList($items);
}
/**
* Create a new report
*
* @param array $data
* @param Form $form
*/
public function createreport($data, $form)
{
// assume a user's okay if they can edit the reportholder
// @TODO have a new create permission here?
if ($this->data()->canEdit()) {
$type = $data['ReportType'];
$classes = ClassInfo::subclassesFor('AdvancedReport');
if (!in_array($type, $classes)) {
throw new Exception("Invalid report type");
}
$report = new ReportPage();
$report->Title = $data['ReportName'];
$report->MetaDescription = isset($data['ReportDescription']) ? $data['ReportDescription'] : '';
$report->ReportType = $type;
$report->ParentID = $this->data()->ID;
$oldMode = Versioned::get_reading_mode();
Versioned::reading_stage('Stage');
$report->write();
$report->doPublish();
Versioned::reading_stage('Live');
$this->redirect($report->Link());
} else {
$form->sessionMessage(_t('ReporHolder.NO_PERMISSION', 'You do not have permission to do that'), 'warning');
$this->redirect($this->data()->Link());
}
}
/**
* Return an ArrayList of pages with the Element Page Extension
*
* @return ArrayList
*/
public function getOwnerPage()
{
$originalMode = Versioned::current_stage();
Versioned::reading_stage('Stage');
foreach (get_declared_classes() as $class) {
if (is_subclass_of($class, 'SiteTree')) {
$object = singleton($class);
$classes = ClassInfo::subclassesFor('ElementPageExtension');
$isElemental = false;
foreach ($classes as $extension) {
if ($object->hasExtension($extension)) {
$isElemental = true;
}
}
if ($isElemental) {
$page = $class::get()->filter('ElementAreaID', $this->ID);
if ($page && $page->exists()) {
Versioned::reading_stage($originalMode);
return $page->first();
}
}
}
}
Versioned::reading_stage($originalMode);
return false;
}
/**
* Model classes, grouped by Module
*/
function Modules() {
$classes = ClassInfo::subclassesFor('DataObject');
array_shift($classes);
$modules = array();
foreach($classes as $class) {
$model = new ModelViewer_Model($class);
if(!isset($modules[$model->Module])) $modules[$model->Module] = new DataObjectSet();
$modules[$model->Module]->push($model);
}
ksort($modules);
unset($modules['userforms']);
if($this->module) {
$modules = array($this->module => $modules[$this->module]);
}
$output = new DataObjectSet();
foreach($modules as $moduleName => $models) {
$output->push(new ArrayData(array(
'Link' => 'dev/viewmodel/' . $moduleName,
'Name' => $moduleName,
'Models' => $models,
)));
}
return $output;
}
/**
* ReplaceFileFields
*/
public static function ReplaceFileFields()
{
if (Config::inst()->get('CloudinaryConfigs', 'replace_relationships')) {
$arrRelationships = array('has_one', 'has_many', 'many_many');
$classes = ClassInfo::subclassesFor('DataObject');
foreach ($classes as $className) {
foreach ($arrRelationships as $relationType) {
if ($relation = Config::inst()->get($className, $relationType)) {
if (in_array('File', $relation) || in_array('Image', $relation)) {
$updateRelations = array();
foreach ($relation as $field => $type) {
$newType = $type;
if ($type == 'File') {
$newType = 'CloudinaryFile';
}
if ($type == 'Image') {
$newType = 'CloudinaryImage';
}
$updateRelations[$field] = $newType;
}
Config::inst()->update($className, $relationType, $updateRelations);
}
}
}
}
}
}
function getManagedModels()
{
$classes = $this->stat('managed_models');
if (is_string($classes)) {
$matches = explode(",", $classes);
foreach ($matches as $key => $value) {
$matches[$key] = substr($value, 10);
}
// remove "decorator:"
if (is_array($matches)) {
$classes = array();
foreach (ClassInfo::subclassesFor('DataObject') as $class) {
$add = false;
// used to guarantee that if multiple matches on a class it's not added multiple times.
foreach ($matches as $match) {
if (Object::has_extension($class, $match)) {
$add = true;
}
}
if ($add) {
$classes[] = $class;
}
}
if (count($class) > 1) {
array_unshift($classes, 'All');
}
} else {
$classes = array($classes);
}
}
return $classes;
}
/**
* Include CSS for page icons. We're not using the JSTree 'types' option
* because it causes too much performance overhead just to add some icons.
*
* @return String CSS
*/
public function generatePageIconsCss()
{
$css = '';
$classes = ClassInfo::subclassesFor('SiteTree');
foreach ($classes as $class) {
$obj = singleton($class);
$iconSpec = $obj->stat('icon');
if (!$iconSpec) {
continue;
}
// Legacy support: We no longer need separate icon definitions for folders etc.
$iconFile = is_array($iconSpec) ? $iconSpec[0] : $iconSpec;
// Legacy support: Add file extension if none exists
if (!pathinfo($iconFile, PATHINFO_EXTENSION)) {
$iconFile .= '-file.gif';
}
$iconPathInfo = pathinfo($iconFile);
// Base filename
$baseFilename = $iconPathInfo['dirname'] . '/' . $iconPathInfo['filename'];
$fileExtension = $iconPathInfo['extension'];
$selector = ".page-icon.class-{$class}, li.class-{$class} > a .jstree-pageicon";
if (Director::fileExists($iconFile)) {
$css .= "{$selector} { background: transparent url('{$iconFile}') 0 0 no-repeat; }\n";
} else {
// Support for more sophisticated rules, e.g. sprited icons
$css .= "{$selector} { {$iconFile} }\n";
}
}
return $css;
}
/**
* Returns an array of variants.
*
* With no arguments, returns all variants
*
* With a classname as the first argument, returns the variants that apply to that class
* (optionally including subclasses)
*
* @static
* @param string $class - The class name to get variants for
* @param bool $includeSubclasses - True if variants should be included if they apply to at least one subclass of $class
* @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
*/
public static function variants($class = null, $includeSubclasses = true)
{
if (!$class) {
if (self::$variants === null) {
$classes = ClassInfo::subclassesFor('SearchVariant');
$concrete = array();
foreach ($classes as $variantclass) {
$ref = new ReflectionClass($variantclass);
if ($ref->isInstantiable()) {
$variant = singleton($variantclass);
if ($variant->appliesToEnvironment()) {
$concrete[$variantclass] = $variant;
}
}
}
self::$variants = $concrete;
}
return self::$variants;
} else {
$key = $class . '!' . $includeSubclasses;
if (!isset(self::$class_variants[$key])) {
self::$class_variants[$key] = array();
foreach (self::variants() as $variantclass => $instance) {
if ($instance->appliesTo($class, $includeSubclasses)) {
self::$class_variants[$key][$variantclass] = $instance;
}
}
}
return self::$class_variants[$key];
}
}
public function updateCMSFields(FieldList $fields)
{
if ($this->owner->ID) {
// Relation handler for Blocks
$SConfig = GridFieldConfig_RelationEditor::create(25);
$SConfig->addComponent(new GridFieldOrderableRows('SortOrder'));
$SConfig->addComponent(new GridFieldDeleteAction());
// If the copy button module is installed, add copy as option
if (class_exists('GridFieldCopyButton')) {
$SConfig->addComponent(new GridFieldCopyButton(), 'GridFieldDeleteAction');
}
$gridField = new GridField("Blocks", "Content blocks", $this->owner->Blocks(), $SConfig);
$classes = array_values(ClassInfo::subclassesFor($gridField->getModelClass()));
if (count($classes) > 1 && class_exists('GridFieldAddNewMultiClass')) {
$SConfig->removeComponentsByType('GridFieldAddNewButton');
$SConfig->addComponent(new GridFieldAddNewMultiClass());
}
if (self::$create_block_tab) {
$fields->addFieldToTab("Root.Blocks", $gridField);
} else {
// Downsize the content field
$fields->removeByName('Content');
$fields->addFieldToTab('Root.Main', HTMLEditorField::create('Content')->setRows(self::$contentarea_rows), 'Metadata');
$fields->addFieldToTab("Root.Main", $gridField, 'Metadata');
}
}
return $fields;
}
/**
* @return array
*/
public function find()
{
$base_entity = singleton($this->table_name);
$relation_name = $this->alias->getName();
$class_name = ClassInfo::baseDataClass($this->table_name);
$subclasses = array_keys(ClassInfo::subclassesFor($class_name));
do {
// relationships ...
$has_many = Config::inst()->get($class_name, 'has_many');
$has_many_many = Config::inst()->get($class_name, 'many_many');
$has_one = Config::inst()->get($class_name, 'has_one');
$belongs_many_many = Config::inst()->get($class_name, 'belongs_many_many');
if (!is_null($has_many) && array_key_exists($relation_name, $has_many)) {
break;
}
if (!is_null($has_one) && array_key_exists($relation_name, $has_one)) {
break;
}
if (!is_null($has_many_many) && array_key_exists($relation_name, $has_many_many)) {
break;
}
if (!is_null($belongs_many_many) && array_key_exists($relation_name, $belongs_many_many)) {
break;
}
$class_name = array_pop($subclasses);
if (is_null($class_name)) {
// we arrive to the end of the hierarchy and didnt find any relation with that name
throw new InvalidArgumentException(sprintf(' relation %s does not exist for %s', $relation_name, $this->table_name));
}
$base_entity = singleton($class_name);
} while (true);
return array($base_entity, $has_one, $has_many, $has_many_many, $belongs_many_many);
}
/**
*
* @return ArrayList
*/
public function AvailableWidgets()
{
$widgets = new ArrayList();
foreach ($this->widgetClasses as $widgetClass) {
$classes = ClassInfo::subclassesFor($widgetClass);
if (isset($classes['Widget'])) {
unset($classes['Widget']);
} else {
if (isset($classes[0]) && $classes[0] == 'Widget') {
unset($classes[0]);
}
}
foreach ($classes as $class) {
$available = Config::inst()->get($class, 'only_available_in');
if (!empty($available) && is_array($available)) {
if (in_array($this->Name, $available)) {
$widgets->push(singleton($class));
}
} else {
$widgets->push(singleton($class));
}
}
}
return $widgets;
}
/**
* Gets the classes that can be created using this button, defaulting to the model class and
* its subclasses.
*
* @param GridField $grid
* @return array a map of class name to title
*/
public function getClasses(GridField $grid)
{
$result = array();
if (is_null($this->classes)) {
$classes = array_values(ClassInfo::subclassesFor($grid->getModelClass()));
sort($classes);
} else {
$classes = $this->classes;
}
foreach ($classes as $class => $title) {
if (!is_string($class)) {
$class = $title;
if (($reflection = new ReflectionClass($class)) && $reflection->isAbstract()) {
continue;
}
$title = singleton($class)->i18n_singular_name();
} else {
if (($reflection = new ReflectionClass($class)) && $reflection->isAbstract()) {
continue;
}
}
if (!singleton($class)->canCreate()) {
continue;
}
$result[$class] = $title;
}
return $result;
}
public function getPopularInteractions($interactionType, $itemClass, $days, $number = 10)
{
$since = date('Y-m-d H:i:s', strtotime("-{$days} days"));
// Execute an SQL query so we can group by and count.
$interactions = UserInteraction::get()->filter(array('Type' => $interactionType, 'ItemClass' => $itemClass, 'Created:GreaterThan' => $since));
$interactionType = Convert::raw2sql($interactionType);
$itemClass = Convert::raw2sql($itemClass);
$subs = ClassInfo::subclassesFor($itemClass);
$subs[] = $itemClass;
if ($i = array_search('ErrorPage', $subs)) {
unset($subs[$i]);
}
$in = "'" . implode("','", $subs) . "'";
$query = new SQLQuery('*', 'UserInteraction', "Type = '{$interactionType}' AND ItemClass IN ({$in}) AND DATEDIFF(NOW(), Created) <= {$days}", 'Views DESC, Title ASC', 'Title', '', $number);
$query->selectField('COUNT(Title)', 'Views');
$results = $query->execute();
$container = ArrayList::create();
// The array list will need to be populated with objects so the template accepts it.
for ($i = 0; $i < $results->numRecords(); $i++) {
$object = UserInteraction::create($results->record());
if ($object->canView()) {
$container->add($object);
}
}
return $container;
}
/**
* Additional magic happens here. Trick LeftAndMain into thinking we're a previewable SiteTree object.
*
* @return Form
*/
public function ItemEditForm()
{
Requirements::javascript(MODULATOR_PATH . '/javascript/LeftAndMain.Preview.js');
$form = parent::ItemEditForm();
$record = $this->getRecord();
// Hide the 'Save & publish' button if we're on a brand new module.
if ($record && $record->ID == 0) {
$actions = $form->Actions();
// Remove the publish button on the pre-module state
$actions->removeByName('action_publish');
// Remove the save action if there are no sub-classes to instantiate
$classes = ClassInfo::subclassesFor('PageModule');
unset($classes['PageModule']);
if (!count($classes)) {
$actions->removeByName('action_save');
}
}
// Enable CMS preview
// .cms-previewable enables the preview panel in the front-end
// .cms-pagemodule CSS class is used by our javascript to handle previews
if ($form && is_object($form)) {
$form->addExtraClass('cms-previewable cms-pagemodule');
}
// Creat a navigaor and point it at the parent page
$navigator = new SilverStripeNavigator($this->record->Page());
$navField = new LiteralField('SilverStripeNavigator', $navigator->renderWith('LeftAndMain_SilverStripeNavigator'));
$navField->setAllowHTML(true);
$fields = $form->Fields();
$fields->push($navField);
return $form;
}
public function getCMSFields()
{
$fields = parent::getCMSFields();
$fields->removeByName('ConfiguredScheduleID');
$interval = $fields->dataFieldByName('Interval')->setDescription('Number of seconds between each run. e.g 3600 is 1 hour');
$fields->replaceField('Interval', $interval);
$dt = new DateTime();
$fields->replaceField('StartDate', DateField::create('StartDate')->setConfig('dateformat', 'dd/MM/yyyy')->setConfig('showcalendar', true)->setDescription('DD/MM/YYYY e.g. ' . $dt->format('d/m/y')));
$fields->replaceField('EndDate', DateField::create('EndDate')->setConfig('dateformat', 'dd/MM/yyyy')->setConfig('showcalendar', true)->setDescription('DD/MM/YYYY e.g. ' . $dt->format('d/m/y')));
if ($this->ID == null) {
foreach ($fields->dataFields() as $field) {
//delete all included fields
$fields->removeByName($field->Name);
}
$rangeTypes = ClassInfo::subclassesFor('ScheduleRange');
$fields->addFieldToTab('Root.Main', TextField::create('Title', 'Title'));
$fields->addFieldToTab('Root.Main', DropdownField::create('ClassName', 'Range Type', $rangeTypes));
} else {
$fields->addFieldToTab('Root.Main', ReadonlyField::create('ClassName', 'Type'));
}
if ($this->ClassName == __CLASS__) {
$fields->removeByName('ApplicableDays');
}
return $fields;
}
/**
* Gets the classes that can be created using this button, defaulting to the model class and
* its subclasses.
*
* @param \GridField $grid
* @return array a map of class name to title
*/
public function getAllowedClasses(\GridField $grid)
{
$result = array();
if ($this->useAllowedClasses) {
$classes = $this->useAllowedClasses;
$this->useAllowedClasses = null;
return $classes;
} else {
if (is_null($this->allowedClasses)) {
$classes = array_values(\ClassInfo::subclassesFor($grid->getModelClass()));
sort($classes);
} else {
$classes = $this->allowedClasses;
}
}
foreach ($classes as $class => $title) {
if (!is_string($class)) {
$class = $title;
$title = singleton($class)->i18n_singular_name();
}
if (!singleton($class)->canCreate()) {
continue;
}
$result[$class] = $title;
}
return $result;
}
/**
* Initializes context.
* Every scenario gets it's own context object.
*
* @param array $parameters context parameters (set them up through behat.yml)
*/
public function __construct(array $parameters)
{
parent::__construct($parameters);
$this->useContext('BasicContext', new BasicContext($parameters));
$this->useContext('LoginContext', new LoginContext($parameters));
$this->useContext('CmsFormsContext', new CmsFormsContext($parameters));
$this->useContext('CmsUiContext', new CmsUiContext($parameters));
$fixtureContext = new FixtureContext($parameters);
$fixtureContext->setFixtureFactory($this->getFixtureFactory());
$this->useContext('FixtureContext', $fixtureContext);
// Use blueprints to set user name from identifier
$factory = $fixtureContext->getFixtureFactory();
$blueprint = \Injector::inst()->create('FixtureBlueprint', 'Member');
$blueprint->addCallback('beforeCreate', function ($identifier, &$data, &$fixtures) {
if (!isset($data['FirstName'])) {
$data['FirstName'] = $identifier;
}
});
$factory->define('Member', $blueprint);
// Auto-publish pages
foreach (\ClassInfo::subclassesFor('SiteTree') as $id => $class) {
$blueprint = \Injector::inst()->create('FixtureBlueprint', $class);
$blueprint->addCallback('afterCreate', function ($obj, $identifier, &$data, &$fixtures) {
$obj->publish('Stage', 'Live');
});
$factory->define($class, $blueprint);
}
}
/**
*
* @return ArrayList
*/
public function AvailableWidgets()
{
$widgets = new ArrayList();
foreach ($this->widgetClasses as $widgetClass) {
$classes = ClassInfo::subclassesFor($widgetClass);
if (isset($classes['Widget'])) {
unset($classes['Widget']);
} else {
if (isset($classes[0]) && $classes[0] == 'Widget') {
unset($classes[0]);
}
}
$record = $this->form->getRecord();
$availableWidgets = null;
$restrictedWidgets = null;
if ($record) {
$availableWidgets = $record->config()->available_widgets;
$restrictedWidgets = $record->config()->restricted_widgets;
}
foreach ($classes as $class) {
if (!empty($availableWidgets) && is_array($availableWidgets) && !in_array($class, $availableWidgets) || !empty($restrictedWidgets) && is_array($restrictedWidgets) && in_array($class, $restrictedWidgets)) {
continue;
}
$available = Config::inst()->get($class, 'only_available_in');
if (!empty($available) && is_array($available)) {
if (in_array($this->Name, $available)) {
$widgets->push(singleton($class));
}
} else {
$widgets->push(singleton($class));
}
}
}
return $widgets;
}
public function index()
{
$subclasses = ClassInfo::subclassesFor($this->class);
unset($subclasses[$this->class]);
if ($subclasses) {
$subclass = array_pop($subclasses);
$task = new $subclass();
$task->index();
return;
}
// Check if access key exists
if (!isset($_REQUEST['Key'])) {
echo 'Error: Access validation failed. No "Key" specified.';
return;
}
// Check against access key defined in _config.php
if ($_REQUEST['Key'] != EMAIL_BOUNCEHANDLER_KEY) {
echo 'Error: Access validation failed. Invalid "Key" specified.';
return;
}
if (!$_REQUEST['Email']) {
echo "No email address";
return;
}
$this->recordBounce($_REQUEST['Email'], $_REQUEST['Date'], $_REQUEST['Time'], $_REQUEST['Message']);
}
/**
* @param SiteTree $record
* @return Array template data
*/
static function get_for_record($record)
{
$items = '';
$message = '';
$navItemClasses = ClassInfo::subclassesFor('SilverStripeNavigatorItem');
array_shift($navItemClasses);
// Sort menu items according to priority
$menuPriority = array();
$i = 0;
foreach ($navItemClasses as $navItemClass) {
if ($navItemClass == 'SilverStripeNavigatorItem') {
continue;
}
$i++;
$obj = new $navItemClass();
// This funny litle formula ensures that the first item added with the same priority will be left-most.
$priority = Object::get_static($navItemClass, 'priority');
$menuPriority[$priority * 100 - 1] = $obj;
}
ksort($menuPriority);
foreach ($menuPriority as $obj) {
$text = $obj->getHTML($record);
if ($text) {
$items .= $text;
}
$newMessage = $obj->getMessage($record);
if ($newMessage) {
$message = $newMessage;
}
}
return array('items' => $items, 'message' => $message);
}
/**
* @return SS_List of SilverStripeNavigatorItem
*/
public function getItems()
{
$items = array();
$classes = ClassInfo::subclassesFor('SilverStripeNavigatorItem');
array_shift($classes);
// Sort menu items according to priority
$i = 0;
foreach ($classes as $class) {
// Skip base class
if ($class == 'SilverStripeNavigatorItem') {
continue;
}
$i++;
$item = new $class($this->record);
if (!$item->canView()) {
continue;
}
// This funny litle formula ensures that the first item added with the same priority will be left-most.
$priority = $item->getPriority() * 100 - 1;
// Ensure that we can have duplicates with the same (default) priority
while (isset($items[$priority])) {
$priority++;
}
$items[$priority] = $item;
}
ksort($items);
// Drop the keys and let the ArrayList handle the numbering, so $First, $Last and others work properly.
return new ArrayList(array_values($items));
}
public function sourceRecords($params = null)
{
$classes = ClassInfo::subclassesFor('RedirectorPage');
$classParams = DB::placeholders($classes);
$classFilter = array("\"ClassName\" IN ({$classParams}) AND \"HasBrokenLink\" = 1" => $classes);
$stage = isset($params['OnLive']) ? 'Live' : 'Stage';
return Versioned::get_by_stage('SiteTree', $stage, $classFilter);
}
