338 lines
8.7 KiB
PHP
338 lines
8.7 KiB
PHP
<?php
|
|
|
|
namespace SilverStripe\ORM;
|
|
|
|
use InvalidArgumentException;
|
|
use ArrayIterator;
|
|
use SilverStripe\ORM\FieldType\DBField;
|
|
|
|
/**
|
|
* An {@link ArrayList} that represents an unsaved relation.
|
|
*
|
|
* has_many and many_many relations cannot be saved until after the DataObject
|
|
* they're on has been written. This List pretends to be a RelationList and
|
|
* stores the related objects in memory.
|
|
*
|
|
* It can store both saved objects (as IDs) or unsaved objects (as instances
|
|
* of $dataClass). Unsaved objects are then written when the list is saved
|
|
* into an instance of {@link RelationList}.
|
|
*/
|
|
class UnsavedRelationList extends ArrayList implements Relation
|
|
{
|
|
|
|
/**
|
|
* The DataObject class name that this relation is on
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $baseClass;
|
|
|
|
/**
|
|
* The name of the relation
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $relationName;
|
|
|
|
/**
|
|
* The DataObject class name that this relation is querying
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $dataClass;
|
|
|
|
/**
|
|
* The extra fields associated with the relation
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $extraFields = [];
|
|
|
|
/**
|
|
* Create a new UnsavedRelationList
|
|
*
|
|
* @param string $baseClass
|
|
* @param string $relationName
|
|
* @param string $dataClass The DataObject class used in the relation
|
|
*/
|
|
public function __construct($baseClass, $relationName, $dataClass)
|
|
{
|
|
$this->baseClass = $baseClass;
|
|
$this->relationName = $relationName;
|
|
$this->dataClass = $dataClass;
|
|
parent::__construct();
|
|
}
|
|
|
|
/**
|
|
* Add an item to this relationship
|
|
*
|
|
* @param mixed $item
|
|
* @param array $extraFields A map of additional columns to insert into the joinTable in the case of a many_many relation
|
|
*/
|
|
public function add($item, $extraFields = null)
|
|
{
|
|
$this->push($item, $extraFields);
|
|
}
|
|
|
|
/**
|
|
* Save all the items in this list into the RelationList
|
|
*
|
|
* @param RelationList $list
|
|
*/
|
|
public function changeToList(RelationList $list)
|
|
{
|
|
foreach ($this->items as $key => $item) {
|
|
$list->add($item, $this->extraFields[$key]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pushes an item onto the end of this list.
|
|
*
|
|
* @param array|object $item
|
|
* @param array $extraFields
|
|
*/
|
|
public function push($item, $extraFields = null)
|
|
{
|
|
if ((is_object($item) && !$item instanceof $this->dataClass)
|
|
|| (!is_object($item) && !is_numeric($item))
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
"UnsavedRelationList::add() expecting a $this->dataClass object, or ID value"
|
|
);
|
|
}
|
|
if (is_object($item) && $item->ID) {
|
|
$item = $item->ID;
|
|
}
|
|
$this->extraFields[] = $extraFields;
|
|
parent::push($item);
|
|
}
|
|
|
|
/**
|
|
* Get the dataClass name for this relation, ie the DataObject ClassName
|
|
*
|
|
* @return string
|
|
*/
|
|
public function dataClass()
|
|
{
|
|
return $this->dataClass;
|
|
}
|
|
|
|
/**
|
|
* Returns an Iterator for this relation.
|
|
*
|
|
* @return ArrayIterator
|
|
*/
|
|
#[\ReturnTypeWillChange]
|
|
public function getIterator()
|
|
{
|
|
return new ArrayIterator($this->toArray());
|
|
}
|
|
|
|
/**
|
|
* Return an array of the actual items that this relation contains at this stage.
|
|
* This is when the query is actually executed.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function toArray()
|
|
{
|
|
$items = [];
|
|
foreach ($this->items as $key => $item) {
|
|
if (is_numeric($item)) {
|
|
$item = DataObject::get_by_id($this->dataClass, $item);
|
|
}
|
|
if (!empty($this->extraFields[$key])) {
|
|
$item->update($this->extraFields[$key]);
|
|
}
|
|
$items[] = $item;
|
|
}
|
|
return $items;
|
|
}
|
|
|
|
/**
|
|
* Add a number of items to the relation.
|
|
*
|
|
* @param array $items Items to add, as either DataObjects or IDs.
|
|
* @return $this
|
|
*/
|
|
public function addMany($items)
|
|
{
|
|
foreach ($items as $item) {
|
|
$this->add($item);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Remove all items from this relation.
|
|
*/
|
|
public function removeAll()
|
|
{
|
|
$this->items = [];
|
|
$this->extraFields = [];
|
|
}
|
|
|
|
/**
|
|
* Remove the items from this list with the given IDs
|
|
*
|
|
* @param array $items
|
|
* @return $this
|
|
*/
|
|
public function removeMany($items)
|
|
{
|
|
$this->items = array_diff($this->items ?? [], $items);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Removes items from this list which are equal.
|
|
*
|
|
* @param string $field unused
|
|
*/
|
|
public function removeDuplicates($field = 'ID')
|
|
{
|
|
$this->items = array_unique($this->items ?? []);
|
|
}
|
|
|
|
/**
|
|
* Sets the Relation to be the given ID list.
|
|
* Records will be added and deleted as appropriate.
|
|
*
|
|
* @param array $idList List of IDs.
|
|
*/
|
|
public function setByIDList($idList)
|
|
{
|
|
$this->removeAll();
|
|
$this->addMany($idList);
|
|
}
|
|
|
|
/**
|
|
* Returns an array with both the keys and values set to the IDs of the records in this list.
|
|
* Does not respect sort order. Use ->column("ID") to get an ID list with the current sort.
|
|
* Does not return the IDs for unsaved DataObjects.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getIDList()
|
|
{
|
|
// Get a list of IDs of our current items - if it's not a number then object then assume it's a DO.
|
|
$ids = array_map(function ($obj) {
|
|
return is_numeric($obj) ? $obj : $obj->ID;
|
|
}, $this->items ?? []);
|
|
|
|
// Strip out duplicates and anything resolving to False.
|
|
$ids = array_filter(array_unique($ids ?? []));
|
|
|
|
// Change the array from (1, 2, 3) to (1 => 1, 2 => 2, 3 => 3)
|
|
if ($ids) {
|
|
$ids = array_combine($ids ?? [], $ids ?? []);
|
|
}
|
|
|
|
return $ids;
|
|
}
|
|
|
|
/**
|
|
* Returns the first item in the list
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function first()
|
|
{
|
|
$item = reset($this->items) ?: null;
|
|
if (is_numeric($item)) {
|
|
$item = DataObject::get_by_id($this->dataClass, $item);
|
|
}
|
|
if ($item && !empty($this->extraFields[key($this->items)])) {
|
|
$item->update($this->extraFields[key($this->items)]);
|
|
}
|
|
return $item;
|
|
}
|
|
|
|
/**
|
|
* Returns the last item in the list
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function last()
|
|
{
|
|
$item = end($this->items) ?: null;
|
|
if (is_numeric($item)) {
|
|
$item = DataObject::get_by_id($this->dataClass, $item);
|
|
}
|
|
if ($item && !empty($this->extraFields[key($this->items)])) {
|
|
$item->update($this->extraFields[key($this->items)]);
|
|
}
|
|
return $item;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of a single field value for all items in the list.
|
|
*
|
|
* @param string $colName
|
|
* @return array
|
|
*/
|
|
public function column($colName = 'ID')
|
|
{
|
|
$list = new ArrayList($this->toArray());
|
|
return $list->column($colName);
|
|
}
|
|
|
|
/**
|
|
* Returns a unique array of a single field value for all items in the list.
|
|
*
|
|
* @param string $colName
|
|
* @return array
|
|
*/
|
|
public function columnUnique($colName = "ID")
|
|
{
|
|
$list = new ArrayList($this->toArray());
|
|
return $list->columnUnique($colName);
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of this list with the relationship linked to the given foreign ID.
|
|
* @param int|array $id An ID or an array of IDs.
|
|
* @return Relation
|
|
*/
|
|
public function forForeignID($id)
|
|
{
|
|
$singleton = DataObject::singleton($this->baseClass);
|
|
/** @var Relation $relation */
|
|
$relation = $singleton->{$this->relationName}($id);
|
|
return $relation;
|
|
}
|
|
|
|
/**
|
|
* @param string $relationName
|
|
* @return Relation
|
|
*/
|
|
public function relation($relationName)
|
|
{
|
|
$ids = $this->column('ID');
|
|
$singleton = DataObject::singleton($this->dataClass);
|
|
/** @var Relation $relation */
|
|
$relation = $singleton->$relationName($ids);
|
|
return $relation;
|
|
}
|
|
|
|
/**
|
|
* Return the DBField object that represents the given field on the related class.
|
|
*
|
|
* @param string $fieldName Name of the field
|
|
* @return DBField The field as a DBField object
|
|
*/
|
|
public function dbObject($fieldName)
|
|
{
|
|
return DataObject::singleton($this->dataClass)->dbObject($fieldName);
|
|
}
|
|
|
|
protected function extractValue($item, $key)
|
|
{
|
|
if (is_numeric($item)) {
|
|
$item = DataObject::get_by_id($this->dataClass, $item);
|
|
}
|
|
return parent::extractValue($item, $key);
|
|
}
|
|
}
|