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