/**
* @see LTIToolProviderOutcomesResourceEntityControllerInterface::save
*/
public function save($entity)
{
$transaction = db_transaction();
try {
$entity->is_new = empty($enity->lti_tool_provider_outcomes_resource_id);
if (empty($entity->lti_tool_provider_outcomes_resource_timestamp_created)) {
$entity->lti_tool_provider_outcomes_resource_timestamp_created = REQUEST_TIME;
}
field_attach_presave('lti_tool_provider_outcomes_resource', $entity);
$primary_key = $entity->lti_tool_provider_outcomes_resource_id ? 'lti_tool_provider_outcomes_resource_id' : array();
if (empty($primary_key)) {
drupal_write_record('lti_tool_provider_outcomes_resource', $entity);
field_attach_insert('lti_tool_provider_outcomes_resource', $entity);
$op = 'insert';
} else {
drupal_write_record('lti_tool_provider_outcomes_resource', $entity, $primary_key);
$op = 'update';
}
$function = 'field_attach_' . $op;
$function('lti_tool_provider_outcomes_resource', $entity);
module_invoke_all('entity_' . $op, $entity, 'lti_tool_provider_outcomes_resource');
unset($entity->is_new);
db_ignore_slave();
return $entity;
} catch (Exception $e) {
$transaction->rollback();
drupal_set_message(t('%e', array('%e' => $entity->{$e})));
watchdog_exception('lti_tool_provider_outcomes_resource', $e, NULL, WATCHDOG_ERROR);
return FALSE;
}
}
function api_node_save($node)
{
$transaction = db_transaction();
try {
// Load the stored entity, if any.
if (!empty($node->nid) && !isset($node->original)) {
$node->original = entity_load_unchanged('node', $node->nid);
}
field_attach_presave('node', $node);
global $user;
// Determine if we will be inserting a new node.
if (!isset($node->is_new)) {
$node->is_new = empty($node->nid);
}
/*
// Set the timestamp fields.
if (empty($node->created)) {
$node->created = REQUEST_TIME;
}
// The changed timestamp is always updated for bookkeeping purposes,
// for example: revisions, searching, etc.
$node->changed = REQUEST_TIME;
$node->timestamp = REQUEST_TIME;
*/
$update_node = TRUE;
// Let modules modify the node before it is saved to the database.
module_invoke_all('node_presave', $node);
module_invoke_all('entity_presave', $node, 'node');
if ($node->is_new || !empty($node->revision)) {
// When inserting either a new node or a new node revision, $node->log
// must be set because {node_revision}.log is a text column and therefore
// cannot have a default value. However, it might not be set at this
// point (for example, if the user submitting a node form does not have
// permission to create revisions), so we ensure that it is at least an
// empty string in that case.
// @todo: Make the {node_revision}.log column nullable so that we can
// remove this check.
if (!isset($node->log)) {
$node->log = '';
}
} elseif (!isset($node->log) || $node->log === '') {
// If we are updating an existing node without adding a new revision, we
// need to make sure $node->log is unset whenever it is empty. As long as
// $node->log is unset, drupal_write_record() will not attempt to update
// the existing database column when re-saving the revision; therefore,
// this code allows us to avoid clobbering an existing log entry with an
// empty one.
unset($node->log);
}
// When saving a new node revision, unset any existing $node->vid so as to
// ensure that a new revision will actually be created, then store the old
// revision ID in a separate property for use by node hook implementations.
if (!$node->is_new && !empty($node->revision) && $node->vid) {
$node->old_vid = $node->vid;
unset($node->vid);
}
// Save the node and node revision.
if ($node->is_new) {
// For new nodes, save new records for both the node itself and the node
// revision.
drupal_write_record('node', $node);
_node_save_revision($node, $user->uid);
$op = 'insert';
} else {
// For existing nodes, update the node record which matches the value of
// $node->nid.
drupal_write_record('node', $node, 'nid');
// Then, if a new node revision was requested, save a new record for
// that; otherwise, update the node revision record which matches the
// value of $node->vid.
if (!empty($node->revision)) {
_node_save_revision($node, $user->uid);
} else {
_node_save_revision($node, $user->uid, 'vid');
$update_node = FALSE;
}
$op = 'update';
}
if ($update_node) {
db_update('node')->fields(array('vid' => $node->vid))->condition('nid', $node->nid)->execute();
}
// Call the node specific callback (if any). This can be
// node_invoke($node, 'insert') or
// node_invoke($node, 'update').
node_invoke($node, $op);
// Save fields.
$function = "field_attach_{$op}";
$function('node', $node);
module_invoke_all('node_' . $op, $node);
module_invoke_all('entity_' . $op, $node, 'node');
// Update the node access table for this node.
node_access_acquire_grants($node);
// Clear internal properties.
unset($node->is_new);
unset($node->original);
// Clear the static loading cache.
entity_get_controller('node')->resetCache(array($node->nid));
// Ignore slave server temporarily to give time for the
// saved node to be propagated to the slave.
db_ignore_slave();
} catch (Exception $e) {
$transaction->rollback();
watchdog_exception('node', $e);
throw $e;
}
}
/**
* Do a fast delete without loading entities of firing delete hooks.
*
* @param array $ids
* An array of entity IDs.
* @param \DatabaseTransaction $transaction
* Optionally a DatabaseTransaction object to use. Allows overrides to pass
* in their transaction object.
*
* @throws \Exception
* When there is a database error.
*/
protected function fastDelete($ids, \DatabaseTransaction $transaction = NULL)
{
$transaction = isset($transaction) ? $transaction : db_transaction();
try {
db_delete($this::getTableName())->condition($this::getTableIdkey(), $ids, 'IN')->execute();
// Reset the cache as soon as the changes have been applied.
$this->resetCache($ids);
// Ignore slave server temporarily.
db_ignore_slave();
} catch (\Exception $e) {
$transaction->rollback();
watchdog_exception($this->entityType, $e);
throw $e;
}
}
