function do_main()
{
//registerTypes registers the mime types and populates the needed tables.
$indexer = Indexer::get();
$indexer->registerTypes();
$oTemplating =& KTTemplating::getSingleton();
$oTemplate =& $oTemplating->loadTemplate('ktcore/search2/reporting/managemimetypes');
$aMimeTypes = KTMime::getAllMimeTypesInformation();
$indexer = Indexer::get();
$numExtensions = 0;
$numIndexedExtensions = 0;
foreach ($aMimeTypes as $key => $mimeType) {
$extractorClass = $mimeType['extractor'];
$numExtensions++;
if (empty($extractorClass)) {
continue;
}
$extractor = $indexer->getExtractor($extractorClass);
$aMimeTypes[$key]['extractor'] = $extractor->getDisplayName();
$numIndexedExtensions++;
}
$indexedPercentage = 0;
if ($numExtensions > 0) {
$indexedPercentage = number_format($numIndexedExtensions * 100 / $numExtensions, 2, '.', ',');
}
$oTemplate->setData(array('context' => $this, 'mime_types' => $aMimeTypes, 'numExtensions' => $numExtensions, 'numIndexedExtensions' => $numIndexedExtensions, 'indexedPercentage' => $indexedPercentage));
return $oTemplate;
}
function transform()
{
global $default;
$iMimeTypeId = $this->oDocument->getMimeTypeId();
$sMimeType = KTMime::getMimeTypeName($iMimeTypeId);
$sFileName = $this->oDocument->getFileName();
$aTestTypes = array('application/octet-stream', 'application/zip', 'application/x-zip');
if (in_array($sMimeType, $aTestTypes)) {
$sExtension = KTMime::stripAllButExtension($sFileName);
$sTable = KTUtil::getTableName('mimetypes');
$sQuery = "SELECT id, mimetypes FROM {$sTable} WHERE LOWER(filetypes) = ?";
$aParams = array($sExtension);
$aRow = DBUtil::getOneResult(array($sQuery, $aParams));
if (PEAR::isError($aRow)) {
$default->log->debug("ODI: error in query: " . print_r($aRow, true));
return;
}
if (empty($aRow)) {
$default->log->debug("ODI: query returned entry");
return;
}
$id = $aRow['id'];
$mimetype = $aRow['mimetypes'];
$default->log->debug("ODI: query returned: " . print_r($aRow, true));
if (in_array($mimetype, $aTestTypes)) {
// Haven't changed, really not an OpenDocument file...
return;
}
if ($id) {
$this->oDocument->setMimeTypeId($id);
$this->oDocument->update();
}
}
parent::transform();
}
/**
* Gets the document path and calls the conversion function
*
* @return boolean
*/
public function processDocument()
{
$oStorage = KTStorageManagerUtil::getSingleton();
$path = $oStorage->temporaryFile($this->document);
$ext = KTMime::getFileType($this->document->getMimeTypeID());
if (!file_exists($path)) {
global $default;
$default->log->debug('PDF Converter: Document, id: ' . $this->document->iId . ', does not exist at given storage path: ' . $path);
return sprintf(_kt("The document, id: %s, does not exist at the given storage path: %s"), $this->document->iId, $path);
}
// check for OO
$available = $this->checkOO();
// do pdf conversion
if (!$available) {
global $default;
$default->log->error("PDF Converter: Cannot connect to Open Office Server on host {$this->ooHost} : {$this->ooPort}");
return _kt('Cannot connect to Open Office Server.');
}
$res = $this->convertFile($path, $ext);
if ($res !== true) {
global $default;
$default->log->debug('PDF Converter: Document, id: ' . $this->document->iId . ', could not be converted to pdf.');
return sprintf(_kt("The document, id: %s, could not be converted to pdf format. The following error occurred: \"%s\"."), $this->document->iId, $res);
}
return true;
}
function do_main()
{
//registerTypes registers the mime types and populates the needed tables.
$indexer = Indexer::get();
$indexer->registerTypes();
$oTemplating =& KTTemplating::getSingleton();
$oTemplating->addLocation('Extractor Information', '/plugins/search2/reporting/templates');
$oTemplate =& $oTemplating->loadTemplate('extractorinfo');
$aExtractorInfo = KTMime::getMimeExtractorInformation();
if (empty($aExtractorInfo)) {
$oTemplate->setData(array('context' => $this, 'extractor_info' => $aExtractorInfo));
return $oTemplate;
}
foreach ($aExtractorInfo as $key => $info) {
$extractorClass = $info['name'];
$extractor = $indexer->getExtractor($extractorClass);
$info['mimeTypes'] = array();
$aMimeTypes = $this->getSupportedMimeTypesDB($extractorClass);
//$extractor->getSupportedMimeTypes();
foreach ($aMimeTypes as $mimeType) {
$sMimeInfo = KTMime::getFriendlyNameAndExtension($mimeType);
$info['mimeTypes'][$mimeType] = array('description' => $sMimeInfo[0]['friendly_name'], 'extensions' => array($sMimeInfo[0]['filetypes']));
$extensions = array();
foreach ($sMimeInfo as $item) {
$extensions[] = $item['filetypes'];
}
$info['mimeTypes'][$mimeType]['extensions'] = implode(', ', $extensions);
}
$aExtractorInfo[$key] = $info;
}
$oTemplate->setData(array('context' => $this, 'extractor_info' => $aExtractorInfo));
return $oTemplate;
}
/**
* Gets the document path and calls the conversion function
*
* @return boolean
*/
public function processDocument()
{
$oStorage = KTStorageManagerUtil::getSingleton();
$path = $oStorage->temporaryFile($this->document);
$ext = KTMime::getFileType($this->document->getMimeTypeID());
if (!file_exists($path)) {
global $default;
$default->log->debug('Document, id: ' . $this->document->iId . ', does not exist at given storage path: ' . $path);
return false;
}
// do pdf conversion
$res = $this->convertFile($path, $ext);
if ($res === false) {
global $default;
$default->log->debug('Document, id: ' . $this->document->iId . ', could not be converted to pdf.');
return false;
}
return true;
}
public function createDocument($repositoryId, $typeId, $properties, $folderId = null, $contentStream = null, $versioningState = null)
{
$objectId = null;
// fetch type definition of supplied type and check for base type "document", if not true throw exception
$RepositoryService = new CMISRepositoryService();
try {
$typeDefinition = $RepositoryService->getTypeDefinition($repositoryId, $typeId);
} catch (Exception $e) {
throw new ConstraintViolationException('Object base type could not be determined. ' . $e->getMessage());
}
if ($typeDefinition['attributes']['baseType'] != 'document') {
throw new ConstraintViolationException('Object is not of base type document');
}
// if no $folderId submitted and repository does not support "unfiling" throw exception
if (empty($folderId)) {
$repositoryInfo = $RepositoryService->getRepositoryInfo($repositoryId);
$capabilities = $repositoryInfo->getCapabilities();
if (!$capabilities->hasCapabilityUnfiling()) {
throw new ConstraintViolationException('Repository does not support the Unfiling capability and no folder id was supplied');
}
}
// Attempt to decode $folderId, use as is if not detected as encoded
$tmpObjectId = $folderId;
$tmpObjectId = CMISUtil::decodeObjectId($tmpObjectId, $tmpTypeId);
if ($tmpTypeId != 'Unknown') {
$folderId = $tmpObjectId;
}
// if parent folder is not allowed to hold this type, throw exception
$CMISFolder = new CMISFolderObject($folderId, $this->ktapi);
$allowed = $CMISFolder->getProperty('AllowedChildObjectTypeIds');
$typeAllowed = false;
if (is_array($allowed)) {
foreach ($allowed as $type) {
if (strtolower($type) == strtolower($typeId)) {
$typeAllowed = true;
break;
}
}
}
if (!$typeAllowed) {
throw new ConstraintViolationException('Parent folder may not hold objects of this type (' . $typeId . ')');
}
// if content stream is required and no content stream is supplied, throw a ConstraintViolationException
if ($typeDefinition['attributes']['contentStreamAllowed'] == 'required' && is_null($contentStream)) {
throw new ConstraintViolationException('This repository requires a content stream for document creation. ' . 'Refusing to create an empty document');
} else {
if ($typeDefinition['attributes']['contentStreamAllowed'] == 'notAllowed' && !empty($contentStream)) {
throw new StreamNotSupportedException('Content Streams are not supported');
}
}
// if versionable attribute is set to false and versioningState is supplied, throw a ConstraintViolationException
if (!$typeDefinition['attributes']['versionable'] && !empty($versioningState)) {
throw new ConstraintViolationException('This repository does not support versioning');
}
// TODO deal with $versioningState when supplied
// set title and name identical if only one submitted
if ($properties['title'] == '') {
$properties['title'] = $properties['name'];
} else {
if ($properties['name'] == '') {
$properties['name'] = $properties['title'];
}
}
// if name is blank throw exception (check type) - using invalidArgument Exception for now
if (trim($properties['name']) == '') {
throw new InvalidArgumentException('Refusing to create an un-named document');
}
// TODO also set to Default if a non-supported type is submitted
if ($properties['type'] == '') {
$properties['type'] = 'Default';
}
// create the content stream from the supplied data
// NOTE since the repository is set to require a content stream and we don't currently have another way to get the document data
// this check isn't strictly necessary; however it is needed for a repository which does not support content streams
if (!is_null($contentStream)) {
$tempfilename = CMISUtil::createTemporaryFile($contentStream);
// metadata
$metadata = array();
$metaFields = array();
$sysdata = array();
if (!empty($properties['summary'])) {
$metadata[] = array('fieldset' => 'Tag Cloud', 'fields' => array(array('name' => 'Tag', 'value' => $properties['summary'])));
}
$user = $this->ktapi->get_user();
if (!PEAR::isError($user)) {
$metaFields['General Information'][] = array('name' => 'Document Author', 'value' => $user->getName());
}
if (!empty($properties['category'])) {
$category = $properties['category'];
} else {
$category = 'Miscellaneous';
}
$metaFields['General Information'][] = array('name' => 'Category', 'value' => $category);
/**
* Try to determine mime type which maps to one of the following KnowledgetTree document types:
*
* Audio
* Image
* Text
* Video
*
* example mime types:
*
* text/plain
* image/gif
* application/x-dosexec
* application/pdf
* application/msword
* audio/mpeg
* application/octet-stream
* application/zip
*/
// TODO check extension for types which are not obvious? e.g. wmv video returns application/octet-stream
$mediatype = null;
include_once KT_LIB_DIR . '/mime.inc.php';
$KTMime = new KTMime();
$mimetype = $KTMime->getMimeTypeFromFile($tempfilename);
preg_match('/^([^\\/]*)\\/([^\\/]*)/', $mimetype, $matches);
if ($matches[1] == 'text' || $matches[1] == 'image' || $matches[1] == 'audio') {
$mediatype = ucwords($matches[1]);
} else {
if ($matches[2] == 'pdf' || $matches[2] == 'msword') {
$mediatype = 'Text';
}
}
if (!is_null($mediatype)) {
$metaFields['General Information'][] = array('name' => 'Media Type', 'value' => $mediatype);
}
if (count($metaFields['General Information']) > 0) {
foreach ($metaFields['General Information'] as $field) {
$fields[] = $field;
}
$metadata[] = array('fieldset' => 'General Information', 'fields' => $fields);
}
$response = $this->ktapi->add_document_with_metadata((int) $folderId, $properties['title'], $properties['name'], $properties['type'], $tempfilename, $metadata, $sysdata);
if ($response['status_code'] != 0) {
throw new StorageException('The repository was unable to create the document. ' . $response['message']);
} else {
$objectId = CMISUtil::encodeObjectId('Document', $response['results']['document_id']);
}
// remove temporary file
@unlink($tempfilename);
} else {
// TODO creation of document without content. leaving this for now as we require content streams and any code
// here will therefore never be executed; if we implement some form of template based document creation
// then we may have something else to do here;
// for now we just throw a general RuntimeException, since we should not
// actually reach this code unless something is wrong; this may be removed or replaced later
throw new RuntimeException('Cannot create document without a content stream');
}
return $objectId;
}
/**
* This returns detailed information on the document.
*
* @author KnowledgeTree Team
* @access public
* @return array The document information
*/
function get_detail()
{
global $default;
// make sure we ge tthe latest
$this->clearCache();
$config = KTConfig::getSingleton();
$wsversion = $config->get('webservice/version', LATEST_WEBSERVICE_VERSION);
$detail = array();
$document = $this->document;
// get the document id
$detail['document_id'] = (int) $document->getId();
$oem_document_no = null;
if ($wsversion >= 2) {
$oem_document_no = $document->getOemNo();
}
if (empty($oem_document_no)) {
$oem_document_no = 'n/a';
}
$detail['custom_document_no'] = 'n/a';
$detail['oem_document_no'] = $oem_document_no;
// get the title
$detail['title'] = $document->getName();
// get the document type
$documenttypeid = $document->getDocumentTypeID();
$documenttype = '* unknown *';
if (is_numeric($documenttypeid)) {
$dt = DocumentType::get($documenttypeid);
if (!is_null($dt) && !PEAR::isError($dt)) {
$documenttype = $dt->getName();
}
}
$detail['document_type'] = $documenttype;
// get the filename
$detail['filename'] = $document->getFilename();
// get the filesize
$detail['filesize'] = (int) $document->getFileSize();
// get the folder id
$detail['folder_id'] = (int) $document->getFolderID();
// get the creator
$userid = $document->getCreatorID();
$username = '******';
if (is_numeric($userid)) {
$username = '******';
$user = User::get($userid);
if (!is_null($user) && !PEAR::isError($user)) {
$username = $user->getName();
}
}
$detail['created_by'] = $username;
// get the creation date
$detail['created_date'] = $document->getCreatedDateTime();
// get the checked out user
$userid = $document->getCheckedOutUserID();
$username = '******';
if (is_numeric($userid)) {
$username = '******';
$user = User::get($userid);
if (!is_null($user) && !PEAR::isError($user)) {
$username = $user->getName();
}
}
$detail['checked_out_by'] = $username;
// get the checked out date
list($major, $minor, $fix) = explode('.', $default->systemVersion);
if ($major == 3 && $minor >= 5) {
$detail['checked_out_date'] = $document->getCheckedOutDate();
} else {
$detail['checked_out_date'] = $detail['modified_date'];
}
if (is_null($detail['checked_out_date'])) {
$detail['checked_out_date'] = 'n/a';
}
// get the modified user
$userid = $document->getModifiedUserId();
$username = '******';
if (is_numeric($userid)) {
$username = '******';
$user = User::get($userid);
if (!is_null($user) && !PEAR::isError($user)) {
$username = $user->getName();
}
}
$detail['modified_by'] = $detail['updated_by'] = $username;
// get the modified date
$detail['updated_date'] = $detail['modified_date'] = $document->getLastModifiedDate();
// get the owner
$userid = $document->getOwnerID();
$username = '******';
if (is_numeric($userid)) {
$username = '******';
$user = User::get($userid);
if (!is_null($user) && !PEAR::isError($user)) {
$username = $user->getName();
}
}
$detail['owned_by'] = $username;
// get the version
$detail['version'] = $document->getVersion();
if ($wsversion >= 2) {
$detail['version'] = (double) $detail['version'];
}
//might be unset at the bottom in case of old webservice version
//make sure we're using the real document for this one
$this->document->switchToRealCore();
$detail['linked_document_id'] = $document->getLinkedDocumentId();
$this->document->switchToLinkedCore();
// check immutability
$detail['is_immutable'] = (bool) $document->getImmutable();
// check permissions
$detail['permissions'] = KTAPI_Document::get_permission_string($document);
// get workflow name
$workflowid = $document->getWorkflowId();
$workflowname = 'n/a';
if (is_numeric($workflowid)) {
$workflow = KTWorkflow::get($workflowid);
if (!is_null($workflow) && !PEAR::isError($workflow)) {
$workflowname = $workflow->getName();
}
}
$detail['workflow'] = $workflowname;
// get the workflow state
$stateid = $document->getWorkflowStateId();
$workflowstate = 'n/a';
if (is_numeric($stateid)) {
$state = KTWorkflowState::get($stateid);
if (!is_null($state) && !PEAR::isError($state)) {
$workflowstate = $state->getName();
}
}
$detail['workflow_state'] = $workflowstate;
// get the full path
$detail['full_path'] = '/' . $this->document->getFullPath();
// get mime info
$mimetypeid = $document->getMimeTypeID();
$detail['mime_type'] = KTMime::getMimeTypeName($mimetypeid);
$detail['mime_icon_path'] = KTMime::getIconPath($mimetypeid);
$detail['mime_display'] = KTMime::getFriendlyNameForString($detail['mime_type']);
// get the storage path
$detail['storage_path'] = $document->getStoragePath();
if ($wsversion >= 2) {
unset($detail['updated_by']);
unset($detail['updated_date']);
}
if ($wsversion < 3) {
unset($detail['linked_document_id']);
}
return $detail;
}
/**
* Method to get any documents added by the user via the Drop Box.
* Returns the HTML displaying the document list.
*
* @param string $sUserName
* @param numeric $iDropDocsFolderID
* @return string HTML - the document list on success or an error message on failure
*/
function getUsersDocument($sUserName, $iDropDocsFolderID)
{
$oUser = $this->oUser;
$oDropDocsFolder = Folder::get($iDropDocsFolderID);
$fullPath = $oDropDocsFolder->getFullPath() . '/' . $sUserName;
$aExternalWhereClauses[] = '(DT.transaction_namespace IN (?,?,?) AND (D.full_path LIKE "' . $fullPath . '/%"))';
$aExternalWhereParams[] = 'ktcore.transactions.create';
$aExternalWhereParams[] = 'ktcore.transactions.check_in';
$aExternalWhereParams[] = 'ktcore.transactions.event';
$aDocumentTransactions = $this->getTransactionsMatchingQuery($oUser, '', $aExternalWhereClauses, $aExternalWhereParams);
if (empty($aDocumentTransactions) || PEAR::isError($aDocumentTransactions)) {
if (PEAR::isError($aDocumentTransactions)) {
global $default;
$default->log->debug('Error retrieving dropped documents - ' . $aDocumentTransactions->getMessage());
}
return _kt('<span class="descriptiveText"> You do not have any dropped documents </span><br><br><br>');
}
$maxcount = 5;
$sReturnTable = '<span class="descriptiveText">' . _kt('Recently Dropped Documents') . '</span>
<table width="100%" class="kt_collection drop_box" cellspacing="0">
<thead>
<tr>
<th width="100%">' . _kt('Document') . '</th>
<th width="1%">' . _kt('Date Dropped') . '</th>
</tr>
</thead>
<tbody>';
$sOddorEven = '';
$count = 1;
$rendered = array();
foreach ($aDocumentTransactions as $aRow) {
$documentId = $aRow['document_id'];
if (in_array($documentId, $rendered)) {
continue;
}
$rendered[] = $documentId;
$oDocument = Document::get($documentId);
$sContentType = KTMime::getIconPath($oDocument->getMimeTypeID());
$aAnchorData = $this->getDocInfo($documentId);
$sLink = $aAnchorData[0];
$sShortDocName = $sDocName = $aAnchorData[1];
$iDocLength = strlen($sDocName);
$iMax = 40;
if ($iDocLength > $iMax) {
$sShortDocName = substr($sDocName, 0, $iMax) . '...';
}
$sOddorEven = $count % 2 == 0 ? 'even' : 'odd';
$sReturnTable .= '<tr class="' . $sOddorEven . '">' . '<td width="100%"><span class="contenttype ' . $sContentType . '"><a title="' . $sDocName . '" href=' . $sLink . '>' . $sShortDocName . '</a></span></td>' . '<td width="1%">' . $aRow['datetime'] . '</td>' . '</tr>';
if (++$count > 5) {
break;
}
}
$location = 'browse.php?fFolderId=' . $iMyDocsFolderID;
$sReturnTable .= '</tbody>' . '</table>' . '<br>' . '<a href="' . $location . '">' . _kt(' View All') . ' </a><br><br>';
//$this->session->logout();
return $sReturnTable;
}
function transform()
{
$iMimeTypeId = $this->oDocument->getMimeTypeId();
$sMimeType = KTMime::getMimeTypeName($iMimeTypeId);
if (!array_key_exists($sMimeType, $this->mimetypes)) {
return;
}
$oStorage = KTStorageManagerUtil::getSingleton();
$sFile = $oStorage->temporaryFile($this->oDocument);
$tempstub = 'transform';
if ($this->command != null) {
$tempstub = $this->command;
}
$oKTConfig =& KTConfig::getSingleton();
$sBasedir = $oKTConfig->get("urls/tmpDirectory");
$myfilename = tempnam($sBasedir, 'kt.' . $tempstub);
if (OS_WINDOWS) {
$intermediate = tempnam($sBasedir, 'kt.' . $tempstub);
if (!@copy($sFile, $intermediate)) {
return;
}
} else {
$intermediate = $sFile;
}
$contents = $this->extract_contents($intermediate, $myfilename);
@unlink($myfilename);
if (OS_WINDOWS) {
@unlink($intermediate);
}
if (empty($contents)) {
return;
}
$aInsertValues = array('document_id' => $this->oDocument->getId(), 'document_text' => $contents);
$sTable = KTUtil::getTableName('document_text');
// clean up the document query "stuff".
// FIXME this suggests that we should move the _old_ document_searchable_text across to the old-document's id if its a checkin.
DBUtil::runQuery(array('DELETE FROM ' . $sTable . ' WHERE document_id = ?', array($this->oDocument->getId())));
DBUtil::autoInsert($sTable, $aInsertValues, array('noid' => true));
}
public static function getDocumentContent($oDocument)
{
global $default;
//get the path to the document on the server
//$docRoot = $default->documentRoot;
$oConfig =& KTConfig::getSingleton();
$docRoot = $oConfig->get('urls/documentRoot');
$path = $docRoot . '/' . $oDocument->getStoragePath();
// Ensure the file exists
if (file_exists($path)) {
// Get the mime type - this is not relevant at the moment...
$mimeId = $oDocument->getMimeTypeID();
$mimetype = KTMime::getMimeTypeName($mimeId);
if ($bIsCheckout && $default->fakeMimetype) {
// note this does not work for "image" types in some browsers
$mimetype = 'application/x-download';
}
$sFileName = $oDocument->getFileName();
$iFileSize = $oDocument->getFileSize();
} else {
return null;
}
$content = file_get_contents($path);
return $content;
}
function getMimeTypeInfo($iUserId, $iDocumentId)
{
global $default;
$mimeinfo['typeId'] = KTrss::getDocumentMimeTypeId($iUserId, $iDocumentId);
// mime type id
$mimeinfo['typeName'] = KTMime::getMimeTypeName($mimeinfo['typeId']);
// mime type name
$mimeinfo['typeFName'] = KTMime::getFriendlyNameForString($mimeinfo['typeName']);
// mime type friendly name
$mimeinfo['typeIcon'] = "http" . ($default->sslEnabled ? "s" : "") . "://" . $_SERVER['HTTP_HOST'] . "/" . $GLOBALS['KTRootUrl'] . "/resources/mimetypes/" . KTMime::getIconPath($mimeinfo['typeId']) . ".png";
//icon path
return $mimeinfo;
}
function getIconPath($iMimeTypeId, $type = null)
{
$icon = KTUtil::arrayGet($GLOBALS['_KT_icon_path_cache'], $iMimeTypeId);
if (empty($icon)) {
$GLOBALS['_KT_icon_path_cache'][$iMimeTypeId] = KTMime::_getIconPath($iMimeTypeId);
$icon = $GLOBALS['_KT_icon_path_cache'][$iMimeTypeId];
}
if (!empty($type)) {
$icon .= '_' . $type;
}
return $icon;
}
/**
* Generates the thumbnail from the pdf
*
* @return boolean
*/
private function generateThumbnail()
{
/*
The thumbnail is displayed in the info panel and the document view
The info panel is in the plugin ktcore/documentpreview/
- add a hook in there but build the functionality in this plugin ie keep the plugins separate and don't create dependencies
- if the thumbnail plugin is disabled then maybe display a normal sized info panel
The document view will display the thumbnail on the right in a document viewlet similar to the workflow viewlet
- check out ktcore/KTDocumentViewlets.php
- viewlet class is below
*/
global $default;
$mimeTypeId = $this->document->getMimeTypeID();
$mimeType = KTMime::getMimeTypeName($mimeTypeId);
// Get the pdf source file - if the document is a pdf then use the document as the source
if ($mimeType == 'application/pdf') {
$pdfDir = $default->documentRoot;
$pdfFile = $pdfDir . DIRECTORY_SEPARATOR . $this->document->getStoragePath();
} else {
$pdfDir = $default->pdfDirectory;
$pdfFile = $pdfDir . DIRECTORY_SEPARATOR . $this->document->iId . '.pdf';
}
$thumbnaildir = $default->varDirectory . DIRECTORY_SEPARATOR . 'thumbnails';
if (stristr(PHP_OS, 'WIN')) {
$thumbnaildir = str_replace('/', '\\', $thumbnaildir);
$pdfFile = str_replace('/', '\\', $pdfFile);
}
$thumbnailfile = $thumbnaildir . DIRECTORY_SEPARATOR . $this->document->iId . '.jpg';
//if thumbail dir does not exist, generate one and add an index file to block access
if (!file_exists($thumbnaildir)) {
mkdir($thumbnaildir, 0755);
touch($thumbnaildir . DIRECTORY_SEPARATOR . 'index.html');
file_put_contents($thumbnaildir . DIRECTORY_SEPARATOR . 'index.html', 'You do not have permission to access this directory.');
}
// if there is no pdf that exists - hop out
if (!file_exists($pdfFile)) {
$default->log->debug('Thumbnail Generator Plugin: PDF file does not exist, cannot generate a thumbnail');
return false;
}
// if a previous version of the thumbnail exists - delete it
if (file_exists($thumbnailfile)) {
@unlink($thumbnailfile);
}
// do generation
$pathConvert = !empty($default->convertPath) ? $default->convertPath : 'convert';
// windows path may contain spaces
if (stristr(PHP_OS, 'WIN')) {
$cmd = "\"{$pathConvert}\" \"{$pdfFile}[0]\" -resize 200x200 \"{$thumbnailfile}\"";
} else {
$cmd = "{$pathConvert} {$pdfFile}[0] -resize 200x200 {$thumbnailfile}";
}
$result = KTUtil::pexec($cmd);
return true;
}
function _mimeHelper($iMimeTypeId)
{
require_once KT_LIB_DIR . '/mime.inc.php';
return KTMime::getIconPath($iMimeTypeId);
}
function rename($oDocument, $sNewFilename, $oUser)
{
$oStorage =& KTStorageManagerUtil::getSingleton();
$oKTConfig = KTConfig::getSingleton();
$updateVersion = $oKTConfig->get('tweaks/incrementVersionOnRename', true);
$iPreviousMetadataVersion = $oDocument->getMetadataVersionId();
$oOldContentVersion = $oDocument->_oDocumentContentVersion;
if ($updateVersion) {
$bSuccess = $oDocument->startNewContentVersion($oUser);
if (PEAR::isError($bSuccess)) {
return $bSuccess;
}
KTDocumentUtil::copyMetadata($oDocument, $iPreviousMetadataVersion);
}
$res = $oStorage->renameDocument($oDocument, $oOldContentVersion, $sNewFilename);
if (!$res) {
return PEAR::raiseError(_kt('An error occurred while storing the new file'));
}
$oDocument->setLastModifiedDate(getCurrentDateTime());
$oDocument->setModifiedUserId($oUser->getId());
if ($updateVersion) {
// Update version number
$oDocument->setMinorVersionNumber($oDocument->getMinorVersionNumber() + 1);
}
$oDocument->_oDocumentContentVersion->setFilename($sNewFilename);
$sType = KTMime::getMimeTypeFromFile($sNewFilename);
$iMimeTypeId = KTMime::getMimeTypeID($sType, $sNewFilename);
$oDocument->setMimeTypeId($iMimeTypeId);
$bSuccess = $oDocument->update();
if ($bSuccess !== true) {
if (PEAR::isError($bSuccess)) {
return $bSuccess;
}
return PEAR::raiseError(_kt('An error occurred while storing this document in the database'));
}
// create the document transaction record
$oDocumentTransaction = new DocumentTransaction($oDocument, _kt('Document renamed'), 'ktcore.transactions.update');
$oDocumentTransaction->create();
$oKTTriggerRegistry = KTTriggerRegistry::getSingleton();
$aTriggers = $oKTTriggerRegistry->getTriggers('renameDocument', 'postValidate');
foreach ($aTriggers as $aTrigger) {
$sTrigger = $aTrigger[0];
$oTrigger = new $sTrigger();
$aInfo = array('document' => $oDocument);
$oTrigger->setInfo($aInfo);
$ret = $oTrigger->postValidate();
if (PEAR::isError($ret)) {
return $ret;
}
}
// fire subscription alerts for the checked in document
$oSubscriptionEvent = new SubscriptionEvent();
$oFolder = Folder::get($oDocument->getFolderID());
$oSubscriptionEvent->ModifyDocument($oDocument, $oFolder);
return true;
}
/**
* Method for getting the MIME type extension for the current document.
*
* @return string mime time extension
*/
function getMimeExtension()
{
if ($this->oDocument == null || $this->oDocument == "" || PEAR::isError($this->oDocument)) {
return _kt('Unknown Type');
}
$oDocument = $this->oDocument;
$iMimeTypeId = $oDocument->getMimeTypeID();
$mimetypename = KTMime::getMimeTypeName($iMimeTypeId);
// mime type name
// the pdf converter uses the mime type and not the extension.
return $mimetypename;
/*
$sTable = KTUtil::getTableName('mimetypes');
$sQuery = "SELECT filetypes FROM " . $sTable . " WHERE mimetypes = ?";
$aQuery = array($sQuery, array($mimetypename));
$res = DBUtil::getResultArray($aQuery);
if (PEAR::isError($res)) {
return $res;
} else if (count($res) != 0){
return $res[0]['filetypes'];
}
return _kt('Unknown Type');
*/
}
/**
* Create a table of the document metadata.
* Hard coded for the moment
*
* @return unknown
*/
function getMetadata()
{
/* Get document info */
// Filename
$sFilenameLb = _kt('Document Filename: ');
$sFilename = $this->_oDocument->getFileName();
// Mime type
$sMimeTypeLb = _kt('File is a: ');
$iMimeId = $this->_oDocument->getMimeTypeID();
$sMimeType = KTMime::getMimeTypeName($iMimeId);
$sMimeType = KTMime::getFriendlyNameForString($sMimeType);
// Version
$sVersionLb = _kt('Document Version: ');
$iVersion = $this->_oDocument->getVersion();
// Created by
$sCreatedByLb = _kt('Created by: ');
$iCreatorId = $this->_oDocument->getCreatorID();
$sCreated = $this->_oDocument->getCreatedDateTime();
$oCreator = User::get($iCreatorId);
$sCreatedBy = $oCreator->getName() . ' (' . $sCreated . ')';
// Owned by
$sOwnedByLb = _kt('Owned by: ');
$iOwnedId = $this->_oDocument->getOwnerID();
$oOwner = User::get($iOwnedId);
$sOwnedBy = $oOwner->getName();
// Last update by
$iModifiedId = $this->_oDocument->getModifiedUserId();
$sLastUpdatedByLb = '';
$sLastUpdatedBy = '';
if (!empty($iModifiedId)) {
$sLastUpdatedByLb = _kt('Last updated by: ');
$sModified = $this->_oDocument->getLastModifiedDate();
$oModifier = User::get($iModifiedId);
$sLastUpdatedBy = $oModifier->getName() . ' (' . $sModified . ')';
}
// Document type
$sDocTypeLb = _kt('Document Type: ');
$iDocTypeId = $this->_oDocument->getDocumentTypeID();
$oDocType = DocumentType::get($iDocTypeId);
$sDocType = $oDocType->getName();
// Workflow
$iWFId = $this->_oDocument->getWorkflowId();
$sWF = '';
$sWFLb = '';
if (!empty($iWFId)) {
$sWFLb = _kt('Workflow: ');
$iWFStateId = $this->_oDocument->getWorkflowStateId();
$oWF = KTWorkflow::get($iWFId);
$sWF = $oWF->getHumanName();
$oWFState = KTWorkflowState::get($iWFStateId);
$sWF .= ' (' . $oWFState->getHumanName() . ')';
}
// Checked out by
$sCheckedLb = '';
$sCheckedOutBy = '';
if ($this->_oDocument->getIsCheckedOut()) {
$sCheckedLb = _kt('Checked out by: ');
$iCheckedID = $this->_oDocument->getCheckedOutUserID();
$oCheckedUser = User::get($iCheckedID);
$sCheckedOutBy = $oCheckedUser->getName();
}
// Id
$sIdLb = _kt('Document ID: ');
$sId = $this->_IDocId;
/* Create table */
$sInfo = "<div style='float:left; width:405px;'>\n <table cellspacing='3px' cellpadding='3px' width='405px'>\n <tr><td>{$sFilenameLb}</td><td><b>{$sFilename}</b></td></tr>\n <tr><td>{$sMimeTypeLb}</td><td><b>{$sMimeType}</b></td></tr>\n <tr><td>{$sVersionLb}</td><td><b>{$iVersion}</b></td></tr>\n <tr><td>{$sCreatedByLb}</td><td><b>{$sCreatedBy}</b></td></tr>\n <tr><td>{$sOwnedByLb}</td><td><b>{$sOwnedBy}</b></td></tr>";
if (!empty($sLastUpdatedBy)) {
$sInfo .= "<tr><td>{$sLastUpdatedByLb}</td><td><b>{$sLastUpdatedBy}</b></td></tr>";
}
$sInfo .= "<tr><td>{$sDocTypeLb}</td><td><b>{$sDocType}</b></td></tr>";
if (!empty($sWF)) {
$sInfo .= "<tr><td>{$sWFLb}</td><td><b>{$sWF}</b></td></tr>";
}
if (!empty($sCheckedOutBy)) {
$sInfo .= "<tr><td>{$sCheckedLb}</td><td><b>{$sCheckedOutBy}</b></td></tr>";
}
$sInfo .= "<tr><td>{$sIdLb}</td><td><b>{$sId}</b></td></tr>";
$sInfo .= " </table></div>";
return $sInfo;
}
/**
* Get's a folder listing, recursing to the maximum depth.
* Derived from the get_listing function.
*
* <code>
* $root = $this->ktapi->get_root_folder();
* $listing = $root->get_full_listing();
* foreach($listing as $val) {
* if($val['item_type'] == 'F') {
* // It's a folder
* echo $val['title'];
* }
* }
* </code>
*
* @author KnowledgeTree Team
* @access public
* @param string $what
* @return array
*/
function get_full_listing($what = 'DFS')
{
$what = strtoupper($what);
$read_permission =& KTPermission::getByName(KTAPI_PERMISSION_READ);
$folder_permission =& KTPermission::getByName(KTAPI_PERMISSION_VIEW_FOLDER);
$config = KTConfig::getSingleton();
$wsversion = $config->get('webservice/version', LATEST_WEBSERVICE_VERSION);
$user = $this->ktapi->get_user();
$contents = array();
if (strpos($what, 'F') !== false) {
$folder_children = Folder::getList(array('parent_id = ?', $this->folderid));
foreach ($folder_children as $folder) {
if (KTPermissionUtil::userHasPermissionOnItem($user, $folder_permission, $folder) || KTPermissionUtil::userHasPermissionOnItem($user, $read_permission, $folder)) {
$sub_folder =& $this->ktapi->get_folder_by_id($folder->getId());
if (!PEAR::isError($sub_folder)) {
$items = $sub_folder->get_full_listing($what);
} else {
$items = array();
}
$creator = $this->_resolve_user($folder->getCreatorID());
if ($wsversion >= 2) {
$array = array('id' => (int) $folder->getId(), 'item_type' => 'F', 'custom_document_no' => 'n/a', 'oem_document_no' => 'n/a', 'title' => $folder->getName(), 'document_type' => 'n/a', 'filename' => $folder->getName(), 'filesize' => 'n/a', 'created_by' => is_null($creator) ? 'n/a' : $creator->getName(), 'created_date' => 'n/a', 'checked_out_by' => 'n/a', 'checked_out_date' => 'n/a', 'modified_by' => 'n/a', 'modified_date' => 'n/a', 'owned_by' => 'n/a', 'version' => 'n/a', 'is_immutable' => 'n/a', 'permissions' => KTAPI_Folder::get_permission_string($folder), 'workflow' => 'n/a', 'workflow_state' => 'n/a', 'mime_type' => 'folder', 'mime_icon_path' => 'folder', 'mime_display' => 'Folder', 'storage_path' => 'n/a');
if ($wsversion >= 3) {
$array['linked_folder_id'] = $folder->getLinkedFolderId();
if ($folder->isSymbolicLink()) {
$array['item_type'] = "S";
}
}
$array['items'] = $items;
if ($wsversion < 3 || strpos($what, 'F') !== false && !$folder->isSymbolicLink() || $folder->isSymbolicLink() && strpos($what, 'S') !== false) {
$contents[] = $array;
}
} else {
$contents[] = array('id' => (int) $folder->getId(), 'item_type' => 'F', 'title' => $folder->getName(), 'creator' => is_null($creator) ? 'n/a' : $creator->getName(), 'checkedoutby' => 'n/a', 'modifiedby' => 'n/a', 'filename' => $folder->getName(), 'size' => 'n/a', 'major_version' => 'n/a', 'minor_version' => 'n/a', 'storage_path' => 'n/a', 'mime_type' => 'folder', 'mime_icon_path' => 'folder', 'mime_display' => 'Folder', 'items' => $items, 'workflow' => 'n/a', 'workflow_state' => 'n/a');
}
}
}
}
if (strpos($what, 'D') !== false) {
$document_children = Document::getList(array('folder_id = ? AND status_id = 1', $this->folderid));
// I hate that KT doesn't cache things nicely...
$mime_cache = array();
foreach ($document_children as $document) {
if (KTPermissionUtil::userHasPermissionOnItem($user, $read_permission, $document)) {
$created_by = $this->_resolve_user($document->getCreatorID());
$created_date = $document->getCreatedDateTime();
if (empty($created_date)) {
$created_date = 'n/a';
}
$checked_out_by = $this->_resolve_user($document->getCheckedOutUserID());
$checked_out_date = $document->getCheckedOutDate();
if (empty($checked_out_date)) {
$checked_out_date = 'n/a';
}
$modified_by = $this->_resolve_user($document->getCreatorID());
$modified_date = $document->getLastModifiedDate();
if (empty($modified_date)) {
$modified_date = 'n/a';
}
$owned_by = $this->_resolve_user($document->getOwnerID());
$mimetypeid = $document->getMimeTypeID();
if (!array_key_exists($mimetypeid, $mime_cache)) {
$type = KTMime::getMimeTypeName($mimetypeid);
$icon = KTMime::getIconPath($mimetypeid);
$display = KTMime::getFriendlyNameForString($type);
$mime_cache[$mimetypeid] = array('type' => $type, 'icon' => $icon, 'display' => $display);
}
$mimeinfo = $mime_cache[$mimetypeid];
$workflow = 'n/a';
$state = 'n/a';
$wf = KTWorkflowUtil::getWorkflowForDocument($document);
if (!is_null($wf) && !PEAR::isError($wf)) {
$workflow = $wf->getHumanName();
$ws = KTWorkflowUtil::getWorkflowStateForDocument($document);
if (!is_null($ws) && !PEAR::isError($ws)) {
$state = $ws->getHumanName();
}
}
if ($wsversion >= 2) {
$docTypeId = $document->getDocumentTypeID();
$documentType = DocumentType::get($docTypeId);
$oemDocumentNo = $document->getOemNo();
if (empty($oemDocumentNo)) {
$oemDocumentNo = 'n/a';
}
$array = array('id' => (int) $document->getId(), 'item_type' => 'D', 'custom_document_no' => 'n/a', 'oem_document_no' => $oemDocumentNo, 'title' => $document->getName(), 'document_type' => $documentType->getName(), 'filename' => $document->getFileName(), 'filesize' => $document->getFileSize(), 'created_by' => is_null($created_by) ? 'n/a' : $created_by->getName(), 'created_date' => $created_date, 'checked_out_by' => is_null($checked_out_by) ? 'n/a' : $checked_out_by->getName(), 'checked_out_date' => $checked_out_date, 'modified_by' => is_null($modified_by) ? 'n/a' : $modified_by->getName(), 'modified_date' => $modified_date, 'owned_by' => is_null($owned_by) ? 'n/a' : $owned_by->getName(), 'version' => $document->getMajorVersionNumber() . '.' . $document->getMinorVersionNumber(), 'content_id' => $document->getContentVersionId(), 'is_immutable' => $document->getImmutable() ? 'true' : 'false', 'permissions' => KTAPI_Document::get_permission_string($document), 'workflow' => $workflow, 'workflow_state' => $state, 'mime_type' => $mime_cache[$mimetypeid]['type'], 'mime_icon_path' => $mime_cache[$mimetypeid]['icon'], 'mime_display' => $mime_cache[$mimetypeid]['display'], 'storage_path' => $document->getStoragePath());
if ($wsversion >= 3) {
$document->switchToRealCore();
$array['linked_document_id'] = $document->getLinkedDocumentId();
$document->switchToLinkedCore();
if ($document->isSymbolicLink()) {
$array['item_type'] = "S";
}
}
$array['items'] = array();
if ($wsversion < 3 || strpos($what, 'D') !== false && !$document->isSymbolicLink() || $document->isSymbolicLink() && strpos($what, 'S') !== false) {
$contents[] = $array;
}
} else {
$contents[] = array('id' => (int) $document->getId(), 'item_type' => 'D', 'title' => $document->getName(), 'creator' => is_null($created_by) ? 'n/a' : $created_by->getName(), 'checkedoutby' => is_null($checked_out_by) ? 'n/a' : $checked_out_by->getName(), 'modifiedby' => is_null($modified_by) ? 'n/a' : $modified_by->getName(), 'filename' => $document->getFileName(), 'size' => $document->getFileSize(), 'major_version' => $document->getMajorVersionNumber(), 'minor_version' => $document->getMinorVersionNumber(), 'storage_path' => $document->getStoragePath(), 'mime_type' => $mime_cache[$mimetypeid]['type'], 'mime_icon_path' => $mime_cache[$mimetypeid]['icon'], 'mime_display' => $mime_cache[$mimetypeid]['display'], 'items' => array(), 'workflow' => $workflow, 'workflow_state' => $state);
}
}
}
}
return $contents;
}
function is_active($oUser)
{
if (!Permission::userIsSystemAdministrator($oUser)) {
return false;
}
require_once KT_LIB_DIR . '/triggers/triggerregistry.inc.php';
$noTransforms = false;
$oKTTriggerRegistry = KTTriggerRegistry::getSingleton();
$aTriggers = $oKTTriggerRegistry->getTriggers('content', 'transform');
$aTriggerSet = array();
if (empty($aTriggers)) {
$noTransforms = true;
} else {
foreach ($aTriggers as $aTrigger) {
$sTrigger = $aTrigger[0];
if ($aTrigger[1]) {
require_once $aTrigger[1];
}
$oTrigger = new $sTrigger();
$sDiagnostic = $oTrigger->getDiagnostic();
// empty is OK.
if (is_null($sDiagnostic) || $sDiagnostic == false) {
continue;
}
$aTypes = (array) $oTrigger->mimetypes;
$aTypesStr = array();
foreach ($aTypes as $sTypeName => $v) {
//if ($sTypeName != 'application/octet-stream') { // never use application/octet-stream
$aTypesStr[KTMime::getFriendlyNameForString($sTypeName)] = 1;
//}
}
$aTriggerSet[] = array('types' => $aTypesStr, 'diagnostic' => $sDiagnostic);
}
}
$this->aTriggerSet = $aTriggerSet;
$this->noTransforms = $noTransforms;
return $noTransforms || !empty($aTriggerSet);
// no diags and have some transforms.
}
/**
* GET method helper
*
* @param array parameter passing array
* @param int Document ID
* @return bool true on success
*/
function _GETDocument(&$options, $iDocumentID)
{
global $default;
$oDocument =& Document::get($iDocumentID);
// get a temp file, and read. NOTE: NEVER WRITE TO THIS
$oStorage =& KTStorageManagerUtil::getSingleton();
$fspath = $oStorage->temporaryFile($oDocument);
$this->ktwebdavLog("Filesystem Path is " . $fspath, 'info', true);
// detect resource type
$mimetype = KTMime::getMimeTypeName($oDocument->getMimeTypeID());
$options['mimetype'] = KTMime::getFriendlyNameForString($mimetype);
// detect modification time
// see rfc2518, section 13.7
// some clients seem to treat this as a reverse rule
// requiering a Last-Modified header if the getlastmodified header was set
$options['mtime'] = $oDocument->getVersionCreated();
// detect resource size
$options['size'] = $oDocument->getFileSize();
// no need to check result here, it is handled by the base class
$options['stream'] = fopen($fspath, "r");
$this->ktwebdavLog("Method is " . $this->currentMethod, 'info', true);
if ($this->currentMethod == "get") {
// create the document transaction record
include_once KT_LIB_DIR . '/documentmanagement/DocumentTransaction.inc';
$oDocumentTransaction =& new DocumentTransaction($oDocument, "Document viewed via KTWebDAV", 'ktcore.transactions.view');
$oDocumentTransaction->iUserID = $this->userID;
$oDocumentTransaction->create();
}
return true;
}
function downloadVersion($oDocument, $iVersionId)
{
//get the document
$oContentVersion = KTDocumentContentVersion::get($iVersionId);
$oConfig =& KTConfig::getSingleton();
$sPath = sprintf("%s/%s", $oConfig->get('urls/documentRoot'), $this->getPath($oContentVersion));
$sVersion = sprintf("%d.%d", $oContentVersion->getMajorVersionNumber(), $oContentVersion->getMinorVersionNumber());
$mimeType = KTMime::getMimeTypeName($oContentVersion->getMimeTypeID());
$fileSize = $oContentVersion->getFileSize();
$fileName = $sVersion . '-' . $oContentVersion->getFileName();
return KTUtil::download($sPath, $mimeType, $fileSize, $fileName);
}
