ktapifolder.inc.php.tmp

PHP 知识管理系统（基于树结构的知识管理系统）, 英文原版的PHP源码。

<?php
/**
 * $Id$
 *
 * KnowledgeTree Community Edition
 * Document Management Made Simple
 * Copyright (C) 2008 KnowledgeTree Inc.
 * Portions copyright The Jam Warehouse Software (Pty) Limited
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
 * California 94120-7775, or email [e-mail].
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU General Public License version 3.
 *
 * In accordance with Section 7(b) of the GNU General Public License version 3,
 * these Appropriate Legal Notices must retain the display of the "Powered by
 * KnowledgeTree" logo and retain the original copyright notice. If the display of the
 * logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
 * must display the words "Powered by KnowledgeTree" and retain the original
 * copyright notice.
 * Contributor( s): ______________________________________
 *
 */

require_once(KT_DIR . '/ktwebservice/KTUploadManager.inc.php');

class KTAPI_Folder extends KTAPI_FolderItem
{
	/**
	 * This is a reference to a base Folder object.
	 *
	 * @access private
	 * @var Folder
	 */
	var $folder;

	/**
	 * This is the id of the folder on the database.
	 *
	 * @access private
	 * @var int
	 */
	var $folderid;

	/**
	 * This is used to get a folder based on a folder id.
	 *
	 * @access private
	 * @param KTAPI $ktapi
	 * @param int $folderid
	 * @return KTAPI_Folder
	 */
	function &get(&$ktapi, $folderid)
	{
		assert(!is_null($ktapi));
		assert(is_a($ktapi, 'KTAPI'));
		assert(is_numeric($folderid));

		$folderid += 0;

		$folder = &Folder::get($folderid);
		if (is_null($folder) || PEAR::isError($folder))
		{
			return new KTAPI_Error(KTAPI_ERROR_FOLDER_INVALID,$folder);
		}

		// A special case. We ignore permission checking on the root folder.
		if ($folderid != 1)
		{
		    $user = $ktapi->can_user_access_object_requiring_permission($folder, KTAPI_PERMISSION_READ);

		    if (is_null($user) || PEAR::isError($user))
		    {
		        $user = $ktapi->can_user_access_object_requiring_permission($folder, KTAPI_PERMISSION_VIEW_FOLDER);
		        if (is_null($user) || PEAR::isError($user))
		        {
		            return $user;
		        }
		    }
		}

		return new KTAPI_Folder($ktapi, $folder);
	}

	/**
	 * Checks if the folder is a shortcut
	 *
	 * @return boolean
	 */
	function is_shortcut()
	{
		return $this->folder->isSymbolicLink();
	}

	/**
	 * Retrieves the shortcuts linking to this folder
	 *
	 */
	function get_shortcuts()
	{
		return $this->folder->getSymbolicLinks();
	}

	/**
	 * This is the constructor for the KTAPI_Folder.
	 *
	 * @access private
	 * @param KTAPI $ktapi
	 * @param Folder $folder
	 * @return KTAPI_Folder
	 */
	function KTAPI_Folder(&$ktapi, &$folder)
	{
		$this->ktapi = &$ktapi;
		$this->folder = &$folder;
		$this->folderid = $folder->getId();
	}

	/**
	 * This returns a reference to the internal folder object.
	 *
	 * @access protected
	 * @return Folder
	 */
	function &get_folder()
	{
		return $this->folder;
	}


	/**
	 * This returns detailed information on the document.
	 *
	 * @return array
	 */
	function get_detail()
	{
		$this->clearCache();

		$config = KTConfig::getSingleton();
		$wsversion = $config->get('webservice/version', LATEST_WEBSERVICE_VERSION);

		$detail = array(
			'id'=>(int) $this->folderid,
			'folder_name'=>$this->get_folder_name(),
			'parent_id'=>(int) $this->get_parent_folder_id(),
			'full_path'=>$this->get_full_path(),
			'linked_folder_id'=>$this->folder->getLinkedFolderId(),
		);

		if($wsversion<3){
			unset($detail['linked_folder_id']);
		}

		return $detail;
	}

	function clearCache()
	{
		// TODO: we should only clear the cache for the document we are working on
		// this is a quick fix but not optimal!!

		$GLOBALS["_OBJECTCACHE"]['Folder'] = array();

		$this->folder = &Folder::get($this->folderid);
	}


	function get_parent_folder_id()
	{
		return (int) $this->folder->getParentID();
	}

	function get_folder_name()
	{
		return $this->folder->getFolderName($this->folderid);
	}


	/**
	 * This returns the folderid.
	 *
	 * @return int
	 */
	function get_folderid()
	{
		return (int) $this->folderid;
	}

	function &_get_folder_by_name($ktapi, $foldername, $folderid)
	{
		$foldername=trim($foldername);
		if (empty($foldername))
		{
			return new PEAR_Error('A valid folder name must be specified.');
		}

		$split = explode('/', $foldername);

		foreach($split as $foldername)
		{
			if (empty($foldername))
			{
				continue;
			}
			$foldername = KTUtil::replaceInvalidCharacters($foldername);
			$foldername = sanitizeForSQL($foldername);
			$sql = "SELECT id FROM folders WHERE
					(name='$foldername' and parent_id=$folderid) OR
					(name='$foldername' and parent_id is null and $folderid=1)";
			$row = DBUtil::getOneResult($sql);
			if (is_null($row) || PEAR::isError($row))
			{
				return new KTAPI_Error(KTAPI_ERROR_FOLDER_INVALID,$row);
			}
			$folderid = $row['id'];
		}

		return KTAPI_Folder::get($ktapi, $folderid);
	}


	/**
	 * This can resolve a folder relative to the current directy by name
	 *
	 * @access public
	 * @param string $foldername
	 * @return KTAPI_Folder
	 */
	function &get_folder_by_name($foldername)
	{
		return KTAPI_Folder::_get_folder_by_name($this->ktapi, $foldername, $this->folderid);
	}

	function get_full_path()
	{
		$path = $this->folder->getFullPath();
		if (empty($path)) $path = '/';

		return $path;
	}

	/**
	 * This gets a document by filename or name.
	 *
	 * @access private
	 * @param string $documentname
	 * @param string $function
	 * @return KTAPI_Document
	 */
	function &_get_document_by_name($documentname, $function='getByNameAndFolder')
	{
		$documentname=trim($documentname);
		if (empty($documentname))
		{
			return new PEAR_Error('A valid document name must be specified.');
		}

		$foldername = dirname($documentname);
		$documentname = basename($documentname);
		$documentname = KTUtil::replaceInvalidCharacters($documentname);

		$ktapi_folder = $this;

		if (!empty($foldername) && ($foldername != '.'))
		{
			$ktapi_folder = $this->get_folder_by_name($foldername);
		}

		$currentFolderName = $this->get_folder_name();

		if (PEAR::isError($ktapi_folder) && substr($foldername, 0, strlen($currentFolderName)) == $currentFolderName)
		{
			if ($currentFolderName == $foldername)
			{
				$ktapi_folder = $this;
			}
			else
			{
				$foldername = substr($foldername, strlen($currentFolderName)+1);
				$ktapi_folder = $this->get_folder_by_name($foldername);
			}
		}

		if (is_null($ktapi_folder) || PEAR::isError($ktapi_folder))
		{
			return new KTAPI_Error(KTAPI_ERROR_FOLDER_INVALID, $ktapi_folder);
		}

		//$folder = $ktapi_folder->get_folder();
		$folderid = $ktapi_folder->folderid;

		$document = Document::$function($documentname, $folderid);
		if (is_null($document) || PEAR::isError($document))
		{
			return new KTAPI_Error(KTAPI_ERROR_DOCUMENT_INVALID, $document);
		}

		$user = $this->can_user_access_object_requiring_permission($document, KTAPI_PERMISSION_READ);
		if (PEAR::isError($user))
		{
			return $user;
		}

		return new KTAPI_Document($this->ktapi, $ktapi_folder, $document);
	}

	/**
	 * This can resolve a document relative to the current directy by name.
	 *
	 * @access public
	 * @param string $documentname
	 * @return KTAPI_Document
	 */
	function &get_document_by_name($documentname)
	{
		return $this->_get_document_by_name($documentname,'getByNameAndFolder');
	}

	/**
	 * This can resolve a document relative to the current directy by filename .
	 *
	 * @access public
	 * @param string $documentname
	 * @return KTAPI_Document
	 */
	function &get_document_by_filename($documentname)
	{
		return $this->_get_document_by_name($documentname,'getByFilenameAndFolder');
	}

	function _resolve_user($userid)
	{
		$user=null;

		if (!is_null($userid))
		{
			$user=User::get($userid);
			if (is_null($user) || PEAR::isError($user))
			{
				$user=null;
			}
		}
		return $user;
	}

	function get_permission_string($folder)
	{
		$perms = 'R';
		if (Permission::userHasFolderWritePermission($folder))
		{
			$perms .= 'W';
		}
		return $perms;
	}

	function get_listing($depth=1, $what='DFS')
	{
		if ($depth < 1)
		{
			return array();
		}

		$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))
				{
					if ($depth-1 > 0)
					{
						$sub_folder = &$this->ktapi->get_folder_by_id($folder->getId());
						$items = $sub_folder->get_listing($depth-1, $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',