PHP DBUtil::startTransaction方法代码示例

 function testRollback()
 {
     $f = Group::getList();
     $iNumGroups = count($f);
     DBUtil::startTransaction();
     $g = Group::createFromArray(array('name' => 'rollback'));
     if (!$this->assertGroup($g)) {
         return;
     }
     $f = Group::getList();
     $iNowNumGroups = count($f);
     $this->assertEqual($iNumGroups + 1, $iNowNumGroups, 'New group not in list');
     DBUtil::rollback();
     $f = Group::getList();
     $iRollbackNumGroups = count($f);
     $this->assertEqual($iNumGroups, $iRollbackNumGroups, 'New group still in list (should be rolled back)');
 }

<?php

require_once "../../config/dmsDefaults.php";
require_once KT_LIB_DIR . '/documentmanagement/documentutil.inc.php';
require_once KT_LIB_DIR . '/filelike/fsfilelike.inc.php';
error_reporting(E_ALL);
$oFolder =& Folder::get(1);
$oUser =& User::get(1);
$sLocalname = KT_DIR . "/tests/document/dataset1/critique-of-pure-reason.txt";
$sFilename = tempnam("/tmp", "kt_tests_document_add");
copy($sLocalname, $sFilename);
DBUtil::startTransaction();
$oDocument =& KTDocumentUtil::add($oFolder, "testfullupload2.txt", $oUser, array('contents' => new KTFSFileLike($sFilename), 'metadata' => array()));
if (PEAR::isError($oDocument)) {
    print "FAILURE\n";
    var_dump($oDocument);
    exit(0);
}
DBUtil::commit();
print "SUCCESS\n";

 function createFolderDetailsPermission()
 {
     $sPermissionsTable = KTUtil::getTableName('permissions');
     $bExists = DBUtil::getOneResultKey("SELECT COUNT(id) AS cnt FROM {$sPermissionsTable} WHERE name = 'ktcore.permissions.folder_details'", 'cnt');
     if ($bExists) {
         return;
     }
     DBUtil::startTransaction();
     $aPermissionInfo = array('human_name' => 'Core: Folder Details', 'name' => 'ktcore.permissions.folder_details', 'built_in' => true);
     $res = DBUtil::autoInsert($sPermissionsTable, $aPermissionInfo);
     if (PEAR::isError($res)) {
         return $res;
     }
     $iFolderDetailsPermissionId = $res;
     $sQuery = "SELECT id FROM {$sPermissionsTable} WHERE name = ?";
     $aParams = array("ktcore.permissions.read");
     $iReadPermissionId = DBUtil::getOneResultKey(array($sQuery, $aParams), "id");
     $sPermissionAssignmentsTable = KTUtil::getTableName('permission_assignments');
     $sQuery = "SELECT permission_object_id, permission_descriptor_id FROM {$sPermissionAssignmentsTable} WHERE permission_id = ?";
     $aParams = array($iReadPermissionId);
     $aRows = DBUtil::getResultArray(array($sQuery, $aParams));
     foreach ($aRows as $aRow) {
         $aRow['permission_id'] = $iFolderDetailsPermissionId;
         DBUtil::autoInsert($sPermissionAssignmentsTable, $aRow);
     }
     $sDocumentTable = KTUtil::getTableName('documents');
     $sFolderTable = KTUtil::getTableName('folders');
     DBUtil::runQuery("UPDATE {$sDocumentTable} SET permission_lookup_id = NULL");
     DBUtil::runQuery("UPDATE {$sFolderTable} SET permission_lookup_id = NULL");
     DBUtil::commit();
 }

 function do_trytype()
 {
     $oForm = $this->form_changetype();
     $res = $oForm->validate();
     $data = $res['results'];
     $errors = $res['errors'];
     if (!empty($errors)) {
         $oForm->handleError();
     }
     $document_type = $data['type'];
     $doctypeid = $document_type->getId();
     // Get the current document type, fieldsets and metadata
     $iOldDocTypeID = $this->oDocument->getDocumentTypeID();
     $fieldsets = KTMetadataUtil::fieldsetsForDocument($this->oDocument, $iOldDocTypeID);
     $mdlist = DocumentFieldLink::getByDocument($this->oDocument);
     $field_values = array();
     foreach ($mdlist as $oFieldLink) {
         $field_values[$oFieldLink->getDocumentFieldID()] = $oFieldLink->getValue();
     }
     DBUtil::startTransaction();
     // Update the document with the new document type id
     $this->oDocument->startNewMetadataVersion($this->oUser);
     $this->oDocument->setDocumentTypeId($doctypeid);
     $res = $this->oDocument->update();
     if (PEAR::isError($res)) {
         DBUtil::rollback();
         return $res;
     }
     // Ensure all values for fieldsets common to both document types are retained
     $fs_ids = array();
     $doctype_fieldsets = KTFieldSet::getForDocumentType($doctypeid);
     foreach ($doctype_fieldsets as $fieldset) {
         $fs_ids[] = $fieldset->getId();
     }
     $MDPack = array();
     foreach ($fieldsets as $oFieldset) {
         if ($oFieldset->getIsGeneric() || in_array($oFieldset->getId(), $fs_ids)) {
             $fields = $oFieldset->getFields();
             foreach ($fields as $oField) {
                 $val = isset($field_values[$oField->getId()]) ? $field_values[$oField->getId()] : '';
                 if (!empty($val)) {
                     $MDPack[] = array($oField, $val);
                 }
             }
         }
     }
     $core_res = KTDocumentUtil::saveMetadata($this->oDocument, $MDPack, array('novalidate' => true));
     if (PEAR::isError($core_res)) {
         DBUtil::rollback();
         return $core_res;
     }
     DBUtil::commit();
     $oKTTriggerRegistry = KTTriggerRegistry::getSingleton();
     $aTriggers = $oKTTriggerRegistry->getTriggers('edit', 'postValidate');
     foreach ($aTriggers as $aTrigger) {
         $sTrigger = $aTrigger[0];
         $oTrigger = new $sTrigger();
         $aInfo = array("document" => $this->oDocument, "aOptions" => $MDPack);
         $oTrigger->setInfo($aInfo);
         $ret = $oTrigger->postValidate();
     }
     // Check if there are any dynamic conditions / permissions that need to be updated on the document
     // If there are dynamic conditions then update the permissions on the document
     // The dynamic condition test fails unless the changes exists in the DB therefore update permissions after committing the transaction.
     $iPermissionObjectId = $this->oDocument->getPermissionObjectID();
     $dynamicCondition = KTPermissionDynamicCondition::getByPermissionObjectId($iPermissionObjectId);
     if (!PEAR::isError($dynamicCondition) && !empty($dynamicCondition)) {
         $res = KTPermissionUtil::updatePermissionLookup($this->oDocument);
     }
     $this->successRedirectToMain(sprintf(_kt("You have selected a new document type: %s. "), $data['type']->getName()));
 }

 /**
  * Loop through the queue and archive the items.
  *
  * @return unknown
  */
 public function processQueue()
 {
     global $default;
     // get items from queue
     $queue = $this->getQueue();
     if (PEAR::isError($queue)) {
         $default->log->debug('Download Queue: error on fetching queue - ' . $queue->getMessage());
         return false;
     }
     // Set queue as locked
     touch($this->lockFile);
     // Loop through items and create downloads
     foreach ($queue as $code => $download) {
         // reset the error messages
         $this->errors = null;
         // if the user_id is not set then skip
         if (!isset($download[0]['user_id']) || empty($download[0]['user_id'])) {
             $default->log->debug('Download Queue: no user id set for download code ' . $code);
             $error = array(_kt('No user id has been set, the archive cannot be created.'));
             $result = $this->setItemStatus($code, 3, $error);
             continue;
         }
         // Force a session for the user
         $_SESSION['userID'] = $download[0]['user_id'];
         $baseFolderId = $download[0]['folder_id'];
         // Create a new instance of the archival class
         $zip = new ZipFolder('', $code);
         $res = $zip->checkConvertEncoding();
         if (PEAR::isError($res)) {
             $default->log->error('Download Queue: Archive class check convert encoding error - ' . $res->getMessage());
             $error = array(_kt('The archive cannot be created. An error occurred in the encoding.'));
             $result = $this->setItemStatus($code, 3, $error);
             continue;
         }
         $result = $this->setItemStatus($code, 1);
         if (PEAR::isError($result)) {
             $default->log->error('Download Queue: item status could not be set for user: ' . $_SESSION['userID'] . ', code: ' . $code . ', error: ' . $result->getMessage());
         }
         $default->log->debug('Download Queue: Creating download for user: ' . $_SESSION['userID'] . ', code: ' . $code);
         DBUtil::startTransaction();
         // Add the individual files and folders into the archive
         foreach ($download as $item) {
             if ($item['object_type'] == 'document') {
                 $docId = $item['object_id'];
                 $this->addDocument($zip, $docId);
             }
             if ($item['object_type'] == 'folder') {
                 $folderId = $item['object_id'];
                 $this->addFolder($zip, $folderId);
             }
         }
         $res = $zip->createZipFile();
         if (PEAR::isError($res)) {
             $default->log->debug('Download Queue: Archive could not be created. Exiting transaction. ' . $res->getMessage());
             DBUtil::rollback();
             $error = array(_kt('The archive could not be created.'));
             $result = $this->setItemStatus($code, 3, $error);
             continue;
         }
         $default->log->debug('Download Queue: Archival successful');
         $oTransaction = KTFolderTransaction::createFromArray(array('folderid' => $baseFolderId, 'comment' => "Bulk export", 'transactionNS' => 'ktstandard.transactions.bulk_export', 'userid' => $_SESSION['userID'], 'ip' => Session::getClientIP()));
         if (PEAR::isError($oTransaction)) {
             $default->log->debug('Download Queue: transaction could not be logged. ' . $oTransaction->getMessage());
         }
         DBUtil::commit();
         // Set status for the download
         $this->errors['archive'] = $_SESSION['zipcompression'];
         $result = $this->setItemStatus($code, 2, $this->errors);
         if (PEAR::isError($result)) {
             $default->log->error('Download Queue: item status could not be set for user: ' . $_SESSION['userID'] . ', code: ' . $code . ', error: ' . $result->getMessage());
         }
         // reset the error messages
         $this->errors = null;
         $_SESSION['zipcompression'] = null;
     }
     // Remove lock file
     @unlink($this->lockFile);
 }

 /**
  * Restores a deleted document
  *
  * @author KnowledgeTree Team
  * @access public
  */
 function restore()
 {
     DBUtil::startTransaction();
     $storage =& KTStorageManagerUtil::getSingleton();
     $folder = Folder::get($this->document->getRestoreFolderId());
     if (PEAR::isError($folder)) {
         $this->document->setFolderId(1);
         $folder = Folder::get(1);
     } else {
         $this->document->setFolderId($this->document->getRestoreFolderId());
     }
     $storage->restore($this->document);
     $this->document->setStatusId(LIVE);
     $this->document->setPermissionObjectId($folder->getPermissionObjectId());
     $res = $this->document->update();
     $res = KTPermissionUtil::updatePermissionLookup($this->document);
     $user = $this->ktapi->get_user();
     $oTransaction = new DocumentTransaction($this->document, 'Restored from deleted state by ' . $user->getName(), 'ktcore.transactions.update');
     $oTransaction->create();
     DBUtil::commit();
 }

 /**
  * Bulk archives a list of folders and/or documents
  *
  * <code>
  * $ktapi = new KTAPI();
  * $session = $ktapi->start_system_session();
  * $document = $ktapi->get_document_by_id($documentid);
  * $folder = $ktapi->get_folder_by_name('New test folder');
  *
  * $aItems = array($document, $folder);
  * $bulk = new KTAPI_BulkActions($ktapi)
  * $res = $bulk->archive($aItems, 'Bulk archive');
  *
  * // if documents / folders failed
  * if(!empty($res)) {
  *     // display reason for documents failure
  *     foreach($res['docs'] as $failedDoc){
  *         echo '<br>' . $failedDoc['object']->get_title() . ' - reason: '.$failedDoc['reason'];
  *     }
  *     // display reason for folders failure
  *     foreach($res['folders'] as $failedDoc){
  *         echo '<br>' . $failedFolder['object']->get_folder_name() . ' - reason: '.$failedFolder['reason'];
  *     }
  * }
  * </code>
  *
  * @author KnowledgeTree Team
  * @access public
  * @param array $items The folders and/or documents
  * @param string $reason The reason for performing the archival
  * @return void|PEAR_Error Nothing on success | PEAR_Error on failure
  */
 function archive($items, $reason)
 {
     if (empty($items)) {
         return;
     }
     if (!is_array($items)) {
         $items = array($items);
     }
     // Archive the document or folder
     // Items that fail are returned in an array with the reason for failure.
     $failed = array();
     foreach ($items as $item) {
         // Documents
         if ($item instanceof KTAPI_Document) {
             $res = $item->archive($reason);
             if (PEAR::isError($res)) {
                 $failed['docs'][] = array('object' => $item, 'reason' => $res->getMessage());
                 continue;
             }
         } else {
             if ($item instanceof KTAPI_Folder) {
                 // Folders - need to recurse in
                 DBUtil::startTransaction();
                 $res = $this->recurseFolder($item, $reason, 'archive');
                 if (PEAR::isError($res)) {
                     DBUtil::rollback();
                     $failed['folders'][] = array('object' => $item, 'reason' => $res->getMessage());
                     continue;
                 }
                 DBUtil::commit();
             }
         }
     }
     return $failed;
 }

 function copy($oSrcFolder, $oDestFolder, $oUser, $sReason, $sDestFolderName = NULL, $copyAll = true)
 {
     $sDestFolderName = empty($sDestFolderName) ? $oSrcFolder->getName() : $sDestFolderName;
     if (KTFolderUtil::exists($oDestFolder, $sDestFolderName)) {
         return PEAR::raiseError(_kt("Folder with the same name already exists in the new parent folder"));
     }
     //
     // FIXME the failure cleanup code here needs some serious work.
     //
     $oPerm = KTPermission::getByName('ktcore.permissions.read');
     $oBaseFolderPerm = KTPermission::getByName('ktcore.permissions.addFolder');
     if (!KTPermissionUtil::userHasPermissionOnItem($oUser, $oBaseFolderPerm, $oDestFolder)) {
         return PEAR::raiseError(_kt('You are not allowed to create folders in the destination.'));
     }
     // Check if the source folder inherits its permissions
     // Get source PO id and its parent PO id
     $iSrcPoId = $oSrcFolder->getPermissionObjectID();
     $oSrcParent = Folder::get($oSrcFolder->getParentID());
     $iSrcParentPoId = $oSrcParent->getPermissionObjectID();
     // If the folder defines its own permissions then we copy the permission object
     // If the source folder inherits permissions we must change it to inherit from the new parent folder
     $bInheritPermissions = false;
     if ($iSrcPoId == $iSrcParentPoId) {
         $bInheritPermissions = true;
     }
     $aFolderIds = array();
     // of oFolder
     $aDocuments = array();
     // of oDocument
     $aFailedDocuments = array();
     // of String
     $aFailedFolders = array();
     // of String
     $aRemainingFolders = array($oSrcFolder->getId());
     DBUtil::startTransaction();
     while (!empty($aRemainingFolders) && $copyAll) {
         $iFolderId = array_pop($aRemainingFolders);
         $oFolder = Folder::get($iFolderId);
         if (PEAR::isError($oFolder) || $oFolder == false) {
             DBUtil::rollback();
             return PEAR::raiseError(sprintf(_kt('Failure resolving child folder with id = %d.'), $iFolderId));
         }
         // don't just stop ... plough on.
         if (KTPermissionUtil::userHasPermissionOnItem($oUser, $oPerm, $oFolder)) {
             $aFolderIds[] = $iFolderId;
         } else {
             $aFailedFolders[] = $oFolder->getName();
         }
         // child documents
         $aChildDocs = Document::getList(array('folder_id = ?', array($iFolderId)));
         foreach ($aChildDocs as $oDoc) {
             if (KTPermissionUtil::userHasPermissionOnItem($oUser, $oPerm, $oDoc)) {
                 $aDocuments[] = $oDoc;
             } else {
                 $aFailedDocuments[] = $oDoc->getName();
             }
         }
         // child folders.
         $aCFIds = Folder::getList(array('parent_id = ?', array($iFolderId)), array('ids' => true));
         $aRemainingFolders = kt_array_merge($aRemainingFolders, $aCFIds);
     }
     if (!empty($aFailedDocuments) || !empty($aFailedFolders)) {
         $sFD = '';
         $sFF = '';
         if (!empty($aFailedDocuments)) {
             $sFD = _kt('Documents: ') . implode(', ', $aFailedDocuments) . '. ';
         }
         if (!empty($aFailedFolders)) {
             $sFF = _kt('Folders: ') . implode(', ', $aFailedFolders) . '.';
         }
         return PEAR::raiseError(_kt('You do not have permission to copy these items. ') . $sFD . $sFF);
     }
     // first we walk the tree, creating in the new location as we go.
     // essentially this is an "ok" pass.
     $oStorage =& KTStorageManagerUtil::getSingleton();
     $aFolderMap = array();
     $sTable = 'folders';
     $sGetQuery = 'SELECT * FROM ' . $sTable . ' WHERE id = ? ';
     $aParams = array($oSrcFolder->getId());
     $aRow = DBUtil::getOneResult(array($sGetQuery, $aParams));
     unset($aRow['id']);
     $aRow['name'] = $sDestFolderName;
     $aRow['description'] = $sDestFolderName;
     $aRow['parent_id'] = $oDestFolder->getId();
     $aRow['parent_folder_ids'] = sprintf('%s,%s', $oDestFolder->getParentFolderIDs(), $oDestFolder->getId());
     $aRow['full_path'] = $oDestFolder->getFullPath() . '/' . $aRow['name'];
     $id = DBUtil::autoInsert($sTable, $aRow);
     if (PEAR::isError($id)) {
         DBUtil::rollback();
         return $id;
     }
     $sSrcFolderId = $oSrcFolder->getId();
     $aFolderMap[$sSrcFolderId]['parent_id'] = $id;
     $aFolderMap[$sSrcFolderId]['parent_folder_ids'] = $aRow['parent_folder_ids'];
     $aFolderMap[$sSrcFolderId]['full_path'] = $aRow['full_path'];
     $aFolderMap[$sSrcFolderId]['name'] = $aRow['name'];
     $oNewBaseFolder = Folder::get($id);
     $res = $oStorage->createFolder($oNewBaseFolder);
     if (PEAR::isError($res)) {
         // it doesn't exist, so rollback and raise..
//.........这里部分代码省略.........

 function startTransaction()
 {
     DBUtil::startTransaction();
     $this->bTransactionStarted = true;
 }

 /**
  * applies queries to the database
  * @return
  * @param $filename Object
  */
 function applySQL($filename)
 {
     global $default;
     DBUtil::setupAdminDatabase();
     $db = $default->_admindb;
     $content = file_get_contents($filename);
     $aQueries = SQLFile::splitSQL($content);
     DBUtil::startTransaction();
     foreach ($aQueries as $sQuery) {
         $res = DBUtil::runQuery($sQuery, $db);
         if (PEAR::isError($res)) {
             continue;
         }
     }
     DBUtil::commit();
 }

 /**
  * Load the plugins for the current page
  *
  * @param unknown_type $sType
  */
 static function loadPlugins($sType)
 {
     // Check the current page - can be extended.
     // Currently we only distinguish between the dashboard and everything else.
     if ($sType != 'dashboard') {
         $sType = 'general';
     }
     $aPlugins = array();
     $aPluginHelpers = array();
     $aDisabled = array();
     // Get the list of enabled plugins
     $query = "SELECT h.classname, h.pathname, h.plugin FROM plugin_helper h\n            INNER JOIN plugins p ON (p.namespace = h.plugin)\n           WHERE p.disabled = 0 AND h.classtype='plugin' ORDER BY p.orderby";
     $aPluginHelpers = DBUtil::getResultArray($query);
     if (PEAR::isError($aPluginHelpers)) {
         global $default;
         $default->log->debug('Error in pluginutil: ' . $aPluginHelpers->getMessage());
         return false;
     }
     // Check that there are plugins and if not, register them
     if (empty($aPluginHelpers) || isset($_POST['_force_plugin_truncate'])) {
         DBUtil::startTransaction();
         KTPluginUtil::registerPlugins();
         DBUtil::commit();
         $query = "SELECT h.classname, h.pathname, h.plugin FROM plugin_helper h\n        \t   INNER JOIN plugins p ON (p.namespace = h.plugin)\n        \t   WHERE p.disabled = 0 AND h.classtype='plugin' ORDER BY p.orderby";
         $aPluginHelpers = DBUtil::getResultArray($query);
     }
     // Create plugin objects
     foreach ($aPluginHelpers as $aItem) {
         $classname = $aItem['classname'];
         $path = $aItem['pathname'];
         if (!empty($path)) {
             $path = KT_DIR . '/' . $path;
             require_once $path;
             $oPlugin = new $classname($path);
             if ($oPlugin->load()) {
                 $aPlugins[] = $oPlugin;
             } else {
                 $aDisabled[] = "'{$aItem['plugin']}'";
             }
         }
     }
     $sDisabled = implode(',', $aDisabled);
     // load plugin helpers into global space
     $query = 'SELECT h.* FROM plugin_helper h
         INNER JOIN plugins p ON (p.namespace = h.plugin)
     	WHERE p.disabled = 0 ';
     //WHERE viewtype='{$sType}'";
     if (!empty($sDisabled)) {
         $query .= " AND h.plugin NOT IN ({$sDisabled}) ";
     }
     $query .= ' ORDER BY p.orderby';
     $aPluginList = DBUtil::getResultArray($query);
     KTPluginUtil::load($aPluginList);
     // Load the template locations - ignore disabled plugins
     // Allow for templates that don't correctly link to the plugin
     $query = "SELECT * FROM plugin_helper h\n            LEFT JOIN plugins p ON (p.namespace = h.plugin)\n            WHERE h.classtype='locations' AND (disabled = 0 OR disabled IS NULL) AND unavailable = 0";
     $aLocations = DBUtil::getResultArray($query);
     if (!empty($aLocations)) {
         $oTemplating =& KTTemplating::getSingleton();
         foreach ($aLocations as $location) {
             $aParams = explode('|', $location['object']);
             call_user_func_array(array(&$oTemplating, 'addLocation2'), $aParams);
         }
     }
     return true;
 }

 /**
  * This tells the manager to manage a file that has been uploaded.
  *
  * @param string $filename
  * @param string $tempfile
  * @param string $action
  */
 function uploaded($filename, $tempfile, $action, $relatedid = null)
 {
     $filename = basename($filename);
     $now = date('Y-m-d H:i:s');
     $now_str = date('YmdHis');
     // Ensure the temp directory exists otherwise an error is thrown.
     if (realpath($this->temp_dir) == FALSE) {
         mkdir($this->temp_dir, 0777, true);
     }
     $newtempfile = realpath($this->temp_dir) . '/' . $_SESSION['userID'] . '-' . $now_str;
     if (OS_WINDOWS) {
         $tempfile = str_replace('/', '\\', $tempfile);
         $newtempfile = str_replace('\\', '/', $newtempfile);
     }
     DBUtil::startTransaction();
     $id = DBUtil::autoInsert('uploaded_files', array('tempfilename' => $newtempfile, 'filename' => $filename, 'userid' => $_SESSION['userID'], 'uploaddate' => $now, 'action' => $action), array('noid' => true));
     if (PEAR::isError($id)) {
         DBUtil::rollback();
         return $id;
     }
     global $php_errormsg;
     if (is_uploaded_file($tempfile)) {
         $result = @move_uploaded_file($tempfile, $newtempfile);
     } else {
         $result = @rename($tempfile, $newtempfile);
     }
     $tmp = $php_errormsg;
     if ($result == false) {
         DBUtil::rollback();
         return new PEAR_Error($tmp);
     }
     DBUtil::commit();
     return $newtempfile;
 }

 /**
  * This copies a folder to another location.
  *
  * <code>
  * $root = $this->ktapi->get_root_folder();
  * $folder = $root->add_folder("Test folder");
  * $new_folder = $root->add_folder("New test folder");
  * $res = $folder->copy($new_folder, "Test copy");
  * </code>
  *
  * @author KnowledgeTree Team
  * @access public
  * @param KTAPI_Folder $ktapi_target_folder
  * @param string $reason
  */
 function copy($ktapi_target_folder, $reason = '')
 {
     assert(!is_null($ktapi_target_folder));
     assert(is_a($ktapi_target_folder, 'KTAPI_Folder'));
     $user = $this->ktapi->get_user();
     $target_folder = $ktapi_target_folder->get_folder();
     $result = $this->can_user_access_object_requiring_permission($target_folder, KTAPI_PERMISSION_WRITE);
     if (PEAR::isError($result)) {
         return $result;
     }
     DBUtil::startTransaction();
     $result = KTFolderUtil::copy($this->folder, $target_folder, $user, $reason);
     if (PEAR::isError($result)) {
         DBUtil::rollback();
         return new KTAPI_Error(KTAPI_ERROR_INTERNAL_ERROR, $result);
     }
     DBUtil::commit();
 }

 /**
  * Delete a selected version of the document.
  */
 function deleteVersion($oDocument, $iVersionID, $sReason)
 {
     $oDocument =& KTUtil::getObject('Document', $oDocument);
     $oVersion =& KTDocumentMetadataVersion::get($iVersionID);
     $oStorageManager =& KTStorageManagerUtil::getSingleton();
     global $default;
     if (empty($sReason)) {
         return PEAR::raiseError(_kt('Deletion requires a reason'));
     }
     if (PEAR::isError($oDocument) || $oDocument == false) {
         return PEAR::raiseError(_kt('Invalid document object.'));
     }
     if (PEAR::isError($oVersion) || $oVersion == false) {
         return PEAR::raiseError(_kt('Invalid document version object.'));
     }
     $iContentId = $oVersion->getContentVersionId();
     $oContentVersion = KTDocumentContentVersion::get($iContentId);
     if (PEAR::isError($oContentVersion) || $oContentVersion == false) {
         return PEAR::raiseError(_kt('Invalid document content version object.'));
     }
     // Check that the document content is not the same as the current content version
     $sDocStoragePath = $oDocument->getStoragePath();
     $sVersionStoragePath = $oContentVersion->getStoragePath();
     if ($sDocStoragePath == $sVersionStoragePath) {
         return PEAR::raiseError(_kt("Can't delete version: content is the same as the current document content."));
     }
     DBUtil::startTransaction();
     // now delete the document version
     $res = $oStorageManager->deleteVersion($oVersion);
     if (PEAR::isError($res) || $res == false) {
         //could not delete the document version from the file system
         $default->log->error('Deletion: Filesystem error deleting the metadata version ' . $oVersion->getMetadataVersion() . ' of the document ' . $oDocument->getFileName() . ' from folder ' . Folder::getFolderPath($oDocument->getFolderID()) . ' id=' . $oDocument->getFolderID());
         // we use a _real_ transaction here ...
         DBUtil::rollback();
         return PEAR::raiseError(_kt('There was a problem deleting the document from storage.'));
     }
     // change status for the metadata version
     $oVersion->setStatusId(VERSION_DELETED);
     $oVersion->update();
     // set the storage path to empty
     //        $oContentVersion->setStoragePath('');
     DBUtil::commit();
 }

 function do_import()
 {
     set_time_limit(0);
     $aErrorOptions = array('redirect_to' => array('main', sprintf('fFolderId=%d', $this->oFolder->getId())));
     $aErrorOptions['message'] = _kt('Invalid document type provided');
     $oDocumentType = $this->oValidator->validateDocumentType($_REQUEST['fDocumentTypeId'], $aErrorOptions);
     $aErrorOptions['message'] = _kt('Invalid path provided');
     $sPath = $this->oValidator->validateString($_REQUEST['path'], $aErrorOptions);
     $matches = array();
     $aFields = array();
     foreach ($_REQUEST as $k => $v) {
         if (preg_match('/^metadata_(\\d+)$/', $k, $matches)) {
             $aFields[] = array(DocumentField::get($matches[1]), $v);
         }
     }
     $aOptions = array('documenttype' => $oDocumentType, 'metadata' => $aFields, 'copy_upload' => 'true');
     $po =& new JavascriptObserver($this);
     $po->start();
     $oUploadChannel =& KTUploadChannel::getSingleton();
     $oUploadChannel->addObserver($po);
     $fs =& new KTFSImportStorage($sPath);
     $bm =& new KTBulkImportManager($this->oFolder, $fs, $this->oUser, $aOptions);
     DBUtil::startTransaction();
     $res = $bm->import();
     if (PEAR::isError($res)) {
         DBUtil::rollback();
         $_SESSION["KTErrorMessage"][] = _kt("Bulk import failed") . ": " . $res->getMessage();
     } else {
         DBUtil::commit();
         $this->addInfoMessage(_kt("Bulk import succeeded"));
     }
     $po->redirectToFolder($this->oFolder->getId());
     exit(0);
 }