function updateImpl($id, $xmlData = null, $version = null)
{
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(MetadataErrors::METADATA_NOT_FOUND, $id);
}
if ($version && $dbMetadata->getVersion() != $version) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_VERSION, $dbMetadata->getVersion());
}
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($dbMetadata->getMetadataProfileId());
if (!$dbMetadataProfile) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE, $dbMetadata->getMetadataProfileId());
}
$previousVersion = null;
if ($dbMetadata->getStatus() == Metadata::STATUS_VALID) {
$previousVersion = $dbMetadata->getVersion();
}
if ($xmlData) {
// if a metadata xslt is defined on the metadata profile - transform the given metadata
$xmlDataTransformed = $this->transformMetadata($dbMetadata->getMetadataProfileId(), $xmlData);
if ($xmlDataTransformed) {
$xmlData = $xmlDataTransformed;
}
$errorMessage = '';
if (!kMetadataManager::validateMetadata($dbMetadata->getMetadataProfileId(), $xmlData, $errorMessage)) {
// if metadata profile is transforming, and metadata profile version is not the latest, try to validate againts previous version
if ($dbMetadataProfile->getStatus() != MetadataProfile::STATUS_TRANSFORMING || $dbMetadata->getMetadataProfileVersion() >= $dbMetadataProfile->getVersion()) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage);
}
// validates against previous version
$errorMessagePrevVersion = '';
if (!kMetadataManager::validateMetadata($dbMetadata->getMetadataProfileId(), $xmlData, $errorMessagePrevVersion, true)) {
KalturaLog::err("Failed to validate metadata object [{$id}] against metadata profile previous version [" . $dbMetadata->getMetadataProfileVersion() . "] error: {$errorMessagePrevVersion}");
// throw the error with the original error message
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_DATA, $errorMessage);
}
} else {
$dbMetadata->setMetadataProfileVersion($dbMetadataProfile->getVersion());
}
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
if (!kFileSyncUtils::compareContent($key, $xmlData)) {
$dbMetadata->incrementVersion();
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
$dbMetadata->save();
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata, $previousVersion));
} else {
KalturaLog::info("XML data MD5 matches current filesync content MD5. Update is not necessary.");
//adding this save() in order to save the metadata profile version field in case there are no diffrences
$dbMetadata->save();
}
}
$metadata = new KalturaMetadata();
$metadata->fromObject($dbMetadata, $this->getResponseProfile());
return $metadata;
}
public static function parseXml($objectType, SimpleXMLElement $scene, $partnerId, CuePoint $cuePoint)
{
$metadataElements = $scene->xpath('scene-customData');
if (!count($metadataElements)) {
return $cuePoint;
}
foreach ($metadataElements as $metadataElement) {
$metadata = null;
$metadataProfile = null;
if (isset($metadataElement['metadataId'])) {
$metadata = MetadataPeer::retrieveByPK($metadataElement['metadataId']);
}
if ($metadata) {
$metadataProfile = $metadata->getMetadataProfile();
} else {
if (isset($metadataElement['metadataProfileId'])) {
$metadataProfile = MetadataProfilePeer::retrieveByPK($metadataElement['metadataProfileId']);
} elseif (isset($metadataElement['metadataProfile'])) {
$metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataElement['metadataProfile']);
}
if ($metadataProfile) {
$metadata = MetadataPeer::retrieveByObject($metadataProfile->getId(), $objectType, $cuePoint->getId());
}
}
if (!$metadataProfile) {
continue;
}
if (!$metadata) {
$metadata = new Metadata();
$metadata->setPartnerId($partnerId);
$metadata->setMetadataProfileId($metadataProfile->getId());
$metadata->setMetadataProfileVersion($metadataProfile->getVersion());
$metadata->setObjectType($objectType);
$metadata->setObjectId($cuePoint->getId());
$metadata->setStatus(KalturaMetadataStatus::VALID);
foreach ($metadataElement->children() as $metadataContent) {
$xmlData = $metadataContent->asXML();
$errorMessage = '';
if (kMetadataManager::validateMetadata($metadataProfile->getId(), $xmlData, $errorMessage)) {
$metadata->save();
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($metadata));
}
break;
}
}
}
return $cuePoint;
}
/**
* @param string $entryId the new created entry
* @param array $data key => value pairs
*/
public static function handleBulkUploadData($entryId, array $data)
{
KalturaLog::debug("Handle metadata bulk upload data:\n" . print_r($data, true));
if (!isset($data[self::BULK_UPLOAD_COLUMN_PROFILE_ID])) {
return;
}
$metadataProfileId = $data[self::BULK_UPLOAD_COLUMN_PROFILE_ID];
$xmlData = null;
$entry = entryPeer::retrieveByPK($entryId);
if (!$entry) {
return;
}
// $criteriaFilter = FileSyncPeer::getCriteriaFilter();
// $criteria = $criteriaFilter->getFilter();
// $criteria->add(FileSyncPeer::PARTNER_ID, $entry->getPartnerId());
$metadataProfile = MetadataProfilePeer::retrieveById($metadataProfileId);
if (!$metadataProfile) {
$errorMessage = "Metadata profile [{$metadataProfileId}] not found";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
return;
}
if (isset($data[self::BULK_UPLOAD_COLUMN_URL])) {
try {
$xmlData = file_get_contents($data[self::BULK_UPLOAD_COLUMN_URL]);
KalturaLog::debug("Metadata downloaded [" . $data[self::BULK_UPLOAD_COLUMN_URL] . "]");
} catch (Exception $e) {
$errorMessage = "Download metadata[" . $data[self::BULK_UPLOAD_COLUMN_URL] . "] error: " . $e->getMessage();
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
$xmlData = null;
}
} elseif (isset($data[self::BULK_UPLOAD_COLUMN_XML])) {
$xmlData = $data[self::BULK_UPLOAD_COLUMN_XML];
} else {
$metadataProfileFields = array();
MetadataProfileFieldPeer::setUseCriteriaFilter(false);
$tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId);
MetadataProfileFieldPeer::setUseCriteriaFilter(true);
foreach ($tmpMetadataProfileFields as $metadataProfileField) {
$metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField;
}
KalturaLog::debug("Found fields [" . count($metadataProfileFields) . "] for metadata profile [{$metadataProfileId}]");
$xml = new DOMDocument();
$dataFound = false;
foreach ($data as $key => $value) {
if (!$value || !strlen($value)) {
continue;
}
if (!preg_match('/^' . self::BULK_UPLOAD_COLUMN_FIELD_PREFIX . '(.+)$/', $key, $matches)) {
continue;
}
$key = $matches[1];
if (!isset($metadataProfileFields[$key])) {
$errorMessage = "Field [{$key}] does not exist";
KalturaLog::debug($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileField = $metadataProfileFields[$key];
KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$value}]");
$fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $value);
foreach ($fieldValues as $fieldValue) {
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldValue)) {
$value = self::parseFormatedDate($fieldValue);
if (!$value || !strlen($value)) {
$errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]";
KalturaLog::debug($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
continue;
}
$fieldValue = $value;
}
self::addXpath($xml, $metadataProfileField->getXpath(), $fieldValue);
}
$dataFound = true;
}
if ($dataFound) {
$xmlData = $xml->saveXML($xml->firstChild);
$xmlData = trim($xmlData, " \n\r\t");
}
}
if (!$xmlData) {
return;
}
$dbMetadata = new Metadata();
$dbMetadata->setPartnerId($entry->getPartnerId());
$dbMetadata->setMetadataProfileId($metadataProfileId);
$dbMetadata->setMetadataProfileVersion($metadataProfile->getVersion());
$dbMetadata->setObjectType(Metadata::TYPE_ENTRY);
$dbMetadata->setObjectId($entryId);
$dbMetadata->setStatus(Metadata::STATUS_INVALID);
$dbMetadata->save();
KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]");
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
$errorMessage = '';
$status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage);
if ($status == Metadata::STATUS_VALID) {
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata));
} else {
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
}
}
/**
* Read multiple metadata schemas
* @param BaseObject $object
* @param array $data
*/
protected static function addMetadataWithProfilesSystemNames(BaseObject $object, array $data)
{
$newFieldValuesMap = array();
$xmlDataArray = array();
//Construct mapping of all metadata profile system names, their fields and the field values.
foreach ($data as $key => $value) {
if (strpos($key, self::BULK_UPLOAD_METADATA_FIELD_PREFIX) === 0) {
$prefix = null;
$metadataProfileSystemName = null;
$metadataProfileFieldName = null;
list($prefix, $metadataProfileSystemName, $metadataProfileFieldName) = explode(self::BULK_UPLOAD_METADATA_SYSTEMNAME_SEPARATOR, $key);
if (!$prefix || !$metadataProfileSystemName || !$metadataProfileFieldName) {
$errorMessage = "Unexpected key structure. Expected metadata::ProfileSystemName::FieldSystemName.";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
if (!isset($newFieldValuesMap[$metadataProfileSystemName])) {
$newFieldValuesMap[$metadataProfileSystemName] = array();
}
$newFieldValuesMap[$metadataProfileSystemName][$metadataProfileFieldName] = $value;
}
}
foreach ($newFieldValuesMap as $metadataProfileSystemName => $fieldsArray) {
/* @var array $fieldsArray */
if (!$fieldsArray || !count($fieldsArray)) {
continue;
}
$metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataProfileSystemName, $object->getPartnerId());
if (!$metadataProfile) {
$errorMessage = "Metadata profile with system name [{$metadataProfileSystemName}] could not be found.";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
if ($metadataProfile->getObjectType() != kMetadataManager::getTypeNameFromObject($object)) {
$errorMessage = "Metadata profile [{$metadataProfileSystemName}] object type [" . $metadataProfile->getObjectType() . "] is not compatible with object type [" . kMetadataManager::getTypeNameFromObject($object) . "]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileId = $metadataProfile->getId();
$xml = new DOMDocument();
$metadataProfileFields = array();
MetadataProfileFieldPeer::setUseCriteriaFilter(false);
$tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId);
MetadataProfileFieldPeer::setUseCriteriaFilter(true);
foreach ($tmpMetadataProfileFields as $metadataProfileField) {
/* @var $metadataProfileField MetadataProfileField */
$metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField;
}
foreach ($fieldsArray as $fieldSysName => $fieldValue) {
if (!isset($metadataProfileFields[$fieldSysName])) {
$errorMessage = "Metadata profile field with system name [{$fieldSysName}] missing from metadata profile with id [{$metadataProfileId}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileField = $metadataProfileFields[$fieldSysName];
KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$fieldValue}]");
$fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $fieldValue);
foreach ($fieldValues as $fieldSingleValue) {
if ($fieldSingleValue) {
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldSingleValue)) {
$valueAsDate = self::parseFormatedDate($fieldSingleValue);
if (!$valueAsDate || !strlen($valueAsDate)) {
$errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$fieldSingleValue = $valueAsDate;
}
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_INT && !is_numeric($fieldSingleValue)) {
$errorMessage = "Could not parse int format [{$fieldSingleValue}] for field [{$key}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
self::addXpath($xml, $metadataProfileField->getXpath(), $fieldSingleValue);
}
}
$dataFound = true;
if ($dataFound && $xml->hasChildNodes()) {
$xmlDataArray[$metadataProfileId] = $xml->saveXML($xml->firstChild);
$xmlDataArray[$metadataProfileId] = trim($xmlDataArray[$metadataProfileId], " \n\r\t");
}
}
}
foreach ($xmlDataArray as $metadataProfileId => $xmlData) {
$errorMessage = '';
if (!kMetadataManager::validateMetadata($metadataProfileId, $xmlData, $errorMessage)) {
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId);
$dbMetadata = self::createOrFindMetadataObject($object, $metadataProfile);
KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]");
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata));
}
}
/**
* Update an existing metadata object definition file
*
* @action revert
* @param int $id
* @param int $toVersion
* @return KalturaMetadataProfile
* @throws MetadataErrors::METADATA_PROFILE_NOT_FOUND
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::METADATA_UNABLE_TO_TRANSFORM
*/
function revertAction($id, $toVersion)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(MetadataErrors::METADATA_PROFILE_NOT_FOUND, $id);
}
$oldKey = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION, $toVersion);
if (!kFileSyncUtils::fileSync_exists($oldKey)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $oldKey);
}
$dbMetadataProfile->incrementFileSyncVersion();
$dbMetadataProfile->incrementVersion();
$dbMetadataProfile->save();
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
kFileSyncUtils::createSyncFileLinkForKey($key, $oldKey);
kMetadataManager::parseProfileSearchFields($this->getPartnerId(), $dbMetadataProfile);
MetadataPeer::setUseCriteriaFilter(false);
$metadatas = MetadataPeer::retrieveByProfile($id, $toVersion);
foreach ($metadatas as $metadata) {
// validate object exists
$object = kMetadataManager::getObjectFromPeer($metadata);
if (!$object) {
continue;
}
$metadata->incrementVersion();
$oldKey = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA, $toVersion);
if (!kFileSyncUtils::fileSync_exists($oldKey)) {
continue;
}
$xml = kFileSyncUtils::file_get_contents($oldKey, true, false);
if (!$xml) {
continue;
}
$errorMessage = '';
if (!kMetadataManager::validateMetadata($dbMetadataProfile->getId(), $xml, $errorMessage)) {
continue;
}
$metadata->setMetadataProfileVersion($dbMetadataProfile->getVersion());
$metadata->setStatus(Metadata::STATUS_VALID);
$metadata->save();
$key = $metadata->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
kFileSyncUtils::createSyncFileLinkForKey($key, $oldKey);
}
$metadataProfile = new KalturaMetadataProfile();
$metadataProfile->fromObject($dbMetadataProfile, $this->getResponseProfile());
return $metadataProfile;
}
/**
* 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;
}
