- Fixed #16160: Call to undefined function ezi18n()
[tinyz:tinyz.git] / kernel / role / edit.php
1 <?php
2 //
3 // Created on: <19-Aug-2002 16:38:41 sp>
4 //
5 // ## BEGIN COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
6 // SOFTWARE NAME: eZ Publish
7 // SOFTWARE RELEASE: 4.1.x
8 // COPYRIGHT NOTICE: Copyright (C) 1999-2010 eZ Systems AS
9 // SOFTWARE LICENSE: GNU General Public License v2.0
10 // NOTICE: >
11 //   This program is free software; you can redistribute it and/or
12 //   modify it under the terms of version 2.0  of the GNU General
13 //   Public License as published by the Free Software Foundation.
14 //
15 //   This program is distributed in the hope that it will be useful,
16 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
17 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 //   GNU General Public License for more details.
19 //
20 //   You should have received a copy of version 2.0 of the GNU General
21 //   Public License along with this program; if not, write to the Free
22 //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
23 //   MA 02110-1301, USA.
24 //
25 //
26 // ## END COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
27 //
28
29 /*! \file
30 */
31
32 require_once( 'kernel/common/template.php' );
33
34 $tpl = templateInit();
35 $Module = $Params['Module'];
36 $roleID = $Params['RoleID'];
37
38 $ini = eZINI::instance( 'module.ini' );
39 $modules = $ini->variable( 'ModuleSettings', 'ModuleList' );
40 sort( $modules );
41
42 $role = eZRole::fetch( 0, $roleID );
43 if ( $role === null )
44 {
45     $role = eZRole::fetch( $roleID );
46     if ( $role )
47     {
48         if ( $role->attribute( 'version' ) == '0' )
49         {
50             $temporaryRole = $role->createTemporaryVersion();
51             unset( $role );
52             $role = $temporaryRole;
53         }
54     }
55     else
56     {
57         return $Module->handleError( eZError::KERNEL_NOT_AVAILABLE, 'kernel' );
58     }
59 }
60
61 $http = eZHTTPTool::instance();
62
63 $tpl->setVariable( 'module', $Module );
64
65 $role->turnOffCaching();
66
67 $tpl->setVariable( 'role', $role );
68 $Module->setTitle( 'Edit ' . $role->attribute( 'name' ) );
69
70 if ( $http->hasPostVariable( 'NewName' ) && $role->attribute( 'name' ) != $http->postVariable( 'NewName' ) )
71 {
72     $role->setAttribute( 'name' , $http->postVariable( 'NewName' ) );
73     $role->store();
74     // Set flag for audit. If true audit will be processed
75     $http->setSessionVariable( 'RoleWasChanged', true );
76 }
77
78 $showModules = true;
79 $showFunctions = false;
80 $showLimitations = false;
81 $noFunctions = false;
82 $noLimitations = false;
83
84 if ( $http->hasPostVariable( 'Apply' ) )
85 {
86     $originalRole = eZRole::fetch( $role->attribute( 'version' ) );
87     $originalRoleName = $originalRole->attribute( 'name' );
88     $originalRoleID = $originalRole->attribute( 'id' );
89
90     // Who changes which role(s) should be logged.
91     if ( $http->hasSessionVariable( 'RoleWasChanged' ) and
92          $http->sessionVariable( 'RoleWasChanged' ) === true )
93     {
94         eZAudit::writeAudit( 'role-change', array( 'Role ID' => $originalRoleID, 'Role name' => $originalRoleName,
95                                                    'Comment' => 'Changed the current role: kernel/role/edit.php' ) );
96         $http->removeSessionVariable( 'RoleWasChanged' );
97     }
98
99     $originalRole->revertFromTemporaryVersion();
100     eZContentCacheManager::clearAllContentCache();
101
102     $Module->redirectTo( $Module->functionURI( 'view' ) . '/' . $originalRoleID . '/');
103
104     /* Clean up policy cache */
105     eZUser::cleanupCache();
106 }
107
108 if ( $http->hasPostVariable( 'Discard' ) )
109 {
110     $http->removeSessionVariable( 'RoleWasChanged' );
111
112     $role = eZRole::fetch( $roleID ) ;
113     $originalRole = eZRole::fetch( $role->attribute( 'version') );
114     $role->removeThis();
115     if ( $originalRole != null && $originalRole->attribute( 'is_new' ) == 1 )
116     {
117         $originalRole->remove();
118     }
119     $Module->redirectTo( $Module->functionURI( 'list' ) . '/' );
120 }
121
122 if ( $http->hasPostVariable( 'ChangeRoleName' ) )
123 {
124     $role->setAttribute( 'name', $http->postVariable( 'NewName' ) );
125     // Set flag for audit. If true audit will be processed
126     $http->setSessionVariable( 'RoleWasChanged', true );
127 }
128 if ( $http->hasPostVariable( 'AddModule' ) )
129 {
130     if ( $http->hasPostVariable( 'Modules' ) )
131             $currentModule = $http->postVariable( 'Modules' );
132     else if ( $http->hasPostVariable( 'CurrentModule' ) )
133             $currentModule = $http->postVariable( 'CurrentModule' );
134     $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
135                                                    'FunctionName' => '*' ) );
136 }
137 if ( $http->hasPostVariable( 'AddFunction' ) )
138 {
139     $currentModule = $http->postVariable( 'CurrentModule' );
140     $currentFunction = $http->postVariable( 'ModuleFunction' );
141     eZDebugSetting::writeDebug( 'kernel-role-edit', $currentModule, 'currentModule');
142     $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
143                                                    'FunctionName' => $currentFunction ) );
144 }
145
146 if ( $http->hasPostVariable( 'AddLimitation' ) )
147 {
148     $policy = false;
149
150     if ( $http->hasSessionVariable( 'BrowsePolicyID' ) )
151     {
152         $hasNodeLimitation = false;
153         $policy = eZPolicy::fetch( $http->sessionVariable( 'BrowsePolicyID' ) );
154         if ( $policy )
155         {
156             $limitationList = eZPolicyLimitation::fetchByPolicyID( $policy->attribute( 'id' ) );
157             foreach ( $limitationList as $limitation )
158             {
159                 $limitationID = $limitation->attribute( 'id' );
160                 $limitationIdentifier = $limitation->attribute( 'identifier' );
161                 if ( $limitationIdentifier != 'Node' and $limitationIdentifier != 'Subtree' )
162                     eZPolicyLimitation::removeByID( $limitationID );
163                 if ( $limitationIdentifier == 'Node' )
164                 {
165                     $nodeLimitationValues = eZPolicyLimitationValue::fetchList( $limitationID );
166                     if ( $nodeLimitationValues != null )
167                         $hasNodeLimitation = true;
168                     else
169                         eZPolicyLimitation::removeByID( $limitationID );
170                 }
171
172                 if ( $limitationIdentifier == 'Subtree' )
173                 {
174                     $nodeLimitationValues = eZPolicyLimitationValue::fetchList( $limitationID );
175                     if ( $nodeLimitationValues == null )
176                         eZPolicyLimitation::removeByID( $limitationID );
177                 }
178             }
179
180 //             if ( !$hasNodeLimitation )
181             {
182                 $currentModule = $http->postVariable( 'CurrentModule' );
183                 $currentFunction = $http->postVariable( 'CurrentFunction' );
184
185                 $mod = eZModule::exists( $currentModule );
186                 $functions = $mod->attribute( 'available_functions' );
187                 $currentFunctionLimitations = $functions[ $currentFunction ];
188                 foreach ( $currentFunctionLimitations as $functionLimitation )
189                 {
190                     if ( $http->hasPostVariable( $functionLimitation['name'] ) and
191                          $functionLimitation['name'] != 'Node' and
192                          $functionLimitation['name'] != 'Subtree' )
193                     {
194                         $limitationValues = $http->postVariable( $functionLimitation['name'] );
195
196                         if ( !in_array( '-1', $limitationValues ) )
197                         {
198                             $policyLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), $functionLimitation['name'], $currentModule, $currentFunction );
199                             foreach ( $limitationValues as $limitationValue )
200                             {
201                                 eZPolicyLimitationValue::createNew( $policyLimitation->attribute( 'id' ), $limitationValue );
202                             }
203                         }
204                     }
205                 }
206             }
207         }
208     }
209
210     if ( !$policy )
211     {
212         $currentModule = $http->postVariable( 'CurrentModule' );
213         $currentFunction = $http->postVariable( 'CurrentFunction' );
214         $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
215                                                         'FunctionName' => $currentFunction,
216                                                         'Limitation' => '' ) );
217
218         $mod = eZModule::exists( $currentModule );
219         $functions = $mod->attribute( 'available_functions' );
220         $currentFunctionLimitations = $functions[ $currentFunction ];
221         eZDebugSetting::writeDebug( 'kernel-role-edit', $currentFunctionLimitations, 'currentFunctionLimitations' );
222
223         $db = eZDB::instance();
224         $db->begin();
225         foreach ( $currentFunctionLimitations as $functionLimitation )
226         {
227             if ( $http->hasPostVariable( $functionLimitation['name'] ) )
228             {
229                 $limitationValues = $http->postVariable( $functionLimitation['name'] );
230                 eZDebugSetting::writeDebug( 'kernel-role-edit', $limitationValues, 'limitationValues' );
231
232                 if ( !in_array('-1', $limitationValues ) )
233                 {
234                     $policyLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), $functionLimitation['name'], $currentModule, $currentFunction );
235                     foreach ( $limitationValues as $limitationValue )
236                     {
237                         eZPolicyLimitationValue::createNew( $policyLimitation->attribute( 'id' ), $limitationValue );
238                     }
239                 }
240             }
241         }
242         $db->commit();
243     }
244 }
245
246 if ( $http->hasPostVariable( 'RemovePolicy' ) )
247 {
248     $policyID = $http->postVariable( 'RolePolicy' ) ;
249     eZDebugSetting::writeDebug( 'kernel-role-edit', $policyID, 'trying to remove policy' );
250     eZPolicy::removeByID( $policyID );
251     // Set flag for audit. If true audit will be processed
252     $http->setSessionVariable( 'RoleWasChanged', true );
253 }
254 if ( $http->hasPostVariable( 'RemovePolicies' ) and
255      $http->hasPostVariable( 'DeleteIDArray' ) )
256 {
257     $db = eZDB::instance();
258     $db->begin();
259     foreach( $http->postVariable( 'DeleteIDArray' ) as $deleteID)
260     {
261         eZDebugSetting::writeDebug( 'kernel-role-edit', $deleteID, 'trying to remove policy' );
262         eZPolicy::removeByID( $deleteID );
263     }
264     $db->commit();
265     // Set flag for audit. If true audit will be processed
266     $http->setSessionVariable( 'RoleWasChanged', true );
267 }
268
269
270 if ( $http->hasPostVariable( 'CustomFunction' ) )
271 {
272     if ( $http->hasPostVariable( 'Modules' ) )
273             $currentModule = $http->postVariable( 'Modules' );
274     else if ( $http->hasPostVariable( 'CurrentModule' ) )
275             $currentModule = $http->postVariable( 'CurrentModule' );
276     if ( $currentModule != '*' )
277     {
278         $mod = eZModule::exists( $currentModule );
279         $functions = $mod->attribute( 'available_functions' );
280         $functionNames = array_keys( $functions );
281     }
282     else
283     {
284         $functionNames = array();
285     }
286
287     $showModules = false;
288     $showFunctions = true;
289
290     if ( count( $functionNames ) < 1 )
291     {
292         $showModules = true;
293         $showFunctions = false;
294         $showLimitations = false;
295         $noFunctions = true;
296     }
297
298     $tpl->setVariable( 'current_module', $currentModule );
299     $tpl->setVariable( 'functions', $functionNames );
300     $tpl->setVariable( 'no_functions', $noFunctions );
301
302     $Module->setTitle( 'Edit ' . $role->attribute( 'name' ) );
303     $Result = array();
304
305     $Result['path'] = array( array( 'url' => false ,
306                                     'text' => ezpI18n::translate( 'kernel/role',
307                                                       'Create new policy, step 2: select function' ) ) );
308
309     $Result['content'] = $tpl->fetch( 'design:role/createpolicystep2.tpl' );
310     return;
311 }
312
313 if ( $http->hasPostVariable( 'DiscardFunction' ) )
314 {
315     $showModules = true;
316     $showFunctions = false;
317 }
318
319 if ( $http->hasPostVariable( 'SelectButton' ) or
320      $http->hasPostVariable( 'BrowseCancelButton' ) or
321      $http->hasPostVariable( 'Limitation' ) or
322      $http->hasPostVariable( 'SelectedNodeIDArray' ) or
323      $http->hasPostVariable( 'BrowseLimitationNodeButton' ) or
324      $http->hasPostVariable( 'DeleteNodeButton' ) or
325      $http->hasPostVariable( 'BrowseLimitationSubtreeButton' ) or
326      $http->hasPostVariable( 'DeleteSubtreeButton' ) )
327 {
328     $db = eZDB::instance();
329     $db->begin();
330     if ( $http->hasPostVariable( 'DeleteNodeButton' ) and $http->hasSessionVariable( 'BrowsePolicyID' ) )
331     {
332         if ( $http->hasPostVariable( 'DeleteNodeIDArray' ) )
333         {
334             $deletedIDList = $http->postVariable( 'DeleteNodeIDArray' );
335
336             foreach ( $deletedIDList as $deletedID )
337             {
338                 eZPolicyLimitationValue::removeByValue( $deletedID, $http->sessionVariable( 'BrowsePolicyID' ) );
339             }
340         }
341     }
342
343     if ( $http->hasPostVariable( 'DeleteSubtreeButton' ) and $http->hasSessionVariable( 'BrowsePolicyID' ) )
344     {
345         if ( $http->hasPostVariable( 'DeleteSubtreeIDArray' ) )
346         {
347             $deletedIDList = $http->postVariable( 'DeleteSubtreeIDArray' );
348
349             foreach ( $deletedIDList as $deletedID )
350             {
351                 $subtree = eZContentObjectTreeNode::fetch( $deletedID , false, false);
352                 $path = $subtree['path_string'];
353                 eZPolicyLimitationValue::removeByValue( $path, $http->sessionVariable( 'BrowsePolicyID' ) );
354             }
355         }
356     }
357
358     if ( $http->hasPostVariable( 'Limitation' ) and $http->hasSessionVariable( 'BrowsePolicyID' ) )
359         $http->removeSessionVariable( 'BrowsePolicyID' );
360
361     if ( $http->hasSessionVariable( 'BrowseCurrentModule' ) )
362         $currentModule = $http->sessionVariable( 'BrowseCurrentModule' );
363
364     if ( $http->hasPostVariable( 'CurrentModule' ) )
365         $currentModule = $http->postVariable( 'CurrentModule' );
366
367     $mod = eZModule::exists( $currentModule );
368     $functions = $mod->attribute( 'available_functions' );
369     $functionNames = array_keys( $functions );
370
371     $showModules = false;
372     $showFunctions = false;
373     $showLimitations = true;
374     $nodeList = array();
375     $nodeIDList = array();
376     $subtreeList = array();
377     $subtreeIDList = array();
378
379     // Check for temporary node and subtree policy limitation
380     if ( $http->hasSessionVariable( 'BrowsePolicyID' ) )
381     {
382         $policyID = $http->sessionVariable( 'BrowsePolicyID' );
383         // Fetch node limitations
384         $nodeLimitation = eZPolicyLimitation::fetchByIdentifier( $policyID, 'Node' );
385         if ( $nodeLimitation != null )
386         {
387             $nodeLimitationID = $nodeLimitation->attribute('id');
388             $nodeLimitationValues = eZPolicyLimitationValue::fetchList( $nodeLimitationID );
389             foreach ( $nodeLimitationValues as $nodeLimitationValue )
390             {
391                 $nodeID = $nodeLimitationValue->attribute( 'value' );
392                 $nodeIDList[] = $nodeID;
393                 $node = eZContentObjectTreeNode::fetch( $nodeID );
394                 $nodeList[] = $node;
395             }
396         }
397
398         // Fetch subtree limitations
399         $subtreeLimitation = eZPolicyLimitation::fetchByIdentifier( $policyID, 'Subtree' );
400         if ( $subtreeLimitation != null )
401         {
402             $subtreeLimitationID = $subtreeLimitation->attribute('id');
403             $subtreeLimitationValues = eZPolicyLimitationValue::fetchList( $subtreeLimitationID );
404
405             foreach ( $subtreeLimitationValues as $subtreeLimitationValue )
406             {
407                 $subtreePath = $subtreeLimitationValue->attribute( 'value' );
408                 $subtreeObject = eZContentObjectTreeNode::fetchByPath( $subtreePath );
409                 if ( $subtreeObject )
410                 {
411                     $subtreeID = $subtreeObject->attribute( 'node_id' );
412                     $subtreeIDList[] = $subtreeID;
413                     $subtree = eZContentObjectTreeNode::fetch( $subtreeID );
414                     $subtreeList[] = $subtree;
415                 }
416             }
417         }
418     }
419
420     if ( $http->hasSessionVariable( 'BrowseCurrentFunction' ) )
421         $currentFunction = $http->sessionVariable( 'BrowseCurrentFunction' );
422
423     if ( $http->hasPostVariable( 'CurrentFunction' ) )
424         $currentFunction = $http->postVariable( 'CurrentFunction' );
425
426     if ( $http->hasPostVariable( 'ModuleFunction' ) )
427         $currentFunction = $http->postVariable( 'ModuleFunction' );
428
429     $currentFunctionLimitations = array();
430     foreach( $functions[ $currentFunction ] as $key => $limitation )
431     {
432         if( count( $limitation[ 'values' ] == 0 ) && array_key_exists( 'class', $limitation ) )
433         {
434             $basePath = 'kernel/'; //set default basepath for limitationValueClasses
435             if( array_key_exists( 'extension', $limitation ) && $limitation['extension'] )
436             {
437                 $basePath = 'extension/' . $limitation['extension'] . '/';
438             }
439             include_once( $basePath . $limitation['path'] . $limitation['file']  );
440             $obj = new $limitation['class']( array() );
441             $limitationValueList = call_user_func_array ( array( $obj , $limitation['function']) , $limitation['parameter'] );
442             $limitationValueArray =  array();
443             foreach( $limitationValueList as $limitationValue )
444             {
445                 $limitationValuePair = array();
446                 $limitationValuePair['Name'] = $limitationValue[ 'name' ];
447                 $limitationValuePair['value'] = $limitationValue[ 'id' ];
448                 $limitationValueArray[] = $limitationValuePair;
449             }
450             $limitation[ 'values' ] = $limitationValueArray;
451         }
452         $currentFunctionLimitations[ $key ] = $limitation;
453     }
454
455     if ( count( $currentFunctionLimitations ) < 1 )
456     {
457         $showModules = false;
458         $showFunctions = true;
459         $showLimitations = false;
460         $noLimitations = true;
461     }
462
463
464     if ( $http->hasPostVariable( 'BrowseLimitationSubtreeButton' ) ||
465          $http->hasPostVariable( 'BrowseLimitationNodeButton' ) )
466     {
467         // Store other limitations
468         if ( $http->hasSessionVariable( 'BrowsePolicyID' ) )
469         {
470             $policy = eZPolicy::fetch( $http->sessionVariable( 'BrowsePolicyID' ) );
471             $limitationList = eZPolicyLimitation::fetchByPolicyID( $policy->attribute( 'id' ) );
472             foreach ( $limitationList as $limitation )
473             {
474                 $limitationID = $limitation->attribute( 'id' );
475                 $limitationIdentifier = $limitation->attribute( 'identifier' );
476                 if ( $limitationIdentifier != 'Node' and $limitationIdentifier != 'Subtree' )
477                     eZPolicyLimitation::removeByID( $limitationID );
478             }
479
480             foreach ( $currentFunctionLimitations as $functionLimitation )
481             {
482                 if ( $http->hasPostVariable( $functionLimitation['name'] ) and
483                      $functionLimitation['name'] != 'Node' and
484                      $functionLimitation['name'] != 'Subtree' )
485                 {
486                     $limitationValues = $http->postVariable( $functionLimitation['name'] );
487                     eZDebugSetting::writeDebug( 'kernel-role-edit', $limitationValues, 'limitationValues');
488
489                     if ( !in_array('-1', $limitationValues ) )
490                     {
491                         $policyLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), $functionLimitation['name'], $currentModule, $currentFunction );
492                         foreach ( $limitationValues as $limitationValue )
493                         {
494                             eZPolicyLimitationValue::createNew( $policyLimitation->attribute( 'id' ), $limitationValue );
495                         }
496                     }
497                 }
498             }
499         }
500         else
501         {
502             $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
503                                                             'FunctionName' => $currentFunction,
504                                                             'Limitation' => '') );
505
506             $http->setSessionVariable( 'BrowsePolicyID', $policy->attribute('id') );
507             foreach ( $currentFunctionLimitations as $functionLimitation )
508             {
509                 if ( $http->hasPostVariable( $functionLimitation['name'] ))
510                 {
511                     $limitationValues = $http->postVariable( $functionLimitation['name'] );
512                     eZDebugSetting::writeDebug( 'kernel-role-edit', $limitationValues, 'limitationValues');
513
514                     if ( !in_array( '-1', $limitationValues ) )
515                     {
516                         $policyLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), $functionLimitation['name'], $currentModule, $currentFunction);
517                         eZDebugSetting::writeDebug( 'kernel-role-edit', $policyLimitation, 'policyLimitationCreated' );
518                         foreach ( $limitationValues as $limitationValue )
519                         {
520                             eZPolicyLimitationValue::createNew( $policyLimitation->attribute( 'id' ), $limitationValue );
521                         }
522                     }
523                 }
524             }
525         }
526         $db->commit();
527
528         $http->setSessionVariable( 'BrowseCurrentModule', $currentModule );
529         $http->setSessionVariable( 'BrowseCurrentFunction', $currentFunction );
530         if ( $http->hasPostVariable( 'BrowseLimitationSubtreeButton' ) )
531         {
532
533             eZContentBrowse::browse( array( 'action_name' => 'FindLimitationSubtree',
534                                             'from_page' => '/role/edit/' . $roleID . '/' ),
535                                      $Module );
536         }
537         elseif ( $http->hasPostVariable( 'BrowseLimitationNodeButton' ) )
538         {
539             eZContentBrowse::browse( array( 'action_name' => 'FindLimitationNode',
540                                             'from_page' => '/role/edit/' . $roleID . '/' ),
541                                      $Module );
542
543         }
544         return;
545     }
546
547     if ( $http->hasPostVariable( 'SelectedNodeIDArray' ) and
548          $http->postVariable( 'BrowseActionName' ) == 'FindLimitationNode' and
549          !$http->hasPostVariable( 'BrowseCancelButton' ) )
550     {
551         $selectedNodeIDList = $http->postVariable( 'SelectedNodeIDArray' );
552
553         if ( $http->hasSessionVariable( 'BrowsePolicyID' ) )
554         {
555             $policy = eZPolicy::fetch( $http->sessionVariable( 'BrowsePolicyID' ) );
556             $limitationList = eZPolicyLimitation::fetchByPolicyID( $policy->attribute( 'id' ) );
557
558             // Remove other limitations. When the policy is applied to node, no other constraints needed.
559             // Removes limitations only from a DropList if it is specified in the module.
560             if ( isset( $currentFunctionLimitations['Node']['DropList'] ) )
561             {
562                 $dropList = $currentFunctionLimitations['Node']['DropList'];
563                 foreach ( $limitationList as $limitation )
564                 {
565                     $limitationID = $limitation->attribute( 'id' );
566                     $limitationIdentifier = $limitation->attribute( 'identifier' );
567                     if ( in_array( $limitationIdentifier, $dropList ) )
568                     {
569                         eZPolicyLimitation::removeByID( $limitationID );
570                     }
571                 }
572             }
573             else
574             {
575                 foreach ( $limitationList as $limitation )
576                 {
577                     $limitationID = $limitation->attribute( 'id' );
578                     $limitationIdentifier = $limitation->attribute( 'identifier' );
579                     if ( $limitationIdentifier != 'Node' and $limitationIdentifier != 'Subtree' )
580                         eZPolicyLimitation::removeByID( $limitationID );
581                 }
582             }
583         }
584         else
585         {
586             $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
587                                                            'FunctionName' => $currentFunction,
588                                                            'Limitation' => '') );
589             $http->setSessionVariable( 'BrowsePolicyID', $policy->attribute('id') );
590         }
591
592         $nodeLimitation = eZPolicyLimitation::fetchByIdentifier( $policy->attribute('id'), 'Node' );
593         if ( $nodeLimitation == null )
594             $nodeLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), 'Node', $currentModule, $currentFunction);
595
596         foreach ( $selectedNodeIDList as $nodeID )
597         {
598             if ( !in_array( $nodeID, $nodeIDList ) )
599             {
600                 $nodeLimitationValue = eZPolicyLimitationValue::createNew( $nodeLimitation->attribute( 'id' ),  $nodeID );
601                 $node = eZContentObjectTreeNode::fetch( $nodeID );
602                 $nodeList[] = $node;
603             }
604         }
605     }
606
607     if ( $http->hasPostVariable( 'SelectedNodeIDArray' ) and
608          $http->postVariable( 'BrowseActionName' ) == 'FindLimitationSubtree' and
609          !$http->hasPostVariable( 'BrowseCancelButton' ) )
610     {
611         $selectedSubtreeIDList = $http->postVariable( 'SelectedNodeIDArray' );
612         if ( $http->hasSessionVariable( 'BrowsePolicyID' ) )
613         {
614             $policy = eZPolicy::fetch( $http->sessionVariable( 'BrowsePolicyID' ) );
615         }
616         else
617         {
618             $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
619                                                             'FunctionName' => $currentFunction,
620                                                             'Limitation' => '') );
621             $http->setSessionVariable( 'BrowsePolicyID', $policy->attribute('id') );
622         }
623
624         $subtreeLimitation = eZPolicyLimitation::fetchByIdentifier( $policy->attribute('id'), 'Subtree' );
625         if ( $subtreeLimitation == null )
626             $subtreeLimitation = eZPolicyLimitation::createNew( $policy->attribute('id'), 'Subtree', $currentModule, $currentFunction);
627
628         foreach ( $selectedSubtreeIDList as $nodeID )
629         {
630             if ( !in_array( $nodeID, $subtreeIDList ) )
631             {
632                 $subtree = eZContentObjectTreeNode::fetch( $nodeID );
633                 $pathString = $subtree->attribute( 'path_string' );
634                 $policyLimitationValue = eZPolicyLimitationValue::createNew( $subtreeLimitation->attribute( 'id' ),  $pathString );
635                 $subtreeList[] = $subtree;
636             }
637         }
638     }
639
640     if ( $http->hasPostVariable( 'Limitation' ) && count( $currentFunctionLimitations ) == 0 )
641     {
642         $currentModule = $http->postVariable( 'CurrentModule' );
643         $currentFunction = $http->postVariable( 'ModuleFunction' );
644         eZDebugSetting::writeDebug( 'kernel-role-edit', $currentModule, 'currentModule' );
645         $policy = eZPolicy::createNew( $roleID, array( 'ModuleName'=> $currentModule,
646                                                        'FunctionName' => $currentFunction ) );
647     }
648     else
649     {
650         $db->commit();
651
652         $currentLimitationList = array();
653         foreach ( $currentFunctionLimitations as $currentFunctionLimitation )
654         {
655             $limitationName = $currentFunctionLimitation['name'];
656             $currentLimitationList[$limitationName] = '-1';
657         }
658         if ( isset( $policyID ) )
659         {
660             $limitationList = eZPolicyLimitation::fetchByPolicyID( $policyID );
661             foreach ( $limitationList as $limitation )
662             {
663                 $limitationID = $limitation->attribute( 'id' );
664                 $limitationIdentifier = $limitation->attribute( 'identifier' );
665                 $limitationValues = eZPolicyLimitationValue::fetchList( $limitationID );
666                 $valueList = array();
667                 foreach ( $limitationValues as $limitationValue )
668                 {
669                     $value = $limitationValue->attribute( 'value' );
670                     $valueList[] = $value;
671                 }
672                 $currentLimitationList[$limitationIdentifier] = $valueList;
673             }
674         }
675
676
677         $tpl->setVariable( 'current_function', $currentFunction );
678         $tpl->setVariable( 'function_limitations', $currentFunctionLimitations );
679         $tpl->setVariable( 'no_limitations', $noLimitations );
680
681         $tpl->setVariable( 'current_module', $currentModule );
682         $tpl->setVariable( 'functions', $functionNames );
683         $tpl->setVariable( 'node_list', $nodeList );
684         $tpl->setVariable( 'subtree_list', $subtreeList );
685         $tpl->setVariable( 'current_limitation_list', $currentLimitationList );
686
687         $Result = array();
688         $Result['path'] = array( array( 'url' => false ,
689                                         'text' => ezpI18n::translate( 'kernel/role',
690                                                           'Create new policy, step three: set function limitations' ) ) );
691
692         $Result['content'] = $tpl->fetch( 'design:role/createpolicystep3.tpl' );
693         return;
694     }
695     $db->commit();
696 }
697
698 if ( $http->hasPostVariable( 'DiscardLimitation' )  || $http->hasPostVariable( 'Step2')  )
699 {
700     $currentModule = $http->postVariable( 'CurrentModule' );
701     $mod = eZModule::exists( $currentModule );
702     $functions = $mod->attribute( 'available_functions' );
703     $functionNames = array_keys( $functions );
704
705     $showModules = false;
706     $showFunctions = true;
707     $tpl->setVariable( 'current_module', $currentModule );
708     $tpl->setVariable( 'functions', $functionNames );
709     $tpl->setVariable( 'no_functions', false );
710
711     $Result = array();
712     $Result['path'] = array( array( 'url' => false ,
713                                     'text' => ezpI18n::translate( 'kernel/role',
714                                                       'Create new policy, step two: select function' ) ) );
715
716     $Result['content'] = $tpl->fetch( 'design:role/createpolicystep2.tpl' );
717     return;
718 }
719
720 if ( $http->hasPostVariable( 'CreatePolicy' ) || $http->hasPostVariable( 'Step1' ) )
721 {
722     // Set flag for audit. If true audit will be processed
723     $http->setSessionVariable( 'RoleWasChanged', true );
724     $Module->setTitle( 'Edit ' . $role->attribute( 'name' ) );
725     $tpl->setVariable( 'modules', $modules );
726
727     $moduleList = array();
728     foreach( $modules as $module )
729     {
730         $moduleList[] = eZModule::exists( $module );
731     }
732     $tpl->setVariable( 'module_list', $moduleList );
733     $tpl->setVariable( 'role', $role );
734     $tpl->setVariable( 'module', $Module );
735
736     $Result = array();
737     $Result['path'] = array( array( 'url' => false ,
738                                     'text' => ezpI18n::translate( 'kernel/role',
739                                                       'Create new policy, step one: select module' ) ) );
740
741     $Result['content'] = $tpl->fetch( 'design:role/createpolicystep1.tpl' );
742     return;
743 }
744
745 // Set flag for audit. If true audit will be processed
746 // Cancel button was pressed
747 if ( $http->hasPostVariable( 'CancelPolicyButton' ) )
748     $http->setSessionVariable( 'RoleWasChanged', false );
749
750 $policies = $role->attribute( 'policies' );
751 $tpl->setVariable( 'no_functions', $noFunctions );
752 $tpl->setVariable( 'no_limitations', $noLimitations );
753
754 $tpl->setVariable( 'show_modules', $showModules );
755 $tpl->setVariable( 'show_limitations', $showLimitations );
756 $tpl->setVariable( 'show_functions', $showFunctions );
757
758 $tpl->setVariable( 'policies', $policies );
759 $tpl->setVariable( 'modules', $modules );
760 $tpl->setVariable( 'module', $Module );
761 $tpl->setVariable( 'role', $role );
762
763 $tpl->setVariable( 'step', 0 );
764
765 $Module->setTitle( 'Edit ' . $role->attribute( 'name' ) );
766
767 $Result = array();
768 $Result['path'] = array( array( 'text' => 'Role',
769                                 'url' => 'role/list' ),
770                          array( 'text' => $role->attribute( 'name' ),
771                                 'url' => false ) );
772
773 $Result['content'] = $tpl->fetch( 'design:role/edit.tpl' );
774
775 ?>