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