/**
* Method to save this form field into the given {@link DataObject}.
*
* By default, makes use of $this->dataValue()
*
* @param DataObject|DataObjectInterface $record DataObject to save data into
*/
public function saveInto(DataObjectInterface $record)
{
if ($this->name) {
$record->setCastedField($this->name, $this->dataValue());
}
}
/**
* Save the contents of this form into the given data object.
* It will make use of setCastedField() to do this.
*
* @param DataObjectInterface $dataObject The object to save data into
* @param FieldList $fieldList An optional list of fields to process. This can be useful when you have a
* form that has some fields that save to one object, and some that save to another.
*/
public function saveInto(DataObjectInterface $dataObject, $fieldList = null)
{
$dataFields = $this->fields->saveableFields();
$lastField = null;
if ($dataFields) {
foreach ($dataFields as $field) {
// Skip fields that have been excluded
if ($fieldList && is_array($fieldList) && !in_array($field->getName(), $fieldList)) {
continue;
}
$saveMethod = "save{$field->getName()}";
if ($field->getName() == "ClassName") {
$lastField = $field;
} else {
if ($dataObject->hasMethod($saveMethod)) {
$dataObject->{$saveMethod}($field->dataValue());
} else {
if ($field->getName() != "ID") {
$field->saveInto($dataObject);
}
}
}
}
}
if ($lastField) {
$lastField->saveInto($dataObject);
}
}
public function saveInto(DataObjectInterface $record)
{
if ($record->hasField($this->name) && $record->escapeTypeForField($this->name) != 'xml') {
throw new Exception('HTMLEditorField->saveInto(): This field should save into a HTMLText or HTMLVarchar field.');
}
// Sanitise if requested
$htmlValue = Injector::inst()->create('HTMLValue', $this->Value());
if ($this->config()->sanitise_server_side) {
$santiser = Injector::inst()->create('HTMLEditorSanitiser', HTMLEditorConfig::get_active());
$santiser->sanitise($htmlValue);
}
// optionally manipulate the HTML after a TinyMCE edit and prior to a save
$this->extend('processHTML', $htmlValue);
// Store into record
$record->{$this->name} = $htmlValue->getContent();
}
public function saveInto(DataObjectInterface $record)
{
$completeNumber = static::joinPhoneNumber($this->parseValue());
$record->setCastedField($this->getName(), $completeNumber);
}
/**
* @param DataObject|DataObjectInterface $record
* @return $this
*/
public function saveInto(DataObjectInterface $record)
{
// Check required relation details are available
$fieldname = $this->getName();
if (!$fieldname) {
return $this;
}
// Get details to save
$idList = $this->getItemIDs();
// Check type of relation
$relation = $record->hasMethod($fieldname) ? $record->{$fieldname}() : null;
if ($relation && ($relation instanceof RelationList || $relation instanceof UnsavedRelationList)) {
// has_many or many_many
$relation->setByIDList($idList);
} elseif (DataObject::getSchema()->hasOneComponent(get_class($record), $fieldname)) {
// has_one
$record->{"{$fieldname}ID"} = $idList ? reset($idList) : 0;
}
return $this;
}
/**
* Save the results into the form
* Calls function $record->onChange($items) before saving to the assummed
* Component set.
*
* @param DataObjectInterface $record
*/
public function saveInto(DataObjectInterface $record)
{
// Detect whether this field has actually been updated
if ($this->value !== 'unchanged') {
$items = array();
$fieldName = $this->name;
$saveDest = $record->{$fieldName}();
if (!$saveDest) {
user_error("TreeMultiselectField::saveInto() Field '{$fieldName}' not found on" . " {$record->class}.{$record->ID}", E_USER_ERROR);
}
if ($this->value) {
$items = preg_split("/ *, */", trim($this->value));
}
// Allows you to modify the items on your object before save
$funcName = "onChange{$fieldName}";
if ($record->hasMethod($funcName)) {
$result = $record->{$funcName}($items);
if (!$result) {
return;
}
}
$saveDest->setByIDList($items);
}
}
/**
* Save the current value of this MultiSelectField into a DataObject.
* If the field it is saving to is a has_many or many_many relationship,
* it is saved by setByIDList(), otherwise it creates a comma separated
* list for a standard DB text/varchar field.
*
* @param DataObject|DataObjectInterface $record The record to save into
*/
public function saveInto(DataObjectInterface $record)
{
$fieldName = $this->getName();
if (empty($fieldName) || empty($record)) {
return;
}
$relation = $record->hasMethod($fieldName) ? $record->{$fieldName}() : null;
// Detect DB relation or field
$items = $this->getValueArray();
if ($relation instanceof Relation) {
// Save ids into relation
$relation->setByIDList($items);
} elseif ($record->hasField($fieldName)) {
// Save dataValue into field
$record->{$fieldName} = $this->stringEncode($items);
}
}
public function saveInto(DataObjectInterface $record)
{
// Check required relation details are available
$name = $this->getName();
if (!$name) {
return $this;
}
$value = $this->Value();
foreach (array('Filename', 'Hash', 'Variant') as $part) {
$partValue = isset($value[$part]) ? $value[$part] : null;
$record->setField("{$name}{$part}", $partValue);
}
return $this;
}
/**
* Update the permission set associated with $record DataObject
*
* @param DataObjectInterface $record
*/
public function saveInto(DataObjectInterface $record)
{
$fieldname = $this->name;
$managedClass = $this->managedClass;
// Remove all "privileged" permissions if the currently logged-in user is not an admin
$privilegedPermissions = Permission::config()->privileged_permissions;
if (!Permission::check('ADMIN')) {
foreach ($this->value as $id => $bool) {
if (in_array($id, $privilegedPermissions)) {
unset($this->value[$id]);
}
}
}
// remove all permissions and re-add them afterwards
$permissions = $record->{$fieldname}();
foreach ($permissions as $permission) {
$permission->delete();
}
if ($fieldname && $record && ($record->hasManyComponent($fieldname) || $record->manyManyComponent($fieldname))) {
if (!$record->ID) {
$record->write();
}
// We need a record ID to write permissions
$idList = array();
if ($this->value) {
foreach ($this->value as $id => $bool) {
if ($bool) {
$perm = new $managedClass();
$perm->{$this->filterField} = $record->ID;
$perm->Code = $id;
$perm->write();
}
}
}
}
}
/**
* 30/06/2009 - Enhancement:
* SaveInto checks if set-methods are available and use them
* instead of setting the values in the money class directly. saveInto
* initiates a new Money class object to pass through the values to the setter
* method.
*
* (see @link MoneyFieldTest_CustomSetter_Object for more information)
*
* @param DataObjectInterface|Object $dataObject
*/
public function saveInto(DataObjectInterface $dataObject)
{
$fieldName = $this->getName();
if ($dataObject->hasMethod("set{$fieldName}")) {
$dataObject->{$fieldName} = DBField::create_field('Money', array("Currency" => $this->fieldCurrency->dataValue(), "Amount" => $this->fieldAmount->dataValue()));
} else {
$currencyField = "{$fieldName}Currency";
$amountField = "{$fieldName}Amount";
$dataObject->{$currencyField} = $this->fieldCurrency->dataValue();
$dataObject->{$amountField} = $this->fieldAmount->dataValue();
}
}
public function saveInto(DataObjectInterface $record)
{
if (!isset($_FILES[$this->name])) {
return false;
}
$fileClass = File::get_class_for_file_extension(File::get_file_extension($_FILES[$this->name]['name'], PATHINFO_EXTENSION));
if ($this->relationAutoSetting) {
// assume that the file is connected via a has-one
$objectClass = $record->hasOne($this->name);
if ($objectClass === 'File' || empty($objectClass)) {
// Create object of the appropriate file class
$file = Object::create($fileClass);
} else {
// try to create a file matching the relation
$file = Object::create($objectClass);
}
} else {
if ($record instanceof File) {
$file = $record;
} else {
$file = Object::create($fileClass);
}
}
$this->upload->loadIntoFile($_FILES[$this->name], $file, $this->getFolderName());
if ($this->upload->isError()) {
return false;
}
if ($this->relationAutoSetting) {
if (!$objectClass) {
return false;
}
$file = $this->upload->getFile();
$record->{$this->name . 'ID'} = $file->ID;
}
return $this;
}