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);
}
}
}
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 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;
}
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);
}
/**
* Adds a metadata object associated with Kaltura object
*
* @param int $metadataProfileId
* @param KalturaMetadataObjectType $objectType
* @param string $objectId
* @return Metadata
* @throws MetadataErrors::METADATA_ALREADY_EXISTS
* @throws MetadataErrors::INVALID_METADATA_PROFILE
* @throws MetadataErrors::INVALID_METADATA_PROFILE_TYPE
* @throws MetadataErrors::INVALID_METADATA_OBJECT
*/
protected function addMetadata($metadataProfileId, $objectType, $objectId)
{
$objectType = kPluginableEnumsManager::apiToCore('MetadataObjectType', $objectType);
$check = MetadataPeer::retrieveByObject($metadataProfileId, $objectType, $objectId);
if ($check) {
throw new KalturaAPIException(MetadataErrors::METADATA_ALREADY_EXISTS, $check->getId());
}
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE, $metadataProfileId);
}
if ($dbMetadataProfile->getObjectType() != $objectType) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE_TYPE, $dbMetadataProfile->getObjectType());
}
$dbMetadata = new Metadata();
$dbMetadata->setPartnerId($this->getPartnerId());
$dbMetadata->setMetadataProfileId($metadataProfileId);
$dbMetadata->setMetadataProfileVersion($dbMetadataProfile->getVersion());
$dbMetadata->setObjectType($objectType);
$dbMetadata->setObjectId($objectId);
$dbMetadata->setStatus(KalturaMetadataStatus::VALID);
$dbMetadata->setLikeNew(true);
// dynamic objects are metadata only, skip validating object id
if ($objectType != KalturaMetadataObjectType::DYNAMIC_OBJECT) {
// validate object exists
$object = kMetadataManager::getObjectFromPeer($dbMetadata);
if (!$object) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_OBJECT, $objectId);
}
}
$dbMetadata->save();
$this->deleteOldVersions($dbMetadata);
return $dbMetadata;
}
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}");
}
}
}
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;
}
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;
}
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);
}
/**
* Function sweeps the given fields of the emailNotificationTemplate, and parses expressions of the type
* {metadata:[metadataProfileSystemName]:[metadataProfileFieldSystemName]}
*/
public static function editTemplateFields($sweepFieldValues, $scope, $objectType)
{
KalturaLog::debug('Field values to sweep: ' . print_r($sweepFieldValues, true));
if (!$scope instanceof kEventScope) {
return array();
}
if (!method_exists($scope->getObject(), 'getPartnerId')) {
return array();
}
$partnerId = $scope->getObject()->getPartnerId();
/* @var $scope kEventScope */
$metadataContentParameters = array();
foreach ($sweepFieldValues as $sweepFieldValue) {
//Obtain matches for the set structure {metadata:[profileSystemName][profileFieldSystemName]}
preg_match_all(self::METADATA_EMAIL_NOTIFICATION_REGEX, $sweepFieldValue, $matches);
foreach ($matches[0] as $match) {
$match = str_replace(array('{', '}'), array('', ''), $match);
list($metadata, $profileSystemName, $fieldSystemName, $format) = explode(':', $match, 4);
$profile = MetadataProfilePeer::retrieveBySystemName($profileSystemName, $partnerId);
if (!$profile) {
KalturaLog::info("Metadata profile with system name {$profileSystemName} not found for this partner. Token will be replaced with empty string.");
$metadataContentParameters[$match] = '';
continue;
}
$objectId = null;
$metadataObjectId = null;
//If the metadataProfileobjectType matches the one on the emailNotification, we can proceed
//If the objectType of the email template is 'asset' we can use the entryId
//If the objectType of the email template is a metadata object we can use its id
if (kMetadataManager::getObjectTypeName($profile->getObjectType()) == KalturaPluginManager::getObjectClass('EventNotificationEventObjectType', $objectType)) {
$objectId = $scope->getObject()->getId();
} elseif (kMetadataManager::getObjectTypeName($profile->getObjectType()) == 'entry' && $scope->getObject() instanceof asset) {
$objectId = $scope->getObject()->getEntryId();
} elseif ($scope->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->getObject();
$objectId = $categoryEntry->{$getter}();
} elseif (KalturaPluginManager::getObjectClass('EventNotificationEventObjectType', $objectType) == MetadataPeer::OM_CLASS) {
$metadataObjectId = $scope->getObject()->getId();
}
if ($objectId) {
$result = MetadataPeer::retrieveByObject($profile->getId(), $profile->getObjectType(), $objectId);
} elseif ($metadataObjectId) {
$result = MetadataPeer::retrieveByPK($metadataObjectId);
} else {
//There is not enough specification regarding the required metadataObject, abort.
KalturaLog::info("The template does not contain an object Id for which custom metadata can be retrieved. Token will be replaced with empty string.");
$metadataContentParameters[$match] = '';
continue;
}
if (!$result) {
KalturaLog::info("Metadata object could not be retrieved. Token will be replaced with empty string.");
$metadataContentParameters[$match] = '';
continue;
}
$strvals = kMetadataManager::getMetadataValueForField($result, $fieldSystemName);
foreach ($strvals as &$strval) {
if ($format && is_numeric($strval)) {
$strval = date($format, $strval);
}
}
$metadataContentParameters[$match] = implode(',', $strvals);
}
}
return $metadataContentParameters;
}
/**
* @param EntryDistribution $entryDistribution
* @param int $action enum from DistributionAction
* @param array $validationErrors
* @param bool $validateDescription
* @param bool $validateTags
* @return array
*/
public function validateMetadataForSubmission(EntryDistribution $entryDistribution, $action, array $validationErrors, &$validateDescription, &$validateTags)
{
$validateDescription = true;
$validateTags = true;
if (!class_exists('MetadataProfile')) {
return $validationErrors;
}
$metadataProfileId = $this->getMetadataProfileId();
if (!$metadataProfileId) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_CATEGORY);
if (!$metadataProfileCategoryField) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, Metadata::TYPE_ENTRY, $entryDistribution->getEntryId());
if (!$metadata) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY);
return $validationErrors;
}
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_CATEGORY);
if (!count($values)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
}
foreach ($values as $value) {
if (!strlen($value)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_DESCRIPTION);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_DESCRIPTION);
if (count($values)) {
foreach ($values as $value) {
if (!strlen($value)) {
continue;
}
$validateDescription = false;
// validate entry description minumum length of 1 character
if (strlen($value) < self::ENTRY_DESCRIPTION_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'Dailymotion description is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// validate entry description minumum length of 1 character
if (strlen($value) > self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'Dailymotion description is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
}
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_TAGS);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_TAGS);
if (count($values) && strlen(implode('', $values))) {
$tags = implode(',', $values);
$tags = explode(',', $tags);
$tagsStr = implode(' , ', $tags);
$validateTags = false;
if (strlen($tagsStr) > self::ENTRY_TAGS_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tags is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (count($tags) < self::ENTRY_TAGS_MINIMUM_COUNT) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tags must contain at least ' . self::ENTRY_TAGS_MINIMUM_COUNT . ' tags');
$validationError->setValidationErrorType(DistributionValidationErrorType::CUSTOM_ERROR);
$validationError->setValidationErrorParam('Dailymotion tags must contain at least ' . self::ENTRY_TAGS_MINIMUM_COUNT . ' tags');
$validationErrors[] = $validationError;
}
foreach ($tags as $tag) {
if (strlen($tag) < self::ENTRY_TAG_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tag [$tag] must contain at least ' . self::ENTRY_TAG_MINIMUM_LENGTH . ' characters');
$validationError->setValidationErrorType(DistributionValidationErrorType::CUSTOM_ERROR);
$validationError->setValidationErrorParam('Dailymotion tag [$tag] must contain at least ' . self::ENTRY_TAG_MINIMUM_LENGTH . ' characters');
$validationErrors[] = $validationError;
}
}
}
}
return $validationErrors;
}
/**
* Allows you to add a metadata object and metadata file associated with Kaltura object
*
* @action addFromFile
* @param int $metadataProfileId
* @param KalturaMetadataObjectType $objectType
* @param string $objectId
* @param file $xmlFile XML metadata
* @return KalturaMetadata
* @throws MetadataErrors::METADATA_ALREADY_EXISTS
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::INVALID_METADATA_DATA
*/
function addFromFileAction($metadataProfileId, $objectType, $objectId, $xmlFile)
{
$check = MetadataPeer::retrieveByObject($metadataProfileId, $objectType, $objectId);
if ($check) {
throw new KalturaAPIException(MetadataErrors::METADATA_ALREADY_EXISTS, $check->getId());
}
$filePath = $xmlFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xmlFile['name']);
}
$dbMetadata = $this->addMetadata($metadataProfileId, $objectType, $objectId);
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::moveFromFile($filePath, $key);
$errorMessage = '';
$status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage);
if ($status == KalturaMetadataStatus::VALID) {
$this->deleteOldVersions($dbMetadata);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata));
} else {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage);
}
$metadata = new KalturaMetadata();
$metadata->fromObject($dbMetadata);
return $metadata;
}
