protected function copyLiveMetadata(baseEntry $object, $liveEntryId) { $recordedEntryId = $object->getId(); $partnerId = $object->getPartnerId(); $metadataProfiles = MetadataProfilePeer::retrieveAllActiveByPartnerId($partnerId, MetadataObjectType::ENTRY); foreach ($metadataProfiles as $metadataProfile) { $originMetadataObj = MetadataPeer::retrieveByObject($metadataProfile->getId(), MetadataObjectType::ENTRY, $liveEntryId); if ($originMetadataObj) { $metadataProfileId = $metadataProfile->getId(); $metadataProfileVersion = $metadataProfile->getVersion(); $destMetadataObj = new Metadata(); $destMetadataObj->setPartnerId($partnerId); $destMetadataObj->setMetadataProfileId($metadataProfileId); $destMetadataObj->setMetadataProfileVersion($metadataProfileVersion); $destMetadataObj->setObjectType(MetadataObjectType::ENTRY); $destMetadataObj->setObjectId($recordedEntryId); $destMetadataObj->setStatus(KalturaMetadataStatus::VALID); $originMetadataKey = $originMetadataObj->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); $originXml = kFileSyncUtils::file_get_contents($originMetadataKey, true, false); // validate object exists $object = kMetadataManager::getObjectFromPeer($destMetadataObj); if ($object) { $destMetadataObj->save(); } else { KalturaLog::err('invalid object type'); continue; } $destMetadataKey = $destMetadataObj->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($destMetadataKey, $originXml); } } }
function createMetadataProfile($version, $versionToXsdMap) { $metadataProfile = new MetadataProfile(); $metadataProfile->setPartnerId(99); $metadataProfile->setStatus(MetadataProfile::STATUS_ACTIVE); $metadataProfile->setName('Tvinci ingest v' . $version); $metadataProfile->setSystemName('TvinciIngestV' . $version); $metadataProfile->setDescription('Tvinci ingest schema version ' . $version); $metadataProfile->setObjectType(MetadataObjectType::ENTRY); $metadataProfile->setRequiredCopyTemplatePermissions(FEATURE_TVINCI_INGEST_BASE . $version); $metadataProfile->save(); $xsdData = $versionToXsdMap[$version]; $key = $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); kFileSyncUtils::file_put_contents($key, $xsdData); kMetadataManager::parseProfileSearchFields($metadataProfile->getPartnerId(), $metadataProfile); }
public function postSave(PropelPDO $con = null) { if ($this->xsdData) { $key = $this->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); kFileSyncUtils::file_put_contents($key, $this->xsdData); kMetadataManager::parseProfileSearchFields($this->getPartnerId(), $this); } if ($this->viewsData) { $key = $this->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS); kFileSyncUtils::file_put_contents($key, $this->viewsData); } if ($this->xsltData) { $key = $this->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_XSLT); kFileSyncUtils::file_put_contents($key, $this->xsltData); } return parent::postSave($con); }
function createMetadataProfile() { $metadataProfile = new MetadataProfile(); $metadataProfile->setPartnerId(99); $metadataProfile->setStatus(MetadataProfile::STATUS_ACTIVE); $metadataProfile->setName('Live Stream Monitoring'); $metadataProfile->setSystemName('LiveMonitor'); $metadataProfile->setDescription('Email notification flag indicating a 24/7 live-entry should be monitored.'); $metadataProfile->setObjectType(MetadataObjectType::ENTRY); $metadataProfile->setRequiredCopyTemplatePermissions(FEATURE_KALTURA_LIVE_MONITOR); $metadataProfile->save(); $xsdData = '<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <xsd:element name="metadata"> <xsd:complexType> <xsd:sequence> <xsd:element name="Monitor" minOccurs="1" maxOccurs="1"> <xsd:annotation> <xsd:documentation></xsd:documentation> <xsd:appinfo> <label>Monitor 24/7</label> <key>monitor</key> <searchable>true</searchable> <description>Send E-mail notification if live-stream broadcast stopped</description> </xsd:appinfo> </xsd:annotation> <xsd:simpleType> <xsd:restriction base="listType"> <xsd:enumeration value="on"/> <xsd:enumeration value="off"/> </xsd:restriction> </xsd:simpleType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:simpleType name="listType"> <xsd:restriction base="xsd:string"/> </xsd:simpleType> </xsd:schema>'; $key = $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); kFileSyncUtils::file_put_contents($key, $xsdData); kMetadataManager::parseProfileSearchFields($metadataProfile->getPartnerId(), $metadataProfile); }
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser) { if (!$puser_kuser) { $this->addError(APIErrors::INVALID_USER_ID, $puser_id); return; } $entry_id = $this->getPM("entry_id"); $entry = entryPeer::retrieveByPK($entry_id); // TODO - verify the user is allowed to modify the entry if ($entry->getKshowId() === kshow::SANDBOX_ID) { $this->addError(APIErrors::SANDBOX_ALERT); return; } $entry->setThumbnail(".jpg"); $entry->setCreateThumb(false); $entry->save(); if (isset($HTTP_RAW_POST_DATA)) { $thumb_data = $HTTP_RAW_POST_DATA; } else { $thumb_data = file_get_contents("php://input"); } $thumb_data_size = strlen($thumb_data); $fileSyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_THUMB); $fileSync = FileSync::createForFileSyncKey($fileSyncKey); kFileSyncUtils::file_put_contents($fileSyncKey, $thumb_data); // update the metadata in case of a roughcut if ($entry->getType() == entryType::MIX) { $sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); $xml_doc = new DOMDocument(); $xml_doc->loadXML(kFileSyncUtils::file_get_contents($sync_key)); if (myMetadataUtils::updateThumbUrl($xml_doc, $entry->getThumbnailUrl())) { $entry->setMetadata(null, $xml_doc->saveXML(), true, null, null); //$entry->getVersion() ); } myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_UPDATE_THUMBNAIL, $entry); } $this->res = $entry->getBigThumbnailUrl(); $wrapper = objectWrapperBase::getWrapperClass($entry, objectWrapperBase::DETAIL_LEVEL_REGULAR); $wrapper->removeFromCache("entry", $entry->getId()); $this->addMsg("entry", $wrapper); }
public function postSave(PropelPDO $con = null) { parent::postSave($con); if ($this->xslModified && $this->xsl && $this->getFeedId()) { KalturaLog::debug("loads syndication feed id [" . $this->getFeedId() . "]"); $syndicationFeed = syndicationFeedPeer::retrieveByPK($this->getFeedId()); KalturaLog::debug("syndication feed id [" . $syndicationFeed->getId() . "] syndication feed type [" . get_class($syndicationFeed) . "]"); if ($syndicationFeed && $syndicationFeed instanceof genericSyndicationFeed) { KalturaLog::log("Updating syndication feed xsl"); $syndicationFeed->setType(syndicationFeedType::KALTURA_XSLT); $syndicationFeed->incrementVersion(); $syndicationFeed->save(); $syncKey = $syndicationFeed->getSyncKey(genericSyndicationFeed::FILE_SYNC_SYNDICATION_FEED_XSLT); kFileSyncUtils::file_put_contents($syncKey, $this->xsl, false); $this->xslModified = false; } } }
private function setObjectContent($assetObject, $content, $accuracy = null, $format = null, $shouldSetTranscriptFileName = false) { $assetObject->incrementVersion(); $ext = "txt"; if ($format) { if ($format == "DFXP") { $ext = "xml"; } if ($format == "SRT") { $ext = "srt"; } } $assetObject->setFileExt($ext); $assetObject->save(); $syncKey = $assetObject->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET); kFileSyncUtils::file_put_contents($syncKey, $content); $finalPath = kFileSyncUtils::getLocalFilePathForKey($syncKey); $assetObject->setSize(kFile::fileSize($finalPath)); if ($shouldSetTranscriptFileName && !$assetObject->getFileName()) { $language = str_replace(" ", "", $assetObject->getLanguage()); $patterns = array("{entryId}", "{language}"); $replacements = array($assetObject->getEntryId(), $language); $fileName = str_replace($patterns, $replacements, self::FILE_NAME_PATTERN); $assetObject->setFileName($fileName); } if (!$accuracy) { $accuracy = self::DEFAULT_ACCURACY; } $assetObject->setAccuracy($accuracy); $assetObject->setStatus(AttachmentAsset::ASSET_STATUS_READY); $assetObject->save(); }
/** * Update Syndication Feed by ID * * @action update * @param string $id * @param KalturaBaseSyndicationFeed $syndicationFeed * @return KalturaBaseSyndicationFeed */ public function updateAction($id, KalturaBaseSyndicationFeed $syndicationFeed) { $syndicationFeedDB = syndicationFeedPeer::retrieveByPK($id); if (!$syndicationFeedDB) { throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $id); } if ($syndicationFeed instanceof KalturaGenericXsltSyndicationFeed && $syndicationFeed->xslt != null) { $syndicationFeed->validateXslt(); $syndicationFeedDB->incrementVersion(); $syndicationFeedDB->save(); } $syndicationFeed->type = null; if ($syndicationFeed instanceof KalturaGenericXsltSyndicationFeed && $syndicationFeed->xslt != null) { $key = $syndicationFeedDB->getSyncKey(genericSyndicationFeed::FILE_SYNC_SYNDICATION_FEED_XSLT); kFileSyncUtils::file_put_contents($key, $syndicationFeed->xslt); } $syndicationFeed = $syndicationFeed->toUpdatableObject($syndicationFeedDB, array('type')); $syndicationFeedDB->save(); $syndicationFeed = KalturaSyndicationFeedFactory::getInstanceByType($syndicationFeedDB->getType()); $syndicationFeed->fromObject($syndicationFeedDB); return $syndicationFeed; }
function updateImpl($id, $xmlData = null, $version = null) { $dbMetadata = MetadataPeer::retrieveByPK($id); if (!$dbMetadata) { throw new KalturaAPIException(MetadataErrors::METADATA_NOT_FOUND, $id); } if ($version && $dbMetadata->getVersion() != $version) { throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_VERSION, $dbMetadata->getVersion()); } $dbMetadataProfile = MetadataProfilePeer::retrieveByPK($dbMetadata->getMetadataProfileId()); if (!$dbMetadataProfile) { throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE, $dbMetadata->getMetadataProfileId()); } $previousVersion = null; if ($dbMetadata->getStatus() == Metadata::STATUS_VALID) { $previousVersion = $dbMetadata->getVersion(); } if ($xmlData) { // if a metadata xslt is defined on the metadata profile - transform the given metadata $xmlDataTransformed = $this->transformMetadata($dbMetadata->getMetadataProfileId(), $xmlData); if ($xmlDataTransformed) { $xmlData = $xmlDataTransformed; } $errorMessage = ''; if (!kMetadataManager::validateMetadata($dbMetadata->getMetadataProfileId(), $xmlData, $errorMessage)) { // if metadata profile is transforming, and metadata profile version is not the latest, try to validate againts previous version if ($dbMetadataProfile->getStatus() != MetadataProfile::STATUS_TRANSFORMING || $dbMetadata->getMetadataProfileVersion() >= $dbMetadataProfile->getVersion()) { throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage); } // validates against previous version $errorMessagePrevVersion = ''; if (!kMetadataManager::validateMetadata($dbMetadata->getMetadataProfileId(), $xmlData, $errorMessagePrevVersion, true)) { KalturaLog::err("Failed to validate metadata object [{$id}] against metadata profile previous version [" . $dbMetadata->getMetadataProfileVersion() . "] error: {$errorMessagePrevVersion}"); // throw the error with the original error message throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage); } } else { $dbMetadata->setMetadataProfileVersion($dbMetadataProfile->getVersion()); } $key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); if (!kFileSyncUtils::compareContent($key, $xmlData)) { $dbMetadata->incrementVersion(); $key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($key, $xmlData); $dbMetadata->save(); kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata, $previousVersion)); } else { KalturaLog::info("XML data MD5 matches current filesync content MD5. Update is not necessary."); //adding this save() in order to save the metadata profile version field in case there are no diffrences $dbMetadata->save(); } } $metadata = new KalturaMetadata(); $metadata->fromObject($dbMetadata, $this->getResponseProfile()); return $metadata; }
/** * Update Syndication Feed by ID * * @action update * @param string $id * @param KalturaBaseSyndicationFeed $syndicationFeed * @return KalturaBaseSyndicationFeed * @throws KalturaErrors::INVALID_FEED_ID */ public function updateAction($id, KalturaBaseSyndicationFeed $syndicationFeed) { $syndicationFeedDB = syndicationFeedPeer::retrieveByPK($id); if (!$syndicationFeedDB) { throw new KalturaAPIException(KalturaErrors::INVALID_FEED_ID, $id); } $syndicationFeed->validateStorageId($this->getPartnerId()); $syndicationFeed->toUpdatableObject($syndicationFeedDB, array('type')); if ($syndicationFeed instanceof KalturaGenericXsltSyndicationFeed && $syndicationFeed->xslt != null) { if (!$syndicationFeedDB instanceof genericSyndicationFeed) { throw new KalturaAPIException(KalturaErrors::INVALID_FEED_TYPE, get_class($syndicationFeedDB)); } $syndicationFeedDB->incrementVersion(); } $syndicationFeedDB->save(); if ($syndicationFeed instanceof KalturaGenericXsltSyndicationFeed && $syndicationFeed->xslt != null) { $key = $syndicationFeedDB->getSyncKey(genericSyndicationFeed::FILE_SYNC_SYNDICATION_FEED_XSLT); kFileSyncUtils::file_put_contents($key, $syndicationFeed->xslt); } $syndicationFeed->type = null; $syndicationFeed = KalturaSyndicationFeedFactory::getInstanceByType($syndicationFeedDB->getType()); $syndicationFeed->fromObject($syndicationFeedDB, $this->getResponseProfile()); return $syndicationFeed; }
/** * @action addFromUrl * @param string $entryId * @param string $url * @return KalturaThumbAsset * * @deprecated use thumbAsset.add and thumbAsset.setContent instead */ public function addFromUrlAction($entryId, $url) { $dbEntry = entryPeer::retrieveByPK($entryId); if (!$dbEntry) { throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId); } $ext = pathinfo(parse_url($url, PHP_URL_PATH), 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::file_put_contents($syncKey, file_get_contents($url)); $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(); $thumbAssets = new KalturaThumbAsset(); $thumbAssets->fromObject($dbThumbAsset); return $thumbAssets; }
/** * Read multiple metadata schemas * @param BaseObject $object * @param array $data */ protected static function addMetadataWithProfilesSystemNames(BaseObject $object, array $data) { $newFieldValuesMap = array(); $xmlDataArray = array(); //Construct mapping of all metadata profile system names, their fields and the field values. foreach ($data as $key => $value) { if (strpos($key, self::BULK_UPLOAD_METADATA_FIELD_PREFIX) === 0) { $prefix = null; $metadataProfileSystemName = null; $metadataProfileFieldName = null; list($prefix, $metadataProfileSystemName, $metadataProfileFieldName) = explode(self::BULK_UPLOAD_METADATA_SYSTEMNAME_SEPARATOR, $key); if (!$prefix || !$metadataProfileSystemName || !$metadataProfileFieldName) { $errorMessage = "Unexpected key structure. Expected metadata::ProfileSystemName::FieldSystemName."; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } if (!isset($newFieldValuesMap[$metadataProfileSystemName])) { $newFieldValuesMap[$metadataProfileSystemName] = array(); } $newFieldValuesMap[$metadataProfileSystemName][$metadataProfileFieldName] = $value; } } foreach ($newFieldValuesMap as $metadataProfileSystemName => $fieldsArray) { /* @var array $fieldsArray */ if (!$fieldsArray || !count($fieldsArray)) { continue; } $metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataProfileSystemName, $object->getPartnerId()); if (!$metadataProfile) { $errorMessage = "Metadata profile with system name [{$metadataProfileSystemName}] could not be found."; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } if ($metadataProfile->getObjectType() != kMetadataManager::getTypeNameFromObject($object)) { $errorMessage = "Metadata profile [{$metadataProfileSystemName}] object type [" . $metadataProfile->getObjectType() . "] is not compatible with object type [" . kMetadataManager::getTypeNameFromObject($object) . "]"; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } $metadataProfileId = $metadataProfile->getId(); $xml = new DOMDocument(); $metadataProfileFields = array(); MetadataProfileFieldPeer::setUseCriteriaFilter(false); $tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId); MetadataProfileFieldPeer::setUseCriteriaFilter(true); foreach ($tmpMetadataProfileFields as $metadataProfileField) { /* @var $metadataProfileField MetadataProfileField */ $metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField; } foreach ($fieldsArray as $fieldSysName => $fieldValue) { if (!isset($metadataProfileFields[$fieldSysName])) { $errorMessage = "Metadata profile field with system name [{$fieldSysName}] missing from metadata profile with id [{$metadataProfileId}]"; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } $metadataProfileField = $metadataProfileFields[$fieldSysName]; KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$fieldValue}]"); $fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $fieldValue); foreach ($fieldValues as $fieldSingleValue) { if ($fieldSingleValue) { if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldSingleValue)) { $valueAsDate = self::parseFormatedDate($fieldSingleValue); if (!$valueAsDate || !strlen($valueAsDate)) { $errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]"; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } $fieldSingleValue = $valueAsDate; } if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_INT && !is_numeric($fieldSingleValue)) { $errorMessage = "Could not parse int format [{$fieldSingleValue}] for field [{$key}]"; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } self::addXpath($xml, $metadataProfileField->getXpath(), $fieldSingleValue); } } $dataFound = true; if ($dataFound && $xml->hasChildNodes()) { $xmlDataArray[$metadataProfileId] = $xml->saveXML($xml->firstChild); $xmlDataArray[$metadataProfileId] = trim($xmlDataArray[$metadataProfileId], " \n\r\t"); } } } foreach ($xmlDataArray as $metadataProfileId => $xmlData) { $errorMessage = ''; if (!kMetadataManager::validateMetadata($metadataProfileId, $xmlData, $errorMessage)) { self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage); continue; } $metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId); $dbMetadata = self::createOrFindMetadataObject($object, $metadataProfile); KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]"); $key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($key, $xmlData); kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata)); } }
/** * Update an existing metadata object * * @action update * @param int $id * @param KalturaMetadataProfile $metadataProfile * @param string $xsdData XSD metadata definition * @param string $viewsData UI views definition * @return KalturaMetadataProfile * @throws KalturaErrors::INVALID_OBJECT_ID * @throws MetadataErrors::METADATA_UNABLE_TO_TRANSFORM * @throws MetadataErrors::METADATA_TRANSFORMING */ function updateAction($id, KalturaMetadataProfile $metadataProfile, $xsdData = null, $viewsData = null) { $dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id); if (!$dbMetadataProfile) { throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id); } if ($dbMetadataProfile->getStatus() != MetadataProfile::STATUS_ACTIVE) { throw new KalturaAPIException(MetadataErrors::METADATA_TRANSFORMING); } $dbMetadataProfile = $metadataProfile->toUpdatableObject($dbMetadataProfile); $key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); $oldXsd = kFileSyncUtils::getLocalFilePathForKey($key); $oldVersion = $dbMetadataProfile->getVersion(); if ($xsdData) { $xsdData = html_entity_decode($xsdData); $dbMetadataProfile->incrementVersion(); } if (!is_null($viewsData)) { $viewsData = html_entity_decode($viewsData); $dbMetadataProfile->incrementViewsVersion(); } if ($xsdData) { $xsdPath = sys_get_temp_dir() . '/' . uniqid() . '.xsd'; file_put_contents($xsdPath, $xsdData); try { kMetadataManager::diffMetadataProfile($dbMetadataProfile, $oldVersion, $oldXsd, $dbMetadataProfile->getVersion(), $xsdPath); } catch (kXsdException $e) { throw new KalturaAPIException(MetadataErrors::METADATA_UNABLE_TO_TRANSFORM, $e->getMessage()); } $dbMetadataProfile->save(); $key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); kFileSyncUtils::moveFromFile($xsdPath, $key); } else { $dbMetadataProfile->save(); } if (!is_null($viewsData) && $viewsData != '') { $key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS); kFileSyncUtils::file_put_contents($key, $viewsData); } kMetadataManager::parseProfileSearchFields($dbMetadataProfile); $metadataProfile->fromObject($dbMetadataProfile); return $metadataProfile; }
/** * addConvertIsmCollectionJob creates a convert collection job * * @param string $tag * @param FileSyncKey $srcSyncKey * @param entry $entry * @param BatchJob $parentJob * @param array<flavorParamsOutput> $flavorParamsOutputs * @return BatchJob */ public static function addConvertIsmCollectionJob($tag, FileSyncKey $srcSyncKey, entry $entry, BatchJob $parentJob = null, array $flavorParamsOutputs, $dbConvertCollectionJob = null) { list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($srcSyncKey, true, false); $localPath = null; $remoteUrl = null; if ($fileSync) { if ($fileSync->getFileType() != FileSync::FILE_SYNC_FILE_TYPE_URL) { $localPath = $fileSync->getFullPath(); } $remoteUrl = $fileSync->getExternalUrl($entry->getId()); } // increment entry version $ismVersion = $entry->incrementIsmVersion(); $entry->save(); $fileName = $entry->generateFileName(0, $ismVersion); // creates convert data $convertCollectionData = new kConvertCollectionJobData(); $convertCollectionData->setSrcFileSyncLocalPath($localPath); $convertCollectionData->setSrcFileSyncRemoteUrl($remoteUrl); $convertCollectionData->setDestFileName($fileName); $clipOffset = null; $clipDuration = null; // look for clipping params foreach ($flavorParamsOutputs as $flavorParamsOutput) { $clipOffset = $flavorParamsOutput->getClipOffset(); $clipDuration = $flavorParamsOutput->getClipDuration(); if (isset($clipOffset) || isset($clipDuration)) { KalturaLog::log("Found clipping params: clipOffset({$clipOffset}),clipDuration({$clipDuration})"); break; } } $bitrates = array(); $finalFlavorParamsOutputs = array(); // check bitrates duplications & update clipping params foreach ($flavorParamsOutputs as $flavorParamsOutputIndex => $flavorParamsOutput) { if (!isset($bitrates[$flavorParamsOutput->getVideoBitrate()])) { $bitrates[$flavorParamsOutput->getVideoBitrate()] = array(); } // if one of clip params exsits - update the object and db if (isset($clipOffset)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->setClipOffset($clipOffset); } if (isset($clipDuration)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->setClipDuration($clipDuration); } if (isset($clipOffset) || isset($clipDuration)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->save(); } $bitrates[$flavorParamsOutput->getVideoBitrate()][] = $flavorParamsOutput->getId(); $finalFlavorParamsOutputs[$flavorParamsOutput->getId()] = $flavorParamsOutput; } foreach ($bitrates as $bitrate => $flavorParamsOutputIds) { if (count($flavorParamsOutputIds) == 1) { // no bitrate dupliaction continue; } $tempFlavorParamsOutputs = array(); foreach ($flavorParamsOutputIds as $index => $flavorParamsOutputId) { $tempFlavorParamsOutputs[] = $finalFlavorParamsOutputs[$flavorParamsOutputId]; } // sort the flavors by height usort($tempFlavorParamsOutputs, array('kBusinessConvertDL', 'compareFlavorsByHeight')); // increment the bitrate so it will be a bit different for each flavor $index = 0; foreach ($tempFlavorParamsOutputs as $flavorParamsOutput) { $finalFlavorParamsOutputs[$flavorParamsOutput->getId()]->setVideoBitrate($bitrate + $index++); } } foreach ($finalFlavorParamsOutputs as $flavorParamsOutput) { $convertCollectionFlavorData = new kConvertCollectionFlavorData(); $convertCollectionFlavorData->setFlavorAssetId($flavorParamsOutput->getFlavorAssetId()); $convertCollectionFlavorData->setFlavorParamsOutputId($flavorParamsOutput->getId()); $convertCollectionFlavorData->setReadyBehavior($flavorParamsOutput->getReadyBehavior()); $convertCollectionFlavorData->setVideoBitrate($flavorParamsOutput->getVideoBitrate()); $convertCollectionFlavorData->setAudioBitrate($flavorParamsOutput->getAudioBitrate()); $convertCollectionFlavorData->setAudioBitrate($flavorParamsOutput->getAudioBitrate()); $convertCollectionData->addFlavor($convertCollectionFlavorData); } $currentConversionEngine = conversionEngineType::EXPRESSION_ENCODER3; KalturaLog::log("Using conversion engine [{$currentConversionEngine}]"); if (!$dbConvertCollectionJob) { // creats a child convert job if ($parentJob) { $dbConvertCollectionJob = $parentJob->createChild(); KalturaLog::log("Created from parent convert job with entry id [" . $dbConvertCollectionJob->getEntryId() . "]"); } else { $dbConvertCollectionJob = new BatchJob(); $dbConvertCollectionJob->setEntryId($entry->getId()); $dbConvertCollectionJob->setPartnerId($entry->getPartnerId()); $dbConvertCollectionJob->save(); KalturaLog::log("Created from convert collection job with entry id [" . $dbConvertCollectionJob->getEntryId() . "]"); } } KalturaLog::log("Calling CDLProceessFlavorsForCollection with [" . count($finalFlavorParamsOutputs) . "] flavor params"); $xml = KDLWrap::CDLProceessFlavorsForCollection($finalFlavorParamsOutputs); $xml = str_replace(KDLCmdlinePlaceholders::OutFileName, $fileName, $xml); $syncKey = $dbConvertCollectionJob->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_CONFIG); kFileSyncUtils::file_put_contents($syncKey, $xml); $fileSync = kFileSyncUtils::getLocalFileSyncForKey($syncKey); $remoteUrl = $fileSync->getExternalUrl($entry->getId()); $localPath = kFileSyncUtils::getLocalFilePathForKey($syncKey); $commandLines = array(conversionEngineType::EXPRESSION_ENCODER3 => KDLCmdlinePlaceholders::InFileName . ' ' . KDLCmdlinePlaceholders::ConfigFileName); $commandLinesStr = flavorParamsOutput::buildCommandLinesStr($commandLines); $convertCollectionData->setInputXmlLocalPath($localPath); $convertCollectionData->setInputXmlRemoteUrl($remoteUrl); $convertCollectionData->setCommandLinesStr($commandLinesStr); $dbConvertCollectionJob->setFileSize(kFile::fileSize($convertCollectionData->getSrcFileSyncLocalPath())); return kJobsManager::addJob($dbConvertCollectionJob, $convertCollectionData, BatchJobType::CONVERT_COLLECTION, $currentConversionEngine); }
private function setConfFileImpl($v, $file_suffix = null, $isClone = false) { // $file_name = $this->getConfFilePath($file_suffix ); if ($this->getCreationMode() == self::UI_CONF_CREATION_MODE_MANUAL) { throw new Exception("Should not edit MANUAL ui_confs via the API!! Only via the SVN"); } if ($file_suffix) { $sync_key = $this->getSyncKey(self::FILE_SYNC_UICONF_SUB_TYPE_FEATURES); } else { $sync_key = $this->getSyncKey(self::FILE_SYNC_UICONF_SUB_TYPE_DATA); } $this->setUpdatedAt(time()); // make sure will be updated in the DB if (version_compare($this->getSwfUrlVersion(), "2.5", ">=")) { $v = str_replace('.entryName}', '.name}', $v); } // This is only called on Save, after parent::save(), so ID is present. kFileSyncUtils::file_put_contents($sync_key, $v); //replaced__setFileContent }
public static function modifyEntryMetadataWithText($entry, $text, $duration = 6, $override = false) { KalturaLog::log("modifyEntryMetadataWithText:\n{$text}"); $content = myContentStorage::getFSContentRootPath(); if (!$override) { // this will reset the data and increment the count $entry->setData(".xml"); } $targetFileSyncKey = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); // doesn't require kFileSyncUtils change - this is a static template that should not be represented as row in the table $source = $content . myContentStorage::getGeneralEntityPath("entry/data", 0, 0, "&metadata_text.xml"); if ($override || !kFileSyncUtils::file_exists($targetFileSyncKey)) { // KalturaLog::log ( "modifyEntryMetadataWithText\n$str_before\n$str_after\n" ); $template_str = file_get_contents($source); $template_str = str_replace(array("__TEXT_PLACEHOLDER__", "__SLIDE_LENGTH_IN_SECS_PLACEHOLDER__"), array($text, $duration), $template_str); kFileSyncUtils::file_put_contents($targetFileSyncKey, $template_str); // KalturaLog::log ( "modifyEntryMetadataWithText:\n$text"); $entry->save(); } }
/** * addConvertIsmCollectionJob creates a convert collection job * * @param string $tag * @param FileSyncKey $srcSyncKey * @param entry $entry * @param BatchJob $parentJob * @param array<flavorParamsOutput> $flavorParamsOutputs * @return BatchJob */ public static function addConvertIsmCollectionJob($tag, FileSyncKey $srcSyncKey, entry $entry, BatchJob $parentJob = null, array $flavorParamsOutputs, $sameRoot = null) { list($fileSync, $local) = kFileSyncUtils::getReadyFileSyncForKey($srcSyncKey, true, false); $srcFileSyncDescriptor = new kSourceFileSyncDescriptor(); if ($fileSync) { if ($fileSync->getFileType() != FileSync::FILE_SYNC_FILE_TYPE_URL) { $srcFileSyncDescriptor->setFileSyncLocalPath($fileSync->getFullPath()); } $srcFileSyncDescriptor->setFileSyncRemoteUrl($fileSync->getExternalUrl($entry->getId())); $srcFileSyncDescriptor->setAssetId($fileSync->getObjectId()); $srcFileSyncDescriptor->setFileSyncObjectSubType($srcSyncKey->getObjectSubType()); } // increment entry version $ismVersion = $entry->incrementIsmVersion(); $entry->save(); $fileName = $entry->generateFileName(0, $ismVersion); // creates convert data $convertCollectionData = new kConvertCollectionJobData(); $convertCollectionData->setSrcFileSyncs(array($srcFileSyncDescriptor)); $convertCollectionData->setDestFileName($fileName); $clipOffset = null; $clipDuration = null; // look for clipping params foreach ($flavorParamsOutputs as $flavorParamsOutput) { $clipOffset = $flavorParamsOutput->getClipOffset(); $clipDuration = $flavorParamsOutput->getClipDuration(); if (isset($clipOffset) || isset($clipDuration)) { KalturaLog::log("Found clipping params: clipOffset({$clipOffset}),clipDuration({$clipDuration})"); break; } } // check bitrates duplications & update clipping params foreach ($flavorParamsOutputs as $flavorParamsOutputIndex => $flavorParamsOutput) { // if one of clip params exsits - update the object and db if (isset($clipOffset)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->setClipOffset($clipOffset); } if (isset($clipDuration)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->setClipDuration($clipDuration); } if (isset($clipOffset) || isset($clipDuration)) { $flavorParamsOutputs[$flavorParamsOutputIndex]->save(); } } /* * Put together all separted flavor XML's into a single Smooth Streaming preset file */ KalturaLog::log("Calling CDLProceessFlavorsForCollection with [" . count($flavorParamsOutputs) . "] flavor params"); $presetXml = KDLWrap::CDLProceessFlavorsForCollection($flavorParamsOutputs); $presetXml = str_replace(KDLCmdlinePlaceholders::OutFileName, $fileName, $presetXml); foreach ($flavorParamsOutputs as $flavorParamsOutput) { /* * Save in case that videoBitrate was changed by the FlavorsForCollection (see above) */ $flavorParamsOutput->save(); $convertCollectionFlavorData = new kConvertCollectionFlavorData(); $convertCollectionFlavorData->setFlavorAssetId($flavorParamsOutput->getFlavorAssetId()); $convertCollectionFlavorData->setFlavorParamsOutputId($flavorParamsOutput->getId()); $convertCollectionFlavorData->setReadyBehavior($flavorParamsOutput->getReadyBehavior()); $convertCollectionFlavorData->setVideoBitrate($flavorParamsOutput->getVideoBitrate()); $convertCollectionFlavorData->setAudioBitrate($flavorParamsOutput->getAudioBitrate()); $convertCollectionFlavorData->setAudioBitrate($flavorParamsOutput->getAudioBitrate()); $convertCollectionData->addFlavor($convertCollectionFlavorData); } $currentConversionEngine = conversionEngineType::EXPRESSION_ENCODER3; KalturaLog::log("Using conversion engine [{$currentConversionEngine}]"); if ($sameRoot == null) { // creats a child convert job if ($parentJob) { $dbConvertCollectionJob = $parentJob->createChild(BatchJobType::CONVERT_COLLECTION, $currentConversionEngine); KalturaLog::log("Created from parent convert job with entry id [" . $dbConvertCollectionJob->getEntryId() . "]"); } else { $dbConvertCollectionJob = new BatchJob(); $dbConvertCollectionJob->setEntryId($entry->getId()); $dbConvertCollectionJob->setPartnerId($entry->getPartnerId()); $dbConvertCollectionJob->setJobType(BatchJobType::CONVERT_COLLECTION); $dbConvertCollectionJob->setJobSubType($currentConversionEngine); } } else { $dbConvertCollectionJob = $parentJob->createChild(BatchJobType::CONVERT_COLLECTION, $currentConversionEngine, false); } $dbConvertCollectionJob->setObjectId($entry->getId()); $dbConvertCollectionJob->setObjectType(BatchJobObjectType::ENTRY); $dbConvertCollectionJob->setStatus(BatchJob::BATCHJOB_STATUS_DONT_PROCESS); $dbConvertCollectionJob = kJobsManager::addJob($dbConvertCollectionJob, $convertCollectionData, BatchJobType::CONVERT_COLLECTION, $currentConversionEngine); $syncKey = $dbConvertCollectionJob->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_CONFIG); kFileSyncUtils::file_put_contents($syncKey, $presetXml); $fileSync = kFileSyncUtils::getLocalFileSyncForKey($syncKey); $remoteUrl = $fileSync->getExternalUrl($entry->getId()); $localPath = kFileSyncUtils::getLocalFilePathForKey($syncKey); $commandLines = array(conversionEngineType::EXPRESSION_ENCODER3 => KDLCmdlinePlaceholders::InFileName . ' ' . KDLCmdlinePlaceholders::ConfigFileName); $commandLinesStr = flavorParamsOutput::buildCommandLinesStr($commandLines); $convertCollectionData->setInputXmlLocalPath($localPath); $convertCollectionData->setInputXmlRemoteUrl($remoteUrl); $convertCollectionData->setCommandLinesStr($commandLinesStr); $dbConvertCollectionJob->setData($convertCollectionData); return kJobsManager::updateBatchJob($dbConvertCollectionJob, BatchJob::BATCHJOB_STATUS_PENDING); }
public function postSave(PropelPDO $con = null) { if ($this->wasObjectSaved() && $this->setPost) { $key = $this->getSyncKey(self::FILE_SYNC_POST); kFileSyncUtils::file_put_contents($key, $this->setPost); $this->cachedPost = $this->setPost; $this->setPost = null; kEventsManager::raiseEvent(new kObjectDataChangedEvent($this, $this->postPreviousVersion)); } return parent::postSave($con); }
private function saveConfFileToDisk($v, $file_suffix = null, $isClone = false) { if ($this->getCreationMode() == self::UI_CONF_CREATION_MODE_MANUAL) { throw new Exception("Should not edit MANUAL ui_confs via the API!! Only via the SVN"); } $subType = $this->getSubTypeBySuffix($file_suffix); $this->incrementVersion($subType); $sync_key = $this->getSyncKey($subType); $this->setUpdatedAt(time()); // make sure will be updated in the DB if (version_compare($this->getSwfUrlVersion(), "2.5", ">=")) { $v = str_replace('.entryName}', '.name}', $v); } // This is only called on Save, after parent::save(), so ID is present. kFileSyncUtils::file_put_contents($sync_key, $v); //replaced__setFileContent }
/** * Add results transform file to generic distribution provider action * * @action addResultsTransform * @param int $id the id of the generic distribution provider action * @param string $transformData transformation data xsl, xPath or regex * @return KalturaGenericDistributionProviderAction * @throws ContentDistributionErrors::GENERIC_DISTRIBUTION_PROVIDER_ACTION_NOT_FOUND */ function addResultsTransformAction($id, $transformData) { $dbGenericDistributionProviderAction = GenericDistributionProviderActionPeer::retrieveByPK($id); if (!$dbGenericDistributionProviderAction) { throw new KalturaAPIException(ContentDistributionErrors::GENERIC_DISTRIBUTION_PROVIDER_ACTION_NOT_FOUND, $id); } $dbGenericDistributionProviderAction->incrementResultsTransformerVersion(); $dbGenericDistributionProviderAction->save(); $key = $dbGenericDistributionProviderAction->getSyncKey(GenericDistributionProviderAction::FILE_SYNC_DISTRIBUTION_PROVIDER_ACTION_RESULTS_TRANSFORMER); kFileSyncUtils::file_put_contents($key, $transformData); $genericDistributionProviderAction = new KalturaGenericDistributionProviderAction(); $genericDistributionProviderAction->fromObject($dbGenericDistributionProviderAction); return $genericDistributionProviderAction; }
public static function parseXml($objectType, SimpleXMLElement $scene, $partnerId, CuePoint $cuePoint) { $metadataElements = $scene->xpath('scene-customData'); if (!count($metadataElements)) { return $cuePoint; } foreach ($metadataElements as $metadataElement) { $metadata = null; $metadataProfile = null; if (isset($metadataElement['metadataId'])) { $metadata = MetadataPeer::retrieveByPK($metadataElement['metadataId']); } if ($metadata) { $metadataProfile = $metadata->getMetadataProfile(); } else { if (isset($metadataElement['metadataProfileId'])) { $metadataProfile = MetadataProfilePeer::retrieveByPK($metadataElement['metadataProfileId']); } elseif (isset($metadataElement['metadataProfile'])) { $metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataElement['metadataProfile']); } if ($metadataProfile) { $metadata = MetadataPeer::retrieveByObject($metadataProfile->getId(), $objectType, $cuePoint->getId()); } } if (!$metadataProfile) { continue; } if (!$metadata) { $metadata = new Metadata(); $metadata->setPartnerId($partnerId); $metadata->setMetadataProfileId($metadataProfile->getId()); $metadata->setMetadataProfileVersion($metadataProfile->getVersion()); $metadata->setObjectType($objectType); $metadata->setObjectId($cuePoint->getId()); $metadata->setStatus(KalturaMetadataStatus::VALID); foreach ($metadataElement->children() as $metadataContent) { $xmlData = $metadataContent->asXML(); $errorMessage = ''; if (kMetadataManager::validateMetadata($metadataProfile->getId(), $xmlData, $errorMessage)) { $metadata->save(); $key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($key, $xmlData); kEventsManager::raiseEvent(new kObjectDataChangedEvent($metadata)); } break; } } } return $cuePoint; }
/** * @param int $metadataProfileId * @param int $srcVersion * @param int $destVersion * @param string $xsl * * @return BatchJob */ private static function addTransformMetadataJob($partnerId, $metadataProfileId, $srcVersion, $destVersion, $xsl = null) { // check if any metadata objects require the transform $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $destVersion, Criteria::LESS_THAN); $c->add(MetadataPeer::STATUS, Metadata::STATUS_VALID); $metadataCount = MetadataPeer::doCount($c); if (!$metadataCount) { return null; } $job = new BatchJob(); $job->setJobType(BatchJobType::METADATA_TRANSFORM); $job->setPartnerId($partnerId); $job->setObjectId($metadataProfileId); $job->setObjectType(kPluginableEnumsManager::apiToCore('BatchJobObjectType', MetadataBatchJobObjectType::METADATA_PROFILE)); $data = new kTransformMetadataJobData(); if ($xsl) { $job->save(); $key = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_CONFIG); kFileSyncUtils::file_put_contents($key, $xsl); $xslPath = kFileSyncUtils::getLocalFilePathForKey($key); $data->setSrcXslPath($xslPath); } $data->setMetadataProfileId($metadataProfileId); $data->setSrcVersion($srcVersion); $data->setDestVersion($destVersion); return kJobsManager::addJob($job, $data, BatchJobType::METADATA_TRANSFORM); }
/** * @param BatchJob $dbBatchJob * @param kDistributionDeleteJobData $data * @param BatchJob $twinJob * @return BatchJob */ public static function onDistributionDeleteJobUpdated(BatchJob $dbBatchJob, kDistributionDeleteJobData $data, BatchJob $twinJob = null) { if ($data->getResults() || $data->getSentData()) { $entryDistribution = EntryDistributionPeer::retrieveByPK($data->getEntryDistributionId()); if (!$entryDistribution) { KalturaLog::err("Entry distribution [" . $data->getEntryDistributionId() . "] not found"); return $dbBatchJob; } if ($data->getResults()) { $entryDistribution->incrementDeleteResultsVersion(); } if ($data->getSentData()) { $entryDistribution->incrementDeleteDataVersion(); } $entryDistribution->save(); if ($data->getResults()) { $key = $entryDistribution->getSyncKey(EntryDistribution::FILE_SYNC_ENTRY_DISTRIBUTION_DELETE_RESULTS); kFileSyncUtils::file_put_contents($key, $data->getResults()); $data->setResults(null); } if ($data->getSentData()) { $key = $entryDistribution->getSyncKey(EntryDistribution::FILE_SYNC_ENTRY_DISTRIBUTION_DELETE_DATA); kFileSyncUtils::file_put_contents($key, $data->getSentData()); $data->setSentData(null); } $dbBatchJob->setData($data); $dbBatchJob->save(); } switch ($dbBatchJob->getStatus()) { case BatchJob::BATCHJOB_STATUS_PENDING: return self::onDistributionDeleteJobPending($dbBatchJob, $data, $twinJob); case BatchJob::BATCHJOB_STATUS_FINISHED: return self::onDistributionDeleteJobFinished($dbBatchJob, $data, $twinJob); case BatchJob::BATCHJOB_STATUS_FAILED: case BatchJob::BATCHJOB_STATUS_FATAL: return self::onDistributionDeleteJobFailed($dbBatchJob, $data, $twinJob); default: return $dbBatchJob; } }
/** * @param string $entryId the new created entry * @param array $data key => value pairs */ public static function handleBulkUploadData($entryId, array $data) { KalturaLog::debug("Handle metadata bulk upload data:\n" . print_r($data, true)); if (!isset($data[self::BULK_UPLOAD_COLUMN_PROFILE_ID])) { return; } $metadataProfileId = $data[self::BULK_UPLOAD_COLUMN_PROFILE_ID]; $xmlData = null; $entry = entryPeer::retrieveByPK($entryId); if (!$entry) { return; } // $criteriaFilter = FileSyncPeer::getCriteriaFilter(); // $criteria = $criteriaFilter->getFilter(); // $criteria->add(FileSyncPeer::PARTNER_ID, $entry->getPartnerId()); $metadataProfile = MetadataProfilePeer::retrieveById($metadataProfileId); if (!$metadataProfile) { $errorMessage = "Metadata profile [{$metadataProfileId}] not found"; KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage); return; } if (isset($data[self::BULK_UPLOAD_COLUMN_URL])) { try { $xmlData = file_get_contents($data[self::BULK_UPLOAD_COLUMN_URL]); KalturaLog::debug("Metadata downloaded [" . $data[self::BULK_UPLOAD_COLUMN_URL] . "]"); } catch (Exception $e) { $errorMessage = "Download metadata[" . $data[self::BULK_UPLOAD_COLUMN_URL] . "] error: " . $e->getMessage(); KalturaLog::err($errorMessage); self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage); $xmlData = null; } } elseif (isset($data[self::BULK_UPLOAD_COLUMN_XML])) { $xmlData = $data[self::BULK_UPLOAD_COLUMN_XML]; } else { $metadataProfileFields = array(); MetadataProfileFieldPeer::setUseCriteriaFilter(false); $tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId); MetadataProfileFieldPeer::setUseCriteriaFilter(true); foreach ($tmpMetadataProfileFields as $metadataProfileField) { $metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField; } KalturaLog::debug("Found fields [" . count($metadataProfileFields) . "] for metadata profile [{$metadataProfileId}]"); $xml = new DOMDocument(); $dataFound = false; foreach ($data as $key => $value) { if (!$value || !strlen($value)) { continue; } if (!preg_match('/^' . self::BULK_UPLOAD_COLUMN_FIELD_PREFIX . '(.+)$/', $key, $matches)) { continue; } $key = $matches[1]; if (!isset($metadataProfileFields[$key])) { $errorMessage = "Field [{$key}] does not exist"; KalturaLog::debug($errorMessage); self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage); continue; } $metadataProfileField = $metadataProfileFields[$key]; KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$value}]"); $fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $value); foreach ($fieldValues as $fieldValue) { if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldValue)) { $value = self::parseFormatedDate($fieldValue); if (!$value || !strlen($value)) { $errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]"; KalturaLog::debug($errorMessage); self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage); continue; } $fieldValue = $value; } self::addXpath($xml, $metadataProfileField->getXpath(), $fieldValue); } $dataFound = true; } if ($dataFound) { $xmlData = $xml->saveXML($xml->firstChild); $xmlData = trim($xmlData, " \n\r\t"); } } if (!$xmlData) { return; } $dbMetadata = new Metadata(); $dbMetadata->setPartnerId($entry->getPartnerId()); $dbMetadata->setMetadataProfileId($metadataProfileId); $dbMetadata->setMetadataProfileVersion($metadataProfile->getVersion()); $dbMetadata->setObjectType(Metadata::TYPE_ENTRY); $dbMetadata->setObjectId($entryId); $dbMetadata->setStatus(Metadata::STATUS_INVALID); $dbMetadata->save(); KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]"); $key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($key, $xmlData); $errorMessage = ''; $status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage); if ($status == Metadata::STATUS_VALID) { kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata)); } else { self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage); } }
/** * Add the data to the flavor asset conversion log, creates it if doesn't exists * * @action logConversion * @param string $flavorAssetId * @param string $data * @throws KalturaErrors::INVALID_FLAVOR_ASSET_ID */ function logConversionAction($flavorAssetId, $data) { $flavorAsset = assetPeer::retrieveById($flavorAssetId); // verifies that flavor asset exists if (!$flavorAsset) { throw new KalturaAPIException(KalturaErrors::INVALID_FLAVOR_ASSET_ID, $flavorAssetId); } $flavorAsset->incLogFileVersion(); $flavorAsset->save(); $syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_CONVERT_LOG); $log = kFileSyncUtils::file_get_contents($syncKey, true, false); $log .= $data; kFileSyncUtils::file_put_contents($syncKey, $log, false); }
/** * Update Conversion Profile by ID * * @action update * @param int $id * @param KalturaConversionProfile $conversionProfile * @return KalturaConversionProfile */ public function updateAction($id, KalturaConversionProfile $conversionProfile) { $conversionProfileDb = conversionProfile2Peer::retrieveByPK($id); if (!$conversionProfileDb) { throw new KalturaAPIException(KalturaErrors::CONVERSION_PROFILE_ID_NOT_FOUND, $id); } $conversionProfile->toUpdatableObject($conversionProfileDb); $conversionProfileDb->setCreationMode(conversionProfile2::CONVERSION_PROFILE_2_CREATION_MODE_KMC); if ($conversionProfile->xslTransformation) { $conversionProfileDb->incrementXslVersion(); } $conversionProfileDb->save(); if ($conversionProfile->flavorParamsIds !== null) { $this->deleteFlavorParamsRelation($conversionProfileDb, $conversionProfile->flavorParamsIds); $this->addFlavorParamsRelation($conversionProfileDb, $conversionProfile->getFlavorParamsAsArray()); } if ($conversionProfile->xslTransformation) { $xsl = html_entity_decode($conversionProfile->xslTransformation); $key = $conversionProfileDb->getSyncKey(conversionProfile2::FILE_SYNC_MRSS_XSL); kFileSyncUtils::file_put_contents($key, $xsl); } $conversionProfile->fromObject($conversionProfileDb); // load flavor params id with the same connection (master connection) that was used for insert $con = myDbHelper::getConnection(myDbHelper::DB_HELPER_CONN_MASTER); $conversionProfile->loadFlavorParamsIds($conversionProfileDb, $con); return $conversionProfile; }
public function postSave(PropelPDO $con = null) { parent::postSave($con); if ($this->xslModified && $this->xsl && $this->getFeedId()) { $podcastFeed = syndicationFeedPeer::retrieveByPK($this->getFeedId()); if ($podcastFeed && $podcastFeed instanceof genericSyndicationFeed) { $podcastFeed->setType(syndicationFeedType::KALTURA_XSLT); $podcastFeed->incrementVersion(); $podcastFeed->save(); $syncKey = $podcastFeed->getSyncKey(genericSyndicationFeed::FILE_SYNC_SYNDICATION_FEED_XSLT); kFileSyncUtils::file_put_contents($syncKey, $this->xsl, false); $this->xslModified = false; } } }
public static function setMetadata($content, $kshow, $show_entry, $ignore_current = false, $version_info = null) { $xml_content = ""; $show_entry_data_key = $show_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); $current_content = $show_entry->getMediaType() != entry::ENTRY_MEDIA_TYPE_SHOW ? "" : kFileSyncUtils::file_get_contents($show_entry_data_key); if ($ignore_current) { $current_content = ""; } $update_kshow = false; // compare the content and store only if different if ($content != $current_content) { $show_entry->setData("metadata.xml"); // re-create data key (to get latest version) $show_entry_data_key = $show_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); //$version = myContentStorage::getVersion($file_name); //$comments = "file path: " . $file_name . "\n"; $comments = "version: " . $show_entry_data_key->version . "\n"; $total_duration = 0; $editor_type = null; $content = myFlvStreamer::fixMetadata($content, $show_entry_data_key->version, $total_duration, $editor_type); // TODO - make fixMetadata a more generic funciton to return the editorType as well // save info file about the version if (isset($version_info)) { $content = self::addVersionInfo($content, $version_info); } //fixme $content = myFlvStreamer::modifiedByKeditor ( $content ); // total_duration is in seconds with 2 digits after the decimal point $show_entry->setLengthInMsecs($total_duration * 1000); $show_entry->setMediaType(entry::ENTRY_MEDIA_TYPE_SHOW); $show_entry->setEditorType($editor_type); $show_entry->setModifiedAt(time()); // update the modified_at date $show_entry->save(); kFileSyncUtils::file_put_contents($show_entry_data_key, $content, true); $xml_content = kFileSyncUtils::file_get_contents($show_entry_data_key); // replaced__getFileContent $update_kshow = true; $show_entry_id = $show_entry->getId(); // update the roughcut_entry table $all_entries_for_roughcut = self::getAllEntries($content); roughcutEntry::updateRoughcut($show_entry->getId(), $show_entry->getVersion(), $show_entry->getKshowId(), $all_entries_for_roughcut); $xml_content = $content; } else { $xml_content = $current_content; $comments = "old and new files are the same"; } if (!$kshow->getHasRoughcut() && $kshow->getIntroId() != $show_entry->getId()) { $kshow->setHasRoughcut(true); $update_kshow = true; } myStatisticsMgr::incKshowUpdates($kshow); $kshow->save(); return array($xml_content, $comments, $update_kshow); }
public function fixMetadata($increment_version = true, $content = null, $total_duration = null, $specific_version = null) { // check that the file of the desired version really exists $content_dir = myContentStorage::getFSContentRootPath(); if (!$content) { $content = $this->getMetadata($specific_version); } if ($increment_version) { // increment the counter of the file $this->setData(parent::getData()); } $file_name = kFileSyncUtils::getLocalFilePathForKey($this->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $specific_version)); // replaced__getDataPath $duration = $total_duration ? $total_duration : myMetadataUtils::getDuration($content); $this->setLengthInMsecs($duration * 1000); $total_duration = null; $editor_type = null; $version = myContentStorage::getVersion($file_name); $fixed_content = myFlvStreamer::fixMetadata($content, $version, $total_duration, $editor_type); $this->save(); $sync_key = $this->getSyncKey(self::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version); kFileSyncUtils::file_put_contents($sync_key, $fixed_content, false); // replaced__setFileContent return $fixed_content; }
/** * Update an existing metadata object with new XML content * * @action update * @param int $id * @param string $xmlData XML metadata * @return KalturaMetadata * @throws KalturaErrors::INVALID_OBJECT_ID * @throws MetadataErrors::INVALID_METADATA_DATA */ function updateAction($id, $xmlData = null) { $dbMetadata = MetadataPeer::retrieveByPK($id); if (!$dbMetadata) { throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id); } $previousVersion = null; if ($dbMetadata->getStatus() == Metadata::STATUS_VALID) { $previousVersion = $dbMetadata->getVersion(); } if ($xmlData) { $dbMetadata->incrementVersion(); } $dbMetadata->save(); if ($xmlData) { $key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); kFileSyncUtils::file_put_contents($key, $xmlData); $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; }