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; }