Peter M. Groen / knowledgetree

Commit 3f8beba386aba16c00a3721f81ecd99ae41f1461

Authored by kevin_fourie 2008-08-02 15:04:59 +0000

Merged in from DEV trunk...

KTS-3415
"Add work spaces plugin to on-premise"
Updated. Corrected license header.

Committed By: Kevin Fourie
Reviewed By: Conrad Vermeulen


git-svn-id: https://kt-dms.svn.sourceforge.net/svnroot/kt-dms/STABLE/trunk@8937 c91229c3-7414-0410-bfa2-8a42b809f60b

Inline Side-by-side

Showing 2 changed files with 738 additions and 720 deletions

plugins/MyDropDocumentsPlugin/MyDropDocumentsDashlet.php

View file @3f8beba

1		-<?php
2		-/*
3		- * The contents of this file are subject to the KnowledgeTree Public
4		- * License Version 1.1.2 ("License"); You may not use this file except in
5		- * compliance with the License. You may obtain a copy of the License at
6		- * http://www.knowledgetree.com/KPL
7		- *
8		- * Software distributed under the License is distributed on an "AS IS"
9		- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
10		- * See the License for the specific language governing rights and
11		- * limitations under the License.
12		- *
13		- * All copies of the Covered Code must include on each user interface screen:
14		- * (i) the "Powered by KnowledgeTree" logo and
15		- * (ii) the KnowledgeTree copyright notice
16		- * in the same form as they appear in the distribution. See the License for
17		- * requirements.
18		- *
19		- * The Original Code is: KnowledgeTree Open Source
20		- *
21		- * The Initial Developer of the Original Code is The Jam Warehouse Software
22		- * (Pty) Ltd, trading as KnowledgeTree.
23		- * Portions created by The Jam Warehouse Software (Pty) Ltd are Copyright
24		- * (C) 2007 The Jam Warehouse Software (Pty) Ltd;
25		- * All Rights Reserved.
26		- * Contributor( s): ______________________________________
27		- *
28		- */
29		-
30		-class MyDropDocumentsDashlet extends KTBaseDashlet {
31		- var $oUser;
32		- //var $sClass = 'ktError';
33		-
34		- function MyDropDocumentsDashlet(){
35		- $this->sTitle = _kt('My Dropped Documents');
36		- }
37		-
38		- function is_active($oUser) {
39		- $this->oUser = $oUser;
40		- return true;
41		- }
42		-
43		-
44		-/*
45		- function is_active($oUser) {
46		- $this->oUser = $oUser;
47		- return Permission::userIsSystemAdministrator($oUser);
48		- }
49		-*/
50		-
51		- function render() {
52		- global $main;
53		- $main->requireJSResource("plugins/MyDropDocumentsPlugin/js/update.js");
54		-
55		- $oPlugin =& $this->oPlugin;
56		-
57		- $oTemplating =& KTTemplating::getSingleton();
58		- $oTemplate = $oTemplating->loadTemplate('MyDropDocumentsPlugin/dashlet');
59		-
60		- $aTemplateData = array(
61		- 'context' => $this,
62		- 'url' => $oPlugin->getPagePath('MyDropDocuments'),
63		-
64		- );
65		-
66		-
67		- return $oTemplate->render($aTemplateData);
68		- }
69		-}
70		-?>
71	1	\ No newline at end of file
	2	+<?php
	3	+/**
	4	+ * $Id: $
	5	+ *
	6	+ * KnowledgeTree Community Edition
	7	+ * Document Management Made Simple
	8	+ * Copyright (C) 2008 KnowledgeTree Inc.
	9	+ * Portions copyright The Jam Warehouse Software (Pty) Limited
	10	+ *
	11	+ * This program is free software; you can redistribute it and/or modify it under
	12	+ * the terms of the GNU General Public License version 3 as published by the
	13	+ * Free Software Foundation.
	14	+ *
	15	+ * This program is distributed in the hope that it will be useful, but WITHOUT
	16	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
	18	+ * details.
	19	+ *
	20	+ * You should have received a copy of the GNU General Public License
	21	+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
	22	+ *
	23	+ * You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
	24	+ * California 94120-7775, or email info@knowledgetree.com.
	25	+ *
	26	+ * The interactive user interfaces in modified source and object code versions
	27	+ * of this program must display Appropriate Legal Notices, as required under
	28	+ * Section 5 of the GNU General Public License version 3.
	29	+ *
	30	+ * In accordance with Section 7(b) of the GNU General Public License version 3,
	31	+ * these Appropriate Legal Notices must retain the display of the "Powered by
	32	+ * KnowledgeTree" logo and retain the original copyright notice. If the display of the
	33	+ * logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
	34	+ * must display the words "Powered by KnowledgeTree" and retain the original
	35	+ * copyright notice.
	36	+ * Contributor( s): ______________________________________
	37	+ *
	38	+ */
	39	+
	40	+class MyDropDocumentsDashlet extends KTBaseDashlet {
	41	+ var $oUser;
	42	+ //var $sClass = 'ktError';
	43	+
	44	+ function MyDropDocumentsDashlet(){
	45	+ $this->sTitle = _kt('My Dropped Documents');
	46	+ }
	47	+
	48	+ function is_active($oUser) {
	49	+ $this->oUser = $oUser;
	50	+ return true;
	51	+ }
	52	+
	53	+
	54	+/*
	55	+ function is_active($oUser) {
	56	+ $this->oUser = $oUser;
	57	+ return Permission::userIsSystemAdministrator($oUser);
	58	+ }
	59	+*/
	60	+
	61	+ function render() {
	62	+ global $main;
	63	+ $main->requireJSResource("plugins/MyDropDocumentsPlugin/js/update.js");
	64	+
	65	+ $oPlugin =& $this->oPlugin;
	66	+
	67	+ $oTemplating =& KTTemplating::getSingleton();
	68	+ $oTemplate = $oTemplating->loadTemplate('MyDropDocumentsPlugin/dashlet');
	69	+
	70	+ $aTemplateData = array(
	71	+ 'context' => $this,
	72	+ 'url' => $oPlugin->getPagePath('MyDropDocuments'),
	73	+
	74	+ );
	75	+
	76	+
	77	+ return $oTemplate->render($aTemplateData);
	78	+ }
	79	+}
	80	+?>
...	...

plugins/MyDropDocumentsPlugin/MyDropDocumentsPage.php

View file @3f8beba

1		-<?php
2		-/*
3		- * The contents of this file are subject to the KnowledgeTree Public
4		- * License Version 1.1.2 ("License"); You may not use this file except in
5		- * compliance with the License. You may obtain a copy of the License at
6		- * http://www.knowledgetree.com/KPL
7		- *
8		- * Software distributed under the License is distributed on an "AS IS"
9		- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
10		- * See the License for the specific language governing rights and
11		- * limitations under the License.
12		- *
13		- * All copies of the Covered Code must include on each user interface screen:
14		- * (i) the "Powered by KnowledgeTree" logo and
15		- * (ii) the KnowledgeTree copyright notice
16		- * in the same form as they appear in the distribution. See the License for
17		- * requirements.
18		- *
19		- * The Original Code is: KnowledgeTree Open Source
20		- *
21		- * The Initial Developer of the Original Code is The Jam Warehouse Software
22		- * (Pty) Ltd, trading as KnowledgeTree.
23		- * Portions created by The Jam Warehouse Software (Pty) Ltd are Copyright
24		- * (C) 2007 The Jam Warehouse Software (Pty) Ltd;
25		- * All Rights Reserved.
26		- * Contributor( s): ______________________________________
27		- *
28		- */
29		-
30		-require_once(KT_DIR . "/ktapi/ktapi.inc.php");
31		-require_once(KT_LIB_DIR . "/plugins/plugin.inc.php");
32		-require_once(KT_LIB_DIR . "/plugins/pluginregistry.inc.php");
33		-require_once(KT_LIB_DIR . "/dashboard/dashlet.inc.php");
34		-require_once(KT_DIR . "/plugins/ktcore/KTFolderActions.php");
35		-require_once(KT_DIR . "/plugins/network/extendedtransactioninfo/simpletransactionutil.inc.php");
36		-require_once(KT_DIR . "/ktapi/KTAPIFolder.inc.php");
37		-require_once(KT_LIB_DIR . "/roles/Role.inc");
38		-require_once(KT_LIB_DIR . "/roles/roleallocation.inc.php");
39		-require_once(KT_LIB_DIR . "/permissions/permissionutil.inc.php");
40		-require_once(KT_LIB_DIR . '/mime.inc.php');
41		-/* This page is run via an AJAX call from the update.js for this plugin.
42		- * It checks to see if both the dropdocuments folder and the users personal folder exist.
43		- * If they don't, it creates them and assigns permission and roles accordingly.
44		- * If the dropdocuments folder does exist it checks if the WorkSpaceOwner role exists.
45		- * If the role exists it assigns the current user to the role on the dropdocuments folder.
46		- * Therefore any users running the plugin after the dropdocuments folder has been created will have access to it too.
47		- * The underlying logic is that everyone is assigned to the WorkSpaceOwner Role, they have all permission except
48		- * Delete, Rename Folder, Manage security and Manage workflow on the dropdocuments folder.
49		- * This role is then assigned to their personal folder too (which is named according to their username) and is overidden
50		- * to give only the current user full rights to their folder.
51		- * Essentially everyone can look at the dropdocuments folder but will only see their own folder within it.
52		- */
53		-
54		-class MyDropDocumentsPage extends KTStandardDispatcher {
55		-
56		- function do_main() {
57		-
58		- $iRootID = (int)1;
59		- $oUser = $this->oUser;
60		- $sUserName = (string)$this->oUser->getUserName();
61		- $this->ktapi = new KTAPI();
62		- $this->session = $this->ktapi->start_system_session();
63		-
64		- if(!Folder::FolderExistsName('DroppedDocuments', $iRootID))
65		- {
66		-
67		- $root=$this->ktapi->get_root_folder();
68		-
69		- //Create dropdocuments folder
70		- $userFolder = $root->add_folder('DroppedDocuments');
71		-
72		- //In order to stop permission inheritance a copy of the parent permission object is created.
73		- //This copy is then used to set separate permissions for this folder.
74		- KTPermissionUtil::copyPermissionObject($userFolder->get_folder());
75		-
76		- //If WorkSpaceOwner role doesn't exist, create it
77		- if(!$this->roleExistsName('WorkSpaceOwner'))
78		- {
79		- $oWorkSpaceOwnerRole = $this->createRole('WorkSpaceOwner');
80		- if ($oWorkSpaceOwnerRole == null)
81		- {
82		- $this->session->logout();
83		- return _kt('Error: Failed to create WorkSpaceOwner Role');
84		- }
85		- }
86		-
87		- //$root=$this->ktapi->get_root_folder();
88		- //$personalFolder = $root->get_folder_by_name('/dropdocuments/'.$sUserName);
89		-
90		- //Get the folder object
91		- $userFolderObject = $userFolder->get_folder();
92		-
93		- //Get the permission object from the dropdocuments folder object
94		- $oUserPO = KTPermissionObject::get($userFolderObject->getPermissionObjectId());
95		-
96		- //Check to see if there are duplicate WorkSpaceOwner roles.
97		- if (count($this->getRoleIdByName('WorkSpaceOwner')) > 1)
98		- {
99		- $this->session->logout();
100		- return _kt('Error: cannot set user role permissions: more than one role named \'WorkSpaceOwner\' exists');
101		-
102		- }
103		-
104		- //call the function to set the permission on the dropdocuments folder
105		- $this->setUserDocsPermissions($oUserPO);
106		-
107		- //Assign the current user to the WorkSpaceOwner role
108		- $this->setUserDocsRoleAllocation($userFolderObject);
109		-
110		- }
111		- else
112		- {
113		-
114		- $root = $this->ktapi->get_root_folder();
115		- $userFolder = $root->get_folder_by_name('/DroppedDocuments');
116		-
117		- //Get the dropdocuments folder object
118		- $userFolderObject = $userFolder->get_folder();
119		-
120		- if(!$this->roleExistsName('WorkSpaceOwner'))
121		- {
122		-
123		- $oWorkSpaceOwnerRole = $this->createRole('WorkSpaceOwner');
124		- if ($oWorkSpaceOwnerRole == null)
125		- {
126		- $this->session->logout();
127		- return _kt('Error: Failed to create WorkSpaceOwner Role');
128		- }
129		-
130		- //set permissions
131		- $oUserPO = KTPermissionObject::get($userFolderObject->getPermissionObjectId());
132		- $this->setUserDocsPermissions($oUserPO);
133		- //assign current user to role
134		- $this->setUserDocsRoleAllocation($userFolderObject);
135		- }
136		- else
137		- {
138		-
139		- //update WrokSpaceOwner role to include current user
140		- $this->updateUserDocsRoleAllocation($userFolderObject);
141		- }
142		-
143		- }
144		-
145		- $iUserDocsFolderID = $this->getFolderID('DroppedDocuments');
146		- $oUserDocsFolder = Folder::get($iUserDocsFolderID);
147		-
148		- if(!Folder::FolderExistsName($sUserName, $iUserDocsFolderID))
149		- {
150		-
151		-
152		- $root=$this->ktapi->get_root_folder();
153		- $userDocsFolder = $root->get_folder_by_name('/DroppedDocuments');
154		-
155		- //create the personal folder. (Use the username to create it)
156		- $personalFolder = $userDocsFolder->add_folder($sUserName);
157		-
158		- //Copy the permission object to stop permission inheritance
159		- KTPermissionUtil::copyPermissionObject($personalFolder->get_folder());
160		-
161		- //The role should exist by now.
162		- //In both the if and else statements for the dropdocuments above the role is created
163		- //If its doesn't exist by now there is an error
164		- if(!$this->roleExistsName('WorkSpaceOwner'))
165		- {
166		-
167		- $this->session->logout();
168		- return _kt('Error: WorkSpaceOwner Role not setup, cannot assign to Personal Folder');
169		-
170		- }
171		-
172		- $personalFolderRole = $root->get_folder_by_name('/DroppedDocuments/'.$sUserName);
173		- $PersonalFolderObject = ($personalFolderRole->get_folder());
174		-
175		- //Get permission object
176		- $oPO = KTPermissionObject::get($PersonalFolderObject->getPermissionObjectId());
177		-
178		- //Check for duplicate WorkSpaceOwner roles
179		- if (count($this->getRoleIdByName('WorkSpaceOwner')) > 1)
180		- {
181		- $this->session->logout();
182		- return _kt('Error: cannot set personal folder role permissions: more than one role named \'WorkSpaceOwner\' exists');
183		-
184		- }
185		-
186		- $this->setPersonalFolderPermissions($oPO);
187		-
188		- $this->updatePersonalFolderRoleAllocation($PersonalFolderObject);
189		-
190		-
191		- //folder just created so no top list of last modified documents
192		-
193		- $iMyDocsFolderID = $this->getFolderID($sUserName);
194		- $this->session->logout();
195		- return _kt('<span class="descriptiveText"> You do not have any dropped documents </span><br><br><br>');
196		-
197		-
198		- }
199		-
200		- else //if personal folder does exist
201		- {
202		- //Getting personal folder id
203		- $iMyDocsFolderID = $this->getFolderID($sUserName);
204		-
205		-
206		- if(!$this->roleExistsName('WorkSpaceOwner'))
207		- {
208		- $this->session->logout();
209		- return _kt('Error: WorkSpaceOwner Role does not exist');
210		- }
211		- else
212		- {
213		-
214		- $oTempPersonalFolder = $root->get_folder_by_name('/DroppedDocuments/'.$sUserName);
215		- $oPersonalFolder = $oTempPersonalFolder->get_folder();
216		- //update WorkSpaceOwner role to include current user
217		-
218		- //Get permission object
219		- $oPO = KTPermissionObject::get($oPersonalFolder->getPermissionObjectId());
220		-
221		- $this->setPersonalFolderPermissions($oPO);
222		-
223		- $this->updatePersonalFolderRoleAllocation($oPersonalFolder);
224		-
225		- }
226		-
227		-
228		-
229		- $aExternalWhereClauses[] = '(DT.transaction_namespace IN (?,?,?) AND (D.parent_folder_ids LIKE "%,'.$iMyDocsFolderID.',%" OR D.parent_folder_ids LIKE "%,'.$iMyDocsFolderID.'"))';
230		- $aExternalWhereParams[] = 'ktcore.transactions.create';
231		- $aExternalWhereParams[] = 'ktcore.transactions.check_in';
232		- $aExternalWhereParams[] = 'ktcore.transactions.event';
233		-
234		-
235		- $aDocumentTransactions = KTSimpleTransactionUtil::getTransactionsMatchingQuery($oUser, '', $aExternalWhereClauses, $aExternalWhereParams);
236		- if (empty($aDocumentTransactions))
237		- {
238		- $this->session->logout();
239		- return _kt('<span class="descriptiveText"> You do not have any dropped documents </span><br><br><br>');
240		- }
241		-
242		- $maxcount = 5;
243		- $aDocumentTransactions = array_slice($aDocumentTransactions, 0, $maxcount);
244		-
245		- $sReturnTable = '<span class="descriptiveText">'._kt('Recently Dropped Documents').'</span>
246		- <table width="100%" class="kt_collection drop_box" cellspacing="0">
247		-
248		- <thead>
249		- <tr>
250		- <th width="100%">'._kt('Document').'</th>
251		- <th width="1%">'._kt('Date Dropped').'</th>
252		- </tr>
253		- </thead>
254		- <tbody>';
255		-
256		- $sOddorEven = '';
257		- $count = 1;
258		- foreach ($aDocumentTransactions as $aRow)
259		- {
260		- $oDocument = Document::get($aRow[document_id]);
261		- $aParentFolders = explode('/',$oDocument->getFullPath());
262		- $sPath = '';
263		-
264		- for($i = 0; $i < count($aParentFolders); $i++)
265		- {
266		- if ($i > 2)
267		- {
268		- $sPath .= '/'.$aParentFolders[$i];
269		- }
270		- }
271		-
272		- $sContentType = KTMime::getIconPath($oDocument->getMimeTypeID());
273		- $aAnchorData = $this->getDocInfo($aRow[document_id]);
274		- $sLink = $aAnchorData[0];
275		- $sDocName = $aAnchorData[1];
276		- $sShortDocName = $sDocName;
277		- if(strlen($sPath) > 0)
278		- {
279		- $sDocName = $sPath.'/'.$sDocName;
280		- }
281		-
282		- $sFullDocName = $sDocName;
283		- $iDocLength = strlen($sDocName);
284		- if ( $iDocLength > 30 )
285		- {
286		- $sDocName = substr($sDocName, ($iDocLength - 30), $iDocLength);
287		- $sDocName = '...'.$sDocName;
288		- }
289		-
290		- if($count%2 == 0)
291		- {
292		- $sOddorEven = 'even';
293		- }
294		- else
295		- {
296		- $sOddorEven = 'odd';
297		- }
298		-
299		- $sReturnTable .= '<tr class="'.$sOddorEven.'">'.
300		- '<td width="100%"><span class="contenttype '.$sContentType.'"><a title="'.$sShortDocName.'" href='.$sLink.'>'.$sDocName.'</a></span></td>'.
301		- '<td width="1%">'.$aRow[datetime].'</td>'.
302		- '</tr>';
303		- $count ++;
304		- }
305		-
306		- $location = 'browse.php?fFolderId='.$iMyDocsFolderID;
307		- $sReturnTable .= '</tbody>'.
308		- '</table>'.
309		- '<br>'.
310		- '<a href="'.$location.'">'._kt(' View All').' </a><br><br>';
311		- $this->session->logout();
312		-
313		- return $sReturnTable;
314		-
315		- }
316		- }
317		-
318		- function handleOutput($sOutput) {
319		- print $sOutput;
320		- }
321		-
322		- //This function is used to set the permission on the dropdocuments folder
323		- function setUserDocsPermissions($oUserPO)
324		- {
325		- //arrays returned from get Role ID's
326		- $aWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
327		- $aAdminGroupID = $this->getGroupIdByName('System Administrators');
328		-
329		- //arrays used to make integers for $aAllowed array variable
330		- $iWorkSpaceOwnerRoleID = $aWorkSpaceOwnerRoleID[0]['id'];
331		- $iAdminGroupID = $aAdminGroupID[0]['id'];
332		- //$aBothAllowed is used to give permissions to the admin group and the WorkSpaceOwner role
333		- $aBothAllowed = array('group' => array($iAdminGroupID), 'role' => array($iWorkSpaceOwnerRoleID));
334		-
335		- //$aAdminAllowed is used to give permissions to the admin group only
336		- $aAdminAllowed = array('group' => array($iAdminGroupID));
337		-
338		- //Get the list of permissions
339		- $aPermissions = KTPermission::getList();
340		-
341		- foreach ($aPermissions as $oPermission)
342		- {
343		- //If the permission is not one of the below then both are allowed the permission
344		- //Otherwise only the admin group is allowed the permission
345		- if($oPermission->getHumanName() != 'Delete' && $oPermission->getHumanName() != 'Rename Folder'
346		- && $oPermission->getHumanName() != 'Manage security' && $oPermission->getHumanName() != 'Manage workflow')
347		- {
348		- KTPermissionUtil::setPermissionForId($oPermission, $oUserPO, $aBothAllowed);
349		- }
350		- else
351		- {
352		- KTPermissionUtil::setPermissionForId($oPermission, $oUserPO, $aAdminAllowed);
353		- }
354		- }
355		-
356		- //UPdate the permission lookup
357		- KTPermissionUtil::updatePermissionLookupForPO($oUserPO);
358		- }
359		-
360		- //This function is used for allocating the user to the WorkSpaceOwner role only when the dropdocuments folder
361		- //has just been created.
362		- function setUserDocsRoleAllocation($oUserFolderObject)
363		- {
364		- $userFolderID = $oUserFolderObject->getId();
365		-
366		- $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
367		- $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
368		-
369		- //create a new role allocation
370		- $oDropdocumentsRoleAllocation = new RoleAllocation();
371		- if ($oDropdocumentsRoleAllocation == null)
372		- {
373		- $this->session->logout();
374		- return _kt('Error: cannot create WorkSpaceOwner role allocation');
375		- }
376		-
377		- //set the folder and role for the allocation
378		- $oDropdocumentsRoleAllocation->setFolderId($userFolderID);
379		- $oDropdocumentsRoleAllocation->setRoleId($WorkSpaceOwnerRoleID);
380		-
381		- $aWorkSpaceOwnerRoleAllowed = array();
382		- $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAllowed);
383		- //It might be a problem that i'm not doing a "start transaction" here.
384		- //Unable to roll back in event of db failure
385		- $res = $oDropdocumentsRoleAllocation->create();
386		-
387		- //The role is created and then updated by adding the current user to the allowed list
388		-
389		- $oPD = $oDropdocumentsRoleAllocation->getPermissionDescriptor();
390		- $aWorkSpaceOwnerRoleAssignAllowed = $oPD->getAllowed();
391		- $aUserId[] = $this->oUser->getId();
392		- $aWorkSpaceOwnerRoleAssignAllowed['user'] = $aUserId;
393		- $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAssignAllowed);
394		- $res = $oDropdocumentsRoleAllocation->update();
395		-
396		- //Update all info linked to the role
397		- $this->renegeratePermissionsForRole($oDropdocumentsRoleAllocation->getRoleId(), $userFolderID);
398		- }
399		-
400		- //This function is used to allocate the current user to the WorkSpaceOwner role after the Dropdocuments folder
401		- //has already been created.
402		- function updateUserDocsRoleAllocation($oUserFolder)
403		- {
404		- $userFolderID = $oUserFolder->getId();
405		- $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');//$oUserRole->getId();
406		- $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
407		-
408		- //Get the role allocation object for the Dropdocuments folder and the WorkSpaceOwner role
409		- $oDropdocumentsRoleAllocation = $oRoleAllocation = RoleAllocation::getAllocationsForFolderAndRole($userFolderID, $WorkSpaceOwnerRoleID);
410		-
411		- //check that the object is not null
412		- if ($oDropdocumentsRoleAllocation == null)
413		- {
414		- $this->session->logout();
415		- return _kt('Error: cannot find WorkSpaceOwner role allocation');
416		- }
417		-
418		- $oPD = $oDropdocumentsRoleAllocation->getPermissionDescriptor();
419		- $aWorkSpaceOwnerRoleAssignAllowed = $oPD->getAllowed();
420		-
421		- //If the user ID is not in the allowed list already then add it to the list.
422		- if(!in_array($this->oUser->getId(), $aWorkSpaceOwnerRoleAssignAllowed['user']))
423		- {
424		- $aNewAllowed = array();
425		- $aNewAllowed = $aWorkSpaceOwnerRoleAssignAllowed['user'];
426		- $aNewAllowed[] = $this->oUser->getId();
427		- $aWorkSpaceOwnerRoleAssignAllowed['user'] = $aNewAllowed;
428		- $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAssignAllowed);
429		- $res = $oDropdocumentsRoleAllocation->update();
430		- $this->renegeratePermissionsForRole($oDropdocumentsRoleAllocation->getRoleId(), $userFolderID);
431		- }
432		- }
433		-
434		- function setPersonalFolderPermissions($oPO)
435		- {
436		- $aWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
437		- $aAdminGroupID = $this->getGroupIdByName('System Administrators');
438		-
439		- //arrays used to make integers for $aAllowed array variable
440		- $iWorkSpaceOwnerRoleID = $aWorkSpaceOwnerRoleID[0]['id'];
441		- $iAdminGroupID = $aAdminGroupID[0]['id'];
442		-
443		- //set permissions for the role and the admin group
444		- $aAllowed = array('role' => array($iWorkSpaceOwnerRoleID), 'group' => array($iAdminGroupID));
445		-
446		- //Get the List of all the permissions
447		- $aPersonalFolderPermissions = KTPermission::getList();
448		-
449		- //Iterate through and apply all permissions to the current user and the admin group
450		- foreach ($aPersonalFolderPermissions as $oPersonalFolderPermission)
451		- {
452		- KTPermissionUtil::setPermissionForId($oPersonalFolderPermission, $oPO, $aAllowed);
453		-
454		- }
455		-
456		- //Update permission lookup
457		- KTPermissionUtil::updatePermissionLookupForPO($oPO);
458		- }
459		-
460		- function updatePersonalFolderRoleAllocation($oPersonalFolder)
461		- {
462		- //Assign user to the WorkSpaceOwner role
463		- $personalFolderID = $oPersonalFolder->getId();
464		- $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
465		- $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
466		-
467		- $oRoleAllocation = new RoleAllocation();
468		- if ($oRoleAllocation == null)
469		- {
470		- $this->session->logout();
471		- return _kt('Error: Cannot create WorkSpaceOwner role allocation on personal folder');
472		- }
473		- $oRoleAllocation->setFolderId($personalFolderID);
474		- $oRoleAllocation->setRoleId($WorkSpaceOwnerRoleID);
475		-
476		- $aRoleAllowed = array();
477		- $oRoleAllocation->setAllowed($aRoleAllowed);
478		-
479		- //It might be a problem that i'm not doing a "start transaction" here.
480		- //Unable to roll back in event of db failure
481		- $res = $oRoleAllocation->create();
482		-
483		- //The role is first created and then the current user is allocated to the role below
484		-
485		- $oPD = $oRoleAllocation->getPermissionDescriptor();
486		- $aRoleAssignAllowed = $oPD->getAllowed();
487		- $aUserId[] = $this->oUser->getId();
488		- $aRoleAssignAllowed['user'] = $aUserId;
489		- $oRoleAllocation->setAllowed($aRoleAssignAllowed);
490		- $res = $oRoleAllocation->update();
491		- $this->renegeratePermissionsForRole($oRoleAllocation->getRoleId(), $personalFolderID);
492		- }
493		-
494		- //FIXME: Direct Database access
495		- function getFolderID($sFolderName) {
496		- $sQuery = 'SELECT id FROM folders WHERE name = \''.$sFolderName.'\'';
497		-
498		- $id = DBUtil::getResultArray($sQuery);
499		- return $id[0]['id'];
500		- }
501		-
502		- //this function returns the document link and document name to be displayed on the dashlet
503		- function getDocInfo($iDocId) {
504		- $oDocument = Document::get($iDocId);
505		-
506		- if (PEAR::isError($oDocument)) {
507		- return _kt('Document no longer exists.');
508		- }
509		-
510		- $sName = htmlentities($oDocument->getName(), ENT_NOQUOTES, 'UTF-8');
511		- $sLink = KTBrowseUtil::getUrlForDocument($oDocument);
512		-
513		- $aAnchorData = array();
514		- $aAnchorData[] = $sLink;
515		- $aAnchorData[] = $sName;
516		- return $aAnchorData;
517		- }
518		-
519		- //This function is used to create the role, role allocation is done separately
520		- function createRole ($sName)
521		- {
522		- $this->startTransaction();
523		- $oRole = Role::createFromArray(array('name' => $sName));
524		-
525		- if (PEAR::isError($oRole) \|\| ($oRole == false))
526		- {
527		- if ($this->bTransactionStarted)
528		- {
529		- $this->rollbackTransaction();
530		- }
531		- //return null on failure
532		- return null;
533		- }
534		- else
535		- {
536		- return $oRole;
537		-
538		- }
539		- }
540		-
541		- //FIXME: Direct Database access
542		- function roleExistsName ($sName)
543		- {
544		- $sQuery = "SELECT id FROM roles WHERE name = ?";
545		- $aParams = array($sName);
546		- $res = DBUtil::getResultArray(array($sQuery, $aParams));
547		-
548		- if (count($res) != 0)
549		- {
550		- return true;
551		- }
552		- return false;
553		- }
554		-
555		- //FIXME: Direct Database access
556		- function groupExistsName ($sName)
557		- {
558		- $sQuery = "SELECT id FROM groups_lookup WHERE name = ?";
559		- $aParams = array($sName);
560		- $res = DBUtil::getResultArray(array($sQuery, $aParams));
561		-
562		- if (count($res) != 0)
563		- {
564		- return true;
565		- }
566		- return false;
567		- }
568		-
569		- //FIXME: Direct Database access
570		- function getRoleIdByName($sName)
571		- {
572		- $sQuery = "SELECT id FROM roles WHERE name = ?";
573		- $aParams = array($sName);
574		- $res = DBUtil::getResultArray(array($sQuery, $aParams));
575		- return $res;
576		- }
577		-
578		- //FIXME: Direct Database access
579		- function getGroupIdByName ($sName)
580		- {
581		- $sQuery = "SELECT id FROM groups_lookup WHERE name = ?";
582		- $aParams = array($sName);
583		- $res = DBUtil::getResultArray(array($sQuery, $aParams));
584		- return $res;
585		- }
586		-
587		- //function taken from KTPermission.php and edited to work here
588		- function renegeratePermissionsForRole($iRoleId, $iFolderId) {
589		- $iStartFolderId = $iFolderId;
590		- /*
591		- * 1. find all folders & documents "below" this one which use the role
592		- * definition _active_ (not necessarily present) at this point.
593		- * 2. tell permissionutil to regen their permissions.
594		- *
595		- * The find algorithm is:
596		- *
597		- * folder_queue <- (iStartFolderId)
598		- * while folder_queue is not empty:
599		- * active_folder =
600		- * for each folder in the active_folder:
601		- * find folders in _this_ folder without a role-allocation on the iRoleId
602		- * add them to the folder_queue
603		- * update the folder's permissions.
604		- * find documents in this folder:
605		- * update their permissions.
606		- */
607		-
608		- $sRoleAllocTable = KTUtil::getTableName('role_allocations');
609		- $sFolderTable = KTUtil::getTableName('folders');
610		- $sQuery = sprintf('SELECT f.id as id FROM %s AS f LEFT JOIN %s AS ra ON (f.id = ra.folder_id) WHERE ra.id IS NULL AND f.parent_id = ?', $sFolderTable, $sRoleAllocTable);
611		-
612		-
613		- $folder_queue = array($iStartFolderId);
614		- while (!empty($folder_queue)) {
615		- $active_folder = array_pop($folder_queue);
616		-
617		- $aParams = array($active_folder);
618		-
619		- $aNewFolders = DBUtil::getResultArrayKey(array($sQuery, $aParams), 'id');
620		- if (PEAR::isError($aNewFolders)) {
621		- //$this->errorRedirectToMain(_kt('Failure to generate folderlisting.'));
622		- echo _kt('Failure to generate folderlisting.');
623		- }
624		- $folder_queue = kt_array_merge ($folder_queue, (array) $aNewFolders); // push.
625		-
626		-
627		- // update the folder.
628		- $oFolder =& Folder::get($active_folder);
629		- if (PEAR::isError($oFolder) \|\| ($oFolder == false)) {
630		- //$this->errorRedirectToMain(_kt('Unable to locate folder: ') . $active_folder);
631		- echo _kt('Unable to locate folder: ').$active_folder;
632		- }
633		-
634		- KTPermissionUtil::updatePermissionLookup($oFolder);
635		- $aDocList =& Document::getList(array('folder_id = ?', $active_folder));
636		- if (PEAR::isError($aDocList) \|\| ($aDocList === false)) {
637		- //$this->errorRedirectToMain(sprintf(_kt('Unable to get documents in folder %s: %s'), $active_folder, $aDocList->getMessage()));
638		- echo _kt('Unable to get documents in folder ').$active_folder;
639		- }
640		-
641		- foreach ($aDocList as $oDoc) {
642		- if (!PEAR::isError($oDoc)) {
643		- KTPermissionUtil::updatePermissionLookup($oDoc);
644		- }
645		- }
646		- }
647		- }
648		-
649		-}
650		-?>
651	1	\ No newline at end of file
	2	+<?php
	3	+/**
	4	+ * $Id: $
	5	+ *
	6	+ * KnowledgeTree Community Edition
	7	+ * Document Management Made Simple
	8	+ * Copyright (C) 2008 KnowledgeTree Inc.
	9	+ * Portions copyright The Jam Warehouse Software (Pty) Limited
	10	+ *
	11	+ * This program is free software; you can redistribute it and/or modify it under
	12	+ * the terms of the GNU General Public License version 3 as published by the
	13	+ * Free Software Foundation.
	14	+ *
	15	+ * This program is distributed in the hope that it will be useful, but WITHOUT
	16	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
	18	+ * details.
	19	+ *
	20	+ * You should have received a copy of the GNU General Public License
	21	+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
	22	+ *
	23	+ * You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
	24	+ * California 94120-7775, or email info@knowledgetree.com.
	25	+ *
	26	+ * The interactive user interfaces in modified source and object code versions
	27	+ * of this program must display Appropriate Legal Notices, as required under
	28	+ * Section 5 of the GNU General Public License version 3.
	29	+ *
	30	+ * In accordance with Section 7(b) of the GNU General Public License version 3,
	31	+ * these Appropriate Legal Notices must retain the display of the "Powered by
	32	+ * KnowledgeTree" logo and retain the original copyright notice. If the display of the
	33	+ * logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
	34	+ * must display the words "Powered by KnowledgeTree" and retain the original
	35	+ * copyright notice.
	36	+ * Contributor( s): ______________________________________
	37	+ *
	38	+ */
	39	+
	40	+require_once(KT_DIR . "/ktapi/ktapi.inc.php");
	41	+require_once(KT_LIB_DIR . "/plugins/plugin.inc.php");
	42	+require_once(KT_LIB_DIR . "/plugins/pluginregistry.inc.php");
	43	+require_once(KT_LIB_DIR . "/dashboard/dashlet.inc.php");
	44	+require_once(KT_DIR . "/plugins/ktcore/KTFolderActions.php");
	45	+require_once(KT_DIR . "/plugins/network/extendedtransactioninfo/simpletransactionutil.inc.php");
	46	+require_once(KT_DIR . "/ktapi/KTAPIFolder.inc.php");
	47	+require_once(KT_LIB_DIR . "/roles/Role.inc");
	48	+require_once(KT_LIB_DIR . "/roles/roleallocation.inc.php");
	49	+require_once(KT_LIB_DIR . "/permissions/permissionutil.inc.php");
	50	+require_once(KT_LIB_DIR . '/mime.inc.php');
	51	+/* This page is run via an AJAX call from the update.js for this plugin.
	52	+ * It checks to see if both the dropdocuments folder and the users personal folder exist.
	53	+ * If they don't, it creates them and assigns permission and roles accordingly.
	54	+ * If the dropdocuments folder does exist it checks if the WorkSpaceOwner role exists.
	55	+ * If the role exists it assigns the current user to the role on the dropdocuments folder.
	56	+ * Therefore any users running the plugin after the dropdocuments folder has been created will have access to it too.
	57	+ * The underlying logic is that everyone is assigned to the WorkSpaceOwner Role, they have all permission except
	58	+ * Delete, Rename Folder, Manage security and Manage workflow on the dropdocuments folder.
	59	+ * This role is then assigned to their personal folder too (which is named according to their username) and is overidden
	60	+ * to give only the current user full rights to their folder.
	61	+ * Essentially everyone can look at the dropdocuments folder but will only see their own folder within it.
	62	+ */
	63	+
	64	+class MyDropDocumentsPage extends KTStandardDispatcher {
	65	+
	66	+ function do_main() {
	67	+
	68	+ $iRootID = (int)1;
	69	+ $oUser = $this->oUser;
	70	+ $sUserName = (string)$this->oUser->getUserName();
	71	+ $this->ktapi = new KTAPI();
	72	+ $this->session = $this->ktapi->start_system_session();
	73	+
	74	+ if(!Folder::FolderExistsName('DroppedDocuments', $iRootID))
	75	+ {
	76	+
	77	+ $root=$this->ktapi->get_root_folder();
	78	+
	79	+ //Create dropdocuments folder
	80	+ $userFolder = $root->add_folder('DroppedDocuments');
	81	+
	82	+ //In order to stop permission inheritance a copy of the parent permission object is created.
	83	+ //This copy is then used to set separate permissions for this folder.
	84	+ KTPermissionUtil::copyPermissionObject($userFolder->get_folder());
	85	+
	86	+ //If WorkSpaceOwner role doesn't exist, create it
	87	+ if(!$this->roleExistsName('WorkSpaceOwner'))
	88	+ {
	89	+ $oWorkSpaceOwnerRole = $this->createRole('WorkSpaceOwner');
	90	+ if ($oWorkSpaceOwnerRole == null)
	91	+ {
	92	+ $this->session->logout();
	93	+ return _kt('Error: Failed to create WorkSpaceOwner Role');
	94	+ }
	95	+ }
	96	+
	97	+ //$root=$this->ktapi->get_root_folder();
	98	+ //$personalFolder = $root->get_folder_by_name('/dropdocuments/'.$sUserName);
	99	+
	100	+ //Get the folder object
	101	+ $userFolderObject = $userFolder->get_folder();
	102	+
	103	+ //Get the permission object from the dropdocuments folder object
	104	+ $oUserPO = KTPermissionObject::get($userFolderObject->getPermissionObjectId());
	105	+
	106	+ //Check to see if there are duplicate WorkSpaceOwner roles.
	107	+ if (count($this->getRoleIdByName('WorkSpaceOwner')) > 1)
	108	+ {
	109	+ $this->session->logout();
	110	+ return _kt('Error: cannot set user role permissions: more than one role named \'WorkSpaceOwner\' exists');
	111	+
	112	+ }
	113	+
	114	+ //call the function to set the permission on the dropdocuments folder
	115	+ $this->setUserDocsPermissions($oUserPO);
	116	+
	117	+ //Assign the current user to the WorkSpaceOwner role
	118	+ $this->setUserDocsRoleAllocation($userFolderObject);
	119	+
	120	+ }
	121	+ else
	122	+ {
	123	+
	124	+ $root = $this->ktapi->get_root_folder();
	125	+ $userFolder = $root->get_folder_by_name('/DroppedDocuments');
	126	+
	127	+ //Get the dropdocuments folder object
	128	+ $userFolderObject = $userFolder->get_folder();
	129	+
	130	+ if(!$this->roleExistsName('WorkSpaceOwner'))
	131	+ {
	132	+
	133	+ $oWorkSpaceOwnerRole = $this->createRole('WorkSpaceOwner');
	134	+ if ($oWorkSpaceOwnerRole == null)
	135	+ {
	136	+ $this->session->logout();
	137	+ return _kt('Error: Failed to create WorkSpaceOwner Role');
	138	+ }
	139	+
	140	+ //set permissions
	141	+ $oUserPO = KTPermissionObject::get($userFolderObject->getPermissionObjectId());
	142	+ $this->setUserDocsPermissions($oUserPO);
	143	+ //assign current user to role
	144	+ $this->setUserDocsRoleAllocation($userFolderObject);
	145	+ }
	146	+ else
	147	+ {
	148	+
	149	+ //update WrokSpaceOwner role to include current user
	150	+ $this->updateUserDocsRoleAllocation($userFolderObject);
	151	+ }
	152	+
	153	+ }
	154	+
	155	+ $iUserDocsFolderID = $this->getFolderID('DroppedDocuments');
	156	+ $oUserDocsFolder = Folder::get($iUserDocsFolderID);
	157	+
	158	+ if(!Folder::FolderExistsName($sUserName, $iUserDocsFolderID))
	159	+ {
	160	+
	161	+
	162	+ $root=$this->ktapi->get_root_folder();
	163	+ $userDocsFolder = $root->get_folder_by_name('/DroppedDocuments');
	164	+
	165	+ //create the personal folder. (Use the username to create it)
	166	+ $personalFolder = $userDocsFolder->add_folder($sUserName);
	167	+
	168	+ //Copy the permission object to stop permission inheritance
	169	+ KTPermissionUtil::copyPermissionObject($personalFolder->get_folder());
	170	+
	171	+ //The role should exist by now.
	172	+ //In both the if and else statements for the dropdocuments above the role is created
	173	+ //If its doesn't exist by now there is an error
	174	+ if(!$this->roleExistsName('WorkSpaceOwner'))
	175	+ {
	176	+
	177	+ $this->session->logout();
	178	+ return _kt('Error: WorkSpaceOwner Role not setup, cannot assign to Personal Folder');
	179	+
	180	+ }
	181	+
	182	+ $personalFolderRole = $root->get_folder_by_name('/DroppedDocuments/'.$sUserName);
	183	+ $PersonalFolderObject = ($personalFolderRole->get_folder());
	184	+
	185	+ //Get permission object
	186	+ $oPO = KTPermissionObject::get($PersonalFolderObject->getPermissionObjectId());
	187	+
	188	+ //Check for duplicate WorkSpaceOwner roles
	189	+ if (count($this->getRoleIdByName('WorkSpaceOwner')) > 1)
	190	+ {
	191	+ $this->session->logout();
	192	+ return _kt('Error: cannot set personal folder role permissions: more than one role named \'WorkSpaceOwner\' exists');
	193	+
	194	+ }
	195	+
	196	+ $this->setPersonalFolderPermissions($oPO);
	197	+
	198	+ $this->updatePersonalFolderRoleAllocation($PersonalFolderObject);
	199	+
	200	+
	201	+ //folder just created so no top list of last modified documents
	202	+
	203	+ $iMyDocsFolderID = $this->getFolderID($sUserName);
	204	+ $this->session->logout();
	205	+ return _kt('<span class="descriptiveText"> You do not have any dropped documents </span><br><br><br>');
	206	+
	207	+
	208	+ }
	209	+
	210	+ else //if personal folder does exist
	211	+ {
	212	+ //Getting personal folder id
	213	+ $iMyDocsFolderID = $this->getFolderID($sUserName);
	214	+
	215	+
	216	+ if(!$this->roleExistsName('WorkSpaceOwner'))
	217	+ {
	218	+ $this->session->logout();
	219	+ return _kt('Error: WorkSpaceOwner Role does not exist');
	220	+ }
	221	+ else
	222	+ {
	223	+
	224	+ $oTempPersonalFolder = $root->get_folder_by_name('/DroppedDocuments/'.$sUserName);
	225	+ $oPersonalFolder = $oTempPersonalFolder->get_folder();
	226	+ //update WorkSpaceOwner role to include current user
	227	+
	228	+ //Get permission object
	229	+ $oPO = KTPermissionObject::get($oPersonalFolder->getPermissionObjectId());
	230	+
	231	+ $this->setPersonalFolderPermissions($oPO);
	232	+
	233	+ $this->updatePersonalFolderRoleAllocation($oPersonalFolder);
	234	+
	235	+ }
	236	+
	237	+
	238	+
	239	+ $aExternalWhereClauses[] = '(DT.transaction_namespace IN (?,?,?) AND (D.parent_folder_ids LIKE "%,'.$iMyDocsFolderID.',%" OR D.parent_folder_ids LIKE "%,'.$iMyDocsFolderID.'"))';
	240	+ $aExternalWhereParams[] = 'ktcore.transactions.create';
	241	+ $aExternalWhereParams[] = 'ktcore.transactions.check_in';
	242	+ $aExternalWhereParams[] = 'ktcore.transactions.event';
	243	+
	244	+
	245	+ $aDocumentTransactions = KTSimpleTransactionUtil::getTransactionsMatchingQuery($oUser, '', $aExternalWhereClauses, $aExternalWhereParams);
	246	+ if (empty($aDocumentTransactions))
	247	+ {
	248	+ $this->session->logout();
	249	+ return _kt('<span class="descriptiveText"> You do not have any dropped documents </span><br><br><br>');
	250	+ }
	251	+
	252	+ $maxcount = 5;
	253	+ $aDocumentTransactions = array_slice($aDocumentTransactions, 0, $maxcount);
	254	+
	255	+ $sReturnTable = '<span class="descriptiveText">'._kt('Recently Dropped Documents').'</span>
	256	+ <table width="100%" class="kt_collection drop_box" cellspacing="0">
	257	+
	258	+ <thead>
	259	+ <tr>
	260	+ <th width="100%">'._kt('Document').'</th>
	261	+ <th width="1%">'._kt('Date Dropped').'</th>
	262	+ </tr>
	263	+ </thead>
	264	+ <tbody>';
	265	+
	266	+ $sOddorEven = '';
	267	+ $count = 1;
	268	+ foreach ($aDocumentTransactions as $aRow)
	269	+ {
	270	+ $oDocument = Document::get($aRow[document_id]);
	271	+ $aParentFolders = explode('/',$oDocument->getFullPath());
	272	+ $sPath = '';
	273	+
	274	+ for($i = 0; $i < count($aParentFolders); $i++)
	275	+ {
	276	+ if ($i > 2)
	277	+ {
	278	+ $sPath .= '/'.$aParentFolders[$i];
	279	+ }
	280	+ }
	281	+
	282	+ $sContentType = KTMime::getIconPath($oDocument->getMimeTypeID());
	283	+ $aAnchorData = $this->getDocInfo($aRow[document_id]);
	284	+ $sLink = $aAnchorData[0];
	285	+ $sDocName = $aAnchorData[1];
	286	+ $sShortDocName = $sDocName;
	287	+ if(strlen($sPath) > 0)
	288	+ {
	289	+ $sDocName = $sPath.'/'.$sDocName;
	290	+ }
	291	+
	292	+ $sFullDocName = $sDocName;
	293	+ $iDocLength = strlen($sDocName);
	294	+ if ( $iDocLength > 30 )
	295	+ {
	296	+ $sDocName = substr($sDocName, ($iDocLength - 30), $iDocLength);
	297	+ $sDocName = '...'.$sDocName;
	298	+ }
	299	+
	300	+ if($count%2 == 0)
	301	+ {
	302	+ $sOddorEven = 'even';
	303	+ }
	304	+ else
	305	+ {
	306	+ $sOddorEven = 'odd';
	307	+ }
	308	+
	309	+ $sReturnTable .= '<tr class="'.$sOddorEven.'">'.
	310	+ '<td width="100%"><span class="contenttype '.$sContentType.'"><a title="'.$sShortDocName.'" href='.$sLink.'>'.$sDocName.'</a></span></td>'.
	311	+ '<td width="1%">'.$aRow[datetime].'</td>'.
	312	+ '</tr>';
	313	+ $count ++;
	314	+ }
	315	+
	316	+ $location = 'browse.php?fFolderId='.$iMyDocsFolderID;
	317	+ $sReturnTable .= '</tbody>'.
	318	+ '</table>'.
	319	+ '<br>'.
	320	+ '<a href="'.$location.'">'._kt(' View All').' </a><br><br>';
	321	+ $this->session->logout();
	322	+
	323	+ return $sReturnTable;
	324	+
	325	+ }
	326	+ }
	327	+
	328	+ function handleOutput($sOutput) {
	329	+ print $sOutput;
	330	+ }
	331	+
	332	+ //This function is used to set the permission on the dropdocuments folder
	333	+ function setUserDocsPermissions($oUserPO)
	334	+ {
	335	+ //arrays returned from get Role ID's
	336	+ $aWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
	337	+ $aAdminGroupID = $this->getGroupIdByName('System Administrators');
	338	+
	339	+ //arrays used to make integers for $aAllowed array variable
	340	+ $iWorkSpaceOwnerRoleID = $aWorkSpaceOwnerRoleID[0]['id'];
	341	+ $iAdminGroupID = $aAdminGroupID[0]['id'];
	342	+ //$aBothAllowed is used to give permissions to the admin group and the WorkSpaceOwner role
	343	+ $aBothAllowed = array('group' => array($iAdminGroupID), 'role' => array($iWorkSpaceOwnerRoleID));
	344	+
	345	+ //$aAdminAllowed is used to give permissions to the admin group only
	346	+ $aAdminAllowed = array('group' => array($iAdminGroupID));
	347	+
	348	+ //Get the list of permissions
	349	+ $aPermissions = KTPermission::getList();
	350	+
	351	+ foreach ($aPermissions as $oPermission)
	352	+ {
	353	+ //If the permission is not one of the below then both are allowed the permission
	354	+ //Otherwise only the admin group is allowed the permission
	355	+ if($oPermission->getHumanName() != 'Delete' && $oPermission->getHumanName() != 'Rename Folder'
	356	+ && $oPermission->getHumanName() != 'Manage security' && $oPermission->getHumanName() != 'Manage workflow')
	357	+ {
	358	+ KTPermissionUtil::setPermissionForId($oPermission, $oUserPO, $aBothAllowed);
	359	+ }
	360	+ else
	361	+ {
	362	+ KTPermissionUtil::setPermissionForId($oPermission, $oUserPO, $aAdminAllowed);
	363	+ }
	364	+ }
	365	+
	366	+ //UPdate the permission lookup
	367	+ KTPermissionUtil::updatePermissionLookupForPO($oUserPO);
	368	+ }
	369	+
	370	+ //This function is used for allocating the user to the WorkSpaceOwner role only when the dropdocuments folder
	371	+ //has just been created.
	372	+ function setUserDocsRoleAllocation($oUserFolderObject)
	373	+ {
	374	+ $userFolderID = $oUserFolderObject->getId();
	375	+
	376	+ $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
	377	+ $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
	378	+
	379	+ //create a new role allocation
	380	+ $oDropdocumentsRoleAllocation = new RoleAllocation();
	381	+ if ($oDropdocumentsRoleAllocation == null)
	382	+ {
	383	+ $this->session->logout();
	384	+ return _kt('Error: cannot create WorkSpaceOwner role allocation');
	385	+ }
	386	+
	387	+ //set the folder and role for the allocation
	388	+ $oDropdocumentsRoleAllocation->setFolderId($userFolderID);
	389	+ $oDropdocumentsRoleAllocation->setRoleId($WorkSpaceOwnerRoleID);
	390	+
	391	+ $aWorkSpaceOwnerRoleAllowed = array();
	392	+ $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAllowed);
	393	+ //It might be a problem that i'm not doing a "start transaction" here.
	394	+ //Unable to roll back in event of db failure
	395	+ $res = $oDropdocumentsRoleAllocation->create();
	396	+
	397	+ //The role is created and then updated by adding the current user to the allowed list
	398	+
	399	+ $oPD = $oDropdocumentsRoleAllocation->getPermissionDescriptor();
	400	+ $aWorkSpaceOwnerRoleAssignAllowed = $oPD->getAllowed();
	401	+ $aUserId[] = $this->oUser->getId();
	402	+ $aWorkSpaceOwnerRoleAssignAllowed['user'] = $aUserId;
	403	+ $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAssignAllowed);
	404	+ $res = $oDropdocumentsRoleAllocation->update();
	405	+
	406	+ //Update all info linked to the role
	407	+ $this->renegeratePermissionsForRole($oDropdocumentsRoleAllocation->getRoleId(), $userFolderID);
	408	+ }
	409	+
	410	+ //This function is used to allocate the current user to the WorkSpaceOwner role after the Dropdocuments folder
	411	+ //has already been created.
	412	+ function updateUserDocsRoleAllocation($oUserFolder)
	413	+ {
	414	+ $userFolderID = $oUserFolder->getId();
	415	+ $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');//$oUserRole->getId();
	416	+ $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
	417	+
	418	+ //Get the role allocation object for the Dropdocuments folder and the WorkSpaceOwner role
	419	+ $oDropdocumentsRoleAllocation = $oRoleAllocation = RoleAllocation::getAllocationsForFolderAndRole($userFolderID, $WorkSpaceOwnerRoleID);
	420	+
	421	+ //check that the object is not null
	422	+ if ($oDropdocumentsRoleAllocation == null)
	423	+ {
	424	+ $this->session->logout();
	425	+ return _kt('Error: cannot find WorkSpaceOwner role allocation');
	426	+ }
	427	+
	428	+ $oPD = $oDropdocumentsRoleAllocation->getPermissionDescriptor();
	429	+ $aWorkSpaceOwnerRoleAssignAllowed = $oPD->getAllowed();
	430	+
	431	+ //If the user ID is not in the allowed list already then add it to the list.
	432	+ if(!in_array($this->oUser->getId(), $aWorkSpaceOwnerRoleAssignAllowed['user']))
	433	+ {
	434	+ $aNewAllowed = array();
	435	+ $aNewAllowed = $aWorkSpaceOwnerRoleAssignAllowed['user'];
	436	+ $aNewAllowed[] = $this->oUser->getId();
	437	+ $aWorkSpaceOwnerRoleAssignAllowed['user'] = $aNewAllowed;
	438	+ $oDropdocumentsRoleAllocation->setAllowed($aWorkSpaceOwnerRoleAssignAllowed);
	439	+ $res = $oDropdocumentsRoleAllocation->update();
	440	+ $this->renegeratePermissionsForRole($oDropdocumentsRoleAllocation->getRoleId(), $userFolderID);
	441	+ }
	442	+ }
	443	+
	444	+ function setPersonalFolderPermissions($oPO)
	445	+ {
	446	+ $aWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
	447	+ $aAdminGroupID = $this->getGroupIdByName('System Administrators');
	448	+
	449	+ //arrays used to make integers for $aAllowed array variable
	450	+ $iWorkSpaceOwnerRoleID = $aWorkSpaceOwnerRoleID[0]['id'];
	451	+ $iAdminGroupID = $aAdminGroupID[0]['id'];
	452	+
	453	+ //set permissions for the role and the admin group
	454	+ $aAllowed = array('role' => array($iWorkSpaceOwnerRoleID), 'group' => array($iAdminGroupID));
	455	+
	456	+ //Get the List of all the permissions
	457	+ $aPersonalFolderPermissions = KTPermission::getList();
	458	+
	459	+ //Iterate through and apply all permissions to the current user and the admin group
	460	+ foreach ($aPersonalFolderPermissions as $oPersonalFolderPermission)
	461	+ {
	462	+ KTPermissionUtil::setPermissionForId($oPersonalFolderPermission, $oPO, $aAllowed);
	463	+
	464	+ }
	465	+
	466	+ //Update permission lookup
	467	+ KTPermissionUtil::updatePermissionLookupForPO($oPO);
	468	+ }
	469	+
	470	+ function updatePersonalFolderRoleAllocation($oPersonalFolder)
	471	+ {
	472	+ //Assign user to the WorkSpaceOwner role
	473	+ $personalFolderID = $oPersonalFolder->getId();
	474	+ $tempWorkSpaceOwnerRoleID = $this->getRoleIdByName('WorkSpaceOwner');
	475	+ $WorkSpaceOwnerRoleID = $tempWorkSpaceOwnerRoleID[0]['id'];
	476	+
	477	+ $oRoleAllocation = new RoleAllocation();
	478	+ if ($oRoleAllocation == null)
	479	+ {
	480	+ $this->session->logout();
	481	+ return _kt('Error: Cannot create WorkSpaceOwner role allocation on personal folder');
	482	+ }
	483	+ $oRoleAllocation->setFolderId($personalFolderID);
	484	+ $oRoleAllocation->setRoleId($WorkSpaceOwnerRoleID);
	485	+
	486	+ $aRoleAllowed = array();
	487	+ $oRoleAllocation->setAllowed($aRoleAllowed);
	488	+
	489	+ //It might be a problem that i'm not doing a "start transaction" here.
	490	+ //Unable to roll back in event of db failure
	491	+ $res = $oRoleAllocation->create();
	492	+
	493	+ //The role is first created and then the current user is allocated to the role below
	494	+
	495	+ $oPD = $oRoleAllocation->getPermissionDescriptor();
	496	+ $aRoleAssignAllowed = $oPD->getAllowed();
	497	+ $aUserId[] = $this->oUser->getId();
	498	+ $aRoleAssignAllowed['user'] = $aUserId;
	499	+ $oRoleAllocation->setAllowed($aRoleAssignAllowed);
	500	+ $res = $oRoleAllocation->update();
	501	+ $this->renegeratePermissionsForRole($oRoleAllocation->getRoleId(), $personalFolderID);
	502	+ }
	503	+
	504	+ //FIXME: Direct Database access
	505	+ function getFolderID($sFolderName) {
	506	+ $sQuery = 'SELECT id FROM folders WHERE name = \''.$sFolderName.'\'';
	507	+
	508	+ $id = DBUtil::getResultArray($sQuery);
	509	+ return $id[0]['id'];
	510	+ }
	511	+
	512	+ //this function returns the document link and document name to be displayed on the dashlet
	513	+ function getDocInfo($iDocId) {
	514	+ $oDocument = Document::get($iDocId);
	515	+
	516	+ if (PEAR::isError($oDocument)) {
	517	+ return _kt('Document no longer exists.');
	518	+ }
	519	+
	520	+ $sName = htmlentities($oDocument->getName(), ENT_NOQUOTES, 'UTF-8');
	521	+ $sLink = KTBrowseUtil::getUrlForDocument($oDocument);
	522	+
	523	+ $aAnchorData = array();
	524	+ $aAnchorData[] = $sLink;
	525	+ $aAnchorData[] = $sName;
	526	+ return $aAnchorData;
	527	+ }
	528	+
	529	+ //This function is used to create the role, role allocation is done separately
	530	+ function createRole ($sName)
	531	+ {
	532	+ $this->startTransaction();
	533	+ $oRole = Role::createFromArray(array('name' => $sName));
	534	+
	535	+ if (PEAR::isError($oRole) \|\| ($oRole == false))
	536	+ {
	537	+ if ($this->bTransactionStarted)
	538	+ {
	539	+ $this->rollbackTransaction();
	540	+ }
	541	+ //return null on failure
	542	+ return null;
	543	+ }
	544	+ else
	545	+ {
	546	+ return $oRole;
	547	+
	548	+ }
	549	+ }
	550	+
	551	+ //FIXME: Direct Database access
	552	+ function roleExistsName ($sName)
	553	+ {
	554	+ $sQuery = "SELECT id FROM roles WHERE name = ?";
	555	+ $aParams = array($sName);
	556	+ $res = DBUtil::getResultArray(array($sQuery, $aParams));
	557	+
	558	+ if (count($res) != 0)
	559	+ {
	560	+ return true;
	561	+ }
	562	+ return false;
	563	+ }
	564	+
	565	+ //FIXME: Direct Database access
	566	+ function groupExistsName ($sName)
	567	+ {
	568	+ $sQuery = "SELECT id FROM groups_lookup WHERE name = ?";
	569	+ $aParams = array($sName);
	570	+ $res = DBUtil::getResultArray(array($sQuery, $aParams));
	571	+
	572	+ if (count($res) != 0)
	573	+ {
	574	+ return true;
	575	+ }
	576	+ return false;
	577	+ }
	578	+
	579	+ //FIXME: Direct Database access
	580	+ function getRoleIdByName($sName)
	581	+ {
	582	+ $sQuery = "SELECT id FROM roles WHERE name = ?";
	583	+ $aParams = array($sName);
	584	+ $res = DBUtil::getResultArray(array($sQuery, $aParams));
	585	+ return $res;
	586	+ }
	587	+
	588	+ //FIXME: Direct Database access
	589	+ function getGroupIdByName ($sName)
	590	+ {
	591	+ $sQuery = "SELECT id FROM groups_lookup WHERE name = ?";
	592	+ $aParams = array($sName);
	593	+ $res = DBUtil::getResultArray(array($sQuery, $aParams));
	594	+ return $res;
	595	+ }
	596	+
	597	+ //function taken from KTPermission.php and edited to work here
	598	+ function renegeratePermissionsForRole($iRoleId, $iFolderId) {
	599	+ $iStartFolderId = $iFolderId;
	600	+ /*
	601	+ * 1. find all folders & documents "below" this one which use the role
	602	+ * definition _active_ (not necessarily present) at this point.
	603	+ * 2. tell permissionutil to regen their permissions.
	604	+ *
	605	+ * The find algorithm is:
	606	+ *
	607	+ * folder_queue <- (iStartFolderId)
	608	+ * while folder_queue is not empty:
	609	+ * active_folder =
	610	+ * for each folder in the active_folder:
	611	+ * find folders in _this_ folder without a role-allocation on the iRoleId
	612	+ * add them to the folder_queue
	613	+ * update the folder's permissions.
	614	+ * find documents in this folder:
	615	+ * update their permissions.
	616	+ */
	617	+
	618	+ $sRoleAllocTable = KTUtil::getTableName('role_allocations');
	619	+ $sFolderTable = KTUtil::getTableName('folders');
	620	+ $sQuery = sprintf('SELECT f.id as id FROM %s AS f LEFT JOIN %s AS ra ON (f.id = ra.folder_id) WHERE ra.id IS NULL AND f.parent_id = ?', $sFolderTable, $sRoleAllocTable);
	621	+
	622	+
	623	+ $folder_queue = array($iStartFolderId);
	624	+ while (!empty($folder_queue)) {
	625	+ $active_folder = array_pop($folder_queue);
	626	+
	627	+ $aParams = array($active_folder);
	628	+
	629	+ $aNewFolders = DBUtil::getResultArrayKey(array($sQuery, $aParams), 'id');
	630	+ if (PEAR::isError($aNewFolders)) {
	631	+ //$this->errorRedirectToMain(_kt('Failure to generate folderlisting.'));
	632	+ echo _kt('Failure to generate folderlisting.');
	633	+ }
	634	+ $folder_queue = kt_array_merge ($folder_queue, (array) $aNewFolders); // push.
	635	+
	636	+
	637	+ // update the folder.
	638	+ $oFolder =& Folder::get($active_folder);
	639	+ if (PEAR::isError($oFolder) \|\| ($oFolder == false)) {
	640	+ //$this->errorRedirectToMain(_kt('Unable to locate folder: ') . $active_folder);
	641	+ echo _kt('Unable to locate folder: ').$active_folder;
	642	+ }
	643	+
	644	+ KTPermissionUtil::updatePermissionLookup($oFolder);
	645	+ $aDocList =& Document::getList(array('folder_id = ?', $active_folder));
	646	+ if (PEAR::isError($aDocList) \|\| ($aDocList === false)) {
	647	+ //$this->errorRedirectToMain(sprintf(_kt('Unable to get documents in folder %s: %s'), $active_folder, $aDocList->getMessage()));
	648	+ echo _kt('Unable to get documents in folder ').$active_folder;
	649	+ }
	650	+
	651	+ foreach ($aDocList as $oDoc) {
	652	+ if (!PEAR::isError($oDoc)) {
	653	+ KTPermissionUtil::updatePermissionLookup($oDoc);
	654	+ }
	655	+ }
	656	+ }
	657	+ }
	658	+
	659	+}
	660	+?>
...	...