ExternalContentItem::getCMSFields() - Code Metrics - Inspection of "MINOR: Added Scrutinizer config" - phptek/silverstripe-exodus - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 357bf5...71cdad )

by Russell

created 2022-09-03 06:43 UTC

ExternalContentItem::getCMSFields() C

↳ Parent: Project

Complexity

Conditions	16
Paths	2

Size

Total Lines	38
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
eloc	27
c	1
b	0
f	1
dl	0
loc	38
rs	5.5666
cc	16
nc	2
nop	0

How to fix Complexity

<?php

use SilverStripe\ORM\DataObject;
use SilverStripe\Control\Controller;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Forms\ReadonlyField;

/**
 * Parent class for all ExternalContentItems.
 *
 * On construction, an ExternalContentItem subclass must load data from the
 * remote repository through the appropriate API layer as returned by getRemoteRepository()
 * from the external content source. It is then up to the content item to
 * store that data in a way that can be used by the rest of SilverStripe.
 *
 * For now, the ExternalContentItem provides the remoteProperties map for
 * storing things, with __get and __set magic methods for retrieving values.
 * Some implementations may choose to store the data in a separate object (for
 * example, the AlfrescoContentItem implementation simply stores things in its
 * contained CMS object and maps back and forward from that).
 *
 * @author Marcus Nyeholt <[email protected]>
 * @license BSD License http://silverstripe.org/bsd-license
 */
class ExternalContentItem extends DataObject
{
    /**
     * @var array
     */
    private static $db = [];

    /**
     * @var string
     */
    private static $table_name = 'ExternalContentItem';

    /**
     * @var string The icon for cms tree
     */
    private static $icon = null;

    protected $ownerId;

    /**
     * The ID of this item in the remote system
     *
     * @var mixed
     */
    protected $externalId;

    public function setOwnerId($id)
    {
        $this->ownerId = $id;
    }

    /**
     * The content source object that this item belongs to
     *
     * @var ExternalContentSource
     */
    protected $source;


    /**
     * The child nodes of this item
     *
     * @var ArrayList
     */
    private $children;

    /**
     * Create a new external content item.
     *
     * @param mixed $source
     * 			The contentSource object this item was laoded through
     * @param mixed $id
     * 			The ID of the item in the remote system
     * @param mixed $content
     * 			A raw representation of the remote item. This allows for
     * 			some systems loading up entire representations when you make
     * 			a call to 'getChildren', for example.
     */
    public function __construct($source = null, $id = null)
    {
        parent::__construct();
        if ($source) {
            $this->source = $source;
            $this->externalId = $id;
            // if we are here, then we have been created in context of a parent, which also
            // means there's a compound ID, so lets get that
            $this->ID = $this->source->ID . ExternalContent::ID_SEPARATOR . $this->source->encodeId($id);
            $this->ShowInMenus = $this->source->ShowContentInMenu;
            $this->init();
        }
    }

    /**
     * Return the ID of the item in its remote system
     *
     * @return string
     */
    public function getExternalId()
    {
        return $this->externalId;
    }

    /**
     * Get the type of this external object.
     *
     * Child classes must implement this as a method for certain functionality
     * to know what the remote object is
     *
     * @return String
     */
    public function getType()
    {
        throw new \Exception("Please implement " . get_class($this) . "::getType()");
    }

    /**
     * Initialise this object based on its source object
     */
    protected function init()
    {
    }

    /**
     * Get the content source for this item
     *
     * @return ExternalContentSource
     */
    public function getSource()
    {
        return $this->source;
    }

    /**
     * Override to ensure exists handles things properly
     *
     * @return boolean
     */
    public function exists()
    {
        return!is_null($this->ID);
    }

    /**
     * Return a URL that simply links back to the externalcontentadmin
     * class' 'view' action
     *
     * @param $action
     * @return String
     */
    public function Link($action = null)
    {
        $cur = Controller::curr();
        if ($cur instanceof ExternalContentPage_Controller) {
            return $cur->data()->LinkFor($this, 'view');
        }
        return ExternalContentPage_Controller::URL_STUB . '/view/' . $this->ID;
    }

    /**
     * Return a URL that simply links back to the externalcontentadmin
     * class' 'view' action
     *
     * @param $action
     * @return String
     */
    public function RelativeLink($action = null)
    {
        $cur = Controller::curr();
        if ($cur instanceof ExternalContentPage_Controller) {
            return $cur->data()->LinkFor($this, 'view');
        }
        return ExternalContentPage_Controller::URL_STUB . '/view/' . $this->ID;
    }

    /**
     * Where this can be downloaded from
     *
     * @return string
     */
    public function DownloadLink()
    {
        // get the base URL, prepend with the external content
        // controller /download action and add this object's id
        $cur = Controller::curr();
        if ($cur instanceof ExternalContentPage_Controller) {
            return $cur->data()->LinkFor($this, 'download');
        }
        return ExternalContentPage_Controller::URL_STUB . '/download/' . $this->ID;
    }

    /**
     * Get the importer for this content item
     *
     * @return ExternalContentImporter
     */
    public function getContentImporter($target=null)
    {
        return $this->source->getContentImporter($target);
    }

    /**
     * Where can this content be imported to?
     *
     * @return array
     */
    public function allowedImportTargets()
    {
        return $this->source->allowedImportTargets();
    }

    /**
     * An overrideable method to return the arbitrary 'content' of this
     * node. Child classes should implement their own version
     */
    public function Content()
    {
    }

    /**
     * Called to stream this content item (if it is streamable)
     *
     */
    public function streamContent()
    {
        throw new \Exception("This object cannot be streamed");
    }

    /**
     * Always return at least one as we never know til we load
     * whether this item has children or not
     *
     * @return int
     */
    public function numChildren()
    {
        return 1;
    }

    /**
     * Overridden to load all children from a remote content
     * source  instead of this node directly
     *
     * @param boolean $showAll
     * @return ArrayList
     */
    public function stageChildren($showAll = false)
    {
        if ($this->Title != 'Content Root' && $this->source) {
            $children = ArrayList::create();
            $item = ExternalContentItem::create($this->source, $this->Title . '1');
            $item->Title = $this->Title . '1';
            $item->MenuTitle = $item->Title;

            $children->push($item);
            return $children;
        }
    }

    /**
     * Handle a children call by retrieving from stageChildren
     */
    public function Children()
    {
        if (!$this->children) {
            $this->children = ArrayList::create();
            $kids = $this->stageChildren();
            if ($kids) {
                foreach ($kids as $child) {
                    if ($child->canView()) {
                        $this->children->push($child);
                    }
                }
            }
        }
        return $this->children;
    }

    /**
     * For now just show a field that says this can't be edited
     *
     * @see sapphire/core/model/DataObject#getCMSFields($params)
     */
    public function getCMSFields()
    {
        $fields = parent::getCMSFields();

        $fields->removeByName('ParentID');
        if (count($this->remoteProperties)) {
            $mapping = $this->editableFieldMapping();
            foreach ($this->remoteProperties as $name => $value) {
                $field = null;
                if (isset($mapping[$name])) {
                    $field = $mapping[$name];
                    if (is_string($field)) {
                        $field = new $field($name, $this->fieldLabel($name), $value);
                        $fields->addFieldToTab('Root.Main', $field);
                    }
                } elseif (!is_object($value) && !is_array($value)) {
                    $value = (string) $value;
                    $field = ReadonlyField::create($name, _t('ExternalContentItem.' . $name, $name), $value);
                    $fields->addFieldToTab('Root.Main', $field);
                } elseif (is_object($value) || is_array($value)) {
                    foreach ($value as $childName => $childValue) {
                        if (is_object($childValue)) {
                            foreach ($childValue as $childChildName => $childChildValue) {
                                $childChildValue = is_object($childChildValue) || is_array($childChildValue) ? json_encode($childChildValue) : (string) $childChildValue;
                                $field = ReadonlyField::create("{$childName}{$childChildName}", "{$childName}: {$childChildName}", $childChildValue);
                                $fields->addFieldToTab('Root.Main', $field);
                            }
                        } else {
                            $childValue =  is_object($childValue) || is_array($childValue) ? json_encode($childValue) : (string) $childValue;
                            $field = ReadonlyField::create("{$childName}{$childValue}", $name . ':' . $childName, $childValue);
                            $fields->addFieldToTab('Root.Main', $field);
                        }
                    }
                }
            }
        }

        return $fields;
    }

    /**
     * Return a mapping of remote field name => field type
     *
     * Note that this also defines the list of fields on the remote object that can be edited by end users
     * and is examined before a form save is triggered
     *
     */
    public function editableFieldMapping()
    {
        return array();
    }

    /**
     * Write back to the content source
     */
    public function remoteWrite($member = null)
    {
    }

    /**
     * We flag external content as being editable so it's
     * accessible in the backend, but the individual
     * implementations will protect users from editing... for now
     *
     * TODO: Fix this up to use proper permission checks
     *
     * @see sapphire/core/model/DataObject#canEdit($member)
     */
    public function canEdit($member = null)
    {
        return $this->source->canEdit();
    }

    /**
     * Is this item viewable?
     *
     * Just proxy to the content source for now. Child implementations can
     * override if needbe
     *
     * @see sapphire/core/model/DataObject#canView($member)
     */
    public function canView($member = null)
    {
        return $this->source->canView();
    }

    /**
     * Returns whether or not this source can be imported, defaulting to the
     * linked source's permission.
     *
     * @return bool
     */
    public function canImport()
    {
        return $this->source->canImport();
    }

    /**
     * The list of properties loaded from a remote data source
     *
     * @var array
     */
    protected $remoteProperties;

    /**
     * Overriding the default behaviour to not worry about how it
     * needs to work with the DB
     *
     * @see sapphire/core/ViewableData#__set($property, $value)
     */
    public function __set($prop, $val)
    {
        $this->remoteProperties[$prop] = $val;
    }

    /**
     * Return from the parent object if it's not in here...
     *
     * @see sapphire/core/ViewableData#__get($property)
     */
    public function __get($prop)
    {
        if (isset($this->remoteProperties[$prop])) {
            return $this->remoteProperties[$prop];
        }

        $val = parent::__get($prop);

        if (!$val) {
            if ($this->source) {
                // get it from there
                return $this->source->$prop;
            }
        }

        return $val;
    }

    /**
     * Override to let remote objects figure out whether they have a
     * field or not
     *
     * @see sapphire/core/model/DataObject#hasField($field)
     */
    public function hasField($field)
    {
        return isset($this->remoteProperties[$field]);
    }

    /**
     * Get all the remote properties
     *
     * @return array
     */
    public function getRemoteProperties()
    {
        return $this->remoteProperties;
    }

    /**
     * Perform a search query on this data source
     *
     * @param $filter A filter expression of some kind, in SQL format.
     * @param $sort A sort expression, in SQL format.
     * @param $join A join expression.  May or may not be relevant.
     * @param $limit A limit expression, either "(count)", or "(start), (count)"
     */
    public function instance_get($filter = "", $sort = "", $join = "", $limit = "", $containerClass = "ArrayList")
    {
    }

    /**
     * Retrieve a single record from this data source
     *
     * @param $filter A filter expression of some kind, in SQL format.
     * @param $sort A sort expression, in SQL format.
     * @param $join A join expression.  May or may not be relevant.
     * @param $limit A limit expression, either "(count)", or "(start), (count)"
     */
    public function instance_get_one($filter, $sort = "")
    {
    }


    /**
     * Write the current object back to the database.  It should know whether this is a new object, in which case this would
     * be an insert command, or if this is an existing object queried from the database, in which case thes would be
     */
    public function write($showDebug = false, $forceInsert = false, $forceWrite = false, $writeComponents = false)
    {
    }

    /**
     * Remove this object from the database.  Doesn't do anything if this object isn't in the database.
     */
    public function delete()
    {
    }

    /**
     * Save content from a form into a field on this data object.
     * Since the data comes straight from a form it can't be trusted and will need to be validated / escaped.'
     */
    public function setCastedField($fieldName, $val)
    {
        $mapping = $this->editableFieldMapping();
        if (isset($mapping[$fieldName])) {
            $this->$fieldName = $val;
        }
    }

    /**
     * Return the CSS classes to apply to this node in the CMS tree
     *
     * @return string
     */
    public function CMSTreeClasses()
    {
        $classes = sprintf('class-%s', $this->class);
        // Ensure that classes relating to whether there are further nodes to download are included
        $classes .= $this->markingClasses();
        return $classes;
    }


    /**
     * Return the CSS declarations to apply to nodes of this type in the CMS tree
     *
     * @return string
     */
    public function CMSTreeCSS()
    {
        return null;
    }


    /**
     * getTreeTitle will return two <span> html DOM elements, an empty <span> with
     * the class 'jstree-pageicon' in front, following by a <span> wrapping around its
     * MenutTitle
     *
     * @return string a html string ready to be directly used in a template
     */
    public function getTreeTitle()
    {
        $title = $this->Title;
        if (!$title) {
            $title = $this->Name;
        }

        $treeTitle = sprintf(
            "<span class=\"jstree-pageicon\"></span><span class=\"item\">%s</span>",
            Convert::raw2xml(str_replace(array("\n","\r"), "", $title))
        );
        return $treeTitle;
    }
}


1			<?php
2
3			use SilverStripe\ORM\DataObject;
4			use SilverStripe\Control\Controller;
5			use SilverStripe\Core\Config\Configurable;
6			use SilverStripe\ORM\ArrayList;
7			use SilverStripe\Core\Convert;
8			use SilverStripe\Core\Extensible;
9			use SilverStripe\Core\Injector\Injectable;
10			use SilverStripe\Forms\ReadonlyField;
11
12			/**
13			* Parent class for all ExternalContentItems.
14			*
15			* On construction, an ExternalContentItem subclass must load data from the
16			* remote repository through the appropriate API layer as returned by getRemoteRepository()
17			* from the external content source. It is then up to the content item to
18			* store that data in a way that can be used by the rest of SilverStripe.
19			*
20			* For now, the ExternalContentItem provides the remoteProperties map for
21			* storing things, with __get and __set magic methods for retrieving values.
22			* Some implementations may choose to store the data in a separate object (for
23			* example, the AlfrescoContentItem implementation simply stores things in its
24			* contained CMS object and maps back and forward from that).
25			*
26			* @author Marcus Nyeholt <[email protected]>
27			* @license BSD License http://silverstripe.org/bsd-license
28			*/
29			class ExternalContentItem extends DataObject
30			{
31			/**
32			* @var array
33			*/
34			private static $db = [];
35
36			/**
37			* @var string
38			*/
39			private static $table_name = 'ExternalContentItem';
40
41			/**
42			* @var string The icon for cms tree
43			*/
44			private static $icon = null;
45
46			protected $ownerId;
47
48			/**
49			* The ID of this item in the remote system
50			*
51			* @var mixed
52			*/
53			protected $externalId;
54
55			public function setOwnerId($id)
56			{
57			$this->ownerId = $id;
58			}
59
60			/**
61			* The content source object that this item belongs to
62			*
63			* @var ExternalContentSource
64			*/
65			protected $source;
66
67
68			/**
69			* The child nodes of this item
70			*
71			* @var ArrayList
72			*/
73			private $children;
74
75			/**
76			* Create a new external content item.
77			*
78			* @param mixed $source
79			* The contentSource object this item was laoded through
80			* @param mixed $id
81			* The ID of the item in the remote system
82			* @param mixed $content
83			* A raw representation of the remote item. This allows for
84			* some systems loading up entire representations when you make
85			* a call to 'getChildren', for example.
86			*/
87			public function __construct($source = null, $id = null)
88			{
89			parent::__construct();
90			if ($source) {
91			$this->source = $source;
92			$this->externalId = $id;
93			// if we are here, then we have been created in context of a parent, which also
94			// means there's a compound ID, so lets get that
95			$this->ID = $this->source->ID . ExternalContent::ID_SEPARATOR . $this->source->encodeId($id);
96			$this->ShowInMenus = $this->source->ShowContentInMenu;
97			$this->init();
98			}
99			}
100
101			/**
102			* Return the ID of the item in its remote system
103			*
104			* @return string
105			*/
106			public function getExternalId()
107			{
108			return $this->externalId;
109			}
110
111			/**
112			* Get the type of this external object.
113			*
114			* Child classes must implement this as a method for certain functionality
115			* to know what the remote object is
116			*
117			* @return String
118			*/
119			public function getType()
120			{
121			throw new \Exception("Please implement " . get_class($this) . "::getType()");
122			}
123
124			/**
125			* Initialise this object based on its source object
126			*/
127			protected function init()
128			{
129			}
130
131			/**
132			* Get the content source for this item
133			*
134			* @return ExternalContentSource
135			*/
136			public function getSource()
137			{
138			return $this->source;
139			}
140
141			/**
142			* Override to ensure exists handles things properly
143			*
144			* @return boolean
145			*/
146			public function exists()
147			{
148			return!is_null($this->ID);
149			}
150
151			/**
152			* Return a URL that simply links back to the externalcontentadmin
153			* class' 'view' action
154			*
155			* @param $action
156			* @return String
157			*/
158			public function Link($action = null)
159			{
160			$cur = Controller::curr();
161			if ($cur instanceof ExternalContentPage_Controller) {
162			return $cur->data()->LinkFor($this, 'view');
163			}
164			return ExternalContentPage_Controller::URL_STUB . '/view/' . $this->ID;
165			}
166
167			/**
168			* Return a URL that simply links back to the externalcontentadmin
169			* class' 'view' action
170			*
171			* @param $action
172			* @return String
173			*/
174			public function RelativeLink($action = null)
175			{
176			$cur = Controller::curr();
177			if ($cur instanceof ExternalContentPage_Controller) {
178			return $cur->data()->LinkFor($this, 'view');
179			}
180			return ExternalContentPage_Controller::URL_STUB . '/view/' . $this->ID;
181			}
182
183			/**
184			* Where this can be downloaded from
185			*
186			* @return string
187			*/
188			public function DownloadLink()
189			{
190			// get the base URL, prepend with the external content
191			// controller /download action and add this object's id
192			$cur = Controller::curr();
193			if ($cur instanceof ExternalContentPage_Controller) {
194			return $cur->data()->LinkFor($this, 'download');
195			}
196			return ExternalContentPage_Controller::URL_STUB . '/download/' . $this->ID;
197			}
198
199			/**
200			* Get the importer for this content item
201			*
202			* @return ExternalContentImporter
203			*/
204			public function getContentImporter($target=null)
205			{
206			return $this->source->getContentImporter($target);
207			}
208
209			/**
210			* Where can this content be imported to?
211			*
212			* @return array
213			*/
214			public function allowedImportTargets()
215			{
216			return $this->source->allowedImportTargets();
217			}
218
219			/**
220			* An overrideable method to return the arbitrary 'content' of this
221			* node. Child classes should implement their own version
222			*/
223			public function Content()
224			{
225			}
226
227			/**
228			* Called to stream this content item (if it is streamable)
229			*
230			*/
231			public function streamContent()
232			{
233			throw new \Exception("This object cannot be streamed");
234			}
235
236			/**
237			* Always return at least one as we never know til we load
238			* whether this item has children or not
239			*
240			* @return int
241			*/
242			public function numChildren()
243			{
244			return 1;
245			}
246
247			/**
248			* Overridden to load all children from a remote content
249			* source instead of this node directly
250			*
251			* @param boolean $showAll
252			* @return ArrayList
253			*/
254			public function stageChildren($showAll = false)
255			{
256			if ($this->Title != 'Content Root' && $this->source) {
257			$children = ArrayList::create();
258			$item = ExternalContentItem::create($this->source, $this->Title . '1');
259			$item->Title = $this->Title . '1';
260			$item->MenuTitle = $item->Title;
261
262			$children->push($item);
263			return $children;
264			}
265			}
266
267			/**
268			* Handle a children call by retrieving from stageChildren
269			*/
270			public function Children()
271			{
272			if (!$this->children) {
273			$this->children = ArrayList::create();
274			$kids = $this->stageChildren();
275			if ($kids) {
276			foreach ($kids as $child) {
277			if ($child->canView()) {
278			$this->children->push($child);
279			}
280			}
281			}
282			}
283			return $this->children;
284			}
285
286			/**
287			* For now just show a field that says this can't be edited
288			*
289			* @see sapphire/core/model/DataObject#getCMSFields($params)
290			*/
291			public function getCMSFields()
292			{
293			$fields = parent::getCMSFields();
294
295			$fields->removeByName('ParentID');
296			if (count($this->remoteProperties)) {
297			$mapping = $this->editableFieldMapping();
298			foreach ($this->remoteProperties as $name => $value) {
299			$field = null;
300			if (isset($mapping[$name])) {
301			$field = $mapping[$name];
302			if (is_string($field)) {
303			$field = new $field($name, $this->fieldLabel($name), $value);
304			$fields->addFieldToTab('Root.Main', $field);
305			}
306			} elseif (!is_object($value) && !is_array($value)) {
307			$value = (string) $value;
308			$field = ReadonlyField::create($name, _t('ExternalContentItem.' . $name, $name), $value);
309			$fields->addFieldToTab('Root.Main', $field);
310			} elseif (is_object($value) \|\| is_array($value)) {
311			foreach ($value as $childName => $childValue) {
312			if (is_object($childValue)) {
313			foreach ($childValue as $childChildName => $childChildValue) {
314			$childChildValue = is_object($childChildValue) \|\| is_array($childChildValue) ? json_encode($childChildValue) : (string) $childChildValue;
315			$field = ReadonlyField::create("{$childName}{$childChildName}", "{$childName}: {$childChildName}", $childChildValue);
316			$fields->addFieldToTab('Root.Main', $field);
317			}
318			} else {
319			$childValue = is_object($childValue) \|\| is_array($childValue) ? json_encode($childValue) : (string) $childValue;
320			$field = ReadonlyField::create("{$childName}{$childValue}", $name . ':' . $childName, $childValue);
321			$fields->addFieldToTab('Root.Main', $field);
322			}
323			}
324			}
325			}
326			}
327
328			return $fields;
329			}
330
331			/**
332			* Return a mapping of remote field name => field type
333			*
334			* Note that this also defines the list of fields on the remote object that can be edited by end users
335			* and is examined before a form save is triggered
336			*
337			*/
338			public function editableFieldMapping()
339			{
340			return array();
341			}
342
343			/**
344			* Write back to the content source
345			*/
346			public function remoteWrite($member = null)
347			{
348			}
349
350			/**
351			* We flag external content as being editable so it's
352			* accessible in the backend, but the individual
353			* implementations will protect users from editing... for now
354			*
355			* TODO: Fix this up to use proper permission checks
356			*
357			* @see sapphire/core/model/DataObject#canEdit($member)
358			*/
359			public function canEdit($member = null)
360			{
361			return $this->source->canEdit();
362			}
363
364			/**
365			* Is this item viewable?
366			*
367			* Just proxy to the content source for now. Child implementations can
368			* override if needbe
369			*
370			* @see sapphire/core/model/DataObject#canView($member)
371			*/
372			public function canView($member = null)
373			{
374			return $this->source->canView();
375			}
376
377			/**
378			* Returns whether or not this source can be imported, defaulting to the
379			* linked source's permission.
380			*
381			* @return bool
382			*/
383			public function canImport()
384			{
385			return $this->source->canImport();
386			}
387
388			/**
389			* The list of properties loaded from a remote data source
390			*
391			* @var array
392			*/
393			protected $remoteProperties;
394
395			/**
396			* Overriding the default behaviour to not worry about how it
397			* needs to work with the DB
398			*
399			* @see sapphire/core/ViewableData#__set($property, $value)
400			*/
401			public function __set($prop, $val)
402			{
403			$this->remoteProperties[$prop] = $val;
404			}
405
406			/**
407			* Return from the parent object if it's not in here...
408			*
409			* @see sapphire/core/ViewableData#__get($property)
410			*/
411			public function __get($prop)
412			{
413			if (isset($this->remoteProperties[$prop])) {
414			return $this->remoteProperties[$prop];
415			}
416
417			$val = parent::__get($prop);
418
419			if (!$val) {
420			if ($this->source) {
421			// get it from there
422			return $this->source->$prop;
423			}
424			}
425
426			return $val;
427			}
428
429			/**
430			* Override to let remote objects figure out whether they have a
431			* field or not
432			*
433			* @see sapphire/core/model/DataObject#hasField($field)
434			*/
435			public function hasField($field)
436			{
437			return isset($this->remoteProperties[$field]);
438			}
439
440			/**
441			* Get all the remote properties
442			*
443			* @return array
444			*/
445			public function getRemoteProperties()
446			{
447			return $this->remoteProperties;
448			}
449
450			/**
451			* Perform a search query on this data source
452			*
453			* @param $filter A filter expression of some kind, in SQL format.
454			* @param $sort A sort expression, in SQL format.
455			* @param $join A join expression. May or may not be relevant.
456			* @param $limit A limit expression, either "(count)", or "(start), (count)"
457			*/
458			public function instance_get($filter = "", $sort = "", $join = "", $limit = "", $containerClass = "ArrayList")
459			{
460			}
461
462			/**
463			* Retrieve a single record from this data source
464			*
465			* @param $filter A filter expression of some kind, in SQL format.
466			* @param $sort A sort expression, in SQL format.
467			* @param $join A join expression. May or may not be relevant.
468			* @param $limit A limit expression, either "(count)", or "(start), (count)"
469			*/
470			public function instance_get_one($filter, $sort = "")
471			{
472			}
473
474
475			/**
476			* Write the current object back to the database. It should know whether this is a new object, in which case this would
477			* be an insert command, or if this is an existing object queried from the database, in which case thes would be
478			*/
479			public function write($showDebug = false, $forceInsert = false, $forceWrite = false, $writeComponents = false)
480			{
481			}
482
483			/**
484			* Remove this object from the database. Doesn't do anything if this object isn't in the database.
485			*/
486			public function delete()
487			{
488			}
489
490			/**
491			* Save content from a form into a field on this data object.
492			* Since the data comes straight from a form it can't be trusted and will need to be validated / escaped.'
493			*/
494			public function setCastedField($fieldName, $val)
495			{
496			$mapping = $this->editableFieldMapping();
497			if (isset($mapping[$fieldName])) {
498			$this->$fieldName = $val;
499			}
500			}
501
502			/**
503			* Return the CSS classes to apply to this node in the CMS tree
504			*
505			* @return string
506			*/
507			public function CMSTreeClasses()
508			{
509			$classes = sprintf('class-%s', $this->class);
510			// Ensure that classes relating to whether there are further nodes to download are included
511			$classes .= $this->markingClasses();
512			return $classes;
513			}
514
515
516			/**
517			* Return the CSS declarations to apply to nodes of this type in the CMS tree
518			*
519			* @return string
520			*/
521			public function CMSTreeCSS()
522			{
523			return null;
524			}
525
526
527			/**
528			* getTreeTitle will return two <span> html DOM elements, an empty <span> with
529			* the class 'jstree-pageicon' in front, following by a <span> wrapping around its
530			* MenutTitle
531			*
532			* @return string a html string ready to be directly used in a template
533			*/
534			public function getTreeTitle()
535			{
536			$title = $this->Title;
537			if (!$title) {
538			$title = $this->Name;
539			}
540
541			$treeTitle = sprintf(
542			"<span class=\"jstree-pageicon\"></span><span class=\"item\">%s</span>",
543			Convert::raw2xml(str_replace(array("\n","\r"), "", $title))
544			);
545			return $treeTitle;
546			}
547			}
548

phptek / silverstripe-exodus

Push — master ( 357bf5...71cdad )

ExternalContentItem::getCMSFields() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like