eZ publish: ezmediatype.php Source File

00001 <?php
00002 //
00003 // Definition of eZMediaType class
00004 //
00005 // Created on: <30-Apr-2002 13:06:21 bf>
00006 //
00007 // ## BEGIN COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
00008 // SOFTWARE NAME: eZ publish
00009 // SOFTWARE RELEASE: 3.9.x
00010 // COPYRIGHT NOTICE: Copyright (C) 1999-2006 eZ systems AS
00011 // SOFTWARE LICENSE: GNU General Public License v2.0
00012 // NOTICE: >
00013 //   This program is free software; you can redistribute it and/or
00014 //   modify it under the terms of version 2.0  of the GNU General
00015 //   Public License as published by the Free Software Foundation.
00016 //
00017 //   This program is distributed in the hope that it will be useful,
00018 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 //   GNU General Public License for more details.
00021 //
00022 //   You should have received a copy of version 2.0 of the GNU General
00023 //   Public License along with this program; if not, write to the Free
00024 //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
00025 //   MA 02110-1301, USA.
00026 //
00027 //
00028 // ## END COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
00029 //
00030 
00031 /*!
00032   \class eZMediaType ezmediatype.php
00033   \ingroup eZDatatype
00034   \brief The class eZMediaType handles storage and playback of media files.
00035 
00036 */
00037 
00038 include_once( "kernel/classes/ezdatatype.php" );
00039 include_once( "kernel/classes/datatypes/ezmedia/ezmedia.php" );
00040 include_once( "lib/ezfile/classes/ezfile.php" );
00041 include_once( "lib/ezutils/classes/ezmimetype.php" );
00042 include_once( "lib/ezutils/classes/ezhttpfile.php" );
00043 include_once( "lib/ezfile/classes/ezdir.php" );
00044 
00045 define( "EZ_DATATYPESTRING_MEDIA", "ezmedia" );
00046 define( 'EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_FIELD', 'data_int1' );
00047 define( 'EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_VARIABLE', '_ezmedia_max_filesize_' );
00048 define( "EZ_DATATYPESTRING_TYPE_FIELD", "data_text1" );
00049 define( "EZ_DATATYPESTRING_TYPE_VARIABLE", "_ezmedia_type_" );
00050 
00051 class eZMediaType extends eZDataType
00052 {
00053     function eZMediaType()
00054     {
00055         $this->eZDataType( EZ_DATATYPESTRING_MEDIA, ezi18n( 'kernel/classes/datatypes', "Media", 'Datatype name' ),
00056                            array( 'serialize_supported' => true ) );
00057     }
00058 
00059     /*!
00060      Sets value according to current version
00061     */
00062     function postInitializeObjectAttribute( &$contentObjectAttribute, $currentVersion, &$originalContentObjectAttribute )
00063     {
00064         if ( $currentVersion != false )
00065         {
00066             $contentObjectAttributeID = $originalContentObjectAttribute->attribute( "id" );
00067             $version = $contentObjectAttribute->attribute( "version" );
00068             $oldfile = eZMedia::fetch( $contentObjectAttributeID, $currentVersion );
00069             if( $oldfile != null )
00070             {
00071                 $oldfile->setAttribute( 'contentobject_attribute_id', $contentObjectAttribute->attribute( 'id' ) );
00072                 $oldfile->setAttribute( "version",  $version );
00073                 $oldfile->store();
00074             }
00075         }
00076         else
00077         {
00078             $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
00079             $version = $contentObjectAttribute->attribute( 'version' );
00080 
00081             $media = eZMedia::create( $contentObjectAttributeID, $version );
00082 
00083             $contentClassAttribute =& $contentObjectAttribute->contentClassAttribute();
00084             $pluginPage = eZMediaType::pluginPage( $contentClassAttribute->attribute( 'data_text1' ) );
00085 
00086             $media->setAttribute( 'quality', 'high' );
00087             $media->setAttribute( 'pluginspage', $pluginPage );
00088             $media->store();
00089         }
00090     }
00091 
00092     /*!
00093      Delete stored attribute
00094     */
00095     function deleteStoredObjectAttribute( &$contentObjectAttribute, $version = null )
00096     {
00097         $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
00098         $mediaFiles = eZMedia::fetch( $contentObjectAttributeID, null );
00099         $sys =& eZSys::instance();
00100         $storage_dir = $sys->storageDirectory();
00101         if ( $version == null )
00102         {
00103             foreach ( $mediaFiles as $mediaFile )
00104             {
00105                 $mimeType =  $mediaFile->attribute( "mime_type" );
00106                 list( $prefix, $suffix ) = split ('[/]', $mimeType );
00107 //                $orig_dir = "var/storage/original/" . $prefix;
00108                 $orig_dir = $storage_dir . '/original/' . $prefix;
00109                 $fileName = $mediaFile->attribute( "filename" );
00110 
00111                 if ( $fileName == '' )
00112                     continue;
00113 
00114                 // VS-DBFILE
00115 
00116                 require_once( 'kernel/classes/ezclusterfilehandler.php' );
00117                 $file = eZClusterFileHandler::instance( $orig_dir . "/" . $fileName );
00118                 if ( $file->exists() )
00119                     $file->delete();
00120             }
00121         }
00122         else
00123         {
00124             $count = 0;
00125             $currentBinaryFile = eZMedia::fetch( $contentObjectAttributeID, $version );
00126             if ( $currentBinaryFile != null )
00127             {
00128                 $mimeType =  $currentBinaryFile->attribute( "mime_type" );
00129                 $currentFileName = $currentBinaryFile->attribute( "filename" );
00130                 list( $prefix, $suffix ) = is_string( $mimeType ) && $mimeType ? split ( '[/]', $mimeType ) : array( null, null );
00131 //              $orig_dir = "var/storage/original/" . $prefix;
00132                 $orig_dir = $storage_dir . '/original/' . $prefix;
00133                 foreach ( $mediaFiles as $mediaFile )
00134                 {
00135                     $fileName = $mediaFile->attribute( "filename" );
00136                     if( $currentFileName == $fileName )
00137                         $count += 1;
00138                 }
00139                 if ( $count == 1 && $currentFileName != '' )
00140                 {
00141                     // VS-DBFILE
00142 
00143                     require_once( 'kernel/classes/ezclusterfilehandler.php' );
00144                     $file = eZClusterFileHandler::instance( $orig_dir . "/" . $currentFileName );
00145                     if ( $file->exists() )
00146                         $file->delete();
00147                 }
00148             }
00149         }
00150         eZMedia::remove( $contentObjectAttributeID, $version );
00151     }
00152 
00153     /*!
00154      Validates the input and returns true if the input was
00155      valid for this datatype.
00156     */
00157     function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
00158     {
00159         $classAttribute =& $contentObjectAttribute->contentClassAttribute();
00160         $httpFileName = $base . "_data_mediafilename_" . $contentObjectAttribute->attribute( "id" );
00161         $maxSize = 1024 * 1024 * $classAttribute->attribute( EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_FIELD );
00162         $mustUpload = false;
00163 
00164         if ( $contentObjectAttribute->validateIsRequired() )
00165         {
00166             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
00167             $version = $contentObjectAttribute->attribute( "version" );
00168             $media = eZMedia::fetch( $contentObjectAttributeID, $version );
00169             if ( $media === null || !$media->attribute( 'filename' ) )
00170             {
00171                 $mustUpload = true;
00172             }
00173         }
00174 
00175         $canFetchResult = eZHTTPFile::canFetch( $httpFileName, $maxSize );
00176         if ( $mustUpload && $canFetchResult == EZ_UPLOADEDFILE_DOES_NOT_EXIST )
00177         {
00178             $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
00179                 'A valid media file is required.' ) );
00180             return EZ_INPUT_VALIDATOR_STATE_INVALID;
00181         }
00182         if ( $canFetchResult == EZ_UPLOADEDFILE_EXCEEDS_PHP_LIMIT )
00183         {
00184             $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
00185                 'The size of the uploaded file exceeds the limit set by upload_max_filesize directive in php.ini. Please contact the site administrator.') );
00186             return EZ_INPUT_VALIDATOR_STATE_INVALID;
00187         }
00188         if ( $canFetchResult == EZ_UPLOADEDFILE_EXCEEDS_MAX_SIZE )
00189         {
00190             $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
00191                 'The size of the uploaded file exceeds site maximum: %1 bytes.' ), $maxSize );
00192             return EZ_INPUT_VALIDATOR_STATE_INVALID;
00193         }
00194         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
00195     }
00196 
00197     /*!
00198      Checks if file uploads are enabled, if not it gives a warning.
00199     */
00200     function checkFileUploads()
00201     {
00202         $isFileUploadsEnabled = ini_get( 'file_uploads' ) != 0;
00203         if ( !$isFileUploadsEnabled )
00204         {
00205             $isFileWarningAdded =& $GLOBALS['eZMediaTypeWarningAdded'];
00206             if ( !isset( $isFileWarningAdded ) or
00207                  !$isFileWarningAdded )
00208             {
00209                 eZAppendWarningItem( array( 'error' => array( 'type' => 'kernel',
00210                                                               'number' => EZ_ERROR_KERNEL_NOT_AVAILABLE ),
00211                                             'text' => ezi18n( 'kernel/classes/datatypes',
00212                                                               'File uploading is not enabled. Please contact the site administrator to enable it.' ) ) );
00213                 $isFileWarningAdded = true;
00214             }
00215         }
00216     }
00217 
00218     /*!
00219      \static
00220      Returns plugin page by media type
00221 
00222     */
00223     function pluginPage( $mediaType )
00224     {
00225         $pluginPage = '';
00226         switch( $mediaType )
00227         {
00228             case 'flash':
00229                 $pluginPage = "http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash";
00230             break;
00231             case 'quick_time':
00232                 $pluginPage = "http://quicktime.apple.com";
00233             break;
00234             case 'real_player' :
00235                 $pluginPage = "http://www.real.com/";
00236             break;
00237             case 'windows_media_player' :
00238                 $pluginPage = "http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,7,1112" ;
00239             break;
00240             default:
00241                 $pluginPage = "";
00242             break;
00243         }
00244 
00245         return $pluginPage;
00246     }
00247 
00248     /*!
00249      Fetches input and stores it in the data instance.
00250     */
00251     function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
00252     {
00253         eZMediaType::checkFileUploads();
00254 
00255         $classAttribute =& $contentObjectAttribute->contentClassAttribute();
00256         $player = $classAttribute->attribute( "data_text1" );
00257         $pluginPage = eZMediaType::pluginPage( $player );
00258 
00259         $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
00260         $version = $contentObjectAttribute->attribute( "version" );
00261         $width = $http->postVariable( $base . "_data_media_width_" . $contentObjectAttribute->attribute( "id" ) );
00262         $height = $http->postVariable( $base . "_data_media_height_" . $contentObjectAttribute->attribute( "id" ) );
00263         $quality = $http->hasPostVariable( $base . "_data_media_quality_" . $contentObjectAttribute->attribute( "id" ) ) ? $http->postVariable( $base . "_data_media_quality_" . $contentObjectAttribute->attribute( "id" ) ) : null;
00264         if ( $http->hasPostVariable( $base . "_data_media_controls_" . $contentObjectAttribute->attribute( "id" ) ) )
00265             $controls = $http->postVariable( $base . "_data_media_controls_" . $contentObjectAttribute->attribute( "id" ) );
00266         else
00267             $controls = null;
00268 
00269         $media = eZMedia::fetch( $contentObjectAttributeID, $version );
00270         if ( $media == null )
00271         {
00272            $media = eZMedia::create( $contentObjectAttributeID, $version );
00273         }
00274 
00275         $media->setAttribute( "contentobject_attribute_id", $contentObjectAttributeID );
00276         $media->setAttribute( "version", $version );
00277         $media->setAttribute( "width", $width );
00278         $media->setAttribute( "height", $height );
00279         $media->setAttribute( "quality", $quality );
00280         $media->setAttribute( "controls", $controls );
00281         $media->setAttribute( "pluginspage", $pluginPage );
00282         if ( $http->hasPostVariable( $base . "_data_media_is_autoplay_" . $contentObjectAttribute->attribute( "id" ) ) )
00283             $media->setAttribute( "is_autoplay", true );
00284         else
00285             $media->setAttribute( "is_autoplay", false );
00286         if ( $http->hasPostVariable( $base . "_data_media_has_controller_" . $contentObjectAttribute->attribute( "id" ) ) )
00287             $media->setAttribute( "has_controller", true );
00288         else
00289             $media->setAttribute( "has_controller", false );
00290         if ( $http->hasPostVariable( $base . "_data_media_is_loop_" . $contentObjectAttribute->attribute( "id" ) ) )
00291             $media->setAttribute( "is_loop", true );
00292         else
00293             $media->setAttribute( "is_loop", false );
00294 
00295         $mediaFilePostVarName = $base . "_data_mediafilename_" . $contentObjectAttribute->attribute( "id" );
00296         if ( eZHTTPFile::canFetch( $mediaFilePostVarName ) )
00297             $mediaFile =& eZHTTPFile::fetch( $mediaFilePostVarName );
00298         else
00299             $mediaFile = null;
00300         if ( get_class( $mediaFile ) == "ezhttpfile" )
00301         {
00302             $mimeData = eZMimeType::findByFileContents( $mediaFile->attribute( "original_filename" ) );
00303             $mime = $mimeData['name'];
00304 
00305             if ( $mime == '' )
00306             {
00307                 $mime = $mediaFile->attribute( "mime_type" );
00308             }
00309             $extension = eZFile::suffix( $mediaFile->attribute( "original_filename" ) );
00310             $mediaFile->setMimeType( $mime );
00311             if ( !$mediaFile->store( "original", $extension ) )
00312             {
00313                 eZDebug::writeError( "Failed to store http-file: " . $mediaFile->attribute( "original_filename" ),
00314                                      "eZMediaType" );
00315                 return false;
00316             }
00317 
00318             $orig_dir = $mediaFile->storageDir( "original" );
00319             eZDebug::writeNotice( "dir=$orig_dir" );
00320             $media->setAttribute( "filename", basename( $mediaFile->attribute( "filename" ) ) );
00321             $media->setAttribute( "original_filename", $mediaFile->attribute( "original_filename" ) );
00322             $media->setAttribute( "mime_type", $mime );
00323 
00324             // VS-DBFILE
00325 
00326             require_once( 'kernel/classes/ezclusterfilehandler.php' );
00327             //$filePath = $media->attribute( 'original_filename' );
00328             $filePath = $mediaFile->attribute( 'filename' );
00329             $fileHandler = eZClusterFileHandler::instance();
00330             $fileHandler->fileStore( $filePath, 'media', true, $mime );
00331         }
00332 
00333         $media->store();
00334         $contentObjectAttribute->setContent( $media );
00335         return true;
00336     }
00337 
00338     function storeObjectAttribute( &$contentObjectAttribute )
00339     {
00340     }
00341 
00342     function customObjectAttributeHTTPAction( $http, $action, &$contentObjectAttribute )
00343     {
00344         if ( $action == "delete_media" )
00345         {
00346             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
00347             $version = $contentObjectAttribute->attribute( "version" );
00348             $this->deleteStoredObjectAttribute( $contentObjectAttribute, $version );
00349             $media = eZMedia::create( $contentObjectAttributeID, $version );
00350             $contentObjectAttribute->setContent( $media );
00351         }
00352     }
00353 
00354     /*!
00355      \reimp
00356      HTTP file insertion is supported.
00357     */
00358     function isHTTPFileInsertionSupported()
00359     {
00360         return true;
00361     }
00362 
00363     /*!
00364      \reimp
00365      Regular file insertion is supported.
00366     */
00367     function isRegularFileInsertionSupported()
00368     {
00369         return true;
00370     }
00371 
00372     /*!
00373      \reimp
00374      Inserts the file using the eZMedia class.
00375     */
00376     function insertHTTPFile( &$object, $objectVersion, $objectLanguage,
00377                              &$objectAttribute, &$httpFile, $mimeData,
00378                              &$result )
00379     {
00380         $result = array( 'errors' => array(),
00381                          'require_storage' => false );
00382         $errors =& $result['errors'];
00383         $attributeID = $objectAttribute->attribute( 'id' );
00384 
00385         $media = eZMedia::fetch( $attributeID, $objectVersion );
00386         if ( $media === null )
00387             $media = eZMedia::create( $attributeID, $objectVersion );
00388 
00389         $httpFile->setMimeType( $mimeData['name'] );
00390         if ( !$httpFile->store( "original", false, false ) )
00391         {
00392             $errors[] = array( 'description' => ezi18n( 'kernel/classes/datatypes/ezmedia',
00393                                                         'Failed to store media file %filename. Please contact the site administrator.', null,
00394                                                         array( '%filename' => $httpFile->attribute( "original_filename" ) ) ) );
00395             return false;
00396         }
00397 
00398         $classAttribute =& $objectAttribute->contentClassAttribute();
00399         $player = $classAttribute->attribute( "data_text1" );
00400         $pluginPage = eZMediaType::pluginPage( $player );
00401 
00402         $media->setAttribute( "contentobject_attribute_id", $attributeID );
00403         $media->setAttribute( "version", $objectVersion );
00404         $media->setAttribute( "filename", basename( $httpFile->attribute( "filename" ) ) );
00405         $media->setAttribute( "original_filename", $httpFile->attribute( "original_filename" ) );
00406         $media->setAttribute( "mime_type", $mimeData['name'] );
00407 
00408         // Setting width and height to zero means that the browser/player must find the size itself.
00409         // In the future we will probably analyze the media file and find this information
00410         $width = $height = 0;
00411         // Quality is not known, so we don't set any
00412         $quality = false;
00413         // Not sure what this is for, set to false
00414         $controls = false;
00415         // We want to show controllers by default
00416         $hasController = true;
00417         // Don't play automatically
00418         $isAutoplay = false;
00419         // Don't loop movie
00420         $isLoop = false;
00421 
00422         $media->setAttribute( "width", $width );
00423         $media->setAttribute( "height", $height );
00424         $media->setAttribute( "quality", $quality );
00425         $media->setAttribute( "controls", $controls );
00426         $media->setAttribute( "pluginspage", $pluginPage );
00427         $media->setAttribute( "is_autoplay", $isAutoplay );
00428         $media->setAttribute( "has_controller", $hasController );
00429         $media->setAttribute( "is_loop", $isLoop );
00430 
00431         // SP-DBFILE
00432 
00433         require_once( 'kernel/classes/ezclusterfilehandler.php' );
00434         $filePath = $httpFile->attribute( 'filename' );
00435         $fileHandler = eZClusterFileHandler::instance();
00436         $fileHandler->fileStore( $filePath, 'mediafile', true, $mimeData['name'] );
00437 
00438 
00439         $media->store();
00440 
00441         $objectAttribute->setContent( $media );
00442         return true;
00443     }
00444 
00445     /*!
00446      \reimp
00447      Inserts the file using the eZMedia class.
00448     */
00449     function insertRegularFile( &$object, $objectVersion, $objectLanguage,
00450                                 &$objectAttribute, $filePath,
00451                                 &$result )
00452     {
00453         $result = array( 'errors' => array(),
00454                          'require_storage' => false );
00455         $errors =& $result['errors'];
00456         $attributeID = $objectAttribute->attribute( 'id' );
00457 
00458         $media = eZMedia::fetch( $attributeID, $objectVersion );
00459         if ( $media === null )
00460             $media = eZMedia::create( $attributeID, $objectVersion );
00461 
00462         $fileName = basename( $filePath );
00463         $mimeData = eZMimeType::findByFileContents( $filePath );
00464         $storageDir = eZSys::storageDirectory();
00465         list( $group, $type ) = explode( '/', $mimeData['name'] );
00466         $destination = $storageDir . '/original/' . $group;
00467 
00468         if ( !file_exists( $destination ) )
00469         {
00470             if ( !eZDir::mkdir( $destination, eZDir::directoryPermission(), true ) )
00471             {
00472                 return false;
00473             }
00474         }
00475 
00476         // create dest filename in the same manner as eZHTTPFile::store()
00477         // grab file's suffix
00478         $fileSuffix = eZFile::suffix( $fileName );
00479         // prepend dot
00480         if( $fileSuffix )
00481             $fileSuffix = '.' . $fileSuffix;
00482         // grab filename without suffix
00483         $fileBaseName = basename( $fileName, $fileSuffix );
00484         // create dest filename
00485         $destFileName = md5( $fileBaseName . microtime() . mt_rand() ) . $fileSuffix;
00486         $destination = $destination . '/' . $destFileName;
00487 
00488         copy( $filePath, $destination );
00489 
00490         // SP-DBFILE
00491         require_once( 'kernel/classes/ezclusterfilehandler.php' );
00492         $fileHandler = eZClusterFileHandler::instance();
00493         $fileHandler->fileStore( $destination, 'mediafile', true, $mimeData['name'] );
00494 
00495         $classAttribute =& $objectAttribute->contentClassAttribute();
00496         $player = $classAttribute->attribute( "data_text1" );
00497         $pluginPage = eZMediaType::pluginPage( $player );
00498 
00499         $media->setAttribute( "contentobject_attribute_id", $attributeID );
00500         $media->setAttribute( "version", $objectVersion );
00501         $media->setAttribute( "filename", $destFileName );
00502         $media->setAttribute( "original_filename", $fileName );
00503         $media->setAttribute( "mime_type", $mimeData['name'] );
00504 
00505         // Setting width and height to zero means that the browser/player must find the size itself.
00506         // In the future we will probably analyze the media file and find this information
00507         $width = $height = 0;
00508         // Quality is not known, so we don't set any
00509         $quality = false;
00510         // Not sure what this is for, set to false
00511         $controls = false;
00512         // We want to show controllers by default
00513         $hasController = true;
00514         // Don't play automatically
00515         $isAutoplay = false;
00516         // Don't loop movie
00517         $isLoop = false;
00518 
00519         $media->setAttribute( "width", $width );
00520         $media->setAttribute( "height", $height );
00521         $media->setAttribute( "quality", $quality );
00522         $media->setAttribute( "controls", $controls );
00523         $media->setAttribute( "pluginspage", $pluginPage );
00524         $media->setAttribute( "is_autoplay", $isAutoplay );
00525         $media->setAttribute( "has_controller", $hasController );
00526         $media->setAttribute( "is_loop", $isLoop );
00527 
00528         $media->store();
00529 
00530         $objectAttribute->setContent( $media );
00531         return true;
00532     }
00533 
00534     /*!
00535       \reimp
00536       We support file information
00537     */
00538     function hasStoredFileInformation( &$object, $objectVersion, $objectLanguage,
00539                                        &$objectAttribute )
00540     {
00541         return true;
00542     }
00543 
00544     /*!
00545       \reimp
00546       Extracts file information for the media entry.
00547     */
00548     function storedFileInformation( &$object, $objectVersion, $objectLanguage,
00549                                     &$objectAttribute )
00550     {
00551         $mediaFile = eZMedia::fetch( $objectAttribute->attribute( "id" ),
00552                                       $objectAttribute->attribute( "version" ) );
00553         if ( $mediaFile )
00554         {
00555             return $mediaFile->storedFileInfo();
00556         }
00557         return false;
00558     }
00559 
00560     function storeClassAttribute( &$attribute, $version )
00561     {
00562     }
00563 
00564     function storeDefinedClassAttribute( &$attribute )
00565     {
00566     }
00567 
00568     /*!
00569      \reimp
00570     */
00571     function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
00572     {
00573         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
00574     }
00575 
00576     /*!
00577      \reimp
00578     */
00579     function fixupClassAttributeHTTPInput( &$http, $base, &$classAttribute )
00580     {
00581     }
00582 
00583     /*!
00584      \reimp
00585     */
00586     function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
00587     {
00588         $filesizeName = $base . EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_VARIABLE . $classAttribute->attribute( 'id' );
00589         $typeName = $base . EZ_DATATYPESTRING_TYPE_VARIABLE . $classAttribute->attribute( 'id' );
00590         if ( $http->hasPostVariable( $filesizeName ) )
00591         {
00592             $filesizeValue = $http->postVariable( $filesizeName );
00593             $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_FIELD, $filesizeValue );
00594         }
00595         if ( $http->hasPostVariable( $typeName ) )
00596         {
00597             $typeValue = $http->postVariable( $typeName );
00598             $classAttribute->setAttribute( EZ_DATATYPESTRING_TYPE_FIELD, $typeValue );
00599         }
00600     }
00601 
00602     /*!
00603      Returns the object title.
00604     */
00605     function title( &$contentObjectAttribute,  $name = "original_filename" )
00606     {
00607         $mediaFile = eZMedia::fetch( $contentObjectAttribute->attribute( "id" ),
00608                                       $contentObjectAttribute->attribute( "version" ) );
00609 
00610         if ( $mediaFile != null )
00611             $value = $mediaFile->attribute( $name );
00612         else
00613             $value = "";
00614         return $value;
00615     }
00616 
00617     function hasObjectAttributeContent( &$contentObjectAttribute )
00618     {
00619         $mediaFile = eZMedia::fetch( $contentObjectAttribute->attribute( "id" ),
00620                                       $contentObjectAttribute->attribute( "version" ) );
00621         if ( !$mediaFile )
00622             return false;
00623         if( $mediaFile->attribute( "filename" ) == "" )
00624             return false;
00625        return true;
00626     }
00627 
00628     function &objectAttributeContent( $contentObjectAttribute )
00629     {
00630         $mediaFile = eZMedia::fetch( $contentObjectAttribute->attribute( "id" ),
00631                                       $contentObjectAttribute->attribute( "version" ) );
00632         if ( !$mediaFile )
00633         {
00634             $retValue = false;
00635             return $retValue;
00636         }
00637         return $mediaFile;
00638     }
00639 
00640     function metaData()
00641     {
00642         return "";
00643     }
00644     /*!
00645      \return string representation of an contentobjectattribute data for simplified export
00646 
00647     */
00648     function toString( $objectAttribute )
00649     {
00650         $mediaFile = $objectAttribute->content();
00651 
00652         if ( is_object( $mediaFile ) )
00653         {
00654             return implode( '|', array( $mediaFile->attribute( 'filepath' ), $mediaFile->attribute( 'original_filename' ) ) );
00655         }
00656         else
00657             return '';
00658     }
00659 
00660 
00661 
00662     function fromString( &$objectAttribute, $string )
00663     {
00664         if( !$string )
00665             return true;
00666 
00667         $result = array();
00668         return $this->insertRegularFile( $objectAttribute->attribute( 'object' ),
00669                                          $objectAttribute->attribute( 'version' ),
00670                                          $objectAttribute->attribute( 'language_code' ),
00671                                          $objectAttribute,
00672                                          $string,
00673                                          $result );
00674 
00675     }
00676 
00677     /*!
00678      \reimp
00679     */
00680     function serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
00681     {
00682         $maxSize = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_FIELD );
00683         $type = $classAttribute->attribute( EZ_DATATYPESTRING_TYPE_FIELD );
00684         $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'max-size', $maxSize,
00685                                                                                      array( 'unit-size' => 'mega' ) ) );
00686         $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'type', $type ) );
00687     }
00688 
00689     /*!
00690      \reimp
00691     */
00692     function unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
00693     {
00694         $maxSize = $attributeParametersNode->elementTextContentByName( 'max-size' );
00695         $sizeNode = $attributeParametersNode->elementByName( 'max-size' );
00696         $unitSize = $sizeNode->attributeValue( 'unit-size' );
00697         $type = $attributeParametersNode->elementTextContentByName( 'type' );
00698         $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_MEDIA_FILESIZE_FIELD, $maxSize );
00699         $classAttribute->setAttribute( EZ_DATATYPESTRING_TYPE_FIELD, $type );
00700     }
00701 
00702     /*!
00703      \param package
00704      \param content attribute
00705 
00706      \return a DOM representation of the content object attribute
00707     */
00708     function serializeContentObjectAttribute( &$package, &$objectAttribute )
00709     {
00710 
00711         $node = $this->createContentObjectAttributeDOMNode( $objectAttribute );
00712 
00713         $mediaFile = $objectAttribute->attribute( 'content' );
00714         if ( !$mediaFile )
00715         {
00716             // Media type content could not be found.
00717             return $node;
00718         }
00719 
00720         $fileKey = md5( mt_rand() );
00721 
00722         $fileInfo = $mediaFile->storedFileInfo();
00723         $package->appendSimpleFile( $fileKey, $fileInfo['filepath'] );
00724 
00725         $mediaNode = eZDOMDocument::createElementNode( 'media-file' );
00726         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'filesize', $mediaFile->attribute( 'filesize' ) ) );
00727         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'filename', $mediaFile->attribute( 'filename' ) ) );
00728         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'original-filename', $mediaFile->attribute( 'original_filename' ) ) );
00729         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'mime-type', $mediaFile->attribute( 'mime_type' ) ) );
00730         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'filekey', $fileKey ) );
00731 
00732         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'width', $mediaFile->attribute( 'width' ) ) );
00733         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'height', $mediaFile->attribute( 'height' ) ) );
00734         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'has-controller', $mediaFile->attribute( 'has_controller' ) ) );
00735         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'controls', $mediaFile->attribute( 'controls' ) ) );
00736         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'is-autoplay', $mediaFile->attribute( 'is_autoplay' ) ) );
00737         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'plugins-page', $mediaFile->attribute( 'pluginspage' ) ) );
00738         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'quality', $mediaFile->attribute( 'quality' ) ) );
00739         $mediaNode->appendAttribute( eZDOMDocument::createAttributeNode( 'is-loop', $mediaFile->attribute( 'is_loop' ) ) );
00740         $node->appendChild( $mediaNode );
00741 
00742         return $node;
00743     }
00744 
00745     /*!
00746      \reimp
00747      \param package
00748      \param contentobject attribute object
00749      \param ezdomnode object
00750     */
00751     function unserializeContentObjectAttribute( &$package, &$objectAttribute, $attributeNode )
00752     {
00753         $mediaNode = $attributeNode->elementByName( 'media-file' );
00754         if ( !$mediaNode )
00755         {
00756             // No media type data found.
00757             return;
00758         }
00759 
00760         $mediaFile = eZMedia::create( $objectAttribute->attribute( 'id' ), $objectAttribute->attribute( 'version' ) );
00761 
00762         $sourcePath = $package->simpleFilePath( $mediaNode->attributeValue( 'filekey' ) );
00763 
00764         include_once( 'lib/ezfile/classes/ezdir.php' );
00765         $ini =& eZINI::instance();
00766         $mimeType = $mediaNode->attributeValue( 'mime-type' );
00767         list( $mimeTypeCategory, $mimeTypeName ) = explode( '/', $mimeType );
00768         $destinationPath = eZSys::storageDirectory() . '/original/' . $mimeTypeCategory . '/';
00769         if ( !file_exists( $destinationPath ) )
00770         {
00771             if ( !eZDir::mkdir( $destinationPath, eZDir::directoryPermission(), true ) )
00772             {
00773                 return false;
00774             }
00775         }
00776 
00777         $basename = basename( $mediaNode->attributeValue( 'filename' ) );
00778         while ( file_exists( $destinationPath . $basename ) )
00779         {
00780             $basename = substr( md5( mt_rand() ), 0, 8 ) . '.' . eZFile::suffix( $mediaNode->attributeValue( 'filename' ) );
00781         }
00782 
00783         include_once( 'lib/ezfile/classes/ezfilehandler.php' );
00784         eZFileHandler::copy( $sourcePath, $destinationPath . $basename );
00785         eZDebug::writeNotice( 'Copied: ' . $sourcePath . ' to: ' . $destinationPath . $basename,
00786                               'eZMediaType::unserializeContentObjectAttribute()' );
00787 
00788         $mediaFile->setAttribute( 'contentobject_attribute_id', $objectAttribute->attribute( 'id' ) );
00789         $mediaFile->setAttribute( 'filename', $basename );
00790         $mediaFile->setAttribute( 'original_filename', $mediaNode->attributeValue( 'original-filename' ) );
00791         $mediaFile->setAttribute( 'mime_type', $mediaNode->attributeValue( 'mime-type' ) );
00792 
00793         $mediaFile->setAttribute( 'width', $mediaNode->attributeValue( 'width' ) );
00794         $mediaFile->setAttribute( 'height', $mediaNode->attributeValue( 'height' ) );
00795         $mediaFile->setAttribute( 'has_controller', $mediaNode->attributeValue( 'has-controller' ) );
00796         $mediaFile->setAttribute( 'controls', $mediaNode->attributeValue( 'controls' ) );
00797         $mediaFile->setAttribute( 'is_autoplay', $mediaNode->attributeValue( 'is-autoplay' ) );
00798         $mediaFile->setAttribute( 'pluginspage', $mediaNode->attributeValue( 'plugins-page' ) );
00799         $mediaFile->setAttribute( 'quality', $mediaNode->attributeValue( 'quality' ) );
00800         $mediaFile->setAttribute( 'is_loop', $mediaNode->attributeValue( 'is-loop' ) );
00801 
00802         // VS-DBFILE
00803 
00804         require_once( 'kernel/classes/ezclusterfilehandler.php' );
00805         $fileHandler = eZClusterFileHandler::instance();
00806         $fileHandler->fileStore( $destinationPath . $basename, 'mediafile', true );
00807 
00808         $mediaFile->store();
00809     }
00810 }
00811 
00812 eZDataType::register( EZ_DATATYPESTRING_MEDIA, "ezmediatype" );
00813 
00814 ?>