931 lines
30 KiB
PHP
931 lines
30 KiB
PHP
<?php
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2004 Media Development Loan Fund
|
|
|
|
This file is part of the LiveSupport project.
|
|
http://livesupport.campware.org/
|
|
To report bugs, send an e-mail to bugs@campware.org
|
|
|
|
LiveSupport is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
LiveSupport is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with LiveSupport; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
|
|
Author : $Author: tomas $
|
|
Version : $Revision: 1.33 $
|
|
Location : $Source: /home/paul/cvs2svn-livesupport/newcvsrepo/livesupport/modules/storageServer/var/GreenBox.php,v $
|
|
|
|
------------------------------------------------------------------------------*/
|
|
require_once "BasicStor.php";
|
|
|
|
/**
|
|
* GreenBox class
|
|
*
|
|
* LiveSupport file storage module
|
|
*
|
|
* @author $Author: tomas $
|
|
* @version $Revision: 1.33 $
|
|
* @see BasicStor
|
|
*/
|
|
class GreenBox extends BasicStor{
|
|
|
|
/* ======================================================= public methods */
|
|
|
|
/**
|
|
* Create new folder
|
|
*
|
|
* @param parid int, parent id
|
|
* @param folderName string, name for new folder
|
|
* @param sessid string, session id
|
|
* @return id of new folder
|
|
* @exception PEAR::error
|
|
*/
|
|
function createFolder($parid, $folderName, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('write', $parid, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsCreateFolder($parid, $folderName);
|
|
}
|
|
|
|
/**
|
|
* Store new file in the storage
|
|
*
|
|
* @param parid int, parent id
|
|
* @param fileName string, name for new file
|
|
* @param mediaFileLP string, local path of media file
|
|
* @param mdataFileLP string, local path of metadata file
|
|
* @param sessid string, session id
|
|
* @param gunid string, global unique id OPTIONAL
|
|
* @param ftype string, internal file type
|
|
* @return int
|
|
* @exception PEAR::error
|
|
*/
|
|
function putFile($parid, $fileName,
|
|
$mediaFileLP, $mdataFileLP, $sessid='',
|
|
$gunid=NULL, $ftype='audioclip')
|
|
{
|
|
if(($res = $this->_authorize('write', $parid, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsPutFile(
|
|
$parid, $fileName, $mediaFileLP, $mdataFileLP, $gunid, $ftype
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Store new webstream
|
|
*
|
|
* @param parid int, parent id
|
|
* @param fileName string, name for new file
|
|
* @param mdataFileLP string, local path of metadata file
|
|
* @param sessid string, session id
|
|
* @param gunid string, global unique id OPTIONAL
|
|
* @param url string, wewbstream url
|
|
* @return int
|
|
* @exception PEAR::error
|
|
*/
|
|
function storeWebstream($parid, $fileName, $mdataFileLP, $sessid='',
|
|
$gunid=NULL, $url)
|
|
{
|
|
if(($res = $this->_authorize('write', $parid, $sessid)) !== TRUE)
|
|
return $res;
|
|
$oid = $this->bsPutFile(
|
|
$parid, $fileName, '', $mdataFileLP, $gunid, 'webstream'
|
|
);
|
|
if(PEAR::isError($oid)) return $oid;
|
|
$r = $this-> bsSetMetadataValue(
|
|
$oid, 'ls:url', $url, NULL, NULL, 'audioClip');
|
|
if(PEAR::isError($r)) return $r;
|
|
return $oid;
|
|
}
|
|
|
|
|
|
/**
|
|
* Access stored file - increase access counter
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param sessid string, session id
|
|
* @return string access token
|
|
*/
|
|
function accessFile($id, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
$gunid = $this->_gunidFromId($id);
|
|
$r = $this->bsAccess(NULL, '', $gunid, 'access');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$token = $r['token'];
|
|
return $token;
|
|
}
|
|
|
|
/**
|
|
* Release stored file - decrease access counter
|
|
*
|
|
* @param token string, access token
|
|
* @param sessid string, session id
|
|
* @return boolean
|
|
*/
|
|
function releaseFile($token, $sessid='')
|
|
{
|
|
$r = $this->bsRelease($token, 'access');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Analyze media file for internal metadata information
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param sessid string, session id
|
|
* @return array
|
|
*/
|
|
function analyzeFile($id, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsAnalyzeFile($id);
|
|
}
|
|
|
|
/**
|
|
* Rename file
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param newName string
|
|
* @param sessid string, session id
|
|
* @return boolean or PEAR::error
|
|
*/
|
|
function renameFile($id, $newName, $sessid='')
|
|
{
|
|
$parid = $this->getParent($id);
|
|
if(($res = $this->_authorize('write', $parid, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsRenameFile($id, $newName);
|
|
}
|
|
|
|
/**
|
|
* Move file
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param did int, destination folder local id
|
|
* @param sessid string, session id
|
|
* @return boolean or PEAR::error
|
|
*/
|
|
function moveFile($id, $did, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize(
|
|
array('read', 'write'), array($id, $did), $sessid
|
|
)) !== TRUE) return $res;
|
|
return $this->bsMoveFile($id, $did);
|
|
}
|
|
|
|
/**
|
|
* Copy file
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param did int, destination folder local id
|
|
* @param sessid string, session id
|
|
* @return boolean or PEAR::error
|
|
*/
|
|
function copyFile($id, $did, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize(
|
|
array('read', 'write'), array($id, $did), $sessid
|
|
)) !== TRUE) return $res;
|
|
return $this->bsCopyFile($id, $did);
|
|
}
|
|
|
|
/**
|
|
* Delete file
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param sessid int
|
|
* @return true or PEAR::error
|
|
*/
|
|
function deleteFile($id, $sessid='')
|
|
{
|
|
$parid = $this->getParent($id);
|
|
if(($res = $this->_authorize('write', $parid, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsDeleteFile($id);
|
|
}
|
|
|
|
/* ---------------------------------------------- replicas, versions etc. */
|
|
/**
|
|
* Create replica.<br>
|
|
* <b>TODO: NOT FINISHED</b>
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param did int, destination folder local id
|
|
* @param replicaName string, name of new replica
|
|
* @param sessid string, session id
|
|
* @return int, local id of new object
|
|
*/
|
|
function createReplica($id, $did, $replicaName='', $sessid='')
|
|
{
|
|
if(($res = $this->_authorize(
|
|
array('read', 'write'), array($id, $did), $sessid
|
|
)) !== TRUE) return $res;
|
|
return $this->bsCreateReplica($id, $did, $replicaName);
|
|
}
|
|
|
|
/**
|
|
* Create version.<br>
|
|
* <b>TODO: NOT FINISHED</b>
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param did int, destination folder local id
|
|
* @param versionLabel string, name of new version
|
|
* @param sessid string, session id
|
|
* @return int, local id of new object
|
|
*/
|
|
function createVersion($id, $did, $versionLabel, $sessid='')
|
|
{
|
|
return $this->bsCreateVersion($id, $did, $versionLabel);
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------- metadata */
|
|
|
|
/**
|
|
* Replace metadata with new XML file or string
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param mdata string, XML string or local path of metadata XML file
|
|
* @param mdataLoc string, metadata location: 'file'|'string'
|
|
* @param sessid string, session id
|
|
* @return boolean or PEAR::error
|
|
*/
|
|
function replaceMetadata($id, $mdata, $mdataLoc='file', $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('write', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsReplaceMetadata($id, $mdata, $mdataLoc);
|
|
}
|
|
|
|
/**
|
|
* Get metadata XML tree as string
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param sessid string, session id
|
|
* @return string or PEAR::error
|
|
*/
|
|
function getMdata($id, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsGetMetadata($id);
|
|
}
|
|
|
|
/**
|
|
* Get metadata element value
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param category string, metadata element name
|
|
* @param sessid string, session id
|
|
* @param lang string, optional xml:lang value for select language version
|
|
* @return array of matching records as hash with fields:
|
|
* <ul>
|
|
* <li>mid int, local metadata record id</li>
|
|
* <li>value string, element value</li>
|
|
* <li>attrs hasharray of element's attributes indexed by
|
|
* qualified name (e.g. xml:lang)</li>
|
|
* </ul>
|
|
*/
|
|
function getMdataValue($id, $category, $sessid='', $lang=NULL)
|
|
{
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsGetMetadataValue($id, $category, $lang);
|
|
}
|
|
|
|
/**
|
|
* Set metadata element value
|
|
*
|
|
* @param id int, virt.file's local id
|
|
* @param category string, metadata element identification (e.g. dc:title)
|
|
* @param sessid string, session id
|
|
* @param value string/NULL value to store, if NULL then delete record
|
|
* @param lang string, optional xml:lang value for select language version
|
|
* @param mid int, metadata record id (OPTIONAL on unique elements)
|
|
* @return boolean
|
|
*/
|
|
function setMdataValue($id, $category, $sessid, $value, $lang=NULL, $mid=NULL)
|
|
{
|
|
if(($res = $this->_authorize('write', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $this->bsSetMetadataValue($id, $category, $value, $lang, $mid);
|
|
}
|
|
|
|
/**
|
|
* Search in local metadata database.
|
|
*
|
|
* @param criteria hash, with following structure:<br>
|
|
* <ul>
|
|
* <li>filetype - string, type of searched files,
|
|
* meaningful values: 'audioclip', 'playlist'</li>
|
|
* <li>operator - string, type of conditions join
|
|
* (any condition matches / all conditions match),
|
|
* meaningful values: 'and', 'or', ''
|
|
* (may be empty or ommited only with less then 2 items in
|
|
* "conditions" field)
|
|
* </li>
|
|
* <li>limit : int - limit for result arrays (0 means unlimited)</li>
|
|
* <li>offset : int - starting point (0 means without offset)</li>
|
|
* <li>conditions - array of hashes with structure:
|
|
* <ul>
|
|
* <li>cat - string, metadata category name</li>
|
|
* <li>op - string, operator - meaningful values:
|
|
* 'full', 'partial', 'prefix', '=', '<',
|
|
* '<=', '>', '>='</li>
|
|
* <li>val - string, search value</li>
|
|
* </ul>
|
|
* </li>
|
|
* </ul>
|
|
* @param sessid string, session id
|
|
* @return hash, field 'results' is an array with gunid strings
|
|
* of files have been found
|
|
* @see BasicStor::bsLocalSearch
|
|
*/
|
|
function localSearch($criteria, $sessid='')
|
|
{
|
|
$limit = intval(isset($criteria['limit']) ? $criteria['limit'] : 0);
|
|
$offset = intval(isset($criteria['offset']) ? $criteria['offset'] : 0);
|
|
return $this->bsLocalSearch($criteria, $limit, $offset);
|
|
}
|
|
|
|
/**
|
|
* Return values of specified metadata category
|
|
*
|
|
* @param category string, metadata category name
|
|
* with or without namespace prefix (dc:title, author)
|
|
* @param criteria hash, see localSearch method
|
|
* @param sessid string
|
|
* @return hash, fields:
|
|
* results : array with gunid strings
|
|
* cnt : integer - number of matching values
|
|
* @see BasicStor::bsBrowseCategory
|
|
*/
|
|
function browseCategory($category, $criteria, $sessid='')
|
|
{
|
|
$limit = intval(isset($criteria['limit']) ? $criteria['limit'] : 0);
|
|
$offset = intval(isset($criteria['offset']) ? $criteria['offset'] : 0);
|
|
$res = $this->bsBrowseCategory($category, $limit, $offset, $criteria);
|
|
return $res;
|
|
}
|
|
|
|
/*====================================================== playlist methods */
|
|
/**
|
|
* Create a new empty playlist.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param gunid string, playlist global unique ID
|
|
* @param fname string, human readable menmonic file name
|
|
* @return string, playlist global unique ID
|
|
*/
|
|
function createPlaylist($sessid, $gunid, $fname)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->createPlaylist($sessid, $gunid, $fname);
|
|
}
|
|
|
|
/**
|
|
* Return playlist as XML string
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param id int, local object id
|
|
* @return string, XML
|
|
*/
|
|
function getPlaylistXml($sessid, $id)
|
|
{
|
|
return $this->getMdata($id, $sessid);
|
|
}
|
|
|
|
/**
|
|
* Return playlist as hierarchical PHP hash-array
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param id int, local object id
|
|
* @return array
|
|
*/
|
|
function getPlaylistArray($sessid, $id)
|
|
{
|
|
$gunid = $this->_gunidFromId($id);
|
|
$pl =& StoredFile::recall($this, $id);
|
|
if(PEAR::isError($pl)){ return $pl; }
|
|
$gunid = $pl->gunid;
|
|
return $pl->md->genPhpArray();
|
|
}
|
|
|
|
/**
|
|
* Mark playlist as edited and return edit token
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param id int, local object id
|
|
* @return string, playlist access token
|
|
*/
|
|
function lockPlaylistForEdit($sessid, $id)
|
|
{
|
|
$gunid = $this->_gunidFromId($id);
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
$res = $lc->editPlaylist($sessid, $gunid);
|
|
if(PEAR::isError($res)) return $res;
|
|
return $res['token'];
|
|
}
|
|
|
|
/**
|
|
* Release token, regenerate XML from DB and clear edit flag.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param token string, playlist access token
|
|
* @return string gunid
|
|
*/
|
|
function releaseLockedPlaylist($sessid, $token)
|
|
{
|
|
$gunid = $this->bsCloseDownload($token, 'metadata');
|
|
if(PEAR::isError($gunid)) return $gunid;
|
|
$ac =& StoredFile::recallByGunid($this, $gunid);
|
|
if(PEAR::isError($ac)){ return $ac; }
|
|
$r = $ac->md->regenerateXmlFile();
|
|
if(PEAR::isError($r)) return $r;
|
|
$this->_setEditFlag($gunid, FALSE);
|
|
return $gunid;
|
|
}
|
|
|
|
/**
|
|
* Add audioclip specified by gunid to the playlist
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param token string, playlist access token
|
|
* @param acGunid string, global unique ID of added file
|
|
* @return string, generated playlistElement gunid
|
|
*/
|
|
function addAudioClipToPlaylist($sessid, $token, $acGunid)
|
|
{
|
|
$plGunid = $this->_gunidFromToken($token, 'download');
|
|
if(PEAR::isError($plGunid)) return $plGunid;
|
|
if(is_null($plGunid)){
|
|
return PEAR::raiseError(
|
|
"GreenBox::addClipToPlaylist: invalid token"
|
|
);
|
|
}
|
|
$pl =& StoredFile::recallByGunid($this, $plGunid);
|
|
if(PEAR::isError($pl)){ return $pl; }
|
|
$id = $pl->getId();
|
|
// get playlist length and record id:
|
|
$r = $pl->md->getMetadataEl('dcterms:extent');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$plLen = $r[0]['value'];
|
|
$plLenMid = $r[0]['mid'];
|
|
if(is_null($plLen)) $plLen = '00:00:00.000000';
|
|
|
|
// get audioClip legth and title
|
|
$ac =& StoredFile::recallByGunid($this, $acGunid);
|
|
if(PEAR::isError($ac)){ return $ac; }
|
|
$r = $ac->md->getMetadataEl('dcterms:extent');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$acLen = $r[0]['value'];
|
|
$r = $ac->md->getMetadataEl('dc:title');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$acTit = $r[0]['value'];
|
|
|
|
// get main playlist container
|
|
$r = $pl->md->getMetadataEl('playlist');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$parid = $r[0]['mid'];
|
|
if(is_null($parid)){
|
|
return PEAR::raiseError(
|
|
"GreenBox::addClipToPlaylist: can't find main container"
|
|
);
|
|
}
|
|
// get metadata container (optionally insert it)
|
|
$r = $pl->md->getMetadataEl('metadata');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$metaParid = $r[0]['mid'];
|
|
if(is_null($metaParid)){
|
|
$r = $pl->md->insertMetadataEl($parid, 'metadata');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$metaParid = $r;
|
|
}
|
|
|
|
// insert new palylist element
|
|
$r = $pl->md->insertMetadataEl($parid, 'playlistElement');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$plElId = $r;
|
|
$plElGunid = StoredFile::_createGunid();
|
|
$r = $pl->md->insertMetadataEl($plElId, 'id', $plElGunid, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$r = $pl->md->insertMetadataEl(
|
|
$plElId, 'relativeOffset', $plLen, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$r = $pl->md->insertMetadataEl($plElId, 'audioClip');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$acId = $r;
|
|
$r = $pl->md->insertMetadataEl($acId, 'id', $acGunid, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$r = $pl->md->insertMetadataEl($acId, 'playlength', $acLen, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$r = $pl->md->insertMetadataEl($acId, 'title', $acTit, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
// calculate and insert total length:
|
|
$newPlLen = $this->_secsToPlTime(
|
|
$this->_plTimeToSecs($plLen) + $this->_plTimeToSecs($acLen)
|
|
);
|
|
if(is_null($plLenMid)){
|
|
$r = $pl->md->insertMetadataEl(
|
|
$metaParid, 'dcterms:extent', $newPlLen);
|
|
}else{
|
|
$r = $pl->md->setMetadataEl($plLenMid, $newPlLen);
|
|
}
|
|
if(PEAR::isError($r)){ return $r; }
|
|
// set access to audio clip:
|
|
$r = $this->bsAccess(NULL, '', $acGunid, 'access');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$acToken = $r['token'];
|
|
// insert token attribute:
|
|
$r = $pl->md->insertMetadataEl($acId, 'accessToken', $acToken, 'A');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
return $plElGunid;
|
|
}
|
|
|
|
/**
|
|
* Remove audioclip from playlist
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param token string, playlist access token
|
|
* @param plElGunid string, global unique ID of deleted playlistElement
|
|
* @return boolean
|
|
*/
|
|
function delAudioClipFromPlaylist($sessid, $token, $plElGunid)
|
|
{
|
|
$plGunid = $this->_gunidFromToken($token, 'download');
|
|
if(PEAR::isError($plGunid)) return $plGunid;
|
|
if(is_null($plGunid)){
|
|
return PEAR::raiseError(
|
|
"GreenBox::addClipToPlaylist: invalid token"
|
|
);
|
|
}
|
|
$pl =& StoredFile::recallByGunid($this, $plGunid);
|
|
if(PEAR::isError($pl)){ return $pl; }
|
|
$id = $pl->getId();
|
|
|
|
// get main playlist container:
|
|
$r = $pl->md->getMetadataEl('playlist');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$parid = $r[0]['mid'];
|
|
if(is_null($parid)){
|
|
return PEAR::raiseError(
|
|
"GreenBox::addClipToPlaylist: can't find main container"
|
|
);
|
|
}
|
|
// get playlist length and record id:
|
|
$r = $pl->md->getMetadataEl('dcterms:extent');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$plLen = $r[0]['value'];
|
|
$plLenMid = $r[0]['mid'];
|
|
// get array of playlist elements:
|
|
$plElArr = $pl->md->getMetadataEl('playlistElement', $parid);
|
|
if(PEAR::isError($plElArr)){ return $plElArr; }
|
|
$found = FALSE;
|
|
foreach($plElArr as $el){
|
|
$plElGunidArr = $pl->md->getMetadataEl('id', $el['mid']);
|
|
if(PEAR::isError($plElGunidArr)){ return $plElGunidArr; }
|
|
// select playlist element to remove
|
|
if($plElGunidArr[0]['value'] == $plElGunid){
|
|
$acArr = $pl->md->getMetadataEl('audioClip', $el['mid']);
|
|
if(PEAR::isError($acArr)){ return $acArr; }
|
|
$acLenArr = $pl->md->getMetadataEl('playlength', $acArr[0]['mid']);
|
|
if(PEAR::isError($acLenArr)){ return $acLenArr; }
|
|
$acLen = $acLenArr[0]['value'];
|
|
$acTokArr = $pl->md->getMetadataEl('accessToken', $acArr[0]['mid']);
|
|
if(PEAR::isError($acTokArr)){ return $acTokArr; }
|
|
$acToken = $acTokArr[0]['value'];
|
|
// remove playlist element:
|
|
$r = $pl->md->setMetadataEl($el['mid'], NULL);
|
|
if(PEAR::isError($r)){ return $r; }
|
|
// release audioClip:
|
|
$r = $this->bsRelease($acToken, 'access');
|
|
if(PEAR::isError($r)){ return $r; }
|
|
$found = TRUE;
|
|
continue;
|
|
}
|
|
if($found){
|
|
// corect relative offsets in remaining elements:
|
|
$acOffArr = $pl->md->getMetadataEl('relativeOffset', $el['mid']);
|
|
if(PEAR::isError($acOffArr)){ return $acOffArr; }
|
|
$newOff = $this->_secsToPlTime(
|
|
$this->_plTimeToSecs($acOffArr[0]['value'])
|
|
-
|
|
$this->_plTimeToSecs($acLen)
|
|
);
|
|
$r = $pl->md->setMetadataEl($acOffArr[0]['mid'], $newOff);
|
|
if(PEAR::isError($r)){ return $r; }
|
|
}
|
|
}
|
|
// correct total length:
|
|
$newPlLen = $this->_secsToPlTime(
|
|
$this->_plTimeToSecs($plLen) - $this->_plTimeToSecs($acLen)
|
|
);
|
|
$r = $pl->md->setMetadataEl($plLenMid, $newPlLen);
|
|
if(PEAR::isError($r)){ return $r; }
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* RollBack playlist changes to the locked state
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param token string, playlist access token
|
|
* @return string gunid of playlist
|
|
*/
|
|
function revertEditedPlaylist($sessid, $token)
|
|
{
|
|
$gunid = $this->bsCloseDownload($token, 'metadata');
|
|
if(PEAR::isError($gunid)) return $gunid;
|
|
$ac =& StoredFile::recallByGunid($this, $gunid);
|
|
if(PEAR::isError($ac)){ return $ac; }
|
|
$id = $ac->getId();
|
|
$mdata = $ac->getMetaData();
|
|
if(PEAR::isError($mdata)){ return $mdata; }
|
|
$res = $ac->replaceMetaData($mdata, 'string');
|
|
if(PEAR::isError($res)){ return $res; }
|
|
$this->_setEditFlag($gunid, FALSE);
|
|
return $gunid;
|
|
}
|
|
|
|
/**
|
|
* Convert playlist time value to float seconds
|
|
*
|
|
* @param plt string, playlist time value (HH:mm:ss.dddddd)
|
|
* @return int, seconds
|
|
*/
|
|
function _plTimeToSecs($plt)
|
|
{
|
|
$arr = split(':', $plt);
|
|
if(isset($arr[2])){ return ($arr[0]*60 + $arr[1])*60 + $arr[2]; }
|
|
if(isset($arr[1])){ return $arr[0]*60 + $arr[1]; }
|
|
return $arr[0];
|
|
}
|
|
|
|
/**
|
|
* Convert float seconds value to playlist time format
|
|
*
|
|
* @param s0 int, seconds
|
|
* @return string, time in playlist time format (HH:mm:ss.dddddd)
|
|
*/
|
|
function _secsToPlTime($s0)
|
|
{
|
|
$m = intval($s0 / 60);
|
|
$r = $s0 - $m*60;
|
|
$h = $m / 60;
|
|
$m = $m % 60;
|
|
return sprintf("%02d:%02d:%09.6f", $h, $m, $r);
|
|
}
|
|
|
|
/* ---------- */
|
|
/**
|
|
* Open a Playlist metafile for editing.
|
|
* Open readable URL and mark file as beeing edited.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param gunid string, playlist global unique ID
|
|
* @return struct
|
|
* {url:readable URL for HTTP GET, token:access token, chsum:checksum}
|
|
*/
|
|
function editPlaylist($sessid, $gunid)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->editPlaylist($sessid, $gunid);
|
|
}
|
|
|
|
/**
|
|
* Store a new Playlist metafile in place of the old one.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param playlistToken string, playlist access token
|
|
* @param newPlaylist string, new playlist as XML string
|
|
* @return string, gunid
|
|
*/
|
|
function savePlaylist($sessid, $playlistToken, $newPlaylist)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->savePlaylist($sessid, $playlistToken, $newPlaylist);
|
|
}
|
|
|
|
/**
|
|
* Delete a Playlist metafile.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param gunid string, playlist global unique ID
|
|
* @return boolean
|
|
*/
|
|
function deletePlaylist($sessid, $gunid)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->deletePlaylist($sessid, $gunid);
|
|
}
|
|
|
|
/**
|
|
* Check whether a Playlist metafile with the given playlist ID exists.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param gunid string, playlist global unique ID
|
|
* @return boolean
|
|
*/
|
|
function existsPlaylist($sessid, $gunid)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->existsPlaylist($sessid, $gunid);
|
|
}
|
|
|
|
/**
|
|
* Check whether a Playlist metafile with the given playlist ID
|
|
* is available for editing, i.e., exists and is not marked as
|
|
* beeing edited.
|
|
*
|
|
* @param sessid string, session ID
|
|
* @param gunid string, playlist global unique ID
|
|
* @return boolean
|
|
*/
|
|
function playlistIsAvailable($sessid, $gunid)
|
|
{
|
|
require_once"LocStor.php";
|
|
$lc =& new LocStor($this->dbc, $this->config);
|
|
return $lc->playlistIsAvailable($sessid, $gunid);
|
|
}
|
|
|
|
/* ============================================== methods for preferences */
|
|
|
|
/**
|
|
* Read preference record by session id
|
|
*
|
|
* @param sessid string, session id
|
|
* @param key string, preference key
|
|
* @return string, preference value
|
|
*/
|
|
function loadPref($sessid, $key)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->loadPref($sessid, $key);
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Save preference record by session id
|
|
*
|
|
* @param sessid string, session id
|
|
* @param key string, preference key
|
|
* @param value string, preference value
|
|
* @return boolean
|
|
*/
|
|
function savePref($sessid, $key, $value)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->savePref($sessid, $key, $value);
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Delete preference record by session id
|
|
*
|
|
* @param sessid string, session id
|
|
* @param key string, preference key
|
|
* @return boolean
|
|
*/
|
|
function delPref($sessid, $key)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->delPref($sessid, $key);
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Read group preference record
|
|
*
|
|
* @param sessid string, session id
|
|
* @param group string, group name
|
|
* @param key string, preference key
|
|
* @return string, preference value
|
|
*/
|
|
function loadGroupPref($sessid, $group, $key)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->loadGroupPref($sessid, $group, $key);
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Save group preference record
|
|
*
|
|
* @param sessid string, session id
|
|
* @param group string, group name
|
|
* @param key string, preference key
|
|
* @param value string, preference value
|
|
* @return boolean
|
|
*/
|
|
function saveGroupPref($sessid, $group, $key, $value)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->saveGroupPref($sessid, $group, $key, $value);
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* Delete group preference record
|
|
*
|
|
* @param sessid string, session id
|
|
* @param group string, group name
|
|
* @param key string, preference key
|
|
* @return boolean
|
|
*/
|
|
function delGroupPref($sessid, $group, $key)
|
|
{
|
|
require_once '../../../storageServer/var/Prefs.php';
|
|
$pr =& new Prefs($this);
|
|
$res = $pr->delGroupPref($sessid, $group, $key);
|
|
return $res;
|
|
}
|
|
/* --------------------------------------------------------- info methods */
|
|
|
|
/**
|
|
* List files in folder
|
|
*
|
|
* @param id int, local id of folder
|
|
* @param sessid string, session id
|
|
* @return array
|
|
*/
|
|
function listFolder($id, $sessid='')
|
|
{
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
$listArr = $this->bsListFolder($id);
|
|
return $listArr;
|
|
}
|
|
|
|
/**
|
|
* Get type of stored file (by local id)
|
|
*
|
|
* @param id int, local id
|
|
* @return string/err
|
|
*/
|
|
function getFileType($id)
|
|
{
|
|
// $id = $this->_idFromGunid($gunid);
|
|
$type = $this->getObjType($id);
|
|
return $type;
|
|
}
|
|
|
|
/**
|
|
* Check if file exists in the storage and
|
|
* user have permission to read it
|
|
*
|
|
* @param gunid string
|
|
* @param ftype string, internal file type
|
|
* @return string/err
|
|
*/
|
|
function existsFile($sessid, $gunid, $ftype=NULL)
|
|
{
|
|
$id = $this->_idFromGunid($gunid);
|
|
$ex = $this->bsExistsFile($id, $ftype);
|
|
if(($res = $this->_authorize('read', $id, $sessid)) !== TRUE)
|
|
return $res;
|
|
return $ex;
|
|
}
|
|
|
|
/* ---------------------------------------------------- redefined methods */
|
|
|
|
/**
|
|
* Get file's path in virtual filesystem
|
|
*
|
|
* @param id int
|
|
* @return array
|
|
*/
|
|
function getPath($id)
|
|
{
|
|
$pa = parent::getPath($id, 'id, name, type');
|
|
array_shift($pa);
|
|
return $pa;
|
|
}
|
|
|
|
}
|
|
?>
|