Exemplo n.º 1
0
function _qwp_process_ops(&$msg, &$data, &$msg_type, &$ret)
{
    global $FN_PROCESS_NEED_TRANSACTION;
    $ctx = false;
    if ($FN_PROCESS_NEED_TRANSACTION) {
        $ctx = db_transaction();
    }
    try {
        global $FN_PROCESS_OPS;
        if (isset($FN_PROCESS_OPS)) {
            if ($FN_PROCESS_OPS($msg, $data) !== false) {
                $msg_type = "info";
                $ret = true;
            }
        } else {
            $msg = L("No ops processor!");
        }
    } catch (PDOException $e) {
        if ($e->errorInfo[1] == 1062) {
            $msg = L("Duplicated record when doing ops, please check the parameters!");
        } else {
            $msg = L("Failed to execute query: ") . (IN_DEBUG ? $e->query_string : $e->getMessage());
        }
    } catch (Exception $e) {
        $msg = L("Exception happens: ") . $e->getMessage();
    }
    if ($ret !== true && $ctx) {
        $ctx->rollback();
    }
}
Exemplo n.º 2
0
 function addComment($props)
 {
     if (!$props) {
         drupal_set_message(t('Insert requested with empty (filtered) data set'), 'error');
         return false;
     }
     //global $user;
     $txn = db_transaction();
     try {
         //$uid = $user->uid;
         //$props['author'] = $uid;
         $now = new DateTime();
         $props['date_posted'] = $now->format('Y-m-d H:i:s');
         // check for top level posts with an empty parent & set it to mysql null.
         if (!isset($props['parent_id']) || empty($props['parent_id'])) {
             $props['parent_id'] = null;
         }
         $result = FALSE;
         $query = db_insert(tableName('comment'))->fields($props);
         $id = $query->execute();
         if ($id) {
             $result = $id;
         } else {
             drupal_set_message(t('We could not add your comment'), 'error');
         }
     } catch (Exception $ex) {
         $txn->rollback();
         drupal_set_message(t('We could not add your comment. ') . (_DEBUG ? $ex->__toString() : ''), 'error');
     }
     return $result;
 }
    /**
     * @param DataControllerCallContext $callcontext
     * @param DatasetMetaData $dataset
     * @param DatasetStorageObserver[] $observers
     * @throws Exception
     */
    protected function dropDatasetStorage(DataControllerCallContext $callcontext, DatasetMetaData $dataset, array $observers = NULL) {
        MetaModelFactory::getInstance()->startGlobalModification();
        try {
            $transaction = db_transaction();
            try {
                if (isset($observers)) {
                    foreach ($observers as $observer) {
                        $observer->unregisterDataset($callcontext, $dataset, DatasetStorageObserver::STAGE__BEFORE);
                    }
                }

                // dropping physical storage of the dataset
                $request = new DatasetStorageRequest($dataset->name);
                LogHelper::log_debug($request);
                $this->datasourceStructureHandler->dropDatasetStorage($callcontext, $request);

                $dataset->used = FALSE;

                if (isset($observers)) {
                    foreach ($observers as $observer) {
                        $observer->unregisterDataset($callcontext, $dataset, DatasetStorageObserver::STAGE__AFTER);
                    }
                }
            }
            catch (Exception $e) {
                $transaction->rollback();
                throw $e;
            }
        }
        catch (Exception $e) {
            MetaModelFactory::getInstance()->finishGlobalModification(FALSE);
            throw $e;
        }
        MetaModelFactory::getInstance()->finishGlobalModification(TRUE);
    }
 public function delete($ids, \DatabaseTransaction $transaction = NULL)
 {
     $transaction = isset($transaction) ? $transaction : db_transaction();
     try {
         parent::delete($ids, $transaction);
         db_delete('observers')->condition('observable_id', $ids, 'IN')->execute();
     } catch (\Exception $e) {
         watchdog_exception($this->entityType, $e);
         $transaction->rollback();
         throw $e;
     }
 }
Exemplo n.º 5
0
 /**
  * @param \Roomify\Bat\Event\Event $event
  * @param $granularity
  *
  * @return bool
  */
 public function storeEvent(Event $event, $granularity = Event::BAT_HOURLY)
 {
     $stored = TRUE;
     $transaction = db_transaction();
     try {
         // Itemize an event so we can save it
         $itemized = $event->itemize(new EventItemizer($event, $granularity));
         //Write days
         foreach ($itemized[Event::BAT_DAY] as $year => $months) {
             foreach ($months as $month => $days) {
                 db_merge($this->day_table_no_prefix)->key(array('unit_id' => $event->getUnitId(), 'year' => $year, 'month' => $month))->fields($days)->execute();
             }
         }
         if ($granularity == Event::BAT_HOURLY && isset($itemized[Event::BAT_HOUR])) {
             // Write Hours
             foreach ($itemized[Event::BAT_HOUR] as $year => $months) {
                 foreach ($months as $month => $days) {
                     foreach ($days as $day => $hours) {
                         // Count required as we may receive empty hours for granular events that start and end on midnight
                         if (count($hours) > 0) {
                             db_merge($this->hour_table_no_prefix)->key(array('unit_id' => $event->getUnitId(), 'year' => $year, 'month' => $month, 'day' => substr($day, 1)))->fields($hours)->execute();
                         }
                     }
                 }
             }
             //If we have minutes write minutes
             foreach ($itemized[Event::BAT_MINUTE] as $year => $months) {
                 foreach ($months as $month => $days) {
                     foreach ($days as $day => $hours) {
                         foreach ($hours as $hour => $minutes) {
                             db_merge($this->minute_table_no_prefix)->key(array('unit_id' => $event->getUnitId(), 'year' => $year, 'month' => $month, 'day' => substr($day, 1), 'hour' => substr($hour, 1)))->fields($minutes)->execute();
                         }
                     }
                 }
             }
         }
     } catch (\Exception $e) {
         $stored = FALSE;
         $transaction->rollback();
         watchdog_exception('BAT Event Save Exception', $e);
     }
     return $stored;
 }
 /**
  * Delete a user from the system. 
  *
  * This is a copy of user_delete() minus the user_load() call.
  */
 private function delete_single(stdClass $account)
 {
     $uids = array($account->uid);
     $transaction = db_transaction();
     try {
         module_invoke_all('user_delete', $account);
         module_invoke_all('entity_delete', $account, 'user');
         field_attach_delete('user', $account);
         drupal_session_destroy_uid($account->uid);
         db_delete('users')->condition('uid', $uids, 'IN')->execute();
         db_delete('users_roles')->condition('uid', $uids, 'IN')->execute();
         db_delete('authmap')->condition('uid', $uids, 'IN')->execute();
     } catch (Exception $e) {
         $transaction->rollback();
         watchdog_exception('user', $e);
         throw $e;
     }
     $this->resetCache($uids);
 }
 /**
  * Delete a list of memberships context entities.
  *
  * @param object $entities
  *   An array of memberships contexts to be deleted.
  */
 public function delete_multiple($entities)
 {
     $ids = array();
     if (!empty($entities)) {
         $transaction = db_transaction();
         try {
             foreach ($entities as $entity) {
                 module_invoke_all('lti_tool_provider_memberships_context_delete', $entity);
                 module_invoke_all('entity_delete', $entity, 'lti_tool_provider_memberships_context');
                 field_attach_delete('lti_tool_provider_memberships_context', $entity);
                 $ids[] = $entity->lti_tool_provider_memberships_context_id;
             }
             db_delete('lti_tool_provider_memberships_context')->condition('lti_tool_provider_memberships_context_id', $ids, 'IN')->execute();
         } catch (Exception $e) {
             $transaction->rollback();
             watchdog_exception('lti_tool_provider_memberships_context', $e);
             throw $e;
         }
     }
 }
 /**
  * Perform menu-specific rebuilding.
  */
 protected function menuLinksRebuild()
 {
     if ($this->lock->acquire(__FUNCTION__)) {
         $transaction = db_transaction();
         try {
             // Ensure the menu links are up to date.
             $this->menuLinkManager->rebuild();
             // Ignore any database replicas temporarily.
             db_ignore_replica();
         } catch (\Exception $e) {
             $transaction->rollback();
             watchdog_exception('menu', $e);
         }
         $this->lock->release(__FUNCTION__);
     } else {
         // Wait for another request that is already doing this work.
         // We choose to block here since otherwise the router item may not
         // be available during routing resulting in a 404.
         $this->lock->wait(__FUNCTION__);
     }
 }
 /**
  * Makes sure that every simple queue has a subqueue.
  */
 protected function ensureSubqueue()
 {
     global $user;
     static $queues = array();
     if (!isset($queues[$this->queue->name])) {
         $queues[$this->queue->name] = TRUE;
         $transaction = db_transaction();
         $query = new EntityFieldQuery();
         $query->entityCondition('entity_type', 'entityqueue_subqueue')->entityCondition('bundle', $this->queue->name);
         $result = $query->execute();
         // If we don't have a subqueue already, create one now.
         if (empty($result['entityqueue_subqueue'])) {
             $subqueue = entityqueue_subqueue_create();
             $subqueue->queue = $this->queue->name;
             $subqueue->name = $this->queue->name;
             $subqueue->label = $this->getSubqueueLabel($subqueue);
             $subqueue->module = 'entityqueue';
             $subqueue->uid = $user->uid;
             entity_get_controller('entityqueue_subqueue')->save($subqueue, $transaction);
         }
     }
 }
Exemplo n.º 10
0
 /**
  * Perform menu-specific rebuilding.
  */
 protected function menuLinksRebuild()
 {
     if ($this->lock->acquire(__FUNCTION__)) {
         $transaction = db_transaction();
         try {
             // Ensure the menu links are up to date.
             menu_link_rebuild_defaults();
             // Clear the menu cache.
             menu_cache_clear_all();
             // Track which menu items are expanded.
             _menu_update_expanded_menus();
         } catch (\Exception $e) {
             $transaction->rollback();
             watchdog_exception('menu', $e);
         }
         $this->lock->release(__FUNCTION__);
     } else {
         // Wait for another request that is already doing this work.
         // We choose to block here since otherwise the router item may not
         // be available during routing resulting in a 404.
         $this->lock->wait(__FUNCTION__);
     }
 }
    /**
     * @param DataControllerCallContext $callcontext
     * @param DatasetMetaData $dataset
     * @param DatasetStorageObserver[] $observers
     * @throws Exception
     */
    protected function disableDatasetStorage(DataControllerCallContext $callcontext, DatasetMetaData $dataset, array $observers = NULL) {
        MetaModelFactory::getInstance()->startGlobalModification();
        try {
            $transaction = db_transaction();
            try {
                $dataset->used = FALSE;

                if (isset($observers)) {
                    foreach ($observers as $observer) {
                        $observer->disableDataset($callcontext, $dataset);
                    }
                }
            }
            catch (Exception $e) {
                $transaction->rollback();
                throw $e;
            }
        }
        catch (Exception $e) {
            MetaModelFactory::getInstance()->finishGlobalModification(FALSE);
            throw $e;
        }
        MetaModelFactory::getInstance()->finishGlobalModification(TRUE);
    }
Exemplo n.º 12
0
 public function __construct($message, $tag, $module, $variables = array(), $name = NULL, array $options = array())
 {
     $this->message = $message;
     $this->tag = $tag;
     $this->module = $module;
     $this->variables = $variables;
     $this->txn = db_transaction($name, $options);
 }
Exemplo n.º 13
0
Arquivo: db.php Projeto: refirio/levis
/**
 * Import SQL from the file.
 *
 * @param string $file
 *
 * @return int
 */
function db_import($file)
{
    if ($fp = fopen($file, 'r')) {
        $sql = '';
        $i = 0;
        $flag = true;
        db_transaction();
        while ($line = fgets($fp)) {
            $line = str_replace("\r\n", "\n", $line);
            $line = str_replace("\r", "\n", $line);
            if ((substr_count($line, '\'') - substr_count($line, '\\\'')) % 2 !== 0) {
                $flag = !$flag;
            }
            $sql .= $line;
            if (preg_match('/;$/', trim($line)) && $flag) {
                $resource = db_query($sql);
                if (!$resource) {
                    db_rollback();
                    if (LOGGING_MESSAGE) {
                        logging('message', 'db: Query error: ' . db_error());
                    }
                    error('db: Query error' . (DEBUG_LEVEL ? ': ' . db_error() : ''));
                }
                $sql = '';
                $i++;
            }
        }
        fclose($fp);
        db_commit();
    } else {
        error('db: Import file can\'t read');
    }
    return $i;
}
    /**
     * @param DataControllerCallContext $callcontext
     * @param DatasetMetaData $originalDataset
     * @param DatasetMetaData $modifiedDataset
     * @param DatasetStorageObserver[] $observers
     * @throws Exception
     */
    protected function updateProperties(DataControllerCallContext $callcontext, DatasetMetaData $originalDataset, DatasetMetaData $modifiedDataset, array $observers = NULL) {
        $justPersistedColumns = NULL;
        ArrayHelper::merge($justPersistedColumns, $callcontext->changeAction->newIncludedColumns);
        ArrayHelper::merge($justPersistedColumns, $callcontext->changeAction->restoredColumns);
        ArrayHelper::merge($justPersistedColumns, $callcontext->changeAction->updatedDataTypeIncludedColumns);

        $columns = $justPersistedColumns;
        ArrayHelper::merge($columns, $callcontext->changeAction->updatedColumns);
        if ($callcontext->changeAction->isDatasetUpdated || isset($columns) || $callcontext->changeAction->isKeyUpdated) {
            MetaModelFactory::getInstance()->startGlobalModification();
            try {
                $transaction = db_transaction();
                try {
                    if (isset($columns)) {
                        foreach ($columns as $column) {
                            if (isset($justPersistedColumns[$column->name])) {
                                $column->used = TRUE;
                            }

                            if (isset($callcontext->changeAction->updatedColumns[$column->name])) {
                                $modifiedColumn = $modifiedDataset->getColumn($column->name);

                                $column->publicName = $modifiedColumn->publicName;
                                $column->description = $modifiedColumn->description;
                                $column->source = $modifiedColumn->source;
                                $column->key = $modifiedColumn->key;
                            }

                            if (isset($observers)) {
                                foreach ($observers as $observer) {
                                    $observer->updateColumn($callcontext, $originalDataset, $column->name);
                                }
                            }
                        }
                    }

                    if ($callcontext->changeAction->isDatasetUpdated) {
                        $originalDataset->publicName = $modifiedDataset->publicName;
                        $originalDataset->description = $modifiedDataset->description;
                        $originalDataset->initializeSourceFrom($modifiedDataset->source, TRUE);
                        $originalDataset->initializeAliasesFrom($modifiedDataset->aliases, TRUE);

                        if (isset($observers)) {
                            foreach ($observers as $observer) {
                                $observer->updateDataset($callcontext, $originalDataset);
                            }
                        }
                    }

                    if ($callcontext->changeAction->isKeyUpdated) {
                        $modifiedDatasetKeyColumnNames = $modifiedDataset->findKeyColumnNames();
                        if (isset($modifiedDatasetKeyColumnNames)) {
                            $this->executeDatasetUpdateOperations(
                                $callcontext,
                                $originalDataset,
                                array(new CreateDatasetKeyOperation()));
                        }
                    }
                }
                catch (Exception $e) {
                    $transaction->rollback();
                    throw $e;
                }
            }
            catch (Exception $e) {
                MetaModelFactory::getInstance()->finishGlobalModification(FALSE);
                throw $e;
            }
            MetaModelFactory::getInstance()->finishGlobalModification(TRUE);
        }
    }
    protected function update(Import\ImportStream $stream, Import\ImportContext $context) {
        $datasets = $stream->get('datasets');
        if (empty($datasets)) {
            return;
        }

        gd_datasource_set_active($context->get('datasourceName'));
        $metamodel = data_controller_get_metamodel();

        $environment_metamodel = data_controller_get_environment_metamodel();
        $datasource = $environment_metamodel->getDataSource($context->get('datasourceName'));

        foreach ( $datasets as $dataset ) {
            $existingDataset = GD_DatasetMetaModelLoaderHelper::findDatasetByUUID($metamodel->datasets, $dataset->uuid);
            if ( !$existingDataset ) {

                // map for re-linking dependent objects
                $dataset->originalName = $dataset->name;

                // create new name
                $newDatasetName = GD_NamingConvention::generateDatasetName();
                $dataset->name = $newDatasetName;
                $dataset->source = $newDatasetName;
                $dataset->datasourceName = $datasource->name;
            } else {
                // map for re-linking dependent objects
                $dataset->originalName = $dataset->name;

                $dataset->name = $existingDataset->name;
                $dataset->source = $existingDataset->source;
                $dataset->datasourceName = $existingDataset->datasourceName;
            }
        }

        // prepare dataset columns for import
        $this->prepareColumns($datasets);

        // prepares the metadata object, has to be of type RecordMetaData
        foreach ( $datasets as $key => $dataset ) {
            $metadata = new DatasetMetaData();
            $metadata->initializeFrom($dataset);
            $datasets[$key] = $metadata;
        }

        // ensure datasets are created in order to satisfy dependencies
        usort($datasets, array(new ReferencedDatasetComparator(), 'compare'));

        foreach ( $datasets as $dataset ) {
            $existingDataset = GD_DatasetMetaModelLoaderHelper::findDatasetByUUID($metamodel->datasets, $dataset->uuid);
            if ($existingDataset) {
                gd_data_controller_ddl_modify_dataset($dataset);
            } else {
                MetaModelFactory::getInstance()->startGlobalModification();
                try {
                    $transaction = db_transaction();
                    try {
                        gd_data_controller_ddl_create_dataset($dataset);
                    } catch (Exception $e) {
                        $transaction->rollback();
                        throw $e;
                    }
                } catch (Exception $e) {
                    MetaModelFactory::getInstance()->finishGlobalModification(false);
                    throw $e;
                }
                MetaModelFactory::getInstance()->finishGlobalModification(true);
            }
        }

        $stream->set('datasets',$datasets);
    }
 public function delete($fpids)
 {
     $transaction = db_transaction();
     if (!empty($fpids)) {
         $entities = fieldable_panels_panes_load_multiple($fpids, array());
         try {
             foreach ($entities as $fpid => $entity) {
                 // Call the entity-specific callback (if any):
                 module_invoke_all('entity_delete', $entity, 'fieldable_panels_pane');
                 field_attach_delete('fieldable_panels_pane', $entity);
             }
             // Delete after calling hooks so that they can query entity tables as needed.
             db_delete('fieldable_panels_panes')->condition('fpid', $fpids, 'IN')->execute();
             db_delete('fieldable_panels_panes_revision')->condition('fpid', $fpids, 'IN')->execute();
         } catch (Exception $e) {
             $transaction->rollback();
             watchdog_exception('fieldable_panels_pane', $e);
             throw $e;
         }
         // Clear the page and block and entity_load_multiple caches.
         entity_get_controller('fieldable_panels_pane')->resetCache();
     }
 }
 /**
  * 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;
     }
 }
Exemplo n.º 18
0
 static function updateProposal($props, $proposal_id)
 {
     if (!$props) {
         drupal_set_message(t('Update requested with empty (filtered) data set'), 'error');
         return false;
     }
     global $user;
     $txn = db_transaction();
     try {
         $uid = Users::getMyId();
         if (!Users::isOfType(_STUDENT_TYPE, $uid) && !Users::isAdmin()) {
             drupal_set_message(t('You must be a student to submit a proposal'), 'error');
             return FALSE;
         }
         //$project = Project::getProjectById($project_id);
         //    		$student_details = Users::getStudentDetails($uid);
         //     		$props['owner_id'] = $uid;
         //     		$props['org_id'] = $project['org_id'];
         //     		$props['inst_id'] = $student_details->inst_id ;
         //     		$props['supervisor_id'] = $student_details->supervisor_id ;
         //$props['pid'] = $project['pid'];
         //$props['state'] = 'draft' ;
         $id = db_update(tableName(_PROPOSAL_OBJ))->fields($props)->condition(self::keyField(_PROPOSAL_OBJ), $proposal_id)->execute();
         //     		if ($id){
         //     			//TODO: notify mentor???
         //     			drupal_set_message('You have saved your proposal. Later you can edit it.');
         //     			return TRUE;
         //     		} else {
         //     			drupal_set_message(tt('We could not add your %1$s.', $type), 'error');
         //     		}
         return TRUE;
     } catch (Exception $ex) {
         $txn->rollback();
         drupal_set_message(t('We could not update your proposal.') . (_DEBUG ? $ex->__toString() : ''), 'error');
     }
     return FALSE;
 }
Exemplo n.º 19
0
 /**
  * {@inheritdoc}
  */
 public function addItem($plugin, $item_type, $item_id)
 {
     $transaction = db_transaction();
     $is_new = FALSE;
     if ($this->isNew()) {
         $this->save();
         $is_new = TRUE;
     }
     $item = tmgmt_job_item_create($plugin, $item_type, $item_id, array('tjid' => $this->id()));
     $item->save();
     if ($item->getWordCount() == 0) {
         $transaction->rollback();
         // In case we got word count 0 for the first job item, NULL tjid so that
         // if there is another addItem() call the rolled back job object will get
         // persisted.
         if ($is_new) {
             $this->tjid = NULL;
         }
         throw new TMGMTException('Job item @label (@type) has no translatable content.', array('@label' => $item->label(), '@type' => $item->getSourceType()));
     }
     return $item;
 }
Exemplo n.º 20
0
 static function addStudentGroup($group)
 {
     if (!$group) {
         drupal_set_message(t('Insert requested with empty (filtered) data set'));
         return false;
     }
     global $user;
     $txn = db_transaction();
     try {
         $uid = $user->uid;
         $institute_ids = db_select('soc_user_membership')->fields('soc_user_membership', array('group_id'))->condition('uid', $uid)->condition('type', _INSTITUTE_GROUP)->execute()->fetchCol();
         if ($institute_ids) {
             $inst_id = $institute_ids[0];
         } else {
             $inst_id = 0;
         }
         $gid = db_insert('soc_studentgroups')->fields(array('name' => $group['name'], 'owner_id' => $uid, 'inst_id' => $inst_id, 'description' => $group['description'] ?: ''))->execute();
         if ($gid) {
             $result = db_insert('soc_user_membership')->fields(array('uid' => $uid, 'type' => _STUDENT_GROUP, 'group_id' => $gid))->execute();
             if ($result) {
                 $result = $result && db_insert('soc_codes')->fields(array('type' => _STUDENT_GROUP, 'code' => createRandomCode(_STUDENT_GROUP, $gid), 'entity_id' => $inst_id, 'studentgroup_id' => $gid))->execute();
                 if (!$result) {
                     drupal_set_message(t('We could not add a code for this group.'), 'error');
                 }
             } else {
                 drupal_set_message(t('We could not add you to this group.'), 'error');
             }
         } else {
             drupal_set_message(t('We could not add your group.'), 'error');
         }
         return $result ? $gid : FALSE;
     } catch (Exception $ex) {
         $txn->rollback();
         drupal_set_message(t('We could not add your group.') . (_DEBUG ? $ex->__toString() : ''), 'error');
     }
     return FALSE;
 }
Exemplo n.º 21
0
 /**
  * 删除Entity
  */
 public function delete($entity)
 {
     $this->beforeDelete($entity);
     if (is_numeric($entity)) {
         $entityId = $entity;
     } else {
         $entityId = $entity->{$this->primaryKey};
     }
     $transaction = db_transaction();
     try {
         db_delete($this->entityInfo['baseTable'])->condition($this->primaryKey, $entityId)->execute();
         EntityField::fieldDelete($this->entityType, $entityId);
         $this->afterDelete($entityId);
     } catch (Exception $e) {
         $transaction->rollback();
         throw $e;
         return false;
     }
     $this->cacheBin->resetCache(array($entityId));
     return true;
 }
Exemplo n.º 22
0
<?php

// ワンタイムトークン
if (!token('check')) {
    error('不正なアクセスです。');
}
// トランザクションを開始
db_transaction();
// 教室を削除
$resource = delete_classes(array('where' => array('classes.id = :id', array('id' => $_POST['id']))), array('associate' => 'true'));
if (!$resource) {
    error('データを削除できません。');
}
// トランザクションを終了
db_commit();
// リダイレクト
redirect('/admin/class?ok=delete');
Exemplo n.º 23
0
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;
    }
}
Exemplo n.º 24
0
 /**
  * Change a field's type, even if it has data.
  *
  * @param $field_name
  *   The name of the field to change.
  * @param $type
  *   The type of field to change it to.
  * @param array $column_renames
  *   An array of existing field schema columns to rename. For example, if the
  *   old field type has a column 'value' which maps to the new field type's
  *   'data' column, use array('value' => 'data') to ensure the old column
  *   is just renamed instead of dropped. To ensure an old field column is
  *   dropped, for example, if the same column name is used in the new
  *   field type, but is used to store different data, use
  *   array('old_column' => FALSE).
  * @param array $field_overrides
  *   An optional array that overrides any of the values in the $field
  *   definition array prior to saving.
  * @param array $field_instance_overrides
  *   An optional array that overrides any of the values in any of the field's
  *   instance definition array prior to saving.
  *
  * @return array
  *   The change field if everything was successful.
  *
  * @throws Exception
  */
 public static function changeType($field_name, $type, array $column_renames = array(), array $field_overrides = array(), array $field_instance_overrides = array())
 {
     $field = $prior_field = field_read_field($field_name);
     if (empty($field)) {
         throw new Exception("Field {$field_name} does not exist or is inactive or deleted.");
     }
     if ($field['type'] === $type) {
         throw new Exception("Field {$field_name} is already type {$type}.");
     }
     if ($field['storage']['type'] !== 'field_sql_storage') {
         throw new Exception("Unable to change field type for field {$field_name} using storage {$field['storage']['type']}.");
     }
     $type_info = field_info_field_types($type);
     if (empty($type_info)) {
         throw new Exception("Invalid field type {$type}.");
     }
     $transaction = db_transaction();
     try {
         // Serialize properties back into the data property so it can be saved
         // to the database.
         $field['data'] = array();
         foreach ($field as $key => $value) {
             switch ($key) {
                 case 'id':
                 case 'field_name':
                 case 'type':
                 case 'module':
                 case 'active':
                 case 'locked':
                 case 'cardinality':
                 case 'deleted':
                 case 'data':
                     break;
                 default:
                     $field['data'][$key] =& $field[$key];
             }
         }
         // Update basic information on the field config.
         $field['type'] = $type;
         $field['module'] = $type_info['module'];
         $field['settings'] = array_intersect_key($field['settings'], $type_info['settings']);
         $field['settings'] += $type_info['settings'];
         // @todo Check if $field['translatable'] needs to be changed.
         // Make any final field overrides before updating the schema and saving
         // the field config record back to the database.
         $field = drupal_array_merge_deep($field, $field_overrides);
         static::changeSchema($field, $column_renames);
         drupal_write_record('field_config', $field, array('id'));
         // Now update the instances for this field.
         static::changeInstances($field, $field_instance_overrides);
         // Clear caches
         field_cache_clear();
         // Invoke external hooks after the cache is cleared for API consistency.
         $has_data = field_has_data($field);
         module_invoke_all('field_update_field', $field, $prior_field, $has_data);
         watchdog('helper', "Converted field {$field_name} from {$prior_field['type']} to {$type}.");
         return $field;
     } catch (Exception $e) {
         $transaction->rollback();
         watchdog_exception('helper', $e);
         throw $e;
     }
 }
 /**
  * Delete Resources.
  *
  * @param array $entities
  *   An array of Resources to delete.
  *
  * @throws Exception
  */
 public function deleteMultiple($entities)
 {
     $ids = array();
     if (!empty($entities)) {
         $transaction = db_transaction();
         try {
             foreach ($entities as $entity) {
                 module_invoke_all('lti_tool_provider_outcomes_resource_delete', $entity);
                 // Invoke hook_entity_delete().
                 module_invoke_all('entity_delete', $entity, 'lti_tool_provider_outcomes_resource');
                 field_attach_delete('lti_tool_provider_outcomes_resource', $entity);
                 $ids[] = $entity->lti_tool_provider_outcomes_resource_id;
             }
             db_delete('lti_tool_provider_outcomes_resource')->condition('lti_tool_provider_outcomes_resource_id', $ids, 'IN')->execute();
         } catch (Exception $e) {
             $transaction->rollback();
             watchdog_exception('lti_tool_provider_outcomes_resource', $e);
             throw $e;
         }
     }
 }
Exemplo n.º 26
0
 /**
  * Tests transaction stacking, commit, and rollback.
  */
 function testTransactionStacking()
 {
     // This test won't work right if transactions are not supported.
     if (!Database::getConnection()->supportsTransactions()) {
         return;
     }
     $database = Database::getConnection();
     // Standard case: pop the inner transaction before the outer transaction.
     $transaction = db_transaction();
     $this->insertRow('outer');
     $transaction2 = db_transaction();
     $this->insertRow('inner');
     // Pop the inner transaction.
     unset($transaction2);
     $this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the inner transaction');
     // Pop the outer transaction.
     unset($transaction);
     $this->assertFalse($database->inTransaction(), 'Transaction closed after popping the outer transaction');
     $this->assertRowPresent('outer');
     $this->assertRowPresent('inner');
     // Pop the transaction in a different order they have been pushed.
     $this->cleanUp();
     $transaction = db_transaction();
     $this->insertRow('outer');
     $transaction2 = db_transaction();
     $this->insertRow('inner');
     // Pop the outer transaction, nothing should happen.
     unset($transaction);
     $this->insertRow('inner-after-outer-commit');
     $this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
     // Pop the inner transaction, the whole transaction should commit.
     unset($transaction2);
     $this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
     $this->assertRowPresent('outer');
     $this->assertRowPresent('inner');
     $this->assertRowPresent('inner-after-outer-commit');
     // Rollback the inner transaction.
     $this->cleanUp();
     $transaction = db_transaction();
     $this->insertRow('outer');
     $transaction2 = db_transaction();
     $this->insertRow('inner');
     // Now rollback the inner transaction.
     $transaction2->rollback();
     unset($transaction2);
     $this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
     // Pop the outer transaction, it should commit.
     $this->insertRow('outer-after-inner-rollback');
     unset($transaction);
     $this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
     $this->assertRowPresent('outer');
     $this->assertRowAbsent('inner');
     $this->assertRowPresent('outer-after-inner-rollback');
     // Rollback the inner transaction after committing the outer one.
     $this->cleanUp();
     $transaction = db_transaction();
     $this->insertRow('outer');
     $transaction2 = db_transaction();
     $this->insertRow('inner');
     // Pop the outer transaction, nothing should happen.
     unset($transaction);
     $this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
     // Now rollback the inner transaction, it should rollback.
     $transaction2->rollback();
     unset($transaction2);
     $this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
     $this->assertRowPresent('outer');
     $this->assertRowAbsent('inner');
     // Rollback the outer transaction while the inner transaction is active.
     // In that case, an exception will be triggered because we cannot
     // ensure that the final result will have any meaning.
     $this->cleanUp();
     $transaction = db_transaction();
     $this->insertRow('outer');
     $transaction2 = db_transaction();
     $this->insertRow('inner');
     $transaction3 = db_transaction();
     $this->insertRow('inner2');
     // Rollback the outer transaction.
     try {
         $transaction->rollback();
         unset($transaction);
         $this->fail('Rolling back the outer transaction while the inner transaction is active resulted in an exception.');
     } catch (TransactionOutOfOrderException $e) {
         $this->pass('Rolling back the outer transaction while the inner transaction is active resulted in an exception.');
     }
     $this->assertFalse($database->inTransaction(), 'No more in a transaction after rolling back the outer transaction');
     // Try to commit one inner transaction.
     unset($transaction3);
     $this->pass('Trying to commit an inner transaction resulted in an exception.');
     // Try to rollback one inner transaction.
     try {
         $transaction->rollback();
         unset($transaction2);
         $this->fail('Trying to commit an inner transaction resulted in an exception.');
     } catch (TransactionNoActiveException $e) {
         $this->pass('Trying to commit an inner transaction resulted in an exception.');
     }
     $this->assertRowAbsent('outer');
     $this->assertRowAbsent('inner');
     $this->assertRowAbsent('inner2');
 }
Exemplo n.º 27
0
 static function addProject($props)
 {
     if (!$props) {
         drupal_set_message(t('Insert requested with empty (filtered) data set'), 'error');
         return false;
     }
     // sort and process the datetime array structure
     // pre sql statement.
     Project::normaliseFormArrays($props);
     global $user;
     $txn = db_transaction();
     try {
         $uid = $user->uid;
         $props['owner_id'] = $uid;
         //TODO: for now we assume the mentor is the same as creating the project. As long as we have not built
         //funcitonality to connect mentors to projects, this is a valid assumption
         $props['mentor_id'] = $uid;
         if (!isset($props['state'])) {
             $props['state'] = 'pending';
         }
         //We normalise urls: if they start with http or https we assume the user inserted a full url
         //otherwise we assume a non-https full url
         if (isset($props['url']) && $props['url'] && stripos($props['url'], 'http') === FALSE) {
             $props['url'] = 'http://' . $props['url'];
         }
         $result = FALSE;
         $query = db_insert(tableName(_PROJECT_OBJ))->fields($props);
         $id = $query->execute();
         if ($id) {
             $result = $id;
         } else {
             drupal_set_message(t('We could not add your project'), 'error');
         }
     } catch (Exception $ex) {
         $txn->rollback();
         drupal_set_message(t('We could not add your project. ') . (_DEBUG ? $ex->__toString() : ''), 'error');
     }
     return $result;
 }
Exemplo n.º 28
0
 public function execute_logged($message, $tag, $module, array $variables = array(), $uid = 0, $referrer = '', $host = '', $timestamp = 0)
 {
     $transaction = Transaction::is_in_transaction() ? null : \db_transaction();
     try {
         $retval = parent::execute();
         if (!Transaction::is_in_transaction()) {
             \cvwobase_add_audit($message, $tag, $module, $variables, $uid, $referrer, $host, $timestamp);
         }
     } catch (Exception $e) {
         if (!empty($transaction)) {
             $transaction->rollback();
         }
         throw $e;
     }
     return $retval;
 }
 /**
  * Generates a database prefix for running tests.
  *
  * The generated database table prefix is used for the Backdrop installation
  * being performed for the test. It is also used as user agent HTTP header
  * value by the cURL-based browser of BackdropWebTestCase, which is sent
  * to the Backdrop installation of the test. During early Backdrop bootstrap,
  * the user agent HTTP header is parsed, and if it matches, all database
  * queries use the database table prefix that has been generated here.
  *
  * @see BackdropWebTestCase::curlInitialize()
  * @see backdrop_valid_test_ua()
  * @see BackdropWebTestCase::setUp()
  */
 protected function prepareDatabasePrefix()
 {
     // Generate a temporary prefixed database to ensure that tests have a clean
     // starting point and confirm that random prefix isn't already in use.
     db_transaction();
     do {
         $prefix = 'simpletest' . mt_rand(100000, 999999);
         $prefix_exists = db_query("SELECT COUNT(*) FROM {simpletest_prefix} WHERE prefix = :prefix", array(':prefix' => $prefix))->fetchField();
     } while ($prefix_exists);
     $this->databasePrefix = $prefix;
     // As soon as the database prefix is set, the test might start to execute.
     // All assertions as well as the SimpleTest batch operations are associated
     // with the testId, so the database prefix has to be associated with it.
     db_insert('simpletest_prefix')->fields(array('test_id' => $this->testId, 'prefix' => $this->databasePrefix))->execute();
 }
Exemplo n.º 30
0
 static function updateAgreement($props)
 {
     if (!$props) {
         drupal_set_message(t('Update requested with empty (filtered) data set'), 'error');
         return false;
     }
     //echo var_dump($props);
     $txn = db_transaction();
     try {
         $id = db_update(tableName(_AGREEMENT_OBJ))->fields($props)->condition(self::keyField(_AGREEMENT_OBJ), $props['agreement_id'])->execute();
         if ($props['student_signed'] && $props['supervisor_signed'] && $props['mentor_signed']) {
             $res = db_update(tableName(_PROJECT_OBJ))->fields(array('state' => 'active'))->condition(self::keyField(_PROJECT_OBJ), $props['project_id'])->execute();
         }
         return TRUE;
     } catch (Exception $ex) {
         $txn->rollback();
         drupal_set_message(t('We could not update your agreement.') . (_DEBUG ? $ex->__toString() : ''), 'error');
     }
     return FALSE;
 }