/**
* @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 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 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;
}
/**
* 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);
}
/**
* @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;
}
}
}
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();
}
}
if ($baseClass == 'KalturaCondition') {
if ($enumValue == MetadataPlugin::getConditionTypeCoreValue(MetadataConditionType::METADATA_FIELD_COMPARE)) {
return new KalturaCompareMetadataCondition();
}
if ($enumValue == MetadataPlugin::getConditionTypeCoreValue(MetadataConditionType::METADATA_FIELD_MATCH)) {
return new KalturaMatchMetadataCondition();
}
if ($enumValue == MetadataPlugin::getConditionTypeCoreValue(MetadataConditionType::METADATA_FIELD_CHANGED)) {
return new KalturaMetadataFieldChangedCondition();
}
}
if ($baseClass == 'KalturaFilter') {
if ($enumValue == 'MetadataFilter') {
return new KalturaMetadataFilter();
}
}
if ($baseClass == 'KIndexingEngine') {
if ($enumValue == KalturaIndexObjectType::METADATA) {
return new KIndexingMetadataEngine();
}
}
if ($baseClass == 'KalturaResponseProfileMapping') {
if ($enumValue == 'kMetadataResponseProfileMapping') {
return new KalturaMetadataResponseProfileMapping();
}
}
return null;
}
/**
* 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;
}
/**
* Update an existing metadata object with new XML file
*
* @action updateFromFile
* @param int $id
* @param file $xmlFile XML metadata
* @return KalturaMetadata
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::INVALID_METADATA_DATA
*/
function updateFromFileAction($id, $xmlFile = null)
{
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$filePath = null;
if ($xmlFile) {
$filePath = $xmlFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xmlFile['name']);
}
}
$previousVersion = null;
if ($dbMetadata->getStatus() == Metadata::STATUS_VALID) {
$previousVersion = $dbMetadata->getVersion();
}
if ($filePath) {
$dbMetadata->incrementVersion();
}
$dbMetadata->save();
if ($filePath) {
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::moveFromFile($filePath, $key);
$errorMessage = '';
$status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata, $previousVersion));
if ($status != KalturaMetadataStatus::VALID) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage);
}
}
$metadata = new KalturaMetadata();
$metadata->fromObject($dbMetadata);
return $metadata;
}
