- Fixed reference bugs.
[tinyz:tinyz.git] / kernel / class / edit.php
1 <?php
2 //
3 // Created on: <16-Apr-2002 11:00:12 amos>
4 //
5 // Copyright (C) 1999-2005 eZ systems as. All rights reserved.
6 //
7 // This source file is part of the eZ publish (tm) Open Source Content
8 // Management System.
9 //
10 // This file may be distributed and/or modified under the terms of the
11 // "GNU General Public License" version 2 as published by the Free
12 // Software Foundation and appearing in the file LICENSE included in
13 // the packaging of this file.
14 //
15 // Licencees holding a valid "eZ publish professional licence" version 2
16 // may use this file in accordance with the "eZ publish professional licence"
17 // version 2 Agreement provided with the Software.
18 //
19 // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
20 // THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 // PURPOSE.
22 //
23 // The "eZ publish professional licence" version 2 is available at
24 // http://ez.no/ez_publish/licences/professional/ and in the file
25 // PROFESSIONAL_LICENCE included in the packaging of this file.
26 // For pricing of this licence please contact us via e-mail to licence@ez.no.
27 // Further contact information is available at http://ez.no/company/contact/.
28 //
29 // The "GNU General Public License" (GPL) is available at
30 // http://www.gnu.org/copyleft/gpl.html.
31 //
32 // Contact licence@ez.no if any conditions of this licencing isn't clear to
33 // you.
34 //
35
36 include_once( 'kernel/classes/ezcontentclass.php' );
37 include_once( 'kernel/classes/ezcontentclassattribute.php' );
38 include_once( 'kernel/classes/ezcontentclassclassgroup.php' );
39 include_once( 'lib/ezutils/classes/ezhttptool.php' );
40 include_once( 'lib/ezutils/classes/ezhttppersistence.php' );
41
42
43 $Module =& $Params['Module'];
44 $ClassID = null;
45 if ( isset( $Params['ClassID'] ) )
46     $ClassID = $Params['ClassID'];
47 $GroupID = null;
48 if ( isset( $Params['GroupID'] ) )
49     $GroupID = $Params['GroupID'];
50 $GroupName = null;
51 if ( isset( $Params['GroupName'] ) )
52     $GroupName = $Params['GroupName'];
53 $ClassVersion = null;
54
55 switch ( $Params['FunctionName'] )
56 {
57     case 'edit':
58     {
59     } break;
60     default:
61     {
62         eZDebug::writeError( 'Undefined function: ' . $params['Function'] );
63         $Module->setExitStatus( EZ_MODULE_STATUS_FAILED );
64         return;
65     };
66 }
67
68 $http =& eZHttpTool::instance();
69 if ( $http->hasPostVariable( 'CancelConflictButton' ) )
70 {
71     $Module->redirectToView( 'grouplist' );
72 }
73
74 if ( is_numeric( $ClassID ) )
75 {
76     $class = eZContentClass::fetch( $ClassID, true, EZ_CLASS_VERSION_STATUS_TEMPORARY );
77
78     // If temporary version does not exist fetch the current and add temperory class to corresponding group
79     if ( !is_object( $class ) or $class->attribute( 'id' ) == null )
80     {
81         $class = eZContentClass::fetch( $ClassID, true, EZ_CLASS_VERSION_STATUS_DEFINED );
82         if( is_null( $class ) ) // Class does not exist
83         {
84             return $Module->handleError( EZ_ERROR_KERNEL_NOT_AVAILABLE, 'kernel' );
85         }
86         $classGroups= eZContentClassClassGroup::fetchGroupList( $ClassID, EZ_CLASS_VERSION_STATUS_DEFINED );
87         foreach ( $classGroups as $classGroup )
88         {
89             $groupID = $classGroup->attribute( 'group_id' );
90             $groupName = $classGroup->attribute( 'group_name' );
91             $ingroup = eZContentClassClassGroup::create( $ClassID, EZ_CLASS_VERSION_STATUS_TEMPORARY, $groupID, $groupName );
92             $ingroup->store();
93         }
94     }
95     else
96     {
97         include_once( 'lib/ezlocale/classes/ezdatetime.php' );
98         $user =& eZUser::currentUser();
99         $contentIni =& eZIni::instance( 'content.ini' );
100         $timeOut = $contentIni->variable( 'ClassSettings', 'DraftTimeout' );
101
102         if ( $class->attribute( 'modifier_id' ) != $user->attribute( 'contentobject_id' ) &&
103              $class->attribute( 'modified' ) + $timeOut > time() )
104         {
105             include_once( 'kernel/common/template.php' );
106             $tpl =& templateInit();
107
108             $res =& eZTemplateDesignResource::instance();
109             $res->setKeys( array( array( 'class', $class->attribute( 'id' ) ) ) ); // Class ID
110             $tpl->setVariable( 'class', $class );
111             $tpl->setVariable( 'lock_timeout', $timeOut );
112
113             $Result = array();
114             $Result['content'] =& $tpl->fetch( 'design:class/edit_denied.tpl' );
115             $Result['path'] = array( array( 'url' => '/class/grouplist/',
116                                             'text' => ezi18n( 'kernel/class', 'Class list' ) ) );
117             return $Result;
118         }
119     }
120 }
121 else
122 {
123     include_once( 'kernel/classes/datatypes/ezuser/ezuser.php' );
124     $user =& eZUser::currentUser();
125     $user_id = $user->attribute( 'contentobject_id' );
126     $class = eZContentClass::create( $user_id );
127     $class->setAttribute( 'name', ezi18n( 'kernel/class/edit', 'New Class' ) );
128     $class->store();
129     $ClassID = $class->attribute( 'id' );
130     $ClassVersion = $class->attribute( 'version' );
131     $ingroup = eZContentClassClassGroup::create( $ClassID, $ClassVersion, $GroupID, $GroupName );
132     $ingroup->store();
133     $Module->redirectTo( $Module->functionURI( 'edit' ) . '/' . $ClassID );
134     return;
135 }
136
137
138 $contentClassHasInput = true;
139 if ( $http->hasPostVariable( 'ContentClassHasInput' ) )
140     $contentClassHasInput = $http->postVariable( 'ContentClassHasInput' );
141
142 // Find out the group where class is created or edited from.
143 if ( $http->hasSessionVariable( 'FromGroupID' ) )
144 {
145     $fromGroupID = $http->sessionVariable( 'FromGroupID' );
146 }
147 else
148 {
149     $fromGroupID = false;
150 }
151 $ClassID = $class->attribute( 'id' );
152 $ClassVersion = $class->attribute( 'version' );
153
154 $validation = array( 'processed' => false,
155                      'groups' => array(),
156                      'attributes' => array(),
157                      'class_errors' => array() );
158 $unvalidatedAttributes = array();
159
160 if ( $http->hasPostVariable( 'DiscardButton' ) )
161 {
162     eZSessionDestroy( $http->sessionVariable( 'CanStoreTicket' ) );
163     $http->removeSessionVariable( 'CanStoreTicket' );
164     $class->setVersion( EZ_CLASS_VERSION_STATUS_TEMPORARY );
165     $class->remove( true, EZ_CLASS_VERSION_STATUS_TEMPORARY );
166     eZContentClassClassGroup::removeClassMembers( $ClassID, EZ_CLASS_VERSION_STATUS_TEMPORARY );
167     if ( $fromGroupID === false )
168     {
169         $Module->redirectToView( 'grouplist' );
170     }
171     else
172     {
173         $Module->redirectTo( $Module->functionURI( 'classlist' ) . '/' . $fromGroupID . '/' );
174     }
175     return;
176 }
177 if ( $http->hasPostVariable( 'AddGroupButton' ) && $http->hasPostVariable( 'ContentClass_group' ) )
178 {
179     include_once( "kernel/class/ezclassfunctions.php" );
180     eZClassFunctions::addGroup( $ClassID, $ClassVersion, $http->postVariable( 'ContentClass_group' ) );
181 }
182 if ( $http->hasPostVariable( 'RemoveGroupButton' ) && $http->hasPostVariable( 'group_id_checked' ) )
183 {
184     include_once( "kernel/class/ezclassfunctions.php" );
185     if ( !eZClassFunctions::removeGroup( $ClassID, $ClassVersion, $http->postVariable( 'group_id_checked' ) ) )
186     {
187         $validation['groups'][] = array( 'text' => ezi18n( 'kernel/class', 'You have to have at least one group that the class belongs to!' ) );
188         $validation['processed'] = true;
189     }
190 }
191
192 // Fetch attributes and definitions
193 $attributes =& $class->fetchAttributes();
194
195 include_once( 'kernel/classes/ezdatatype.php' );
196 eZDataType::loadAndRegisterAllTypes();
197 $datatypes = eZDataType::registeredDataTypes();
198
199 $customAction = false;
200 $customActionAttributeID = null;
201 // Check for custom actions
202 if ( $http->hasPostVariable( 'CustomActionButton' ) )
203 {
204     $customActionArray = $http->postVariable( 'CustomActionButton' );
205     $customActionString = key( $customActionArray );
206
207     $customActionAttributeID = preg_match( "#^([0-9]+)_(.*)$#", $customActionString, $matchArray );
208
209     $customActionAttributeID = $matchArray[1];
210     $customAction = $matchArray[2];
211 }
212
213
214 // Validate input
215 $storeActions = array( 'MoveUp',
216                        'MoveDown',
217                        'StoreButton',
218                        'ApplyButton',
219                        'NewButton',
220                        'CustomActionButton');
221 $validationRequired = false;
222 foreach( $storeActions as $storeAction )
223 {
224     if ( $http->hasPostVariable( $storeAction ) )
225     {
226         $validationRequired = true;
227         break;
228     }
229 }
230
231 include_once( 'lib/ezutils/classes/ezinputvalidator.php' );
232 $canStore = true;
233 $requireFixup = false;
234 if ( $contentClassHasInput )
235 {
236     if ( $validationRequired )
237     {
238         foreach ( array_keys( $attributes ) as $key )
239         {
240             $attribute =& $attributes[$key];
241             $dataType = $attribute->dataType();
242             $status = $dataType->validateClassAttributeHTTPInput( $http, 'ContentClass', $attribute );
243             if ( $status == EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE )
244                 $requireFixup = true;
245             else if ( $status == EZ_INPUT_VALIDATOR_STATE_INVALID )
246             {
247                 $canStore = false;
248                 $attributeName = $dataType->attribute( 'information' );
249                 $attributeName = $attributeName['name'];
250                 $unvalidatedAttributes[] = array( 'id' => $attribute->attribute( 'id' ),
251                                                   'identifier' => $attribute->attribute( 'identifier' ) ? $attribute->attribute( 'identifier' ) : $attribute->attribute( 'name' ),
252                                                   'name' => $attributeName );
253             }
254         }
255         $validation['processed'] = true;
256         $validation['attributes'] = $unvalidatedAttributes;
257         $requireVariable = 'ContentAttribute_is_required_checked';
258         $searchableVariable = 'ContentAttribute_is_searchable_checked';
259         $informationCollectorVariable = 'ContentAttribute_is_information_collector_checked';
260         $canTranslateVariable = 'ContentAttribute_can_translate_checked';
261         $requireCheckedArray = array();
262         $searchableCheckedArray = array();
263         $informationCollectorCheckedArray = array();
264         $canTranslateCheckedArray = array();
265         if ( $http->hasPostVariable( $requireVariable ) )
266             $requireCheckedArray = $http->postVariable( $requireVariable );
267         if ( $http->hasPostVariable( $searchableVariable ) )
268             $searchableCheckedArray = $http->postVariable( $searchableVariable );
269         if ( $http->hasPostVariable( $informationCollectorVariable ) )
270             $informationCollectorCheckedArray = $http->postVariable( $informationCollectorVariable );
271         if ( $http->hasPostVariable( $canTranslateVariable ) )
272             $canTranslateCheckedArray = $http->postVariable( $canTranslateVariable );
273
274         foreach ( array_keys( $attributes ) as $key )
275         {
276             $attribute =& $attributes[$key];
277             $attributeID = $attribute->attribute( 'id' );
278             $attribute->setAttribute( 'is_required', in_array( $attributeID, $requireCheckedArray ) );
279             $attribute->setAttribute( 'is_searchable', in_array( $attributeID, $searchableCheckedArray ) );
280             $attribute->setAttribute( 'is_information_collector', in_array( $attributeID, $informationCollectorCheckedArray ) );
281             // Set can_translate to 0 if user has clicked Disable translation in GUI
282             $attribute->setAttribute( 'can_translate', !in_array( $attributeID, $canTranslateCheckedArray ) );
283         }
284     }
285 }
286
287 // Fixup input
288 if ( $requireFixup )
289 {
290     foreach( array_keys( $attributes ) as $key )
291     {
292         $attribute =& $attributes[$key];
293         $dataType = $attribute->dataType();
294         $status = $dataType->fixupClassAttributeHTTPInput( $http, 'ContentClass', $attribute );
295     }
296 }
297
298 $cur_datatype = 'ezstring';
299 // Apply HTTP POST variables
300 if ( $contentClassHasInput )
301 {
302     eZHTTPPersistence::fetch( 'ContentAttribute', eZContentClassAttribute::definition(),
303                               $attributes, $http, true );
304     eZHttpPersistence::fetch( 'ContentClass', eZContentClass::definition(),
305                               $class, $http, false );
306     if ( $http->hasVariable( 'ContentClass_is_container_exists' ) )
307     {
308         if ( $http->hasVariable( 'ContentClass_is_container_checked' ) )
309         {
310             $class->setAttribute( "is_container", 1 );
311         }
312         else
313         {
314             $class->setAttribute( "is_container", 0 );
315         }
316     }
317     if ( $http->hasPostVariable( 'DataTypeString' ) )
318         $cur_datatype = $http->postVariable( 'DataTypeString' );
319 }
320
321 $class->setAttribute( 'version', EZ_CLASS_VERSION_STATUS_TEMPORARY );
322
323 include_once( 'lib/ezi18n/classes/ezchartransform.php' );
324 $trans =& eZCharTransform::instance();
325
326 // Fixed identifiers to only contain a-z0-9_
327 foreach( array_keys( $attributes ) as $key )
328 {
329     $attribute =& $attributes[$key];
330     $attribute->setAttribute( 'version', EZ_CLASS_VERSION_STATUS_TEMPORARY );
331     $identifier = $attribute->attribute( 'identifier' );
332     if ( $identifier == '' )
333         $identifier = $attribute->attribute( 'name' );
334
335     $identifier = $trans->transformByGroup( $identifier, 'identifier' );
336
337     $attribute->setAttribute( 'identifier', $identifier );
338     $dataType = $attribute->dataType();
339     $dataType->initializeClassAttribute( $attribute );
340 }
341
342 // Fixed class identifier to only contain a-z0-9_
343 $identifier = $class->attribute( 'identifier' );
344 if ( $identifier == '' )
345     $identifier = $class->attribute( 'name' );
346 $identifier = $trans->transformByGroup( $identifier, 'identifier' );
347 $class->setAttribute( 'identifier', $identifier );
348
349 // Run custom actions if any
350 if ( $customAction )
351 {
352     foreach( array_keys( $attributes ) as $key )
353     {
354         $attribute =& $attributes[$key];
355         if ( $customActionAttributeID == $attribute->attribute( 'id' ) )
356         {
357             $attribute->customHTTPAction( $Module, $http, $customAction );
358         }
359     }
360 }
361 // Set new modification date
362 $date_time = time();
363 $class->setAttribute( 'modified', $date_time );
364 include_once( 'kernel/classes/datatypes/ezuser/ezuser.php' );
365 $user =& eZUser::currentUser();
366 $user_id = $user->attribute( 'contentobject_id' );
367 $class->setAttribute( 'modifier_id', $user_id );
368
369 // Remove attributes which are to be deleted
370 if ( $http->hasPostVariable( 'RemoveButton' ) )
371 {
372     $validation['processed'] = true;
373     if ( eZHttpPersistence::splitSelected( 'ContentAttribute', $attributes,
374                                            $http, 'id',
375                                            $keepers, $rejects ) )
376     {
377         $attributes = $keepers;
378         foreach ( $rejects as $reject )
379         {
380             $dataType = $reject->dataType();
381             if ( $dataType->isClassAttributeRemovable( $reject ) )
382             {
383                 $reject->remove();
384             }
385             else
386             {
387                 $removeInfo = $dataType->classAttributeRemovableInformation( $reject );
388                 if ( $removeInfo !== false )
389                 {
390                     $validation['attributes'] = array( array( 'id' => $reject->attribute( 'id' ),
391                                                               'identifier' => $reject->attribute( 'identifier' ),
392                                                               'reason' => $removeInfo ) );
393                 }
394             }
395         }
396     }
397 }
398
399 // Fetch HTTP input
400 if ( $contentClassHasInput )
401 {
402     foreach( array_keys( $attributes ) as $key )
403     {
404         $attribute =& $attributes[$key];
405         $dataType = $attribute->dataType();
406         $dataType->fetchClassAttributeHTTPInput( $http, 'ContentClass', $attribute );
407     }
408 }
409
410 if ( $validationRequired )
411 {
412     // check for duplicate attribute identifiers in the input
413     if ( count( $attributes ) > 1 )
414     {
415         for( $attrIndex = 0; $attrIndex < count( $attributes ) - 1; $attrIndex++ )
416         {
417             $classAttribute = $attributes[$attrIndex];
418             $identifier = $classAttribute->attribute( 'identifier' );
419             for ( $attrIndex2 = $attrIndex + 1; $attrIndex2 < count( $attributes ); $attrIndex2++ )
420             {
421                 $classAttribute2 = $attributes[$attrIndex2];
422                 $identifier2 = $classAttribute2->attribute( 'identifier' );
423                 if ( $identifier == $identifier2 )
424                 {
425                     $validation['attributes'][] = array( 'identifier' => $identifier,
426                                                          'name' => $classAttribute->attribute( 'name' ),
427                                                          'id' => $classAttribute->attribute( 'id' ),
428                                                          'reason' => array ( 'text' => 'duplicate attribute identifier' ) );
429                     $canStore = false;
430                     break;
431                 }
432             }
433         }
434     }
435 }
436
437 // Store version 0 and discard version 1
438 if ( $http->hasPostVariable( 'StoreButton' ) && $canStore )
439 {
440
441     $id = $class->attribute( 'id' );
442     $oldClassAttributes = $class->fetchAttributes( $id, true, EZ_CLASS_VERSION_STATUS_DEFINED );
443     $newClassAttributes = $class->fetchAttributes( );
444
445     // validate class name and identifier; check presence of class attributes
446     // FIXME: object pattern name is never validated
447
448     $basicClassPropertiesValid = true;
449     {
450         $className       =& $class->attribute( 'name' );
451         $classIdentifier =& $class->attribute( 'identifier' );
452         $classID         =& $class->attribute( 'id' );
453
454         // validate class name
455         if( trim( $className ) == '' )
456         {
457             $validation['class_errors'][] = array( 'text' => ezi18n( 'kernel/class', 'The class should have nonempty \'Name\' attribute.' ) );
458             $basicClassPropertiesValid = false;
459         }
460
461         // check presence of attributes
462         $newClassAttributes = $class->fetchAttributes( );
463         if ( count( $newClassAttributes ) == 0 )
464         {
465             $validation['class_errors'][] = array( 'text' => ezi18n( 'kernel/class', 'The class should have at least one attribute.' ) );
466             $basicClassPropertiesValid = false;
467         }
468
469         // validate class identifier
470
471         $db =& eZDB::instance();
472         $classCount = $db->arrayQuery( "SELECT COUNT(*) AS count FROM ezcontentclass WHERE  identifier='$classIdentifier' AND version=" . EZ_CLASS_VERSION_STATUS_DEFINED . " AND id <> $classID" );
473         if ( $classCount[0]['count'] > 0 )
474         {
475             $validation['class_errors'][] = array( 'text' => ezi18n( 'kernel/class', 'There is a class already having the same identifier.' ) );
476             $basicClassPropertiesValid = false;
477         }
478         unset( $classList );
479         unset( $db );
480     }
481
482     if ( !$basicClassPropertiesValid )
483     {
484         $canStore = false;
485         $validation['processed'] = false;
486     }
487     else
488     {
489         $firstStoreAttempt =& eZSessionRead( $http->sessionVariable( 'CanStoreTicket' ) );
490         if ( !$firstStoreAttempt )
491         {
492             return $Module->redirectToView( 'view', array( $ClassID ) );
493         }
494         eZSessionDestroy( $http->sessionVariable( 'CanStoreTicket' ) );
495
496         // Class cleanup, update existing class objects according to new changes
497         include_once( 'kernel/classes/ezcontentobject.php' );
498
499         $objects = null;
500         $objectCount = eZContentObject::fetchSameClassListCount( $ClassID );
501         if ( $objectCount > 0 )
502         {
503             // Delete object attributes which have been removed.
504             foreach ( $oldClassAttributes as $oldClassAttribute )
505             {
506                 $attributeExist = false;
507                 $oldClassAttributeID = $oldClassAttribute->attribute( 'id' );
508                 foreach ( $newClassAttributes as $newClassAttribute )
509                 {
510                     $newClassAttributeID = $newClassAttribute->attribute( 'id' );
511                     if ( $oldClassAttributeID == $newClassAttributeID )
512                         $attributeExist = true;
513                 }
514                 if ( !$attributeExist )
515                 {
516                     $objectAttributes = eZContentObjectAttribute::fetchSameClassAttributeIDList( $oldClassAttributeID );
517                     foreach ( $objectAttributes as $objectAttribute )
518                     {
519                         $objectAttributeID = $objectAttribute->attribute( 'id' );
520                         $objectAttribute->remove( $objectAttributeID );
521                     }
522                 }
523             }
524             $class->storeDefined( $attributes );
525
526             // Add object attributes which have been added.
527             foreach ( $newClassAttributes as $newClassAttribute )
528             {
529                 $attributeExist = false;
530                 $newClassAttributeID = $newClassAttribute->attribute( 'id' );
531                 foreach ( $oldClassAttributes as $oldClassAttribute )
532                 {
533                     $oldClassAttributeID = $oldClassAttribute->attribute( 'id' );
534                     if ( $oldClassAttributeID == $newClassAttributeID )
535                         $attributeExist = true;
536                 }
537                 if ( !$attributeExist )
538                 {
539                     if ( $objects == null )
540                     {
541                         $objects = eZContentObject::fetchSameClassList( $ClassID );
542                     }
543                     foreach ( $objects as $object )
544                     {
545                         $contentobjectID = $object->attribute( 'id' );
546                         $objectVersions =& $object->versions();
547                         foreach ( $objectVersions as $objectVersion )
548                         {
549                             $translations = $objectVersion->translations( false );
550                             $version = $objectVersion->attribute( 'version' );
551                             foreach ( $translations as $translation )
552                             {
553                                 $objectAttribute = eZContentObjectAttribute::create( $newClassAttributeID, $contentobjectID, $version );
554                                 $objectAttribute->setAttribute( 'language_code', $translation );
555                                 $objectAttribute->initialize();
556                                 $objectAttribute->store();
557                                 $objectAttribute->postInitialize();
558                             }
559                         }
560                     }
561                 }
562             }
563         }
564         else
565         {
566             $class->storeDefined( $attributes );
567         }
568
569         $http->removeSessionVariable( 'CanStoreTicket' );
570         return $Module->redirectToView( 'view', array( $ClassID ) );
571     }
572 }
573
574 // Store changes
575 if ( $canStore )
576     $class->store( $attributes );
577
578 if ( $http->hasPostVariable( 'NewButton' ) )
579 {
580     $new_attribute = eZContentClassAttribute::create( $ClassID, $cur_datatype );
581     $attrcnt = count( $attributes ) + 1;
582     $new_attribute->setAttribute( 'name', ezi18n( 'kernel/class/edit', 'new attribute' ) . $attrcnt );
583     $dataType = $new_attribute->dataType();
584     $dataType->initializeClassAttribute( $new_attribute );
585     $new_attribute->store();
586     $attributes[] =& $new_attribute;
587 }
588 else if ( $http->hasPostVariable( 'MoveUp' ) )
589 {
590     $attribute =& eZContentClassAttribute::fetch( $http->postVariable( 'MoveUp' ), true, EZ_CLASS_VERSION_STATUS_TEMPORARY,
591                                                   array( 'contentclass_id', 'version', 'placement' ) );
592     $attribute->move( false );
593     $Module->redirectTo( $Module->functionURI( 'edit' ) . '/' . $ClassID );
594     return;
595 }
596 else if ( $http->hasPostVariable( 'MoveDown' ) )
597 {
598     $attribute =& eZContentClassAttribute::fetch( $http->postVariable( 'MoveDown' ), true, EZ_CLASS_VERSION_STATUS_TEMPORARY,
599                                                   array( 'contentclass_id', 'version', 'placement' ) );
600     $attribute->move( true );
601     $Module->redirectTo( $Module->functionURI( 'edit' ) . '/' . $ClassID );
602     return;
603 }
604
605 $Module->setTitle( 'Edit class ' . $class->attribute( 'name' ) );
606 if ( !$http->hasSessionVariable( 'CanStoreTicket' ) )
607 {
608     $http->setSessionVariable( 'CanStoreTicket', md5( (string)rand() ) );
609     eZSessionWrite( $http->sessionVariable( 'CanStoreTicket' ), 1 );
610 }
611
612 // Fetch updated attributes
613 $attributes = $class->fetchAttributes();
614
615 // Template handling
616 include_once( 'kernel/common/template.php' );
617 $tpl =& templateInit();
618 $res =& eZTemplateDesignResource::instance();
619 $res->setKeys( array( array( 'class', $class->attribute( 'id' ) ) ) ); // Class ID
620 $tpl->setVariable( 'http', $http );
621 $tpl->setVariable( 'validation', $validation );
622 $tpl->setVariable( 'can_store', $canStore );
623 $tpl->setVariable( 'require_fixup', $requireFixup );
624 $tpl->setVariable( 'module', $Module );
625 $tpl->setVariable( 'class', $class );
626 $tpl->setVariable( 'attributes', $attributes );
627 $tpl->setVariable( 'datatypes', $datatypes );
628 $tpl->setVariable( 'datatype', $cur_datatype );
629
630 $Result = array();
631 $Result['content'] =& $tpl->fetch( 'design:class/edit.tpl' );
632 $Result['path'] = array( array( 'url' => '/class/edit/',
633                                 'text' => ezi18n( 'kernel/class', 'Class edit' ) ) );
634
635 ?>