/**
* @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));
}
/**
* @action sync
* @param int $fileSyncId
* @param file $fileData
* @return KalturaFileSync
*/
function syncAction($fileSyncId, $fileData)
{
$dbFileSync = FileSyncPeer::retrieveByPK($fileSyncId);
if (!$dbFileSync) {
throw new APIException(APIErrors::INVALID_FILE_SYNC_ID, $fileSyncId);
}
$key = kFileSyncUtils::getKeyForFileSync($dbFileSync);
kFileSyncUtils::moveFromFile($fileData['tmp_name'], $key, false);
list($file_root, $real_path) = kPathManager::getFilePathArr($key);
$full_path = $file_root . $real_path;
chmod($full_path, 0644);
if (file_exists($full_path)) {
$dbFileSync->setFileRoot($file_root);
$dbFileSync->setFilePath($real_path);
$dbFileSync->setFileSizeFromPath($full_path);
$dbFileSync->setStatus(FileSync::FILE_SYNC_STATUS_READY);
} else {
$dbFileSync->setFileSize(-1);
$dbFileSync->setStatus(FileSync::FILE_SYNC_STATUS_ERROR);
}
$dbFileSync->save();
$fileSync = new KalturaFileSync();
$fileSync->fromObject($dbFileSync);
return $fileSync;
}
/**
* Add new document entry after the specific document file was uploaded and the upload token id exists
*
* @action addFromUploadedFile
* @param KalturaDocumentEntry $documentEntry Document entry metadata
* @param string $uploadTokenId Upload token id
* @return KalturaDocumentEntry The new document entry
*
* @throws KalturaErrors::PROPERTY_VALIDATION_MIN_LENGTH
* @throws KalturaErrors::PROPERTY_VALIDATION_CANNOT_BE_NULL
* @throws KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN
*/
function addFromUploadedFileAction(KalturaDocumentEntry $documentEntry, $uploadTokenId)
{
try {
// check that the uploaded file exists
$entryFullPath = kUploadTokenMgr::getFullPathByUploadTokenId($uploadTokenId);
} 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)) {
$remoteDCHost = kUploadTokenMgr::getRemoteHostForUploadToken($uploadTokenId, kDataCenterMgr::getCurrentDcId());
if ($remoteDCHost) {
kFile::dumpApiRequest($remoteDCHost);
} else {
throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN);
}
}
$dbEntry = $this->prepareEntryForInsert($documentEntry);
$dbEntry->setSource(KalturaSourceType::FILE);
$dbEntry->setSourceLink("file:{$entryFullPath}");
$dbEntry->save();
$te = new TrackEntry();
$te->setEntryId($dbEntry->getId());
$te->setTrackEventTypeId(TrackEntry::TRACK_ENTRY_EVENT_TYPE_ADD_ENTRY);
$te->setDescription(__METHOD__ . ":" . __LINE__ . "::ENTRY_MEDIA_SOURCE_FILE");
TrackEntry::addTrackEntry($te);
$msg = null;
$flavorAsset = kFlowHelper::createOriginalFlavorAsset($this->getPartnerId(), $dbEntry->getId(), $msg);
if (!$flavorAsset) {
KalturaLog::err("Flavor asset not created for entry [" . $dbEntry->getId() . "] reason [{$msg}]");
$dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
$dbEntry->save();
} else {
$ext = pathinfo($entryFullPath, PATHINFO_EXTENSION);
KalturaLog::info("Uploaded file extension: {$ext}");
$flavorAsset->setFileExt($ext);
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($entryFullPath, $syncKey);
kEventsManager::raiseEvent(new kObjectAddedEvent($flavorAsset));
}
kUploadTokenMgr::closeUploadTokenById($uploadTokenId);
myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_ADD, $dbEntry);
$documentEntry->fromObject($dbEntry);
return $documentEntry;
}
public static function handleJobFinished(BatchJob $job, kScheduledTaskJobData $data)
{
$resultFilePath = $data->getResultsFilePath();
if (!file_exists($resultFilePath)) {
return self::finishJobWithError($job, 'Results file was not found');
}
// we are using the bulk upload sync key, as this should actually be a generic sync key for batch job object
$syncKey = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_BULKUPLOAD);
try {
kFileSyncUtils::moveFromFile($resultFilePath, $syncKey, true);
} catch (Exception $ex) {
KalturaLog::err($ex);
return self::finishJobWithError($job, 'Failed to move file: ' . $ex->getMessage());
}
return $job;
}
/**
* Add new bulk upload batch job
* Conversion profile id can be specified in the API or in the CSV file, the one in the CSV file will be stronger.
* If no conversion profile was specified, partner's default will be used
*
* @action add
* @param int $conversionProfileId Convertion profile id to use for converting the current bulk (-1 to use partner's default)
* @param file $csvFileData CSV File
* @return KalturaBulkUpload
*/
function addAction($conversionProfileId, $csvFileData)
{
// first we copy the file to "content/batchfiles/[partner_id]/"
$origFilename = $csvFileData["name"];
$fileInfo = pathinfo($origFilename);
$extension = strtolower($fileInfo["extension"]);
if ($extension != "csv") {
throw new KalturaAPIException(KalturaErrors::INVALID_FILE_EXTENSION);
}
$job = new BatchJob();
$job->setPartnerId($this->getPartnerId());
$job->save();
$syncKey = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_BULKUPLOADCSV);
// kFileSyncUtils::file_put_contents($syncKey, file_get_contents($csvFileData["tmp_name"]));
try {
kFileSyncUtils::moveFromFile($csvFileData["tmp_name"], $syncKey, true);
} catch (Exception $e) {
throw new KalturaAPIException(KalturaErrors::BULK_UPLOAD_CREATE_CSV_FILE_SYNC_ERROR);
}
$csvPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$data = new KalturaBulkUploadJobData();
$data->csvFilePath = $csvPath;
$data->userId = $this->getKuser()->getPuserId();
$data->uploadedBy = $this->getKuser()->getScreenName();
if ($conversionProfileId === -1) {
$conversionProfileId = $this->getPartner()->getDefaultConversionProfileId();
}
$kmcVersion = $this->getPartner()->getKmcVersion();
$check = null;
if ($kmcVersion < 2) {
$check = ConversionProfilePeer::retrieveByPK($conversionProfileId);
} else {
$check = conversionProfile2Peer::retrieveByPK($conversionProfileId);
}
if (!$check) {
throw new KalturaAPIException(KalturaErrors::CONVERSION_PROFILE_ID_NOT_FOUND, $conversionProfileId);
}
$data->conversionProfileId = $conversionProfileId;
$dbJob = kJobsManager::addJob($job, $data->toObject(), KalturaBatchJobType::BULKUPLOAD);
$bulkUpload = new KalturaBulkUpload();
$bulkUpload->fromObject($dbJob);
return $bulkUpload;
}
public function objectChanged(BaseObject $object, array $modifiedColumns)
{
// replacing the ismc file name in the ism file
$ismPrevVersionFileSyncKey = $object->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
$ismContents = kFileSyncUtils::file_get_contents($ismPrevVersionFileSyncKey);
$ismcPrevVersionFileSyncKey = $object->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ISMC);
$ismcContents = kFileSyncUtils::file_get_contents($ismcPrevVersionFileSyncKey);
$ismcPrevVersionFilePath = kFileSyncUtils::getLocalFilePathForKey($ismcPrevVersionFileSyncKey);
$object->incrementVersion();
$object->save();
$ismcFileSyncKey = $object->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ISMC);
kFileSyncUtils::moveFromFile($ismcPrevVersionFilePath, $ismcFileSyncKey);
$ismcNewName = basename(kFileSyncUtils::getLocalFilePathForKey($ismcFileSyncKey));
KalturaLog::debug("Editing ISM set content to [{$ismcNewName}]");
$ismXml = new SimpleXMLElement($ismContents);
$ismXml->head->meta['content'] = $ismcNewName;
$tmpPath = kFileSyncUtils::getLocalFilePathForKey($ismPrevVersionFileSyncKey) . '.tmp';
file_put_contents($tmpPath, $ismXml->asXML());
kFileSyncUtils::moveFromFile($tmpPath, $object->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET));
return true;
}
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser)
{
$fileField = "csv_file";
$profileId = $this->getP("profile_id");
if (count($_FILES) == 0) {
$this->addError(APIErrors::NO_FILES_RECEIVED);
return;
}
if (!@$_FILES[$fileField]) {
$this->addError(APIErrors::INVALID_FILE_FIELD, $fileField);
return;
}
// first we copy the file to "content/batchfiles/[partner_id]/"
$origFilename = $_FILES[$fileField]['name'];
$fileInfo = pathinfo($origFilename);
$extension = strtolower($fileInfo['extension']);
if ($extension != "csv") {
$this->addError(APIErrors::INVALID_FILE_EXTENSION);
return;
}
$job = new BatchJob();
$job->setPartnerId($partner_id);
$job->save();
$syncKey = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_BULKUPLOADCSV);
// kFileSyncUtils::file_put_contents($syncKey, file_get_contents($csvFileData["tmp_name"]));
try {
kFileSyncUtils::moveFromFile($_FILES[$fileField]['tmp_name'], $syncKey, true);
} catch (Exception $e) {
throw new KalturaAPIException(KalturaErrors::BULK_UPLOAD_CREATE_CSV_FILE_SYNC_ERROR);
}
$csvPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$data = new kBulkUploadJobData();
$data->setCsvFilePath($csvPath);
$data->setUserId($puser_kuser->getPuserId());
$data->setUploadedBy($puser_kuser->getPuserName());
$data->setConversionProfileId($profileId);
kJobsManager::addJob($job, $data, BatchJobType::BULKUPLOAD);
$this->addMsg("status", "ok");
}
private function onBulkUploadJobStatusUpdated(BatchJob $dbBatchJob)
{
$xmlDropFolderFile = DropFolderFilePeer::retrieveByPK($dbBatchJob->getObjectId());
if (!$xmlDropFolderFile) {
return;
}
KalturaLog::debug('object id ' . $dbBatchJob->getObjectId());
switch ($dbBatchJob->getStatus()) {
case BatchJob::BATCHJOB_STATUS_QUEUED:
$jobData = $dbBatchJob->getData();
if (!is_null($jobData->getFilePath())) {
$syncKey = $dbBatchJob->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_BULKUPLOAD);
try {
kFileSyncUtils::moveFromFile($jobData->getFilePath(), $syncKey, true);
} catch (Exception $e) {
KalturaLog::err($e);
throw new APIException(APIErrors::BULK_UPLOAD_CREATE_CSV_FILE_SYNC_ERROR);
}
$filePath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$jobData->setFilePath($filePath);
//save new info on the batch job
$dbBatchJob->setData($jobData);
$dbBatchJob->save();
}
break;
case BatchJob::BATCHJOB_STATUS_FINISHED:
case BatchJob::BATCHJOB_STATUS_FINISHED_PARTIALLY:
KalturaLog::debug("Handling Bulk Upload finished");
$xmlDropFolderFile->setStatus(DropFolderFileStatus::HANDLED);
$xmlDropFolderFile->save();
break;
case BatchJob::BATCHJOB_STATUS_FAILED:
case BatchJob::BATCHJOB_STATUS_FATAL:
KalturaLog::debug("Handling Bulk Upload failed");
$relatedFiles = DropFolderFilePeer::retrieveByLeadIdAndStatuses($xmlDropFolderFile->getId(), array(DropFolderFileStatus::PROCESSING));
foreach ($relatedFiles as $relatedFile) {
$this->setFileError($relatedFile, DropFolderFileStatus::ERROR_HANDLING, DropFolderXmlBulkUploadPlugin::getErrorCodeCoreValue(DropFolderXmlBulkUploadErrorCode::ERROR_IN_BULK_UPLOAD), DropFolderXmlBulkUploadPlugin::ERROR_IN_BULK_UPLOAD_MESSAGE);
}
break;
}
}
/**
* @action addFromImage
* @param string $entryId
* @param file $fileData
* @return KalturaThumbAsset
*
* @throws KalturaErrors::ENTRY_ID_NOT_FOUND
*/
public function addFromImageAction($entryId, $fileData)
{
$dbEntry = entryPeer::retrieveByPK($entryId);
if (!$dbEntry) {
throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
}
$ext = pathinfo($fileData["name"], PATHINFO_EXTENSION);
$dbThumbAsset = new thumbAsset();
$dbThumbAsset->setPartnerId($dbEntry->getPartnerId());
$dbThumbAsset->setEntryId($dbEntry->getId());
$dbThumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_QUEUED);
$dbThumbAsset->setFileExt($ext);
$dbThumbAsset->incrementVersion();
$dbThumbAsset->save();
$syncKey = $dbThumbAsset->getSyncKey(thumbAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($fileData["tmp_name"], $syncKey);
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
list($width, $height, $type, $attr) = getimagesize($finalPath);
$dbThumbAsset->setWidth($width);
$dbThumbAsset->setHeight($height);
$dbThumbAsset->setSize(filesize($finalPath));
$dbThumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_READY);
$dbThumbAsset->save();
$thumbAssets = new KalturaThumbAsset();
$thumbAssets->fromObject($dbThumbAsset);
return $thumbAssets;
}
// ---------------------------------------------------------------------------
$xsltFilePath = '';
//TODO: change to valid xslt file path
$metadataProfileId = null;
//TODO: change to a valid metadata profile id
// ---------------------------------------------------------------------------
if (!$xsltFilePath) {
die('ERROR - Missing parameter [$xsltFilePath]' . PHP_EOL);
}
if (!$metadataProfileId) {
die('ERROR - Missing parameter [$metadataProfileId]' . PHP_EOL);
}
if (!file_exists($xsltFilePath)) {
die('ERROR - Cannot find file at [' . $xsltFilePath . ']' . PHP_EOL);
}
require_once dirname(__FILE__) . '/../bootstrap.php';
require_once dirname(__FILE__) . '/../../api_v3/bootstrap.php';
KAutoloader::addClassPath(KAutoloader::buildPath(KALTURA_ROOT_PATH, "vendor", "propel", "*"));
KAutoloader::addClassPath(KAutoloader::buildPath(KALTURA_ROOT_PATH, "plugins", "metadata", "*"));
KAutoloader::setClassMapFilePath(kConf::get("cache_root_path") . '/scripts/' . basename(__FILE__) . '.cache');
KAutoloader::register();
KalturaPluginManager::addPlugin('MetadataPlugin');
$dbMetadataProfile = MetadataProfilePeer::retrieveById($metadataProfileId);
if (!$dbMetadataProfile) {
die('ERROR - Cannot find metadata profile with id [' . $metadataProfileId . ']' . PHP_EOL);
}
$dbMetadataProfile->incrementXsltVersion();
$dbMetadataProfile->save();
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_XSLT);
kFileSyncUtils::moveFromFile($xsltFilePath, $key, true, true);
echo 'Done' . PHP_EOL;
/**
* decideThumbGenerate is the decision layer for a single thumbnail generation
*
* @param entry $entry
* @param thumbParams $destThumbParams
* @param BatchJob $parentJob
* @return thumbAsset
*/
public static function decideThumbGenerate(entry $entry, thumbParams $destThumbParams, BatchJob $parentJob = null, $sourceAssetId = null, $runSync = false)
{
$srcAsset = null;
assetPeer::resetInstanceCriteriaFilter();
if ($sourceAssetId) {
$srcAsset = assetPeer::retrieveById($sourceAssetId);
} else {
if ($destThumbParams->getSourceParamsId()) {
KalturaLog::debug("Look for flavor params [" . $destThumbParams->getSourceParamsId() . "]");
$srcAsset = assetPeer::retrieveByEntryIdAndParams($entry->getId(), $destThumbParams->getSourceParamsId());
}
if (is_null($srcAsset)) {
KalturaLog::debug("Look for original flavor");
$srcAsset = flavorAssetPeer::retrieveOriginalByEntryId($entry->getId());
}
if (is_null($srcAsset) || $srcAsset->getStatus() != flavorAsset::FLAVOR_ASSET_STATUS_READY) {
KalturaLog::debug("Look for highest bitrate flavor");
$srcAsset = flavorAssetPeer::retrieveHighestBitrateByEntryId($entry->getId());
}
}
if (is_null($srcAsset)) {
throw new APIException(APIErrors::FLAVOR_ASSET_IS_NOT_READY);
}
$errDescription = null;
$mediaInfo = mediaInfoPeer::retrieveByFlavorAssetId($srcAsset->getId());
$destThumbParamsOutput = self::validateThumbAndMediaInfo($destThumbParams, $mediaInfo, $errDescription);
$thumbAsset = thumbAssetPeer::retrieveByEntryIdAndParams($entry->getId(), $destThumbParams->getId());
if ($thumbAsset) {
$description = $thumbAsset->getDescription() . "\n" . $errDescription;
$thumbAsset->setDescription($description);
} else {
$thumbAsset = new thumbAsset();
$thumbAsset->setPartnerId($entry->getPartnerId());
$thumbAsset->setEntryId($entry->getId());
$thumbAsset->setDescription($errDescription);
$thumbAsset->setFlavorParamsId($destThumbParams->getId());
}
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_CONVERTING);
$thumbAsset->setTags($destThumbParamsOutput->getTags());
$thumbAsset->setFileExt($destThumbParamsOutput->getFileExt());
if (!$destThumbParamsOutput) {
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->save();
return null;
}
$thumbAsset->save();
// save flavor params
$destThumbParamsOutput->setPartnerId($entry->getPartnerId());
$destThumbParamsOutput->setEntryId($entry->getId());
$destThumbParamsOutput->setFlavorAssetId($thumbAsset->getId());
$destThumbParamsOutput->setFlavorAssetVersion($thumbAsset->getVersion());
$destThumbParamsOutput->save();
$srcSyncKey = $srcAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$srcAssetType = $srcAsset->getType();
if (!$runSync) {
$job = kJobsManager::addCapturaThumbJob($parentJob, $entry->getPartnerId(), $entry->getId(), $thumbAsset->getId(), $srcSyncKey, $srcAssetType, $destThumbParamsOutput);
return $thumbAsset;
}
$errDescription = null;
$capturedPath = self::generateThumbnail($srcAsset, $destThumbParamsOutput, $errDescription);
// failed
if (!$capturedPath) {
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->setDescription($thumbAsset->getDescription() . "\n{$errDescription}");
$thumbAsset->save();
return $thumbAsset;
}
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_READY);
if (file_exists($capturedPath)) {
list($width, $height, $type, $attr) = getimagesize($capturedPath);
$thumbAsset->setWidth($width);
$thumbAsset->setHeight($height);
$thumbAsset->setSize(filesize($capturedPath));
}
$logPath = $capturedPath . '.log';
if (file_exists($logPath)) {
$thumbAsset->incLogFileVersion();
$thumbAsset->save();
// creats the file sync
$logSyncKey = $thumbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_CONVERT_LOG);
kFileSyncUtils::moveFromFile($logPath, $logSyncKey);
KalturaLog::debug("Log archived file to: " . kFileSyncUtils::getLocalFilePathForKey($logSyncKey));
} else {
$thumbAsset->save();
}
$syncKey = $thumbAsset->getSyncKey(thumbAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($capturedPath, $syncKey);
KalturaLog::debug("Thumbnail archived file to: " . kFileSyncUtils::getLocalFilePathForKey($syncKey));
if ($thumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
// increment thumbnail version
$entry->setThumbnail(".jpg");
$entry->save();
$entrySyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
$syncFile = kFileSyncUtils::createSyncFileLinkForKey($entrySyncKey, $syncKey, false);
if ($syncFile) {
// removes the DEFAULT_THUMB tag from all other thumb assets
$entryThumbAssets = thumbAssetPeer::retrieveByEntryId($thumbAsset->getEntryId());
foreach ($entryThumbAssets as $entryThumbAsset) {
if ($entryThumbAsset->getId() == $thumbAsset->getId()) {
continue;
}
if (!$entryThumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
continue;
}
$entryThumbAsset->removeTags(array(thumbParams::TAG_DEFAULT_THUMB));
$entryThumbAsset->save();
}
}
}
if (!is_null($thumbAsset->getFlavorParamsId())) {
kFlowHelper::generateThumbnailsFromFlavor($thumbAsset->getEntryId(), null, $thumbAsset->getFlavorParamsId());
}
return $thumbAsset;
}
/**
* @param string $entryFullPath
* @param entry $dbEntry
* @param asset $dbAsset
* @return asset
* @throws KalturaErrors::UPLOAD_TOKEN_INVALID_STATUS_FOR_ADD_ENTRY
* @throws KalturaErrors::UPLOADED_FILE_NOT_FOUND_BY_TOKEN
*/
protected function attachFile($entryFullPath, entry $dbEntry, asset $dbAsset = null, $copyOnly = false)
{
// TODO - move image handling to media service
if ($dbEntry->getMediaType() == KalturaMediaType::IMAGE) {
$exifImageType = @exif_imagetype($entryFullPath);
$validTypes = array(IMAGETYPE_JPEG, IMAGETYPE_TIFF_II, IMAGETYPE_TIFF_MM, IMAGETYPE_IFF, IMAGETYPE_PNG);
if (in_array($exifImageType, $validTypes)) {
$exifData = @exif_read_data($entryFullPath);
if ($exifData && isset($exifData["DateTimeOriginal"]) && $exifData["DateTimeOriginal"]) {
$mediaDate = $exifData["DateTimeOriginal"];
$ts = strtotime($mediaDate);
// 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')) {
$mediaDate = null;
}
$dbEntry->setMediaDate($mediaDate);
}
}
list($width, $height, $type, $attr) = getimagesize($entryFullPath);
$dbEntry->setDimensions($width, $height);
$dbEntry->setData(".jpg");
// this will increase the data version
$dbEntry->save();
$syncKey = $dbEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
try {
kFileSyncUtils::moveFromFile($entryFullPath, $syncKey, true, $copyOnly);
} catch (Exception $e) {
if ($dbEntry->getStatus() == entryStatus::NO_CONTENT) {
$dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
$dbEntry->save();
}
throw $e;
}
$dbEntry->setStatus(entryStatus::READY);
$dbEntry->save();
return null;
}
$isNewAsset = false;
if (!$dbAsset) {
$isNewAsset = true;
$dbAsset = kFlowHelper::createOriginalFlavorAsset($this->getPartnerId(), $dbEntry->getId());
}
if (!$dbAsset && $dbEntry->getStatus() == entryStatus::NO_CONTENT) {
$dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
$dbEntry->save();
}
$ext = pathinfo($entryFullPath, PATHINFO_EXTENSION);
$dbAsset->setFileExt($ext);
$dbAsset->save();
if ($dbAsset && $dbAsset instanceof thumbAsset) {
list($width, $height, $type, $attr) = getimagesize($entryFullPath);
$dbAsset->setWidth($width);
$dbAsset->setHeight($height);
$dbAsset->save();
}
$syncKey = $dbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($entryFullPath, $syncKey, true, $copyOnly);
} catch (Exception $e) {
if ($dbEntry->getStatus() == entryStatus::NO_CONTENT) {
$dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
$dbEntry->save();
}
$dbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$dbAsset->save();
throw $e;
}
if ($dbAsset && !$dbAsset instanceof flavorAsset) {
$dbAsset->setStatusLocalReady();
if ($dbAsset->getFlavorParamsId()) {
$dbFlavorParams = assetParamsPeer::retrieveByPK($dbAsset->getFlavorParamsId());
if ($dbFlavorParams) {
$dbAsset->setTags($dbFlavorParams->getTags());
}
}
$dbAsset->save();
}
if ($isNewAsset) {
kEventsManager::raiseEvent(new kObjectAddedEvent($dbAsset));
}
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbAsset));
return $dbAsset;
}
/**
* decideThumbGenerate is the decision layer for a single thumbnail generation
*
* @param entry $entry
* @param thumbParams $destThumbParams
* @param BatchJob $parentJob
* @return thumbAsset
*/
public static function decideThumbGenerate(entry $entry, thumbParams $destThumbParams, BatchJob $parentJob = null, $sourceAssetId = null, $runSync = false, $srcAsset = null)
{
if (is_null($srcAsset)) {
$srcAsset = self::getSourceAssetForGenerateThumbnail($sourceAssetId, $destThumbParams->getSourceParamsId(), $entry->getId());
if (is_null($srcAsset)) {
throw new APIException(APIErrors::FLAVOR_ASSET_IS_NOT_READY);
}
}
$errDescription = null;
$mediaInfo = mediaInfoPeer::retrieveByFlavorAssetId($srcAsset->getId());
$destThumbParamsOutput = self::validateThumbAndMediaInfo($destThumbParams, $mediaInfo, $errDescription);
if ($srcAsset->getType() == assetType::FLAVOR && is_null($destThumbParamsOutput->getVideoOffset())) {
$destThumbParamsOutput->setVideoOffset($entry->getThumbOffset());
}
$destThumbParamsOutput->setVideoOffset(min($destThumbParamsOutput->getVideoOffset(), $entry->getDuration()));
if (!$destThumbParamsOutput->getDensity()) {
$partner = $entry->getPartner();
if (!is_null($partner)) {
$destThumbParamsOutput->setDensity($partner->getDefThumbDensity());
}
}
$thumbAsset = assetPeer::retrieveByEntryIdAndParams($entry->getId(), $destThumbParams->getId());
if ($thumbAsset) {
$description = $thumbAsset->getDescription() . "\n" . $errDescription;
$thumbAsset->setDescription($description);
} else {
$thumbAsset = new thumbAsset();
$thumbAsset->setPartnerId($entry->getPartnerId());
$thumbAsset->setEntryId($entry->getId());
$thumbAsset->setDescription($errDescription);
$thumbAsset->setFlavorParamsId($destThumbParams->getId());
}
$thumbAsset->incrementVersion();
$thumbAsset->setTags($destThumbParamsOutput->getTags());
$thumbAsset->setFileExt($destThumbParamsOutput->getFileExt());
if ($thumbAsset->getStatus() != asset::ASSET_STATUS_READY) {
$thumbAsset->setStatus(asset::ASSET_STATUS_CONVERTING);
}
//Sets the default thumb if this the only default thumb
kBusinessPreConvertDL::setIsDefaultThumb($thumbAsset);
if (!$destThumbParamsOutput) {
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->save();
return null;
}
$thumbAsset->save();
// save flavor params
$destThumbParamsOutput->setPartnerId($entry->getPartnerId());
$destThumbParamsOutput->setEntryId($entry->getId());
$destThumbParamsOutput->setFlavorAssetId($thumbAsset->getId());
$destThumbParamsOutput->setFlavorAssetVersion($thumbAsset->getVersion());
$destThumbParamsOutput->save();
$srcSyncKey = $srcAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
$srcAssetType = $srcAsset->getType();
if (!$runSync) {
$job = kJobsManager::addCapturaThumbJob($parentJob, $entry->getPartnerId(), $entry->getId(), $thumbAsset->getId(), $srcSyncKey, $srcAsset->getId(), $srcAssetType, $destThumbParamsOutput);
return $thumbAsset;
}
$errDescription = null;
// Since this method is called when trying to crop an existing thumbnail, need to add this check - thumbAssets have no mediaInfo.
$capturedPath = self::generateThumbnail($srcAsset, $destThumbParamsOutput, $errDescription, $mediaInfo ? $mediaInfo->getVideoRotation() : null);
// failed
if (!$capturedPath) {
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_ERROR);
$thumbAsset->setDescription($thumbAsset->getDescription() . "\n{$errDescription}");
$thumbAsset->save();
return $thumbAsset;
}
$thumbAsset->incrementVersion();
$thumbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_READY);
if (file_exists($capturedPath)) {
list($width, $height, $type, $attr) = getimagesize($capturedPath);
$thumbAsset->setWidth($width);
$thumbAsset->setHeight($height);
$thumbAsset->setSize(filesize($capturedPath));
}
$logPath = $capturedPath . '.log';
if (file_exists($logPath)) {
$thumbAsset->incLogFileVersion();
$thumbAsset->save();
// creats the file sync
$logSyncKey = $thumbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_CONVERT_LOG);
kFileSyncUtils::moveFromFile($logPath, $logSyncKey);
KalturaLog::debug("Log archived file to: " . kFileSyncUtils::getLocalFilePathForKey($logSyncKey));
} else {
$thumbAsset->save();
}
$syncKey = $thumbAsset->getSyncKey(thumbAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($capturedPath, $syncKey);
KalturaLog::debug("Thumbnail archived file to: " . kFileSyncUtils::getLocalFilePathForKey($syncKey));
if ($thumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
// increment thumbnail version
$entry->setThumbnail(".jpg");
$entry->setCreateThumb(false);
$entry->save();
$entrySyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
$syncFile = kFileSyncUtils::createSyncFileLinkForKey($entrySyncKey, $syncKey);
if ($syncFile) {
// removes the DEFAULT_THUMB tag from all other thumb assets
$entryThumbAssets = assetPeer::retrieveThumbnailsByEntryId($thumbAsset->getEntryId());
foreach ($entryThumbAssets as $entryThumbAsset) {
if ($entryThumbAsset->getId() == $thumbAsset->getId()) {
continue;
}
if (!$entryThumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
continue;
}
$entryThumbAsset->removeTags(array(thumbParams::TAG_DEFAULT_THUMB));
$entryThumbAsset->save();
}
}
}
if (!is_null($thumbAsset->getFlavorParamsId())) {
kFlowHelper::generateThumbnailsFromFlavor($thumbAsset->getEntryId(), null, $thumbAsset->getFlavorParamsId());
}
return $thumbAsset;
}
/**
* Function adds bulk upload job to the queue
* @param Partner $partner
* @param kBulkUploadJobData $jobData
* @param string $bulkUploadType
* @throws APIException
* @return BatchJob
*/
public static function addBulkUploadJob(Partner $partner, kBulkUploadJobData $jobData, $bulkUploadType = null, $objectId = null, $objectType = null)
{
KalturaLog::debug("adding BulkUpload job");
$job = new BatchJob();
$job->setPartnerId($partner->getId());
$job->setJobType(BatchJobType::BULKUPLOAD);
$job->setJobSubType($bulkUploadType);
if (!is_null($objectId) && !is_null($objectType)) {
$job->setObjectId($objectId);
$job->setObjectType($objectType);
}
if (is_null($jobData)) {
throw new APIException(APIErrors::BULK_UPLOAD_BULK_UPLOAD_TYPE_NOT_VALID, $bulkUploadType);
}
$job->setStatus(BatchJob::BATCHJOB_STATUS_DONT_PROCESS);
$job = kJobsManager::addJob($job, $jobData, BatchJobType::BULKUPLOAD, $bulkUploadType);
if (!is_null($jobData->getFilePath())) {
$syncKey = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_BULKUPLOAD);
// kFileSyncUtils::file_put_contents($syncKey, file_get_contents($csvFileData["tmp_name"]));
try {
kFileSyncUtils::moveFromFile($jobData->getFilePath(), $syncKey, true);
} catch (Exception $e) {
KalturaLog::err($e);
throw new APIException(APIErrors::BULK_UPLOAD_CREATE_CSV_FILE_SYNC_ERROR);
}
$filePath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$jobData->setFilePath($filePath);
}
if (!$jobData->getBulkUploadObjectType()) {
$jobData->setBulkUploadObjectType(BulkUploadObjectType::ENTRY);
}
if ($jobData->getBulkUploadObjectType() == BulkUploadObjectType::ENTRY && !$jobData->getObjectData()->getConversionProfileId()) {
$jobData->setConversionProfileId($partner->getDefaultConversionProfileId());
$kmcVersion = $partner->getKmcVersion();
$check = null;
if ($kmcVersion < 2) {
$check = ConversionProfilePeer::retrieveByPK($jobData->getConversionProfileId());
} else {
$check = conversionProfile2Peer::retrieveByPK($jobData->getConversionProfileId());
}
if (!$check) {
throw new APIException(APIErrors::CONVERSION_PROFILE_ID_NOT_FOUND, $jobData->getConversionProfileId());
}
}
$job->setData($jobData);
return kJobsManager::updateBatchJob($job, BatchJob::BATCHJOB_STATUS_PENDING);
}
/**
* @param flavorAsset $flavorAsset
* @param string $fullPath
* @param bool $copyOnly
*/
protected function attachFile(flavorAsset $flavorAsset, $fullPath, $copyOnly = false)
{
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
$flavorAsset->setFileExt($ext);
$flavorAsset->setSize(kFile::fileSize($fullPath));
$flavorAsset->incrementVersion();
$flavorAsset->save();
$syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, $copyOnly);
} catch (Exception $e) {
if ($flavorAsset->getStatus() == flavorAsset::FLAVOR_ASSET_STATUS_QUEUED || $flavorAsset->getStatus() == flavorAsset::FLAVOR_ASSET_STATUS_NOT_APPLICABLE) {
$flavorAsset->setDescription($e->getMessage());
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$flavorAsset->save();
}
throw $e;
}
if (!$flavorAsset->isLocalReadyStatus()) {
$flavorAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_QUEUED);
}
$flavorAsset->save();
}
/**
* @param FileAsset $dbFileAsset
* @param string $fullPath
* @param bool $copyOnly
*/
protected function attachFile(FileAsset $dbFileAsset, $fullPath, $copyOnly = false)
{
if (!$dbFileAsset->getFileExt()) {
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
$dbFileAsset->setFileExt($ext);
}
$dbFileAsset->setSize(kFile::fileSize($fullPath));
$dbFileAsset->incrementVersion();
$dbFileAsset->save();
$syncKey = $dbFileAsset->getSyncKey(FileAsset::FILE_SYNC_ASSET);
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, $copyOnly);
$dbFileAsset->setStatus(FileAssetStatus::READY);
$dbFileAsset->save();
}
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;
}
/**
* @param UploadToken $uploadToken
*/
public static function handleUploadFinished(UploadToken $uploadToken)
{
if (!is_subclass_of($uploadToken->getObjectType(), assetPeer::OM_CLASS) && $uploadToken->getObjectType() != FileAssetPeer::OM_CLASS && $uploadToken->getObjectType() != entryPeer::OM_CLASS) {
KalturaLog::info("Class [" . $uploadToken->getObjectType() . "] not supported");
return;
}
$fullPath = kUploadTokenMgr::getFullPathByUploadTokenId($uploadToken->getId());
if (!file_exists($fullPath)) {
KalturaLog::info("File path [{$fullPath}] not found");
$remoteDCHost = kUploadTokenMgr::getRemoteHostForUploadToken($uploadToken->getId(), kDataCenterMgr::getCurrentDcId());
if (!$remoteDCHost) {
KalturaLog::err("File path [{$fullPath}] could not be redirected");
return;
}
kFileUtils::dumpApiRequest($remoteDCHost);
}
if ($uploadToken->getObjectType() == FileAssetPeer::OM_CLASS) {
$dbFileAsset = FileAssetPeer::retrieveByPK($uploadToken->getObjectId());
if (!$dbFileAsset) {
KalturaLog::err("File asset id [" . $uploadToken->getObjectId() . "] not found");
return;
}
if (!$dbFileAsset->getFileExt()) {
$dbFileAsset->setFileExt(pathinfo($fullPath, PATHINFO_EXTENSION));
}
$dbFileAsset->incrementVersion();
$dbFileAsset->save();
$syncKey = $dbFileAsset->getSyncKey(FileAsset::FILE_SYNC_ASSET);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true);
} catch (Exception $e) {
$dbFileAsset->setStatus(FileAssetStatus::ERROR);
$dbFileAsset->save();
throw $e;
}
if ($dbFileAsset->getStatus() == FileAssetStatus::UPLOADING) {
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$dbFileAsset->setSize(kFile::fileSize($finalPath));
$dbFileAsset->setStatus(FileAssetStatus::READY);
$dbFileAsset->save();
}
$uploadToken->setStatus(UploadToken::UPLOAD_TOKEN_CLOSED);
$uploadToken->save();
KalturaLog::info("File asset [" . $dbFileAsset->getId() . "] handled");
return;
}
if (is_subclass_of($uploadToken->getObjectType(), assetPeer::OM_CLASS)) {
$dbAsset = assetPeer::retrieveById($uploadToken->getObjectId());
if (!$dbAsset) {
KalturaLog::err("Asset id [" . $uploadToken->getObjectId() . "] not found");
return;
}
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
$dbAsset->setFileExt($ext);
$dbAsset->incrementVersion();
$dbAsset->save();
$syncKey = $dbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true);
} catch (Exception $e) {
if ($dbAsset instanceof flavorAsset) {
kBatchManager::updateEntry($dbAsset->getEntryId(), entryStatus::ERROR_IMPORTING);
}
$dbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
$dbAsset->save();
throw $e;
}
if ($dbAsset->getStatus() == flavorAsset::FLAVOR_ASSET_STATUS_IMPORTING) {
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$dbAsset->setSize(kFile::fileSize($finalPath));
if ($dbAsset instanceof flavorAsset) {
if ($dbAsset->getIsOriginal()) {
$dbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_QUEUED);
} else {
$dbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_VALIDATING);
}
} else {
$dbAsset->setStatus(thumbAsset::FLAVOR_ASSET_STATUS_READY);
}
if ($dbAsset instanceof thumbAsset) {
list($width, $height, $type, $attr) = getimagesize($finalPath);
$dbAsset->setWidth($width);
$dbAsset->setHeight($height);
}
$dbAsset->save();
kEventsManager::raiseEvent(new kObjectAddedEvent($dbAsset));
}
$uploadToken->setStatus(UploadToken::UPLOAD_TOKEN_CLOSED);
$uploadToken->save();
}
if ($uploadToken->getObjectType() == entryPeer::OM_CLASS) {
$dbEntry = entryPeer::retrieveByPK($uploadToken->getObjectId());
if (!$dbEntry) {
KalturaLog::err("Entry id [" . $uploadToken->getObjectId() . "] not found");
return;
}
//Keep original extention
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
// increments version
$dbEntry->setData('100000.' . $ext);
$dbEntry->save();
$syncKey = $dbEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true);
} catch (Exception $e) {
if ($dbAsset instanceof flavorAsset) {
kBatchManager::updateEntry($dbEntry->getId(), entryStatus::ERROR_IMPORTING);
}
throw $e;
}
$dbEntry->setStatus(entryStatus::READY);
$dbEntry->save();
$uploadToken->setStatus(UploadToken::UPLOAD_TOKEN_CLOSED);
$uploadToken->save();
}
}
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;
}
/**
* Update an existing metadata object views file
*
* @action updateViewsFromFile
* @param int $id
* @param file $viewsFile UI views file
* @return KalturaMetadataProfile
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
*/
function updateViewsFromFileAction($id, $viewsFile)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$filePath = null;
if ($viewsFile) {
$filePath = $viewsFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $viewsFile['name']);
}
}
$dbMetadataProfile->incrementViewsVersion();
$dbMetadataProfile->save();
if (trim(file_get_contents($filePath)) != '') {
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS);
kFileSyncUtils::moveFromFile($filePath, $key);
}
$metadataProfile = new KalturaMetadataProfile();
$metadataProfile->fromObject($dbMetadataProfile);
return $metadataProfile;
}
/**
* @param BatchJob $dbBatchJob
* @param kPostConvertJobData $data
*/
protected static function createThumbnail(BatchJob $dbBatchJob, kPostConvertJobData $data)
{
KalturaLog::debug("Post Convert finished with thumnail: " . $data->getThumbPath());
$ignoreThumbnail = false;
// this logic decide when this thumbnail should be used
$rootBatchJob = $dbBatchJob->getRootJob();
if ($rootBatchJob->getJobType() == BatchJobType::CONVERT_PROFILE) {
$thisFlavorHeight = $data->getThumbHeight();
$thisFlavorBitrate = $data->getThumbBitrate();
$rootBatchJobData = $rootBatchJob->getData();
if (!$rootBatchJobData->getCreateThumb() || $rootBatchJobData->getThumbBitrate() > $thisFlavorBitrate) {
$ignoreThumbnail = true;
} elseif ($rootBatchJobData->getThumbBitrate() == $thisFlavorBitrate && $rootBatchJobData->getThumbHeight() > $thisFlavorHeight) {
$ignoreThumbnail = true;
} else {
$rootBatchJobData->setThumbHeight($thisFlavorHeight);
$rootBatchJobData->setThumbBitrate($thisFlavorBitrate);
$rootBatchJob->setData($rootBatchJobData);
$rootBatchJob->save();
}
}
if (!$ignoreThumbnail) {
KalturaLog::debug("Saving thumbnail from: " . $data->getThumbPath());
// creats thumbnail the file sync
$entry = $dbBatchJob->getEntry(false, false);
if (!$entry) {
KalturaLog::err("Entry not found [" . $dbBatchJob->getEntryId() . "]");
return;
}
KalturaLog::debug("Entry duration: " . $entry->getLengthInMsecs());
if (!$entry->getLengthInMsecs()) {
KalturaLog::debug("Copy duration from flvor asset: " . $data->getFlavorAssetId());
$mediaInfo = mediaInfoPeer::retrieveByFlavorAssetId($data->getFlavorAssetId());
if ($mediaInfo) {
KalturaLog::debug("Set duration to: " . $mediaInfo->getContainerDuration());
$entry->setDimensions($mediaInfo->getVideoWidth(), $mediaInfo->getVideoHeight());
$entry->setLengthInMsecs($mediaInfo->getContainerDuration());
}
}
$entry->reload();
// make sure that the thumbnail version is the latest
$entry->setThumbnail(".jpg");
$entry->save();
$syncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB);
kFileSyncUtils::moveFromFile($data->getThumbPath(), $syncKey);
}
}
/**
* @action addFromImage
* @param string $entryId
* @param file $fileData
* @return KalturaThumbAsset
*
* @throws KalturaErrors::ENTRY_ID_NOT_FOUND
* @validateUser entry entryId edit
*/
public function addFromImageAction($entryId, $fileData)
{
$dbEntry = entryPeer::retrieveByPK($entryId);
if (!$dbEntry) {
throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
}
$ext = pathinfo($fileData["name"], PATHINFO_EXTENSION);
$dbThumbAsset = new thumbAsset();
$dbThumbAsset->setPartnerId($dbEntry->getPartnerId());
$dbThumbAsset->setEntryId($dbEntry->getId());
$dbThumbAsset->setStatus(thumbAsset::ASSET_STATUS_QUEUED);
$dbThumbAsset->setFileExt($ext);
$dbThumbAsset->incrementVersion();
$dbThumbAsset->save();
$syncKey = $dbThumbAsset->getSyncKey(thumbAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($fileData["tmp_name"], $syncKey);
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
list($width, $height, $type, $attr) = getimagesize($finalPath);
$dbThumbAsset->setWidth($width);
$dbThumbAsset->setHeight($height);
$dbThumbAsset->setSize(filesize($finalPath));
$dbThumbAsset->setStatus(thumbAsset::ASSET_STATUS_READY);
$dbThumbAsset->save();
$dbEntryThumbs = assetPeer::retrieveThumbnailsByEntryId($entryId);
//If the thums has the default tag or the entry is in no content and this is the first thumb
if ($dbEntry->getCreateThumb() && ($dbThumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB) || $dbEntry->getStatus() == KalturaEntryStatus::NO_CONTENT && count($dbEntryThumbs) == 1)) {
$this->setAsDefaultAction($dbThumbAsset->getId());
}
$thumbAssets = new KalturaThumbAsset();
$thumbAssets->fromObject($dbThumbAsset);
return $thumbAssets;
}
public static function copyFromFile($temp_file_path, FileSyncKey $target_key, $strict = true)
{
KalturaLog::debug("copy file: [{$temp_file_path}] to key [{$target_key}], ");
kFileSyncUtils::moveFromFile($temp_file_path, $target_key, $strict, true);
}
private function ingestAsset(entry $entry, $dbAsset, $filename)
{
$flavorParamsId = $dbAsset->getFlavorParamsId();
$flavorParams = assetParamsPeer::retrieveByPKNoFilter($flavorParamsId);
// is first chunk
$recordedAsset = assetPeer::retrieveByEntryIdAndParams($entry->getId(), $flavorParamsId);
if ($recordedAsset) {
KalturaLog::info("Asset [" . $recordedAsset->getId() . "] of flavor params id [{$flavorParamsId}] already exists");
return;
}
// create asset
$recordedAsset = assetPeer::getNewAsset(assetType::FLAVOR);
$recordedAsset->setPartnerId($entry->getPartnerId());
$recordedAsset->setEntryId($entry->getId());
$recordedAsset->setStatus(asset::FLAVOR_ASSET_STATUS_QUEUED);
$recordedAsset->setFlavorParamsId($flavorParams->getId());
$recordedAsset->setFromAssetParams($flavorParams);
if ($dbAsset->hasTag(assetParams::TAG_RECORDING_ANCHOR)) {
$recordedAsset->addTags(array(assetParams::TAG_RECORDING_ANCHOR));
}
if ($flavorParams->hasTag(assetParams::TAG_SOURCE)) {
$recordedAsset->setIsOriginal(true);
}
$ext = pathinfo($filename, PATHINFO_EXTENSION);
if ($ext) {
$recordedAsset->setFileExt($ext);
}
$recordedAsset->save();
// create file sync
$recordedAssetKey = $recordedAsset->getSyncKey(flavorAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
kFileSyncUtils::moveFromFile($filename, $recordedAssetKey, true, true);
kEventsManager::raiseEvent(new kObjectAddedEvent($recordedAsset));
}
/**
* @param AttachmentAsset $attachmentAsset
* @param string $fullPath
* @param bool $copyOnly
*/
protected function attachFile(AttachmentAsset $attachmentAsset, $fullPath, $copyOnly = false)
{
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
$attachmentAsset->incrementVersion();
$attachmentAsset->setFileExt($ext);
$attachmentAsset->setSize(kFile::fileSize($fullPath));
$attachmentAsset->save();
$syncKey = $attachmentAsset->getSyncKey(AttachmentAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, $copyOnly);
} catch (Exception $e) {
if ($attachmentAsset->getStatus() == AttachmentAsset::ASSET_STATUS_QUEUED || $attachmentAsset->getStatus() == AttachmentAsset::ASSET_STATUS_NOT_APPLICABLE) {
$attachmentAsset->setDescription($e->getMessage());
$attachmentAsset->setStatus(AttachmentAsset::ASSET_STATUS_ERROR);
$attachmentAsset->save();
}
throw $e;
}
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
$wamsURL = kFileSyncUtils::getWamsURLForKey($syncKey);
if (empty($wamsURL)) {
list($width, $height, $type, $attr) = getimagesize($finalPath);
$fileSize = kFile::fileSize($finalPath);
} else {
list($width, $height, $type, $attr) = getimagesize($wamsURL);
$wamsAssetId = kFileSyncUtils::getWamsAssetIdForKey($syncKey);
$fileSize = kWAMS::getInstance($syncKey->getPartnerId())->getFileSizeForAssetId($wamsAssetId, pathinfo($finalPath, PATHINFO_EXTENSION));
}
$attachmentAsset->setWidth($width);
$attachmentAsset->setHeight($height);
$attachmentAsset->setSize($fileSize);
$attachmentAsset->setStatus(AttachmentAsset::ASSET_STATUS_READY);
$attachmentAsset->save();
}
/**
* @param CaptionAsset $captionAsset
* @param string $fullPath
* @param bool $copyOnly
*/
protected function attachFile(CaptionAsset $captionAsset, $fullPath, $copyOnly = false)
{
$ext = pathinfo($fullPath, PATHINFO_EXTENSION);
$captionAsset->incrementVersion();
$captionAsset->setFileExt($ext);
$captionAsset->setSize(filesize($fullPath));
$captionAsset->save();
$syncKey = $captionAsset->getSyncKey(CaptionAsset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
try {
kFileSyncUtils::moveFromFile($fullPath, $syncKey, true, $copyOnly);
} catch (Exception $e) {
if ($captionAsset->getStatus() == CaptionAsset::ASSET_STATUS_QUEUED || $captionAsset->getStatus() == CaptionAsset::ASSET_STATUS_NOT_APPLICABLE) {
$captionAsset->setDescription($e->getMessage());
$captionAsset->setStatus(CaptionAsset::ASSET_STATUS_ERROR);
$captionAsset->save();
}
throw $e;
}
$finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey);
list($width, $height, $type, $attr) = getimagesize($finalPath);
$captionAsset->setWidth($width);
$captionAsset->setHeight($height);
$captionAsset->setSize(filesize($finalPath));
$captionAsset->setStatus(CaptionAsset::ASSET_STATUS_READY);
$captionAsset->save();
}
/**
* Add MRSS transform file to generic distribution provider action
*
* @action addResultsTransformFromFile
* @param int $id the id of the generic distribution provider action
* @param file $transformFile transformation file xsl, xPath or regex
* @return KalturaGenericDistributionProviderAction
* @throws ContentDistributionErrors::GENERIC_DISTRIBUTION_PROVIDER_ACTION_NOT_FOUND
* @throws KalturaErrors::UPLOADED_FILE_NOT_FOUND
*/
function addResultsTransformFromFileAction($id, $transformFile)
{
$dbGenericDistributionProviderAction = GenericDistributionProviderActionPeer::retrieveByPK($id);
if (!$dbGenericDistributionProviderAction) {
throw new KalturaAPIException(ContentDistributionErrors::GENERIC_DISTRIBUTION_PROVIDER_ACTION_NOT_FOUND, $id);
}
$filePath = $transformFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(KalturaErrors::UPLOADED_FILE_NOT_FOUND, $transformFile['name']);
}
$dbGenericDistributionProviderAction->incrementResultsTransformerVersion();
$dbGenericDistributionProviderAction->save();
$key = $dbGenericDistributionProviderAction->getSyncKey(GenericDistributionProviderAction::FILE_SYNC_DISTRIBUTION_PROVIDER_ACTION_RESULTS_TRANSFORMER);
kFileSyncUtils::moveFromFile($filePath, $key);
$genericDistributionProviderAction = new KalturaGenericDistributionProviderAction();
$genericDistributionProviderAction->fromObject($dbGenericDistributionProviderAction);
return $genericDistributionProviderAction;
}
/**
* Update an existing metadata object with new XML file
*
* @action updateFromFile
* @param int $id
* @param file $xmlFile XML metadata
* @return KalturaMetadata
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::INVALID_METADATA_DATA
*/
function updateFromFileAction($id, $xmlFile = null)
{
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$filePath = null;
if ($xmlFile) {
$filePath = $xmlFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xmlFile['name']);
}
}
$previousVersion = null;
if ($dbMetadata->getStatus() == Metadata::STATUS_VALID) {
$previousVersion = $dbMetadata->getVersion();
}
if ($filePath) {
$dbMetadata->incrementVersion();
}
$dbMetadata->save();
if ($filePath) {
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::moveFromFile($filePath, $key);
$errorMessage = '';
$status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata, $previousVersion));
if ($status != KalturaMetadataStatus::VALID) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage);
}
}
$metadata = new KalturaMetadata();
$metadata->fromObject($dbMetadata);
return $metadata;
}
