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); }