/**
* @param entry $entry
* @param SimpleXMLElement $mrss
* @return SimpleXMLElement
*/
public function contribute(entry $entry, SimpleXMLElement $mrss)
{
$metadatas = MetadataPeer::retrieveAllByObject(Metadata::TYPE_ENTRY, $entry->getId());
foreach ($metadatas as $metadata) {
$this->contributeMetadata($metadata, $mrss);
}
}
/**
* @param KalturaMetadataObjectType $objectType
* @param BaseObject $fromObject
* @param BaseObject $toObject
*/
protected function copyMetadata($objectType, BaseObject $fromObject, BaseObject $toObject)
{
KalturaLog::debug("Copy metadata type [{$objectType}] from " . get_class($fromObject) . '[' . $fromObject->getId() . "] to[" . $toObject->getId() . "]");
$c = new Criteria();
$c->add(MetadataPeer::OBJECT_TYPE, $objectType);
$c->add(MetadataPeer::OBJECT_ID, $fromObject->getId());
$metadatas = MetadataPeer::doSelect($c);
foreach ($metadatas as $metadata) {
$newMetadata = $metadata->copy();
$newMetadata->setObjectId($toObject->getId());
if ($toObject instanceof Partner) {
$newMetadata->setPartnerId($toObject->getId());
} else {
$newMetadata->setPartnerId($toObject->getPartnerId());
}
$metadataProfileId = kObjectCopyHandler::getMappedId('MetadataProfile', $metadata->getMetadataProfileId());
if ($metadataProfileId) {
$metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId);
if ($metadataProfile) {
$newMetadata->setMetadataProfileId($metadataProfileId);
$newMetadata->setMetadataProfileVersion($metadataProfile->getVersion());
}
}
$newMetadata->save();
kFileSyncUtils::createSyncFileLinkForKey($newMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA), $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA));
}
}
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);
}
}
}
/**
* @param string $baseClass
* @param string $enumValue
* @param array $constructorArgs
* @return object
*/
public static function loadObject($baseClass, $enumValue, array $constructorArgs = null)
{
if ($baseClass == 'ISyncableFile' && isset($constructorArgs['objectId'])) {
$objectId = $constructorArgs['objectId'];
switch ($enumValue) {
case FileSyncObjectType::METADATA:
MetadataPeer::setUseCriteriaFilter(false);
$object = MetadataPeer::retrieveByPK($objectId);
MetadataPeer::setUseCriteriaFilter(true);
return $object;
case FileSyncObjectType::METADATA_PROFILE:
MetadataProfilePeer::setUseCriteriaFilter(false);
$object = MetadataProfilePeer::retrieveByPK($objectId);
MetadataProfilePeer::setUseCriteriaFilter(true);
return $object;
}
}
if ($baseClass == 'kJobData') {
switch ($enumValue) {
case KalturaBatchJobType::METADATA_IMPORT:
return new kImportJobData();
case KalturaBatchJobType::METADATA_TRANSFORM:
return new kTransformMetadataJobData();
}
}
if ($baseClass == 'KalturaJobData') {
switch ($enumValue) {
case KalturaBatchJobType::METADATA_IMPORT:
return new KalturaImportJobData();
case KalturaBatchJobType::METADATA_TRANSFORM:
return new KalturaTransformMetadataJobData();
}
}
return null;
}
public function contribute(BaseObject $object, SimpleXMLElement $mrss, kMrssParameters $mrssParams = null)
{
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadatas = MetadataPeer::retrieveAllByObject($objectType, $object->getId());
foreach ($metadatas as $metadata) {
$this->contributeMetadata($metadata, $mrss, $mrssParams);
}
}
public function getFieldValue(accessControl $accessControl)
{
$scope = $accessControl->getScope();
$metadata = MetadataPeer::retrieveByObject($this->profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
if ($metadata) {
return kMetadataManager::parseMetadataValues($metadata, $this->xPath);
}
return null;
}
public function hasPeerFieldName($fieldName)
{
if (strpos($fieldName, '.') === false) {
$fieldName = strtoupper($fieldName);
$fieldName = "metadata.{$fieldName}";
}
$metadataFields = MetadataPeer::getFieldNames(BasePeer::TYPE_COLNAME);
return in_array($fieldName, $metadataFields);
}
public function __construct(KalturaDistributionJobData $distributionJobData = null)
{
parent::__construct($distributionJobData);
if (!$distributionJobData || !$distributionJobData->distributionProfile instanceof KalturaTvinciDistributionProfile || !$distributionJobData->entryDistribution) {
return;
}
$entry = null;
if ($distributionJobData->entryDistribution->entryId) {
$entry = entryPeer::retrieveByPK($distributionJobData->entryDistribution->entryId);
}
if (!$entry) {
KalturaLog::err("Can't find entry with id: {$distributionJobData->entryDistribution->entryId}");
return;
}
$feedHelper = new TvinciDistributionFeedHelper($distributionJobData->distributionProfile);
$feedHelper->setEntryId($entry->getId());
$feedHelper->setReferenceId($entry->getReferenceID());
$feedHelper->setDescription($entry->getDescription());
$feedHelper->setTitleName($entry->getName());
$feedHelper->setSunrise($distributionJobData->entryDistribution->sunrise);
$feedHelper->setSunset($distributionJobData->entryDistribution->sunset);
$thumbAssets = assetPeer::retrieveByIds(explode(',', $distributionJobData->entryDistribution->thumbAssetIds));
$picRatios = array();
$defaultThumbUrl = null;
foreach ($thumbAssets as $thumbAsset) {
$thumbDownloadUrl = $this->getAssetDownloadUrl($thumbAsset);
$ratio = KDLVideoAspectRatio::ConvertFrameSize($thumbAsset->getWidth(), $thumbAsset->getHeight());
$picRatios[] = array('url' => $thumbDownloadUrl, 'ratio' => $ratio);
if ($thumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) {
$defaultThumbUrl = $thumbDownloadUrl;
}
}
$feedHelper->setPicRatiosArray($picRatios);
if (!$defaultThumbUrl && count($picRatios)) {
// Choose the URL of the first resource in the array
$defaultThumbUrl = $picRatios[0]['url'];
}
$feedHelper->setDefaultThumbnailUrl($defaultThumbUrl);
$this->createPlayManifestURLs($distributionJobData->entryDistribution, $entry, $feedHelper);
$metadatas = MetadataPeer::retrieveAllByObject(MetadataObjectType::ENTRY, $distributionJobData->entryDistribution->entryId);
$fullMetadataXML = '';
foreach ($metadatas as $metadataField) {
$syncKey = $metadataField->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$currMetaXML = kFileSyncUtils::file_get_contents($syncKey, true, false);
$fullMetadataXML .= $currMetaXML;
}
$feedHelper->setMetasXML($fullMetadataXML);
if ($distributionJobData instanceof KalturaDistributionSubmitJobData) {
$this->xml = $feedHelper->buildSubmitFeed();
} elseif ($distributionJobData instanceof KalturaDistributionUpdateJobData) {
$this->xml = $feedHelper->buildUpdateFeed();
} elseif ($distributionJobData instanceof KalturaDistributionDeleteJobData) {
$this->xml = $feedHelper->buildDeleteFeed();
}
KalturaLog::debug("XML Constructed by the Tvinci feed helper :{$this->xml}");
}
public static function validateMetadataObjects($profileField, $objectIds, &$errorMessage)
{
/** @var MetadataProfileField $profileField */
$subMetadataProfileId = $profileField->getRelatedMetadataProfileId();
$subMetadataProfile = MetadataProfilePeer::retrieveByPK($subMetadataProfileId);
if (!$subMetadataProfile) {
$errorMessage = 'Sub metadata profile ' . $subMetadataProfileId . ' was not found';
return false;
}
$subMetadataObjects = MetadataPeer::retrieveByObjects($subMetadataProfileId, $subMetadataProfile->getObjectType(), $objectIds);
if (count($subMetadataObjects) != count($objectIds)) {
$errorMessage = 'One of the following objects: ' . implode(', ', $objectIds) . ' was not found for profile ' . $subMetadataProfileId;
return false;
}
return true;
}
/**
* @param int $objectType
* @param string $objectId
*/
protected function deleteMetadataObjects($objectType, $objectId)
{
$c = new Criteria();
$c->add(MetadataPeer::OBJECT_TYPE, $objectType);
$c->add(MetadataPeer::OBJECT_ID, $objectId);
$c->add(MetadataPeer::STATUS, Metadata::STATUS_DELETED, Criteria::NOT_EQUAL);
$peer = null;
MetadataPeer::setUseCriteriaFilter(false);
$metadatas = MetadataPeer::doSelect($c);
foreach ($metadatas as $metadata) {
kEventsManager::raiseEvent(new kObjectDeletedEvent($metadata));
}
$update = new Criteria();
$update->add(MetadataPeer::STATUS, Metadata::STATUS_DELETED);
$con = Propel::getConnection(MetadataPeer::DATABASE_NAME, Propel::CONNECTION_READ);
BasePeer::doUpdate($c, $update, $con);
}
public function getFieldValue(kScope $scope)
{
$profileId = $this->profileId;
if (!$profileId) {
if (!$this->profileSystemName) {
KalturaLog::err("No metadata profile id and system-name supplied");
return null;
}
$profile = MetadataProfilePeer::retrieveBySystemName($this->profileSystemName, kCurrentContext::getCurrentPartnerId());
if (!$profile) {
KalturaLog::notice("Metadata profile with system-name [{$this->profileSystemName}] not found");
return null;
}
$profileId = $profile->getId();
}
$metadata = null;
if ($scope instanceof accessControlScope || $scope instanceof kStorageProfileScope) {
$metadata = MetadataPeer::retrieveByObject($profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
} elseif ($scope instanceof kEventScope) {
$object = $scope->getEvent()->getObject();
if (kMetadataManager::isMetadataObject($object)) {
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadata = MetadataPeer::retrieveByObject($profileId, $objectType, $object->getId());
} else {
if ($object instanceof Metadata) {
$metadata = $object;
} elseif ($scope->getEvent()->getObject() instanceof categoryEntry) {
$profileObject = kMetadataManager::getObjectTypeName($profile->getObjectType());
$getter = "get{$profileObject}Id";
KalturaLog::info("Using {$getter} in order to retrieve the metadata object ID");
$categoryEntry = $scope->getEvent()->getObject();
$objectId = $categoryEntry->{$getter}();
$metadata = MetadataPeer::retrieveByObject($profileId, $profile->getObjectType(), $objectId);
} elseif ($object instanceof asset) {
$metadata = MetadataPeer::retrieveByObject($profileId, MetadataObjectType::ENTRY, $object->getEntryId());
}
}
}
if ($metadata) {
return kMetadataManager::parseMetadataValues($metadata, $this->xPath);
}
KalturaLog::notice("Metadata object not found for scope [" . get_class($scope) . "]");
return null;
}
/**
* batch getTransformMetadataObjects action retrieve all metadata objects that requires upgrade and the total count
*
* @action getTransformMetadataObjects
* @param int $metadataProfileId The id of the metadata profile
* @param int $srcVersion The old metadata profile version
* @param int $destVersion The new metadata profile version
* @param KalturaFilterPager $pager
* @return KalturaTransformMetadataResponse
*/
function getTransformMetadataObjectsAction($metadataProfileId, $srcVersion, $destVersion, KalturaFilterPager $pager = null)
{
$response = new KalturaTransformMetadataResponse();
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId);
$c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion, Criteria::LESS_THAN);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID);
$response->lowerVersionCount = MetadataPeer::doCount($c);
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId);
$c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID);
$response->totalCount = MetadataPeer::doCount($c);
if ($pager) {
$pager->attachToCriteria($c);
}
$list = MetadataPeer::doSelect($c);
$response->objects = KalturaMetadataArray::fromDbArray($list);
return $response;
}
public function validateMetadataForSubmission(EntryDistribution $entryDistribution, $action, array $validationErrors)
{
if (!class_exists('MetadataProfile')) {
return $validationErrors;
}
$metadataProfileId = $this->getMetadataProfileId();
if (!$metadataProfileId) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_MEDIAKEY, '');
return $validationErrors;
}
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, MetadataObjectType::ENTRY, $entryDistribution->getEntryId());
if (!$metadata) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_MEDIAKEY);
return $validationErrors;
}
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_MEDIAKEY);
if (!count($values)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_MEDIAKEY, '');
}
return $validationErrors;
}
protected function internalFulfilled(kScope $scope)
{
$profileId = $this->profileId;
if (!$profileId) {
if (!$this->profileSystemName) {
return null;
}
$profile = MetadataProfilePeer::retrieveBySystemName($this->profileSystemName, kCurrentContext::getCurrentPartnerId());
if (!$profile) {
return null;
}
$profileId = $profile->getId();
}
$metadata = null;
if ($scope instanceof accessControlScope) {
$metadata = MetadataPeer::retrieveByObject($profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
} elseif ($scope instanceof kEventScope && $scope->getEvent() instanceof kApplicativeEvent) {
$object = $scope->getEvent()->getObject();
if ($object instanceof Metadata) {
$metadata = $object;
} elseif (kMetadataManager::isMetadataObject($object)) {
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadata = MetadataPeer::retrieveByObject($profileId, $objectType, $object->getId());
}
}
if (!$metadata) {
return false;
}
if ($this->versionA) {
$valuesA = kMetadataManager::parseMetadataValues($metadata, $this->xPath, $this->versionA);
}
$valuesB = kMetadataManager::parseMetadataValues($metadata, $this->xPath, $this->versionB);
if (!$valuesA || !count($valuesA)) {
//previous MD version does not exist
$changedValues = $valuesB;
} else {
$changedValues = array_diff($valuesA, $valuesB);
}
return count($changedValues) > 0;
}
public function getFieldValue(kScope $scope)
{
$profileId = $this->profileId;
if (!$profileId) {
if (!$this->profileSystemName) {
return null;
}
$profile = MetadataProfilePeer::retrieveBySystemName($this->profileSystemName, kCurrentContext::getCurrentPartnerId());
if (!$profile) {
return null;
}
$profileId = $profile->getId();
}
$metadata = null;
if ($scope instanceof accessControlScope || $scope instanceof kStorageProfileScope) {
$metadata = MetadataPeer::retrieveByObject($profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
} elseif ($scope instanceof kEventScope && $scope->getEvent() instanceof kApplicativeEvent) {
$object = $scope->getEvent()->getObject();
if (kMetadataManager::isMetadataObject($object)) {
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadata = MetadataPeer::retrieveByObject($profileId, $objectType, $object->getId());
} else {
if ($object instanceof Metadata) {
$metadata = $object;
}
}
}
if (!$metadata) {
return null;
}
$values = kMetadataManager::parseMetadataValues($metadata, $this->xPath);
if (is_null($values)) {
return null;
}
return array_map('intval', $values);
}
public function updateFromXSLImpl($id, $xslData)
{
$dbMetadataObject = MetadataPeer::retrieveByPK($id);
if (!$dbMetadataObject) {
throw new KalturaAPIException(MetadataErrors::METADATA_NOT_FOUND);
}
$dbMetadataObjectFileSyncKey = $dbMetadataObject->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xsltErrors = array();
$transformMetadataObjectData = kXml::transformXmlUsingXslt(kFileSyncUtils::file_get_contents($dbMetadataObjectFileSyncKey), $xslData, array(), $xsltErrors);
if (count($xsltErrors)) {
throw new KalturaAPIException(MetadataErrors::XSLT_VALIDATION_ERROR, implode(',', $xsltErrors));
}
return $this->updateImpl($id, $transformMetadataObjectData);
}
public function adjustAssetParams($entryId, array &$flavors)
{
$entry = entryPeer::retrieveByPK($entryId);
if (!isset($entry)) {
KalturaLog::warning("Bad entry id ({$entryId}).");
return;
}
$partnerId = $entry->getPartnerId();
$profile = MetadataProfilePeer::retrieveBySystemName(self::TRANSCODING_METADATA_PROF_SYSNAME, $partnerId);
if (!isset($profile)) {
KalturaLog::log("No Transcoding Metadata Profile (sysName:" . self::TRANSCODING_METADATA_PROF_SYSNAME . ", partner:{$partnerId}). Nothing to adjust");
return;
}
$metadata = MetadataPeer::retrieveByObject($profile->getId(), MetadataObjectType::ENTRY, $entryId);
if (!isset($metadata)) {
KalturaLog::log("No Metadata for entry({$entryId}), metadata profile (id:" . $profile->getId() . "). Nothing to adjust");
return;
}
KalturaLog::log("Entry ({$entryId}) has following metadata fields:" . print_r($metadata, 1));
// Retrieve the associated XML file
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
if (!isset($key)) {
KalturaLog::log("Entry({$entryId}) metadata object misses file sync key! Nothing to adjust");
return;
}
$xmlStr = kFileSyncUtils::file_get_contents($key, true, false);
if (!isset($xmlStr)) {
KalturaLog::log("Entry({$entryId}) metadata object misses valid file sync! Nothing to adjust");
return;
}
KalturaLog::log("Adjusting: entry({$entryId}),metadata profile(" . self::TRANSCODING_METADATA_PROF_SYSNAME . "),xml==>{$xmlStr}");
$watermarkSettingsStr = null;
$imageEntry = null;
$imageUrl = null;
// Retrieve the custom metadata fields from the asocieted XML
$xml = new SimpleXMLElement($xmlStr);
$fldName = self::TRANSCODING_METADATA_WATERMMARK_SETTINGS;
if (isset($xml->{$fldName})) {
$watermarkSettingsStr = (string) $xml->{$fldName};
KalturaLog::log("Found metadata - {$fldName}({$watermarkSettingsStr})");
}
$fldName = self::TRANSCODING_METADATA_WATERMMARK_IMAGE_ENTRY;
if (isset($xml->{$fldName})) {
$imageEntry = (string) $xml->{$fldName};
KalturaLog::log("Found metadata - {$fldName}({$imageEntry})");
}
$fldName = self::TRANSCODING_METADATA_WATERMMARK_IMAGE_URL;
if (isset($xml->{$fldName})) {
$imageUrl = (string) $xml->{$fldName};
KalturaLog::log("Found metadata - {$fldName}({$imageUrl})");
}
/*
* The imageEntry is preffered if both imageEntry and url are set,
* in such case - remove the url
*/
if (isset($imageEntry) && isset($imageUrl)) {
KalturaLog::log("Found both " . self::TRANSCODING_METADATA_WATERMMARK_IMAGE_URL . "({$imageEntry}) and {$fldName}({$imageUrl}). Removing {$fldName}");
$imageUrl = null;
//
}
/*
* If custom-metadate contains 'full' WM settings ('watermarkSettingsStr' is set),
* adjust it to custom meta imageEntry/imageUrl values,
* if those provided.
*/
if (isset($watermarkSettingsStr)) {
$watermarkSettings = json_decode($watermarkSettingsStr);
$this->adjustWatermarSettings($watermarkSettings, $imageEntry, $imageUrl);
}
/*
* Loop through the flavor params to update the WM settings,
* if it is required.
*/
foreach ($flavors as $k => $flavor) {
KalturaLog::log("Processing flavor id:" . $flavor->getId());
$wmDataObj = null;
/*
* The 'full' WM settings in the custom metadata overides any exitings WM settings
*/
if (isset($watermarkSettings)) {
$wmDataObj = clone $watermarkSettings;
} else {
/*
* No 'full' settings.
* Adjust the existing flavor WM data with custom metadata imageEntry/imageUrl
*/
$wmDataStr = $flavor->getWatermarkData();
if (isset($wmDataStr)) {
$wmDataObj = json_decode($wmDataStr);
if ($this->adjustWatermarSettings($wmDataObj, $imageEntry, $imageUrl) == false) {
continue;
}
}
}
if (isset($wmDataObj)) {
$toJson = json_encode($wmDataObj);
$flavor->setWatermarkData($toJson);
$flavors[$k] = $flavor;
KalturaLog::log("Set flavor (" . $flavor->getId() . ") WM to {$toJson}");
}
}
}
/**
* Builds a Criteria object containing the primary key for this object.
*
* Unlike buildCriteria() this method includes the primary key values regardless
* of whether or not they have been modified.
*
* @return Criteria The Criteria object containing value(s) for primary key(s).
*/
public function buildPkeyCriteria()
{
$criteria = new Criteria(MetadataPeer::DATABASE_NAME);
$criteria->add(MetadataPeer::ID, $this->id);
if ($this->alreadyInSave && count($this->modifiedColumns) == 2 && $this->isColumnModified(MetadataPeer::UPDATED_AT)) {
$theModifiedColumn = null;
foreach ($this->modifiedColumns as $modifiedColumn) {
if ($modifiedColumn != MetadataPeer::UPDATED_AT) {
$theModifiedColumn = $modifiedColumn;
}
}
$atomicColumns = MetadataPeer::getAtomicColumns();
if (in_array($theModifiedColumn, $atomicColumns)) {
$criteria->add($theModifiedColumn, $this->getByName($theModifiedColumn, BasePeer::TYPE_COLNAME), Criteria::NOT_EQUAL);
}
}
return $criteria;
}
public static function generateCuePointXml(SimpleXMLElement $scene, $objectType, $cuePointId)
{
$metadatas = MetadataPeer::retrieveAllByObject($objectType, $cuePointId);
foreach ($metadatas as $metadata) {
/* @var $metadata Metadata */
$metadataElement = $scene->addChild('scene-customData');
$metadataElement->addAttribute('metadataId', $metadata->getId());
$metadataElement->addAttribute('metadataVersion', $metadata->getVersion());
$metadataElement->addAttribute('metadataProfileId', $metadata->getMetadataProfileId());
$metadataElement->addAttribute('metadataProfileVersion', $metadata->getMetadataProfileVersion());
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xml = kFileSyncUtils::file_get_contents($key, true, false);
if ($xml) {
$xmlElement = new SimpleXMLElement($xml);
self::appendXML($metadataElement, $xmlElement);
}
$metadataProfile = $metadata->getMetadataProfile();
if (!$metadataProfile) {
continue;
}
if ($metadataProfile->getSystemName()) {
$metadataElement->addAttribute('metadataProfile', $metadataProfile->getSystemName());
}
if ($metadataProfile->getName()) {
$metadataElement->addAttribute('metadataProfileName', $metadataProfile->getName());
}
}
return $scene;
}
/**
* Retrieve multiple objects by pkey.
*
* @param array $pks List of primary keys
* @param PropelPDO $con the connection to use
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function retrieveByPKs($pks, PropelPDO $con = null)
{
$objs = null;
if (empty($pks)) {
$objs = array();
} else {
$criteria = new Criteria(MetadataPeer::DATABASE_NAME);
$criteria->add(MetadataPeer::ID, $pks, Criteria::IN);
$objs = MetadataPeer::doSelect($criteria, $con);
}
return $objs;
}
/**
* Serves metadata XML file
*
* @action serve
* @param int $id
* @return file
*
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws KalturaErrors::FILE_DOESNT_EXIST
*/
public function serveAction($id)
{
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$fileName = $dbMetadata->getObjectId() . '.xml';
$fileSubType = Metadata::FILE_SYNC_METADATA_DATA;
return $this->serveFile($dbMetadata, $fileSubType, $fileName);
}
public function getListResponse(KalturaFilterPager $pager, KalturaDetachedResponseProfile $responseProfile = null)
{
if (kEntitlementUtils::getEntitlementEnforcement() && (is_null($this->objectIdIn) && is_null($this->objectIdEqual))) {
throw new KalturaAPIException(MetadataErrors::MUST_FILTER_ON_OBJECT_ID);
}
if (!$this->metadataObjectTypeEqual) {
throw new KalturaAPIException(MetadataErrors::MUST_FILTER_ON_OBJECT_TYPE);
}
if ($this->metadataObjectTypeEqual == MetadataObjectType::CATEGORY) {
if ($this->objectIdEqual) {
$categoryIds = array($this->objectIdEqual);
} else {
if ($this->objectIdIn) {
$categoryIds = explode(',', $this->objectIdIn);
}
}
if ($categoryIds) {
$categories = categoryPeer::retrieveByPKs($categoryIds);
if (!count($categories)) {
KalturaLog::debug("No categories found");
$response = new KalturaMetadataListResponse();
$response->objects = new KalturaMetadataArray();
$response->totalCount = 0;
return $response;
}
$categoryIds = array();
foreach ($categories as $category) {
$categoryIds[] = $category->getId();
}
$this->objectIdEqual = null;
$this->objectIdIn = implode(',', $categoryIds);
}
}
$metadataFilter = $this->toObject();
$c = KalturaCriteria::create(MetadataPeer::OM_CLASS);
$metadataFilter->attachToCriteria($c);
$pager->attachToCriteria($c);
$list = MetadataPeer::doSelect($c);
$response = new KalturaMetadataListResponse();
$response->objects = KalturaMetadataArray::fromDbArray($list, $responseProfile);
if ($c instanceof SphinxMetadataCriteria) {
$response->totalCount = $c->getRecordsCount();
} elseif ($pager->pageIndex == 1 && count($response->objects) < $pager->pageSize) {
$response->totalCount = count($response->objects);
} else {
$pager->detachFromCriteria($c);
$response->totalCount = MetadataPeer::doCount($c);
}
return $response;
}
public function validateForSubmission(EntryDistribution $entryDistribution, $action)
{
$validationErrors = parent::validateForSubmission($entryDistribution, $action);
$entry = entryPeer::retrieveByPK($entryDistribution->getEntryId());
if (!$entry) {
KalturaLog::err("Entry [" . $entryDistribution->getEntryId() . "] not found");
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, 'entry', 'entry not found');
return $validationErrors;
}
// validate entry name minumum length of 1 character
if (strlen($entry->getName()) < self::ENTRY_NAME_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, '');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// validate entry name maximum length of 60 characters
if (strlen($entry->getName()) > self::ENTRY_NAME_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, '');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
$validateDescription = true;
$validateTags = true;
$validationErrors = $this->validateMetadataForSubmission($entryDistribution, $action, $validationErrors, $validateDescription, $validateTags);
if ($validateDescription) {
if (!strlen($entry->getDescription())) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::DESCRIPTION, 'Description is empty');
} elseif (strlen($entry->getDescription()) < self::ENTRY_DESCRIPTION_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::DESCRIPTION, 'Description is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
} elseif (strlen($entry->getDescription()) > self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::DESCRIPTION, 'Description is too log');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
$tags = $entry->getTags();
if ($validateTags) {
if (!strlen($tags)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::TAGS, 'Tags is empty');
} elseif (strlen($tags) < self::ENTRY_TAGS_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::TAGS, 'Tags is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
} elseif (strlen($tags) > self::ENTRY_TAGS_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::TAGS, 'Tags is too log');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
} elseif (class_exists('MetadataProfile')) {
$metadataProfileId = $this->getMetadataProfileId();
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, Metadata::TYPE_ENTRY, $entryDistribution->getEntryId());
if ($metadata) {
$tagsArray = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_TAGS);
$tags = implode(',', $tagsArray);
}
}
// validate each tag length between 2 and 30 characters
$tags = explode(',', $tags);
foreach ($tags as &$tag) {
$tag = trim($tag);
}
foreach ($tags as $tag) {
if (strlen($tag) < self::ENTRY_EACH_TAG_MANIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, 'Tag', $tag);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_EACH_TAG_MANIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (strlen($tag) > self::ENTRY_EACH_TAG_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, 'Tag', $tag);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_EACH_TAG_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
return $validationErrors;
}
/**
* @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);
}
/**
* batch getTransformMetadataObjects action retrieve all metadata objects that requires upgrade and the total count
*
* @action upgradeMetadataObjects
* @param int $metadataProfileId The id of the metadata profile
* @param int $srcVersion The old metadata profile version
* @param int $destVersion The new metadata profile version
* @return KalturaUpgradeMetadataResponse
*/
function upgradeMetadataObjectsAction($metadataProfileId, $srcVersion, $destVersion, KalturaFilterPager $pager = null)
{
$response = new KalturaUpgradeMetadataResponse();
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId);
$c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion, Criteria::LESS_THAN);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID);
$response->lowerVersionCount = MetadataPeer::doCount($c);
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId);
$c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID);
$update = new Criteria();
$update->add(MetadataPeer::METADATA_PROFILE_VERSION, $destVersion);
$con = Propel::getConnection(MetadataPeer::DATABASE_NAME, Propel::CONNECTION_READ);
$response->totalCount = BasePeer::doUpdate($c, $update, $con);
return $response;
}
public static function doCountOnPeer(Criteria $c)
{
return MetadataPeer::doCount($c);
}
public function getFieldNameFromPeer($field_name)
{
$res = MetadataPeer::translateFieldName($field_name, $this->field_name_translation_type, BasePeer::TYPE_COLNAME);
return $res;
}
protected function loadPlaylistsFromMetadata($entryId, KalturaYoutubeApiDistributionProfile $distributionProfile)
{
$playlists = array();
$metadataProfileId = $distributionProfile->metadataProfileId;
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, Metadata::TYPE_ENTRY, $entryId);
if ($metadata) {
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xmlContent = kFileSyncUtils::file_get_contents($key, true, false);
$xml = new DOMDocument();
$xml->loadXML($xmlContent);
// first metada field
$nodes = $xml->getElementsByTagName(YoutubeApiDistributionProfile::METADATA_FIELD_PLAYLIST);
foreach ($nodes as $node) {
$playlists[] = $node->textContent;
}
// second metadata field
$nodes = $xml->getElementsByTagName(YoutubeApiDistributionProfile::METADATA_FIELD_PLAYLISTS);
foreach ($nodes as $node) {
$playlists[] = $node->textContent;
}
}
$this->playlists = implode(',', $playlists);
}
public function validateForSubmission(EntryDistribution $entryDistribution, $action)
{
$missingDesc = false;
$missingTags = false;
$validationErrors = parent::validateForSubmission($entryDistribution, $action);
$entry = entryPeer::retrieveByPK($entryDistribution->getEntryId());
if (!$entry) {
KalturaLog::err("Entry [" . $entryDistribution->getEntryId() . "] not found");
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, 'entry', 'entry not found');
return $validationErrors;
}
// validate entry name minumum length of 1 character
if (strlen($entry->getName()) < self::ENTRY_NAME_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, '');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (strlen($entry->getName()) > self::ENTRY_NAME_MAXIMUM_LENGTH) {
$description = 'entry name length must be between ' . self::ENTRY_NAME_MINIMUM_LENGTH . ' and ' . self::ENTRY_NAME_MAXIMUM_LENGTH;
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (strlen($entry->getDescription()) < self::ENTRY_DESC_MINIMUM_LENGTH) {
$missingDesc = true;
}
if (strlen($entry->getTags()) < self::ENTRY_DESC_MINIMUM_LENGTH) {
$missingTags = true;
}
if (!class_exists('MetadataProfile')) {
return $validationErrors;
}
$metadataFields = array(self::METADATA_FIELD_KEYWORDS, self::METADATA_FIELD_DESCRIPTION);
$metadataProfileId = $this->getMetadataProfileId();
$metadatas = MetadataPeer::retrieveAllByObject(MetadataObjectType::ENTRY, $entryDistribution->getEntryId());
foreach ($metadataFields as $index => $metadataField) {
$values = $this->findMetadataValue($metadatas, $metadataField);
if (!count($values)) {
switch ($metadataField) {
case self::METADATA_FIELD_DESCRIPTION:
if ($missingDesc) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::DESCRIPTION, "");
}
break;
case self::METADATA_FIELD_KEYWORDS:
if ($missingTags) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::TAGS, "");
}
break;
default:
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, $metadataField);
}
}
foreach ($values as $value) {
if (!strlen($value)) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, $metadataField, "");
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_EMPTY);
$validationError->setMetadataProfileId($metadataProfileId);
$validationErrors[] = $validationError;
break;
}
}
}
return $validationErrors;
}
/**
* @param BaseObject $object
*/
protected function setRelatedObject(AuditTrail $auditTrail, BaseObject $object)
{
if (class_exists('Metadata') && $object instanceof Metadata) {
$auditTrail->setRelatedObjectType(AuditTrailObjectType::METADATA_PROFILE);
$auditTrail->setRelatedObjectId($object->getMetadataProfileId());
}
if ($auditTrail->getAction() == AuditTrail::AUDIT_TRAIL_ACTION_FILE_SYNC_CREATED) {
$peer = $object->getPeer();
$objectType = $peer->getOMClass(false, null);
$auditTrail->setRelatedObjectType($objectType);
$auditTrail->setRelatedObjectId($object->getId());
}
if ($object instanceof FileSync) {
switch ($object->getObjectType()) {
case FileSyncObjectType::ENTRY:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::ENTRY);
$auditTrail->setRelatedObjectId($object->getObjectId());
$auditTrail->setEntryId($object->getObjectId());
break;
case FileSyncObjectType::UICONF:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::UI_CONF);
$auditTrail->setRelatedObjectId($object->getObjectId());
break;
case FileSyncObjectType::BATCHJOB:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::BATCH_JOB);
$auditTrail->setRelatedObjectId($object->getObjectId());
$batchJob = BatchJobPeer::retrieveByPK($object->getObjectId());
if ($batchJob) {
$auditTrail->setEntryId($batchJob->getEntryId());
}
break;
case FileSyncObjectType::FLAVOR_ASSET:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::FLAVOR_ASSET);
$auditTrail->setRelatedObjectId($object->getObjectId());
$flavorAsset = assetPeer::retrieveById($object->getObjectId());
if ($flavorAsset) {
$auditTrail->setEntryId($flavorAsset->getEntryId());
}
break;
case FileSyncObjectType::METADATA:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::METADATA);
$auditTrail->setRelatedObjectId($object->getObjectId());
if (class_exists('Metadata')) {
$metadata = MetadataPeer::retrieveByPK($object->getObjectId());
if ($metadata && $metadata->getObjectType() == MetadataObjectType::ENTRY) {
$auditTrail->setEntryId($metadata->getObjectId());
}
}
break;
case FileSyncObjectType::METADATA_PROFILE:
$auditTrail->setRelatedObjectType(AuditTrailObjectType::METADATA_PROFILE);
$auditTrail->setRelatedObjectId($object->getObjectId());
break;
}
}
}
