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 generateFileName($sub_type, $version = null)
{
self::validateFileSyncSubType($sub_type);
if (!$version) {
$version = $this->getVersion();
}
return kMetadataManager::getObjectTypeName($this->getObjectType()) . "_" . $this->getObjectId() . "_" . $this->getId() . "_{$version}.xml";
}
public function contribute(BaseObject $object, SimpleXMLElement $mrss, kMrssParameters $mrssParams = null)
{
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadatas = MetadataPeer::retrieveAllByObject($objectType, $object->getId());
foreach ($metadatas as $metadata) {
$this->contributeMetadata($metadata, $mrss, $mrssParams);
}
}
public function getFieldValue(accessControl $accessControl)
{
$scope = $accessControl->getScope();
$metadata = MetadataPeer::retrieveByObject($this->profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
if ($metadata) {
return kMetadataManager::parseMetadataValues($metadata, $this->xPath);
}
return null;
}
/**
* @param Metadata $metadata
*/
protected function metadataDeleted(Metadata $metadata)
{
$this->syncableDeleted($metadata->getId(), FileSyncObjectType::METADATA);
// updated in the indexing server (sphinx)
$object = kMetadataManager::getObjectFromPeer($metadata);
if ($object && $object instanceof IIndexable) {
kEventsManager::raiseEvent(new kObjectUpdatedEvent($object));
}
}
function createMetadataProfile($version, $versionToXsdMap)
{
$metadataProfile = new MetadataProfile();
$metadataProfile->setPartnerId(99);
$metadataProfile->setStatus(MetadataProfile::STATUS_ACTIVE);
$metadataProfile->setName('Tvinci ingest v' . $version);
$metadataProfile->setSystemName('TvinciIngestV' . $version);
$metadataProfile->setDescription('Tvinci ingest schema version ' . $version);
$metadataProfile->setObjectType(MetadataObjectType::ENTRY);
$metadataProfile->setRequiredCopyTemplatePermissions(FEATURE_TVINCI_INGEST_BASE . $version);
$metadataProfile->save();
$xsdData = $versionToXsdMap[$version];
$key = $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
kFileSyncUtils::file_put_contents($key, $xsdData);
kMetadataManager::parseProfileSearchFields($metadataProfile->getPartnerId(), $metadataProfile);
}
function createMetadataProfile()
{
$metadataProfile = new MetadataProfile();
$metadataProfile->setPartnerId(99);
$metadataProfile->setStatus(MetadataProfile::STATUS_ACTIVE);
$metadataProfile->setName('Live Stream Monitoring');
$metadataProfile->setSystemName('LiveMonitor');
$metadataProfile->setDescription('Email notification flag indicating a 24/7 live-entry should be monitored.');
$metadataProfile->setObjectType(MetadataObjectType::ENTRY);
$metadataProfile->setRequiredCopyTemplatePermissions(FEATURE_KALTURA_LIVE_MONITOR);
$metadataProfile->save();
$xsdData = '<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Monitor" minOccurs="1" maxOccurs="1">
<xsd:annotation>
<xsd:documentation></xsd:documentation>
<xsd:appinfo>
<label>Monitor 24/7</label>
<key>monitor</key>
<searchable>true</searchable>
<description>Send E-mail notification if live-stream broadcast stopped</description>
</xsd:appinfo>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="listType">
<xsd:enumeration value="on"/>
<xsd:enumeration value="off"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:simpleType name="listType">
<xsd:restriction base="xsd:string"/>
</xsd:simpleType>
</xsd:schema>';
$key = $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
kFileSyncUtils::file_put_contents($key, $xsdData);
kMetadataManager::parseProfileSearchFields($metadataProfile->getPartnerId(), $metadataProfile);
}
public function getFieldValue(kScope $scope)
{
$profileId = $this->profileId;
if (!$profileId) {
if (!$this->profileSystemName) {
return null;
}
$profile = MetadataProfilePeer::retrieveBySystemName($this->profileSystemName, kCurrentContext::getCurrentPartnerId());
if (!$profile) {
return null;
}
$profileId = $profile->getId();
}
$metadata = null;
if ($scope instanceof accessControlScope || $scope instanceof kStorageProfileScope) {
$metadata = MetadataPeer::retrieveByObject($profileId, MetadataObjectType::ENTRY, $scope->getEntryId());
} elseif ($scope instanceof kEventScope && $scope->getEvent() instanceof kApplicativeEvent) {
$object = $scope->getEvent()->getObject();
if (kMetadataManager::isMetadataObject($object)) {
$objectType = kMetadataManager::getTypeNameFromObject($object);
$metadata = MetadataPeer::retrieveByObject($profileId, $objectType, $object->getId());
} else {
if ($object instanceof Metadata) {
$metadata = $object;
}
}
}
if (!$metadata) {
return null;
}
$values = kMetadataManager::parseMetadataValues($metadata, $this->xPath);
if (is_null($values)) {
return null;
}
return array_map('intval', $values);
}
public function 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 objectDataChanged(BaseObject $object, $previousVersion = null, BatchJob $raisedJob = null)
{
// updated in the indexing server (sphinx)
$relatedObject = kMetadataManager::getObjectFromPeer($object);
if ($relatedObject && $relatedObject instanceof IIndexable) {
$relatedObject->setUpdatedAt(time());
$relatedObject->save();
$relatedObject->indexToSearchIndex();
}
/** @var Metadata $object */
if ($object->getObjectType() == MetadataObjectType::DYNAMIC_OBJECT && !$object->isLikeNew()) {
/**
* when dynamic object is modified, we need to reindex the metadata and the objects (users, entries)
* that are referencing it
*/
$profileFields = MetadataProfileFieldPeer::retrieveByPartnerAndRelatedMetadataProfileId($object->getPartnerId(), $object->getMetadataProfileId());
$relatedMetadataProfiles = array();
foreach ($profileFields as $profileField) {
/** @var MetadataProfileField $profileField */
if (in_array($profileField->getMetadataProfileId(), $relatedMetadataProfiles)) {
continue;
}
$filter = new MetadataFilter();
$filter->set('_eq_metadata_profile_id', $profileField->getMetadataProfileId());
$indexObjectType = kPluginableEnumsManager::apiToCore('IndexObjectType', MetadataPlugin::getApiValue(MetadataIndexObjectType::METADATA));
kJobsManager::addIndexJob($object->getPartnerId(), $indexObjectType, $filter, true);
$relatedMetadataProfiles[] = $profileField->getMetadataProfileId();
}
}
if ($relatedObject instanceof entry) {
kStorageExporter::reExportEntry($relatedObject);
}
return true;
}
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 static function getSearchData(BaseObject $object)
{
if ($object instanceof CuePoint) {
$pluginInstances = KalturaPluginManager::getPluginInstances('IKalturaCuePoint');
$cuePointCalssName = lcfirst(get_class($object));
if (MetadataPlugin::isAllowedPartner($object->getPartnerId()) && isset($pluginInstances[$cuePointCalssName])) {
return kMetadataManager::getSearchValuesByObject($object->getMetadataObjectType(), $object->getId());
}
}
return null;
}
/**
* Update an existing metadata object with new XML content
*
* @action update
* @param int $id
* @param string $xmlData XML metadata
* @param int $version Enable update only if the metadata object version did not change by other process
* @return KalturaMetadata
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws MetadataErrors::INVALID_METADATA_DATA
* @throws MetadataErrors::INVALID_METADATA_VERSION
*/
function updateAction($id, $xmlData = null, $version = null)
{
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $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, $dbMetadata->getMetadataProfileVersion())) {
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());
}
$dbMetadata->incrementVersion();
$dbMetadata->save();
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata, $previousVersion));
}
$metadata = new KalturaMetadata();
$metadata->fromObject($dbMetadata);
return $metadata;
}
public function generateFileName($sub_type, $version = null)
{
$version = $this->getFileSyncSubTypeVersion($sub_type, $version);
return kMetadataManager::getObjectTypeName($this->getObjectType()) . "_" . $this->getId() . "_{$sub_type}_{$version}.xml";
}
/**
* 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;
}
/**
* Return textual search data to be associated with the object
*
* @param BaseObject $object
* @return string
*/
public static function getSearchData(BaseObject $object)
{
if ($object instanceof entry) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getSearchValuesByObject(Metadata::TYPE_ENTRY, $object->getId());
}
}
return null;
}
public function getRootObjects(IBaseObject $object)
{
$parentObject = kMetadataManager::getObjectFromPeer($object);
$roots = array();
if ($parentObject && $parentObject instanceof IBaseObject) {
$parentPeer = $parentObject->getPeer();
if ($parentPeer instanceof IRelatedObjectPeer) {
$roots = $parentPeer->getRootObjects($parentObject);
}
$roots[] = $parentObject;
}
return $roots;
}
/**
* @param BaseObject $object
* @param string $previousVersion
* @return bool true if should continue to the next consumer
*/
public function objectDataChanged(BaseObject $object, $previousVersion = null)
{
if (!class_exists('Metadata') || !$object instanceof Metadata) {
return true;
}
// updated in the indexing server (sphinx)
$relatedObject = kMetadataManager::getObjectFromPeer($object);
if ($relatedObject && $relatedObject instanceof IIndexable) {
$relatedObject->setUpdatedAt(time());
$relatedObject->save();
}
return true;
}
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;
}
/**
* Index metadata by id, will also index the related object
*
* @action index
* @param string $id
* @param bool $shouldUpdate
* @return int
*/
function indexAction($id, $shouldUpdate)
{
if (kEntitlementUtils::getEntitlementEnforcement()) {
throw new KalturaAPIException(KalturaErrors::CANNOT_INDEX_OBJECT_WHEN_ENTITLEMENT_IS_ENABLE);
}
$dbMetadata = MetadataPeer::retrieveByPK($id);
if (!$dbMetadata) {
throw new KalturaAPIException(MetadataErrors::METADATA_NOT_FOUND, $id);
}
$dbMetadata->indexToSearchIndex();
$relatedObject = kMetadataManager::getObjectFromPeer($dbMetadata);
if ($relatedObject && $relatedObject instanceof IIndexable) {
$relatedObject->indexToSearchIndex();
}
return $dbMetadata->getId();
}
public static function getSearchData(BaseObject $object)
{
if ($object instanceof entry) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getSearchValuesByObject(MetadataObjectType::ENTRY, $object->getId());
}
}
if ($object instanceof category) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getSearchValuesByObject(MetadataObjectType::CATEGORY, $object->getId());
}
}
if ($object instanceof Partner) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getSearchValuesByObject(MetadataObjectType::PARTNER, $object->getId());
}
}
if ($object instanceof kuser) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getSearchValuesByObject(MetadataObjectType::USER, $object->getId());
}
}
if ($object instanceof Metadata) {
if (self::isAllowedPartner($object->getPartnerId())) {
return kMetadataManager::getMetadataValuesByMetadataObjects(array($object));
}
}
return null;
}
/**
* Update an existing metadata object definition file
*
* @action updateDefinitionFromFile
* @param int $id
* @param file $xsdFile XSD metadata definition
* @return KalturaMetadataProfile
* @throws MetadataErrors::METADATA_PROFILE_NOT_FOUND
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::METADATA_UNABLE_TO_TRANSFORM
*/
function updateDefinitionFromFileAction($id, $xsdFile)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(MetadataErrors::METADATA_PROFILE_NOT_FOUND, $id);
}
$filePath = null;
if ($xsdFile) {
$filePath = $xsdFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xsdFile['name']);
}
}
$newXsd = file_get_contents($filePath);
if (!$newXsd) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xsdFile['name']);
}
if (!kMetadataProfileManager::validateXsdData($newXsd, $errorMessage)) {
throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE_SCHEMA, $errorMessage);
}
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
$oldXsd = kFileSyncUtils::file_get_contents($key);
if (!$oldXsd) {
throw new KalturaAPIException(MetadataErrors::METADATA_PROFILE_FILE_NOT_FOUND, $id);
}
$dbMetadataProfile->setXsdData($newXsd);
try {
kMetadataManager::diffMetadataProfile($dbMetadataProfile, $oldXsd, $newXsd);
} catch (kXsdException $e) {
throw new KalturaAPIException(MetadataErrors::METADATA_UNABLE_TO_TRANSFORM, $e->getMessage());
}
$dbMetadataProfile->save();
$metadataProfile = new KalturaMetadataProfile();
$metadataProfile->fromObject($dbMetadataProfile, $this->getResponseProfile());
return $metadataProfile;
}
/**
* Update an existing metadata object definition file
*
* @action updateDefinitionFromFile
* @param int $id
* @param file $xsdFile XSD metadata definition
* @return KalturaMetadataProfile
* @throws KalturaErrors::INVALID_OBJECT_ID
* @throws MetadataErrors::METADATA_FILE_NOT_FOUND
* @throws MetadataErrors::METADATA_UNABLE_TO_TRANSFORM
*/
function updateDefinitionFromFileAction($id, $xsdFile)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$filePath = null;
if ($xsdFile) {
$filePath = $xsdFile['tmp_name'];
if (!file_exists($filePath)) {
throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xsdFile['name']);
}
}
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
$oldXsd = kFileSyncUtils::getLocalFilePathForKey($key);
$oldVersion = $dbMetadataProfile->getVersion();
$dbMetadataProfile->incrementVersion();
try {
kMetadataManager::diffMetadataProfile($dbMetadataProfile, $oldVersion, $oldXsd, $dbMetadataProfile->getVersion(), $filePath);
} catch (kXsdException $e) {
throw new KalturaAPIException(MetadataErrors::METADATA_UNABLE_TO_TRANSFORM);
}
$dbMetadataProfile->save();
$key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION);
kFileSyncUtils::moveFromFile($filePath, $key);
kMetadataManager::parseProfileSearchFields($dbMetadataProfile);
$metadataProfile = new KalturaMetadataProfile();
$metadataProfile->fromObject($dbMetadataProfile);
return $metadataProfile;
}
public function objectDataChanged(BaseObject $object, $previousVersion = null, BatchJob $raisedJob = null)
{
// updated in the indexing server (sphinx)
$relatedObject = kMetadataManager::getObjectFromPeer($object);
if ($relatedObject && $relatedObject instanceof IIndexable) {
$relatedObject->setUpdatedAt(time());
$relatedObject->save();
$relatedObject->indexToSearchIndex();
}
return true;
}
<?php
if ($argc != 2) {
echo "Arguments missing.\n\n";
echo "Usage: php parseMetadataProfileFields.php {metadata profile id}\n";
exit;
}
$metadataProfileId = $argv[1];
set_time_limit(0);
ini_set("memory_limit", "1024M");
define('ROOT_DIR', realpath(dirname(__FILE__) . '/../../'));
require_once ROOT_DIR . '/infra/bootstrap_base.php';
require_once ROOT_DIR . '/infra/KAutoloader.php';
KAutoloader::addClassPath(KAutoloader::buildPath(KALTURA_ROOT_PATH, "vendor", "propel", "*"));
KAutoloader::addClassPath(KAutoloader::buildPath(KALTURA_ROOT_PATH, "plugins", "metadata", "*"));
KAutoloader::setClassMapFilePath(kConf::get("cache_root_path") . '/scripts/' . basename(__FILE__) . '.cache');
KAutoloader::register();
error_reporting(E_ALL);
KalturaLog::setLogger(new KalturaStdoutLogger());
$dbConf = kConf::getDB();
DbManager::setConfig($dbConf);
DbManager::initialize();
$metadataProfile = MetadataProfilePeer::retrieveById($metadataProfileId);
if (!$metadataProfile) {
echo "Metadata Profile not found.\n";
exit;
}
kMetadataManager::parseProfileSearchFields($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;
}
