/**
* @param CaptionAsset $captionAsset
* @param BatchJob $parentJob
* @throws kCoreException FILE_NOT_FOUND
* @return BatchJob
*/
public function addParseCaptionAssetJob(CaptionAsset $captionAsset, BatchJob $parentJob = null)
{
$syncKey = $captionAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
$fileSync = kFileSyncUtils::getReadyInternalFileSyncForKey($syncKey);
if (!$fileSync) {
if (!PermissionPeer::isValidForPartner(CaptionPermissionName::IMPORT_REMOTE_CAPTION_FOR_INDEXING, $captionAsset->getPartnerId())) {
throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND);
}
$fileSync = kFileSyncUtils::getReadyExternalFileSyncForKey($syncKey);
if (!$fileSync) {
throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND);
}
$fullPath = myContentStorage::getFSUploadsPath() . '/' . $captionAsset->getId() . '.tmp';
if (!kFile::downloadUrlToFile($fileSync->getExternalUrl($captionAsset->getEntryId()), $fullPath)) {
throw new kCoreException("File sync not found: {$syncKey}", kCoreException::FILE_NOT_FOUND);
}
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, false, true);
}
$jobData = new kParseCaptionAssetJobData();
$jobData->setCaptionAssetId($captionAsset->getId());
$batchJob = null;
if ($parentJob) {
$batchJob = $parentJob->createChild();
} else {
$batchJob = new BatchJob();
$batchJob->setEntryId($captionAsset->getEntryId());
$batchJob->setPartnerId($captionAsset->getPartnerId());
}
return kJobsManager::addJob($batchJob, $jobData, CaptionSearchPlugin::getBatchJobTypeCoreValue(CaptionSearchBatchJobType::PARSE_CAPTION_ASSET));
}
public function toObject($object_to_fill = null, $props_to_skip = array())
{
if (!$object_to_fill) {
$object_to_fill = new kLocalFileResource();
}
file_put_contents($fname = tempnam(myContentStorage::getFSUploadsPath(), "KFR"), $this->content);
$object_to_fill->setLocalFilePath($fname);
$object_to_fill->setSourceType(entry::ENTRY_MEDIA_SOURCE_TEXT);
return parent::toObject($object_to_fill, $props_to_skip);
}
public function toObject($object_to_fill = null, $props_to_skip = array())
{
if (!$object_to_fill) {
$object_to_fill = new kLocalFileResource();
}
$ext = pathinfo($this->fileData['name'], PATHINFO_EXTENSION);
$uploadPath = $this->fileData['tmp_name'];
$tempPath = myContentStorage::getFSUploadsPath() . '/' . uniqid(time()) . '.' . $ext;
$moved = kFile::moveFile($uploadPath, $tempPath, true);
if (!$moved) {
throw new KalturaAPIException(KalturaErrors::UPLOAD_ERROR);
}
$object_to_fill->setLocalFilePath($tempPath);
return $object_to_fill;
}
public static function getUploadPathAndUrl($token, $file_alias, $extra_id = null, $extension = "")
{
// $extension = ""; // strtolower($parts['extension']);
$filename = $token . '_' . $file_alias;
// add the file extension after the "." character
$suffix = $filename . ($extra_id ? "_" . $extra_id : "") . "." . $extension;
$fullPath = myContentStorage::getFSUploadsPath() . $suffix;
$fullUrl = requestUtils::getRequestHost() . "/" . myContentStorage::getFSUploadsPath(false) . $suffix;
return array($fullPath, $fullUrl);
}
/**
* @param kUrlResource $resource
* @param entry $dbEntry
* @param asset $dbAsset
* @return asset
*/
protected function attachUrlResource(kUrlResource $resource, entry $dbEntry, asset $dbAsset = null)
{
if ($dbAsset instanceof flavorAsset) {
$dbEntry->setSource(KalturaSourceType::URL);
$dbEntry->save();
}
$url = $resource->getUrl();
if (!$resource->getForceAsyncDownload()) {
// TODO - move image handling to media service
if ($dbEntry->getMediaType() == KalturaMediaType::IMAGE) {
$entryFullPath = myContentStorage::getFSUploadsPath() . '/' . $dbEntry->getId() . '.jpg';
if (KCurlWrapper::getDataFromFile($url, $entryFullPath)) {
return $this->attachFile($entryFullPath, $dbEntry, $dbAsset);
}
KalturaLog::err("Failed downloading file[{$url}]");
$dbEntry->setStatus(entryStatus::ERROR_IMPORTING);
$dbEntry->save();
return null;
}
if ($dbAsset && !$dbAsset instanceof flavorAsset) {
$ext = pathinfo($url, PATHINFO_EXTENSION);
$entryFullPath = myContentStorage::getFSUploadsPath() . '/' . $dbEntry->getId() . '.' . $ext;
if (KCurlWrapper::getDataFromFile($url, $entryFullPath)) {
$dbAsset = $this->attachFile($entryFullPath, $dbEntry, $dbAsset);
return $dbAsset;
}
KalturaLog::err("Failed downloading file[{$url}]");
$dbAsset->setStatus(asset::FLAVOR_ASSET_STATUS_ERROR);
$dbAsset->save();
return null;
}
}
kJobsManager::addImportJob(null, $dbEntry->getId(), $this->getPartnerId(), $url, $dbAsset, null, $resource->getImportJobData());
return $dbAsset;
}
public static function createImageByFile($source_file)
{
global $global_kaltura_memory_limit;
if (!isset($global_kaltura_memory_limit)) {
ini_set("memory_limit", "256M");
}
if (!file_exists($source_file)) {
KalturaLog::log("file not found [{$source_file}]");
return null;
}
if (!is_file($source_file)) {
KalturaLog::log("path is not file [{$source_file}]");
return null;
}
list($sourcewidth, $sourceheight, $type, $attr) = getimagesize($source_file);
$srcIm = NULL;
switch ($type) {
case IMAGETYPE_JPEG:
$srcIm = imagecreatefromjpeg($source_file);
break;
case IMAGETYPE_PNG:
$srcIm = imagecreatefrompng($source_file);
break;
case IMAGETYPE_GIF:
$srcIm = imagecreatefromgif($source_file);
break;
case IMAGETYPE_WBMP:
$srcIm = imagecreatefromwbmp($source_file);
break;
default:
$srcIm = NULL;
}
if (!$srcIm) {
$output = array();
$cmd = kConf::get("bin_path_imagemagick");
$jpeg_file = myContentStorage::getFSUploadsPath(true) . pathinfo($source_file, PATHINFO_FILENAME) . ".jpg";
$validInput = true;
$validInput &= realpath($source_file) !== FALSE;
if (!$validInput) {
throw new Exception("Illegal input was given");
}
exec($cmd . " \"{$source_file}\" \"{$jpeg_file}\"", $output);
if (file_exists($jpeg_file)) {
list($sourcewidth, $sourceheight, $type, $attr) = getimagesize($jpeg_file);
$srcIm = imagecreatefromjpeg($jpeg_file);
}
//fixme echo ('myFileConverter::createImageByFile - file extension not supported: '.$source_file.' type:'.$type );
}
// if image failed to load return a null result instead of an errornous one due to a bad file
if (!$srcIm) {
return array(0, 0, IMAGETYPE_JPEG, "", null);
}
return array($sourcewidth, $sourceheight, $type, $attr, $srcIm);
}
/**
* Add new entry after the specific media file was uploaded and the upload token id exists
*
* @action addFromUploadedFile
* @param KalturaMediaEntry $mediaEntry Media entry metadata
* @param string $uploadTokenId Upload token id
* @return KalturaMediaEntry The new media entry
*
* @throws KalturaErrors::PROPERTY_VALIDATION_MIN_LENGTH
* @throws KalturaErrors::PROPERTY_VALIDATION_CANNOT_BE_NULL
* @throws KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN
*
* @deprecated use media.add instead
*/
function addFromUploadedFileAction(KalturaMediaEntry $mediaEntry, $uploadTokenId)
{
if ($mediaEntry->conversionQuality && !$mediaEntry->conversionProfileId) {
$mediaEntry->conversionProfileId = $mediaEntry->conversionQuality;
}
try {
// check that the uploaded file exists
$entryFullPath = kUploadTokenMgr::getFullPathByUploadTokenId($uploadTokenId);
// Make sure that the uploads path is not modified by $uploadTokenId (with the value of "../" for example )
$entryRootDir = realpath(dirname($entryFullPath));
$uploadPathBase = realpath(myContentStorage::getFSUploadsPath());
if (strpos($entryRootDir, $uploadPathBase) !== 0) {
KalturaLog::err("uploadTokenId [{$uploadTokenId}] points outside of uploads directory");
throw new KalturaAPIException(KalturaErrors::INVALID_UPLOAD_TOKEN_ID);
}
} catch (kCoreException $ex) {
if ($ex->getCode() == kUploadTokenException::UPLOAD_TOKEN_INVALID_STATUS) {
}
throw new KalturaAPIException(KalturaErrors::UPLOAD_TOKEN_INVALID_STATUS_FOR_ADD_ENTRY);
throw $ex;
}
if (!file_exists($entryFullPath)) {
// Backward compatability - support case in which the required file exist in the other DC
kFileUtils::dumpApiRequest(kDataCenterMgr::getRemoteDcExternalUrlByDcId(1 - kDataCenterMgr::getCurrentDcId()));
/*
$remoteDCHost = kUploadTokenMgr::getRemoteHostForUploadToken($uploadTokenId, kDataCenterMgr::getCurrentDcId());
if($remoteDCHost)
{
kFileUtils::dumpApiRequest($remoteDCHost);
}
else
{
throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN);
}
*/
}
$dbEntry = parent::add($mediaEntry, $mediaEntry->conversionProfileId);
$kshowId = $dbEntry->getKshowId();
// setup the needed params for my insert entry helper
$paramsArray = array("entry_media_source" => KalturaSourceType::FILE, "entry_media_type" => $dbEntry->getMediaType(), "entry_full_path" => $entryFullPath, "entry_license" => $dbEntry->getLicenseType(), "entry_credit" => $dbEntry->getCredit(), "entry_source_link" => $dbEntry->getSourceLink(), "entry_tags" => $dbEntry->getTags());
$token = $this->getKsUniqueString();
$insert_entry_helper = new myInsertEntryHelper(null, $dbEntry->getKuserId(), $kshowId, $paramsArray);
$insert_entry_helper->setPartnerId($this->getPartnerId(), $this->getPartnerId() * 100);
$insert_entry_helper->insertEntry($token, $dbEntry->getType(), $dbEntry->getId(), $dbEntry->getName(), $dbEntry->getTags(), $dbEntry);
$dbEntry = $insert_entry_helper->getEntry();
kUploadTokenMgr::closeUploadTokenById($uploadTokenId);
$ret = new KalturaMediaEntry();
if ($dbEntry) {
myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_ADD, $dbEntry, $dbEntry->getPartnerId(), null, null, null, $dbEntry->getId());
$ret->fromObject($dbEntry, $this->getResponseProfile());
}
return $ret;
}
private function handleEntry($onlyExtractThumb, $prefix, $type, $entry_id, $name = null, $tags = null, $entry = null)
{
KalturaLog::debug("handleEntry({$type}, {$entry_id}, {$name})");
$this->clear($prefix, $entry_id);
$kuser_id = $this->kuser_id;
$entry_data_prefix = $kuser_id . '_' . ($prefix == '' ? 'data' : rtrim($prefix, '_'));
$uploads = myContentStorage::getFSUploadsPath();
$content = myContentStorage::getFSContentRootPath();
$media_source = $this->getParam('entry_media_source');
$media_type = $this->getParam('entry_media_type');
$entry_url = $this->getParam('entry_url');
$entry_source_link = $this->getParam('entry_source_link');
$entry_fileName = $this->getParam('entry_data');
$entry_thumbNum = $this->getParam('entry_thumb_num', 0);
$entry_thumbUrl = $this->getParam('entry_thumb_url', '');
$should_copy = $this->getParam('should_copy', false);
$skip_conversion = $this->getParam('skip_conversion', false);
$webcam_suffix = $this->getParam('webcam_suffix', '');
$duration = $this->getParam('duration', null);
$entry_fullPath = "";
$ext = null;
$entry = null;
if ($entry_id) {
$entry = entryPeer::retrieveByPK($entry_id);
} else {
$entry = new entry();
}
$this->entry = $entry;
$entry_status = $entry->getStatus();
if (is_null($entry_status)) {
$entry_status = entryStatus::READY;
}
// by the end of this block of code $entry_fullPath will point to the location of the entry
// the entry status will be set (IMPORT / PRECONVERT / READY)
// a background image is always previewed by the user no matter what source he used
// so the entry is already in the /uploads directory
// continue tracking the file upload
$te = new TrackEntry();
$te->setEntryId($entry_id);
$te->setTrackEventTypeId(TrackEntry::TRACK_ENTRY_EVENT_TYPE_ADD_ENTRY);
KalturaLog::debug("handleEntry: media_source: {$media_source}, prefix: {$prefix}");
if ($media_source == entry::ENTRY_MEDIA_SOURCE_FILE || $prefix == 'bg_') {
$full_path = $this->getParam('entry_full_path');
if ($full_path) {
$entry_fullPath = $full_path;
} else {
$entry_fullPath = $uploads . $entry_data_prefix . strrchr($entry_fileName, '.');
}
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO || $media_type == entry::ENTRY_MEDIA_TYPE_AUDIO) {
$entry_status = entryStatus::PRECONVERT;
}
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_FILE");
} else {
if ($media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
// set $entry_fileName to webcam output file and flag that conversion is not needed
$webcam_basePath = $content . '/content/webcam/' . ($webcam_suffix ? $webcam_suffix : 'my_recorded_stream_' . $kuser_id);
$entry_fullPath = $webcam_basePath . '.' . kWAMSWebcam::OUTPUT_FILE_EXT;
$ext = kWAMSWebcam::OUTPUT_FILE_EXT;
if (file_exists($entry_fullPath)) {
// continue tracking the webcam
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_WEBCAM");
} else {
KalturaLog::err("File [{$entry_fullPath}] does not exist");
$entry_status = entryStatus::ERROR_IMPORTING;
}
} else {
// if the url ends with .ext, we'll extract it this way
$urlext = strrchr($entry_url, '.');
// TODO: fix this patch
if (strlen($urlext) > 4) {
$urlext = '.jpg';
}
// if we got something wierd, assume we're downloading a jpg
$entry_fileName = $entry_data_prefix . $urlext;
KalturaLog::debug("handleEntry: media_type: {$media_type}");
if ($media_type == entry::ENTRY_MEDIA_TYPE_IMAGE) {
$duration = 0;
$entry_fullPath = $uploads . $entry_fileName;
if (!kFile::downloadUrlToFile($entry_url, $entry_fullPath)) {
KalturaLog::debug("Failed downloading file[{$entry_url}]");
$entry_status = entryStatus::ERROR_IMPORTING;
}
// track images
$te->setParam3Str($entry_fullPath);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_URL:ENTRY_MEDIA_TYPE_IMAGE");
} else {
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO) {
//fixme - we can extract during import
$ext = "flv";
} else {
$ext = "mp3";
}
$entry_status = entryStatus::IMPORT;
// track images
$te->setParam3Str($ext);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_URL:ENTRY_MEDIA_TYPE_VIDEO");
}
}
}
if ($ext == null) {
$entry_fullPathTmp = $entry_fullPath;
$qpos = strpos($entry_fullPathTmp, "?");
if ($qpos !== false) {
$entry_fullPathTmp = substr($entry_fullPathTmp, 0, $qpos);
}
$ext = strtolower(pathinfo($entry_fullPathTmp, PATHINFO_EXTENSION));
}
// save the Trackentry
TrackEntry::addTrackEntry($te);
KalturaLog::debug("handleEntry: ext: {$ext}");
// We don't want to reject entries based on file extentions anumore
// Remarked by Tan-Tan
//
// if ($entry_status == entryStatus::PRECONVERT && !myContentStorage::fileExtNeedConversion($ext))
// {
//
// $this->errorMsg = "insertEntryAction Error - PRECONVERT file type not acceptable ($ext)";
// KalturaLog::debug("handleEntry: err: $this->errorMsg");
// if(is_null($entry) && $this->entry_id)
// {
// $entry = entryPeer::retrieveByPK($this->entry_id);
// }
// if($entry)
// {
// $entry->setStatus(entryStatus::ERROR_CONVERTING);
// $entry->save();
// }
// return false;
// }
$media_date = null;
// We don't want to reject entries based on file extentions anumore
// Remarked by Tan-Tan
//
// // if entry is ready, validate file type (webcam is an exception since we control the file type - flv)
// if ($entry_status == entryStatus::READY &&
// $media_source != entry::ENTRY_MEDIA_SOURCE_WEBCAM && !myContentStorage::fileExtAccepted($ext))
// {
// $this->errorMsg = "insertEntryAction Error - READY file type not acceptable ($ext)";
// KalturaLog::debug("handleEntry: err: $this->errorMsg");
// if(is_null($entry) && $this->entry_id)
// {
// $entry = entryPeer::retrieveByPK($this->entry_id);
// }
// if($entry)
// {
// $entry->setStatus(entryStatus::ERROR_CONVERTING);
// $entry->save();
// }
// return false;
// }
if ($entry_status == entryStatus::ERROR_IMPORTING) {
$need_thumb = false;
// we wont be needing a thumb for an errornous entry
KalturaLog::debug("handleEntry: error importing, thumb not needed");
} else {
// thumbs are created by one of the following ways:
// 1. Image - images are already on disk for every selection method, so we can just create a thumb
// 2. Audio - no thumb is needed
// 3. Video -
// a. uploaded (file / webcam) - file is on disk and the user already selected a thumb
// b. imported - the source site had a thumbnail and we'll use it
$thumbTempPrefix = $uploads . $entry_data_prefix . '_thumbnail_';
$thumbBigFullPath = null;
$need_thumb = $type == entryType::MEDIA_CLIP;
KalturaLog::debug("handleEntry: handling media {$media_type}");
if ($media_type == entry::ENTRY_MEDIA_TYPE_IMAGE) {
// fetch media creation date
$exif_image_type = @exif_imagetype($entry_fullPath);
if ($exif_image_type == IMAGETYPE_JPEG || $exif_image_type == IMAGETYPE_TIFF_II || $exif_image_type == IMAGETYPE_TIFF_MM || $exif_image_type == IMAGETYPE_IFF || $exif_image_type == IMAGETYPE_PNG) {
$exif_data = @exif_read_data($entry_fullPath);
if ($exif_data && isset($exif_data["DateTimeOriginal"]) && $exif_data["DateTimeOriginal"]) {
$media_date = $exif_data["DateTimeOriginal"];
$ts = strtotime($media_date);
// handle invalid dates either due to bad format or out of range
if ($ts === -1 || $ts === false || $ts < strtotime('2000-01-01') || $ts > strtotime('2015-01-01')) {
$media_date = null;
}
}
}
// create thumb
$thumbFullPath = $thumbTempPrefix . '1.jpg';
$entry_thumbNum = 1;
$need_thumb = true;
//copy($entry_fullPath, $thumbFullPath);
myFileConverter::createImageThumbnail($entry_fullPath, $thumbFullPath, "image2");
//$thumbBigFullPath = $thumbFullPath; // no filesync for thumbnail of image
} else {
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO) {
if ($entry_status == entryStatus::IMPORT || $media_source == entry::ENTRY_MEDIA_SOURCE_URL) {
// import thumb and convert to our size
$thumbFullPath = $thumbTempPrefix . '1.jpg';
$entry_thumbNum = 1;
$importedThumbPath = $uploads . $entry_data_prefix . '_temp_thumb' . strrchr($entry_thumbUrl, '.');
if (kFile::downloadUrlToFile($entry_thumbUrl, $importedThumbPath)) {
myFileConverter::createImageThumbnail($importedThumbPath, $thumbFullPath, "image2");
// set thumb as big thumb so fileSync will be created.
$thumbBigFullPath = $thumbFullPath;
} else {
$need_thumb = false;
}
} else {
if ($entry_thumbNum == 0) {
$entry_thumbNum = 1;
$thumbTime = 3;
if ($duration && $duration < $thumbTime * 1000) {
$thumbTime = floor($duration / 1000);
}
// for videos - thumbail should be created in post convert
// otherwise this code will fail if the thumbanil wasn't created successfully (roman)
//myFileConverter::autoCaptureFrame($entry_fullPath, $thumbTempPrefix."big_", $thumbTime, -1, -1);
$need_thumb = false;
$thumbBigFullPath = $thumbTempPrefix . "big_" . $entry_thumbNum . '.jpg';
}
}
//else select existing thumb ($entry_thumbNum already points to the right thumbnail)
}
}
$thumbFullPath = $thumbTempPrefix . $entry_thumbNum . '.jpg';
// if we arrived here both entry and thumbnail are valid we can now update the db
// in order to have the final entry_id and move its data to its final destination
if ($onlyExtractThumb) {
return $thumbFullPath;
}
}
$entry->setkshowId($this->kshow_id);
$entry->setKuserId($kuser_id);
$entry->setCreatorKuserId($kuser_id);
if ($this->partner_id != null) {
$entry->setPartnerId($this->partner_id);
$entry->setSubpId($this->subp_id);
}
$entry->setName($name ? $name : $this->getParam('entry_name'));
// $entry->setDescription('');//$this->getParam('entry_description'));
$entry->setType($type);
$entry->setMediaType($media_type);
$entry->setTags($tags ? $tags : $this->getParam('entry_tags'));
$entry->setSource($media_source);
$entry->setSourceId($this->getParam('entry_media_id'));
if ($media_date) {
$entry->setMediaDate($media_date);
}
// if source_link wasnt given use the entry_url HOWEVER, use it only if id doesnt contain @ which suggests the use of a password
$entry->setSourceLink($entry_source_link ? $entry_source_link : (strstr($entry_url, '@') ? "" : $entry_url));
if ($media_source == entry::ENTRY_MEDIA_SOURCE_FILE) {
$entry->setSourceLink("file:{$entry_fullPath}");
}
$entry->setLicenseType($this->getParam('entry_license'));
$entry->setCredit($this->getParam('entry_credit'));
$entry->setStatus($entry_status);
if ($duration !== null) {
$entry->setLengthInMsecs($duration);
}
if ($this->entry_id == 0) {
$entry->save();
$this->entry_id = $entry->getId();
}
// move thumb to final destination and set db entry
if ($media_type != entry::ENTRY_MEDIA_TYPE_AUDIO && $entry_thumbNum && $need_thumb) {
KalturaLog::debug("handleEntry: saving none audio thumb [{$thumbBigFullPath}]");
$entry->setThumbnail('.jpg');
if ($thumbBigFullPath) {
if ($media_type != entry::ENTRY_MEDIA_TYPE_IMAGE) {
myFileConverter::convertImage($thumbBigFullPath, $thumbFullPath);
}
/*$thumbBigFinalPath = $content.$entry->getBigThumbnailPath();
myContentStorage::moveFile($thumbBigFullPath, $thumbBigFinalPath, true , $should_copy );
*/
$entryThumbKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($thumbBigFullPath, $entryThumbKey);
} else {
kFileSyncUtils::copyFromFile($thumbBigFullPath, $entryThumbKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$entry->save();
throw $e;
}
}
}
// after extracting the thumb we can move the entry to its next destination
KalturaLog::debug("handleEntry: current status [" . $entry->getStatus() . "]");
// if needed a job will be submitted for importing external media sources
if ($entry->getStatus() == entryStatus::IMPORT) {
KalturaLog::debug("handleEntry: creating import job");
// changed by Tan-Tan, Nov 09 to support the new batch mechanism
kJobsManager::addImportJob(null, $this->entry_id, $this->partner_id, $entry_url);
// remarked by Tan-Tan
// $entry_fullPath = $content.'/content/imports/data/'.$this->entry_id.".".$ext;
// myContentStorage::fullMkdir($entry_fullPath);
//
// $batchClient = new myBatchUrlImportClient();
// $batchClient->addJob($this->entry_id, $entry_url, $entry_fullPath);
} else {
if ($entry->getStatus() == entryStatus::PRECONVERT) {
if (!$skip_conversion) {
// changed by Tan-Tan, Dec 09 to support the new batch mechanism
KalturaLog::debug("handleEntry: creating original flavor asset for pre convert");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
} else {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
}
// Remarked by Tan-Tan
// $targetFileName = $this->entry_id.".".$ext;
// if ( false /* old conversion */)
// {
// // if we need to convert move entry to conversion directory
// $preConvPath = $content.'/content/preconvert/';
// myContentStorage::moveFile($entry_fullPath, $preConvPath."data/".$targetFileName, true , $should_copy );
//
// $signalFilePath = $preConvPath."files/".$targetFileName;
// myContentStorage::fullMkdir($signalFilePath);
// touch($signalFilePath);
// }
// else
// {
// $preConvPath = myContentStorage::getFSContentRootPath (). "/content/new_preconvert";
// $to_data = $preConvPath . "/$targetFileName" ;
// myContentStorage::moveFile($entry_fullPath, $to_data , true);
// touch ( $to_data . ".indicator" );
// }
}
} else {
if ($entry->getStatus() == entryStatus::PENDING || $media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
$entry->setData($entry_fullPath);
$entry->save();
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO || $media_type == entry::ENTRY_MEDIA_TYPE_AUDIO) {
KalturaLog::debug("handleEntry: creating original flavor asset for ready entry");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$ext = pathinfo($entry_fullPath, PATHINFO_EXTENSION);
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $syncKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
// // bypass to conversion
// kBusinessPreConvertDL::bypassConversion($flavorAsset, $entry);
/**
* if this is webcam entry, create mediaInfo for the source flavor asset synchronously
* since entry is ready right at the beginning
*/
if ($media_source == entry::ENTRY_MEDIA_SOURCE_WEBCAM) {
require_once SF_ROOT_DIR . DIRECTORY_SEPARATOR . ".." . DIRECTORY_SEPARATOR . "api_v3" . DIRECTORY_SEPARATOR . "bootstrap.php";
// extract file path
$sourceFileKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$sourceFilePath = kFileSyncUtils::getLocalFilePathForKey($sourceFileKey);
// call mediaInfo for file
$mediaInfo = new mediaInfo();
try {
$mediaInfoParser = new KMediaInfoMediaParser($sourceFilePath, kConf::get('bin_path_mediainfo'));
$KalturaMediaInfo = new KalturaMediaInfo();
$KalturaMediaInfo = $mediaInfoParser->getMediaInfo();
$mediaInfo = $KalturaMediaInfo->toInsertableObject($mediaInfo);
$mediaInfo->setFlavorAssetId($flavorAsset->getId());
$mediaInfo->save();
} catch (Exception $e) {
KalturaLog::err("Getting media info: " . $e->getMessage());
$mediaInfo = null;
}
// fix flavor asset according to mediainfo
if ($mediaInfo) {
KDLWrap::ConvertMediainfoCdl2FlavorAsset($mediaInfo, $flavorAsset);
$flavorTags = KDLWrap::CDLMediaInfo2Tags($mediaInfo, array(flavorParams::TAG_WEB, flavorParams::TAG_MBR));
$flavorAsset->setTags(implode(',', $flavorTags));
}
$flavorAsset->save();
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
$flavorAsset->setStatusLocalReady();
$flavorAsset->save();
} else {
$entry->setStatus(entryStatus::ERROR_IMPORTING);
}
} else {
if ($entry->getType() == entryType::DOCUMENT) {
//TODO: document should be handled by the plugin manager)
KalturaLog::debug("handleEntry: creating original flavor asset for ready entry");
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->partner_id, $this->entry_id);
if ($flavorAsset) {
$ext = pathinfo($entry_fullPath, PATHINFO_EXTENSION);
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $syncKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $syncKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$entry->save();
$flavorAsset->save();
throw $e;
}
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
}
} else {
KalturaLog::debug("handleEntry: creating data file sync for file [{$entry_fullPath}]");
$entryDataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
if (!kFileSyncUtils::file_exists($entryDataKey)) {
try {
if (!$should_copy) {
kFileSyncUtils::moveFromFile($entry_fullPath, $entryDataKey);
} else {
// copy & create file sync from $entry_fullPath
kFileSyncUtils::copyFromFile($entry_fullPath, $entryDataKey);
}
} catch (Exception $e) {
$entry->setStatus(entryStatus::ERROR_CONVERTING);
$entry->save();
throw $e;
}
}
$entry->setStatus(entryStatus::READY);
$entry->save();
}
}
// Remarked by Tan-Tan, the flavor asset should be synced instead of the entry
//
// $entryDataKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
// if(!$should_copy)
// {
// kFileSyncUtils::moveFromFile($entry_fullPath, $entryDataKey);
// }
// else
// {
// // copy & create file sync from $entry_fullPath
// kFileSyncUtils::copyFromFile($entry_fullPath, $entryDataKey);
// }
}
}
}
if ($entry->getStatus() == entryStatus::READY) {
$entry->updateDimensions();
}
$entry->save();
return true;
}
public static function removeTempKUserContent($kuser_id)
{
$filePattern = myContentStorage::getFSUploadsPath() . $kuser_id . '_*.*';
foreach (glob($filePattern) as $filename) {
unlink($filename);
}
}
}
</script>
<h1>Recent MMS uploads</h1>
<?php
require_once 'myMailAttachmentImporter.class.php';
$host = "mail.kaltura.com";
// imap host
$login = "******";
//imap login
$password = "******";
//imap password
$importer = new myMailAttachmentImporter();
// Creating instance of class####
$importedMessageDataArray = $importer->getdata($host, $login, $password, myContentStorage::getFSUploadsPath());
if ($importedMessageDataArray != null) {
echo 'Number of messages in mailbox ' . $login . ': ' . count($importedMessageDataArray);
echo '<hr>';
foreach ($importedMessageDataArray as $importedMessageData) {
echo 'subject:' . $importedMessageData["subject"] . '<BR>';
echo 'from:' . $importedMessageData["fromaddress"] . '<BR>';
echo 'date:' . $importedMessageData["date"] . '<BR>';
echo 'body:' . $importedMessageData["body"] . '<BR>';
if ($importedMessageData["attachment"]) {
echo 'type = ' . $importedMessageData["attachment"]["type"] . '/' . $importedMessageData["attachment"]["subtype"] . '<BR>';
if ($importedMessageData["attachment"]["type"] == 'image') {
echo '<img width="100" width="100" src="/content/uploads/' . $importedMessageData["attachment"]["filename"] . '"><BR>';
} else {
echo '<img width="100" width="100" src="/content/uploads/' . $importedMessageData["attachment"]["thumbnail"] . '">';
echo '<a href="/content/uploads/' . $importedMessageData["attachment"]["filename"] . '">download file</a>';
public static function createThumbnailFromEntry(entry $entry, entry $source_entry, $time_offset, $flavorParamsId = null)
{
$media_type = $source_entry->getMediaType();
// should capture thumbnail from video
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO && $time_offset != -1) {
$flavorAsset = null;
if ($flavorParamsId) {
$flavorAsset = flavorAssetPeer::retrieveByEntryIdAndFlavorParams($source_entry->getId(), $flavorParamsId);
}
if (is_null($flavorAsset) || $flavorAsset->getStatus() != flavorAsset::FLAVOR_ASSET_STATUS_READY) {
$flavorAsset = flavorAssetPeer::retrieveOriginalByEntryId($source_entry->getId());
}
if (is_null($flavorAsset)) {
$flavorAsset = flavorAssetPeer::retrieveHighestBitrateByEntryId($source_entry->getId());
}
if (is_null($flavorAsset)) {
throw new Exception("Flavor asset not found");
}
$flavorSyncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
if (!$flavorSyncKey) {
return false;
}
$dataPath = kFileSyncUtils::getReadyLocalFilePathForKey($flavorSyncKey);
$tempPath = myContentStorage::getFSUploadsPath();
$tempThumbPrefix = $tempPath . "temp_thumb" . microtime(true);
$thumbBigFullPath = $tempThumbPrefix . "big_1.jpg";
$thumbFullPath = $tempThumbPrefix . '1.jpg';
myFileConverter::autoCaptureFrame($dataPath, $tempThumbPrefix . "big_", $time_offset, -1, -1);
// removed creation of "small thumb" - not in use
myFileConverter::convertImage($thumbBigFullPath, $thumbFullPath);
$bigThumbExists = file_exists($thumbBigFullPath) && filesize($thumbBigFullPath);
if (!$bigThumbExists) {
return false;
}
$entry->setThumbnail(".jpg");
$entry->save();
// create new thumb file for entry
$newThumbKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
kFileSyncUtils::moveFromFile($thumbBigFullPath, $newThumbKey);
} else {
if ($media_type == entry::ENTRY_MEDIA_TYPE_VIDEO && $time_offset == -1 || $media_type == entry::ENTRY_MEDIA_TYPE_SHOW) {
$thumbBigFullKey = $source_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
if (!kFileSyncUtils::fileSync_exists($thumbBigFullKey)) {
return false;
}
$entry->setThumbnail(".jpg");
$entry->save();
// copy existing thumb
$newThumbKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
kFileSyncUtils::softCopy($thumbBigFullKey, $newThumbKey);
} elseif ($media_type == entry::ENTRY_MEDIA_TYPE_IMAGE) {
$thumb_key = $source_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
$thumb_path = kFileSyncUtils::getLocalFilePathForKey($thumb_key);
$entry->setThumbnail(".jpg");
$entry->save();
// copy existing thumb
$newThumbKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
kFileSyncUtils::copyFromFile($thumb_path, $newThumbKey);
} else {
return false;
}
}
self::disableAutoThumbnailCreation($entry->getId());
return true;
}
function saveAttachments($mid)
{
$attachments = $this->locateAttachments();
if (!$attachments) {
$this->importedMessageDataArray[$mid]["attachment"] = null;
return;
}
$part = $this->getPartByPartNum("1");
// we will save only the first attachment, which is always in position 2
$mege = imap_fetchbody($this->mbox, $mid, "2");
$ext = strtolower($part->subtype);
if ($ext == 'jpeg') {
$ext = 'jpg';
}
$data = $this->getdecodevalue($mege, $part->encoding);
$filename = "{$this->savedDirPath}" . $mid . "_attach." . $ext;
$fp = fopen($filename, "w");
fputs($fp, $data);
fclose($fp);
// now create thumbnail images
if ($part->type == 5) {
myFileConverter::createImageThumbnail($filename, "{$this->savedDirPath}" . $mid . "_thumbnail1.jpg", "image2");
$this->importedMessageDataArray[$mid]["attachment"]["thumbnail"] = $mid . "_thumbnail1.jpg";
} else {
if ($part->type == 6) {
$thumbPrefix = myContentStorage::getFSUploadsPath() . '_thumbnail';
myFileConverter::captureFrame($filename, "{$this->savedDirPath}" . $mid . "_thumbnail%d.jpg", 1, "image2");
$this->importedMessageDataArray[$mid]["attachment"]["thumbnail"] = $mid . "_thumbnail1.jpg";
} else {
$this->importedMessageDataArray[$mid]["attachment"]["thumbnail"] = "";
}
}
/*
* TODO: handle the case for audio upload, or other cases where there is no image thumbnail
*/
$this->importedMessageDataArray[$mid]["attachment"]["type"] = $this->attachmenttype[$part->type];
$this->importedMessageDataArray[$mid]["attachment"]["subtype"] = strtolower($part->subtype);
$this->importedMessageDataArray[$mid]["attachment"]["filename"] = $mid . "_attach." . $ext;
}
/**
* Returns the target upload path for upload token id and extension
* @param string $uploadTokenId
* @param string $extension
*/
protected function getUploadPath($uploadTokenId, $extension = '')
{
if (!$extension) {
$extension = self::NO_EXTENSION_IDENTIFIER;
}
return myContentStorage::getFSUploadsPath() . $uploadTokenId . '.' . $extension;
}
/**
* @param CaptionAsset $captionAsset
* @param string $url
*/
protected function attachUrl(CaptionAsset $captionAsset, $url)
{
$fullPath = myContentStorage::getFSUploadsPath() . '/' . basename($url);
if (KCurlWrapper::getDataFromFile($url, $fullPath)) {
return $this->attachFile($captionAsset, $fullPath);
}
if ($captionAsset->getStatus() == CaptionAsset::ASSET_STATUS_QUEUED || $captionAsset->getStatus() == CaptionAsset::ASSET_STATUS_NOT_APPLICABLE) {
$captionAsset->setDescription("Failed downloading file[{$url}]");
$captionAsset->setStatus(CaptionAsset::ASSET_STATUS_ERROR);
$captionAsset->save();
}
throw new KalturaAPIException(KalturaCaptionErrors::CAPTION_ASSET_DOWNLOAD_FAILED, $url);
}
/**
* @param thumbAsset $thumbAsset
* @param string $url
*/
protected function attachUrl(thumbAsset $thumbAsset, $url)
{
$fullPath = myContentStorage::getFSUploadsPath() . '/' . $thumbAsset->getId() . '.jpg';
if (kFile::downloadUrlToFile($url, $fullPath)) {
return $this->attachFile($thumbAsset, $fullPath);
}
if ($thumbAsset->getStatus() == thumbAsset::ASSET_STATUS_QUEUED || $thumbAsset->getStatus() == thumbAsset::ASSET_STATUS_NOT_APPLICABLE) {
$thumbAsset->setDescription("Failed downloading file[{$url}]");
$thumbAsset->setStatus(thumbAsset::ASSET_STATUS_ERROR);
$thumbAsset->save();
}
throw new KalturaAPIException(KalturaErrors::THUMB_ASSET_DOWNLOAD_FAILED, $url);
}
/**
* @param AttachmentAsset $attachmentAsset
* @param string $url
*/
protected function attachUrl(AttachmentAsset $attachmentAsset, $url)
{
$fullPath = myContentStorage::getFSUploadsPath() . '/' . basename($url);
if (kFile::downloadUrlToFile($url, $fullPath)) {
return $this->attachFile($attachmentAsset, $fullPath);
}
if ($attachmentAsset->getStatus() == AttachmentAsset::ASSET_STATUS_QUEUED || $attachmentAsset->getStatus() == AttachmentAsset::ASSET_STATUS_NOT_APPLICABLE) {
$attachmentAsset->setDescription("Failed downloading file[{$url}]");
$attachmentAsset->setStatus(AttachmentAsset::ASSET_STATUS_ERROR);
$attachmentAsset->save();
}
throw new KalturaAPIException(KalturaAttachmentErrors::ATTACHMENT_ASSET_DOWNLOAD_FAILED, $url);
}
/**
* @param BatchJob $parentJob
* @param int $partnerId
* @param string $entryId
* @param string $thumbAssetId
* @param FileSyncKey $srcSyncKey
* @param string $srcAssetId
* @param int $srcAssetType enum of assetType
* @param thumbParamsOutput $thumbParams
* @return BatchJob
*/
public static function addCapturaThumbJob(BatchJob $parentJob = null, $partnerId, $entryId, $thumbAssetId, FileSyncKey $srcSyncKey, $srcAssetId, $srcAssetType, thumbParamsOutput $thumbParams = null)
{
$thumbAsset = assetPeer::retrieveById($thumbAssetId);
if (!$thumbAsset) {
KalturaLog::err("No thumbnail asset found for id [{$thumbAssetId}]");
return null;
}
$partner = PartnerPeer::retrieveByPK($thumbAsset->getPartnerId());
list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($srcSyncKey, true, false);
if (!$fileSync) {
$thumbAsset->setStatus(asset::ASSET_STATUS_ERROR);
$thumbAsset->setDescription("Source file sync not found: {$srcSyncKey}");
$thumbAsset->save();
KalturaLog::err("Source file sync not found: {$srcSyncKey}");
return null;
}
if (!$local) {
if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL && $partner && $partner->getImportRemoteSourceForConvert()) {
$url = $fileSync->getExternalUrl($entryId);
$originalAsset = kFileSyncUtils::retrieveObjectForSyncKey($srcSyncKey);
if ($originalAsset instanceof flavorAsset) {
KalturaLog::debug("Creates import job for remote file sync [{$url}]");
if ($thumbParams) {
$thumbParams->setSourceParamsId($originalAsset->getFlavorParamsId());
$thumbParams->save();
}
$thumbAsset->setStatus(asset::ASSET_STATUS_WAIT_FOR_CONVERT);
$thumbAsset->setDescription("Source file sync is importing: {$srcSyncKey}");
$thumbAsset->save();
return kJobsManager::addImportJob($parentJob, $thumbAsset->getEntryId(), $partner->getId(), $url, $originalAsset, null, null, true);
}
KalturaLog::debug("Downloading remote file sync [{$url}]");
$downloadPath = myContentStorage::getFSUploadsPath() . '/' . $thumbAsset->getId() . '.jpg';
if (KCurlWrapper::getDataFromFile($url, $downloadPath)) {
kFileSyncUtils::moveFromFile($downloadPath, $srcSyncKey);
list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($srcSyncKey, false, false);
if (!$fileSync) {
throw new kCoreException("Source file not found for thumbnail capture [{$thumbAssetId}]", kCoreException::SOURCE_FILE_NOT_FOUND);
}
}
} else {
throw new kCoreException("Source file not found for thumbnail capture [{$thumbAssetId}]", kCoreException::SOURCE_FILE_NOT_FOUND);
}
}
$localPath = $fileSync->getFullPath();
$remoteUrl = $fileSync->getExternalUrl($entryId);
// creates convert data
$data = new kCaptureThumbJobData();
$data->setThumbAssetId($thumbAssetId);
$data->setSrcAssetId($srcAssetId);
$data->setSrcAssetType($srcAssetType);
$data->setSrcFileSyncLocalPath($localPath);
$data->setSrcFileSyncRemoteUrl($remoteUrl);
$data->setThumbParamsOutputId($thumbParams->getId());
$batchJob = null;
if ($parentJob) {
$batchJob = $parentJob->createChild(BatchJobType::CAPTURE_THUMB);
} else {
$batchJob = new BatchJob();
$batchJob->setEntryId($entryId);
$batchJob->setPartnerId($partnerId);
}
$batchJob->setObjectId($thumbAssetId);
$batchJob->setObjectType(BatchJobObjectType::ASSET);
return kJobsManager::addJob($batchJob, $data, BatchJobType::CAPTURE_THUMB);
}
/**
* Returns the target upload path for upload token id and extension
* @param string $uploadTokenId
* @param string $extension
*/
protected function getUploadPath($uploadTokenId, $extension = '')
{
if (!$extension) {
$extension = 'noext';
}
return myContentStorage::getFSUploadsPath() . $uploadTokenId . '.' . $extension;
}
