/** * @param entry $entry * @param SimpleXMLElement $mrss * @return SimpleXMLElement */ public function contribute(entry $entry, SimpleXMLElement $mrss) { $metadatas = MetadataPeer::retrieveAllByObject(Metadata::TYPE_ENTRY, $entry->getId()); foreach ($metadatas as $metadata) { $this->contributeMetadata($metadata, $mrss); } }
/** * @param KalturaMetadataObjectType $objectType * @param BaseObject $fromObject * @param BaseObject $toObject */ protected function copyMetadata($objectType, BaseObject $fromObject, BaseObject $toObject) { KalturaLog::debug("Copy metadata type [{$objectType}] from " . get_class($fromObject) . '[' . $fromObject->getId() . "] to[" . $toObject->getId() . "]"); $c = new Criteria(); $c->add(MetadataPeer::OBJECT_TYPE, $objectType); $c->add(MetadataPeer::OBJECT_ID, $fromObject->getId()); $metadatas = MetadataPeer::doSelect($c); foreach ($metadatas as $metadata) { $newMetadata = $metadata->copy(); $newMetadata->setObjectId($toObject->getId()); if ($toObject instanceof Partner) { $newMetadata->setPartnerId($toObject->getId()); } else { $newMetadata->setPartnerId($toObject->getPartnerId()); } $metadataProfileId = kObjectCopyHandler::getMappedId('MetadataProfile', $metadata->getMetadataProfileId()); if ($metadataProfileId) { $metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId); if ($metadataProfile) { $newMetadata->setMetadataProfileId($metadataProfileId); $newMetadata->setMetadataProfileVersion($metadataProfile->getVersion()); } } $newMetadata->save(); kFileSyncUtils::createSyncFileLinkForKey($newMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA), $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA)); } }
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); } } }
/** * @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 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; }
public function hasPeerFieldName($fieldName) { if (strpos($fieldName, '.') === false) { $fieldName = strtoupper($fieldName); $fieldName = "metadata.{$fieldName}"; } $metadataFields = MetadataPeer::getFieldNames(BasePeer::TYPE_COLNAME); return in_array($fieldName, $metadataFields); }
public function __construct(KalturaDistributionJobData $distributionJobData = null) { parent::__construct($distributionJobData); if (!$distributionJobData || !$distributionJobData->distributionProfile instanceof KalturaTvinciDistributionProfile || !$distributionJobData->entryDistribution) { return; } $entry = null; if ($distributionJobData->entryDistribution->entryId) { $entry = entryPeer::retrieveByPK($distributionJobData->entryDistribution->entryId); } if (!$entry) { KalturaLog::err("Can't find entry with id: {$distributionJobData->entryDistribution->entryId}"); return; } $feedHelper = new TvinciDistributionFeedHelper($distributionJobData->distributionProfile); $feedHelper->setEntryId($entry->getId()); $feedHelper->setReferenceId($entry->getReferenceID()); $feedHelper->setDescription($entry->getDescription()); $feedHelper->setTitleName($entry->getName()); $feedHelper->setSunrise($distributionJobData->entryDistribution->sunrise); $feedHelper->setSunset($distributionJobData->entryDistribution->sunset); $thumbAssets = assetPeer::retrieveByIds(explode(',', $distributionJobData->entryDistribution->thumbAssetIds)); $picRatios = array(); $defaultThumbUrl = null; foreach ($thumbAssets as $thumbAsset) { $thumbDownloadUrl = $this->getAssetDownloadUrl($thumbAsset); $ratio = KDLVideoAspectRatio::ConvertFrameSize($thumbAsset->getWidth(), $thumbAsset->getHeight()); $picRatios[] = array('url' => $thumbDownloadUrl, 'ratio' => $ratio); if ($thumbAsset->hasTag(thumbParams::TAG_DEFAULT_THUMB)) { $defaultThumbUrl = $thumbDownloadUrl; } } $feedHelper->setPicRatiosArray($picRatios); if (!$defaultThumbUrl && count($picRatios)) { // Choose the URL of the first resource in the array $defaultThumbUrl = $picRatios[0]['url']; } $feedHelper->setDefaultThumbnailUrl($defaultThumbUrl); $this->createPlayManifestURLs($distributionJobData->entryDistribution, $entry, $feedHelper); $metadatas = MetadataPeer::retrieveAllByObject(MetadataObjectType::ENTRY, $distributionJobData->entryDistribution->entryId); $fullMetadataXML = ''; foreach ($metadatas as $metadataField) { $syncKey = $metadataField->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); $currMetaXML = kFileSyncUtils::file_get_contents($syncKey, true, false); $fullMetadataXML .= $currMetaXML; } $feedHelper->setMetasXML($fullMetadataXML); if ($distributionJobData instanceof KalturaDistributionSubmitJobData) { $this->xml = $feedHelper->buildSubmitFeed(); } elseif ($distributionJobData instanceof KalturaDistributionUpdateJobData) { $this->xml = $feedHelper->buildUpdateFeed(); } elseif ($distributionJobData instanceof KalturaDistributionDeleteJobData) { $this->xml = $feedHelper->buildDeleteFeed(); } KalturaLog::debug("XML Constructed by the Tvinci feed helper :{$this->xml}"); }
public static function validateMetadataObjects($profileField, $objectIds, &$errorMessage) { /** @var MetadataProfileField $profileField */ $subMetadataProfileId = $profileField->getRelatedMetadataProfileId(); $subMetadataProfile = MetadataProfilePeer::retrieveByPK($subMetadataProfileId); if (!$subMetadataProfile) { $errorMessage = 'Sub metadata profile ' . $subMetadataProfileId . ' was not found'; return false; } $subMetadataObjects = MetadataPeer::retrieveByObjects($subMetadataProfileId, $subMetadataProfile->getObjectType(), $objectIds); if (count($subMetadataObjects) != count($objectIds)) { $errorMessage = 'One of the following objects: ' . implode(', ', $objectIds) . ' was not found for profile ' . $subMetadataProfileId; return false; } return true; }
/** * @param int $objectType * @param string $objectId */ protected function deleteMetadataObjects($objectType, $objectId) { $c = new Criteria(); $c->add(MetadataPeer::OBJECT_TYPE, $objectType); $c->add(MetadataPeer::OBJECT_ID, $objectId); $c->add(MetadataPeer::STATUS, Metadata::STATUS_DELETED, Criteria::NOT_EQUAL); $peer = null; MetadataPeer::setUseCriteriaFilter(false); $metadatas = MetadataPeer::doSelect($c); foreach ($metadatas as $metadata) { kEventsManager::raiseEvent(new kObjectDeletedEvent($metadata)); } $update = new Criteria(); $update->add(MetadataPeer::STATUS, Metadata::STATUS_DELETED); $con = Propel::getConnection(MetadataPeer::DATABASE_NAME, Propel::CONNECTION_READ); BasePeer::doUpdate($c, $update, $con); }
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; }
/** * batch getTransformMetadataObjects action retrieve all metadata objects that requires upgrade and the total count * * @action getTransformMetadataObjects * @param int $metadataProfileId The id of the metadata profile * @param int $srcVersion The old metadata profile version * @param int $destVersion The new metadata profile version * @param KalturaFilterPager $pager * @return KalturaTransformMetadataResponse */ function getTransformMetadataObjectsAction($metadataProfileId, $srcVersion, $destVersion, KalturaFilterPager $pager = null) { $response = new KalturaTransformMetadataResponse(); $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion, Criteria::LESS_THAN); $c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID); $response->lowerVersionCount = MetadataPeer::doCount($c); $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion); $c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID); $response->totalCount = MetadataPeer::doCount($c); if ($pager) { $pager->attachToCriteria($c); } $list = MetadataPeer::doSelect($c); $response->objects = KalturaMetadataArray::fromDbArray($list); return $response; }
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); }
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 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}"); } } }
/** * Builds a Criteria object containing the primary key for this object. * * Unlike buildCriteria() this method includes the primary key values regardless * of whether or not they have been modified. * * @return Criteria The Criteria object containing value(s) for primary key(s). */ public function buildPkeyCriteria() { $criteria = new Criteria(MetadataPeer::DATABASE_NAME); $criteria->add(MetadataPeer::ID, $this->id); if ($this->alreadyInSave && count($this->modifiedColumns) == 2 && $this->isColumnModified(MetadataPeer::UPDATED_AT)) { $theModifiedColumn = null; foreach ($this->modifiedColumns as $modifiedColumn) { if ($modifiedColumn != MetadataPeer::UPDATED_AT) { $theModifiedColumn = $modifiedColumn; } } $atomicColumns = MetadataPeer::getAtomicColumns(); if (in_array($theModifiedColumn, $atomicColumns)) { $criteria->add($theModifiedColumn, $this->getByName($theModifiedColumn, BasePeer::TYPE_COLNAME), Criteria::NOT_EQUAL); } } return $criteria; }
public static function generateCuePointXml(SimpleXMLElement $scene, $objectType, $cuePointId) { $metadatas = MetadataPeer::retrieveAllByObject($objectType, $cuePointId); foreach ($metadatas as $metadata) { /* @var $metadata Metadata */ $metadataElement = $scene->addChild('scene-customData'); $metadataElement->addAttribute('metadataId', $metadata->getId()); $metadataElement->addAttribute('metadataVersion', $metadata->getVersion()); $metadataElement->addAttribute('metadataProfileId', $metadata->getMetadataProfileId()); $metadataElement->addAttribute('metadataProfileVersion', $metadata->getMetadataProfileVersion()); $key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); $xml = kFileSyncUtils::file_get_contents($key, true, false); if ($xml) { $xmlElement = new SimpleXMLElement($xml); self::appendXML($metadataElement, $xmlElement); } $metadataProfile = $metadata->getMetadataProfile(); if (!$metadataProfile) { continue; } if ($metadataProfile->getSystemName()) { $metadataElement->addAttribute('metadataProfile', $metadataProfile->getSystemName()); } if ($metadataProfile->getName()) { $metadataElement->addAttribute('metadataProfileName', $metadataProfile->getName()); } } return $scene; }
/** * Retrieve multiple objects by pkey. * * @param array $pks List of primary keys * @param PropelPDO $con the connection to use * @throws PropelException Any exceptions caught during processing will be * rethrown wrapped into a PropelException. */ public static function retrieveByPKs($pks, PropelPDO $con = null) { $objs = null; if (empty($pks)) { $objs = array(); } else { $criteria = new Criteria(MetadataPeer::DATABASE_NAME); $criteria->add(MetadataPeer::ID, $pks, Criteria::IN); $objs = MetadataPeer::doSelect($criteria, $con); } return $objs; }
/** * 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); }
public function getListResponse(KalturaFilterPager $pager, KalturaDetachedResponseProfile $responseProfile = null) { if (kEntitlementUtils::getEntitlementEnforcement() && (is_null($this->objectIdIn) && is_null($this->objectIdEqual))) { throw new KalturaAPIException(MetadataErrors::MUST_FILTER_ON_OBJECT_ID); } if (!$this->metadataObjectTypeEqual) { throw new KalturaAPIException(MetadataErrors::MUST_FILTER_ON_OBJECT_TYPE); } if ($this->metadataObjectTypeEqual == MetadataObjectType::CATEGORY) { if ($this->objectIdEqual) { $categoryIds = array($this->objectIdEqual); } else { if ($this->objectIdIn) { $categoryIds = explode(',', $this->objectIdIn); } } if ($categoryIds) { $categories = categoryPeer::retrieveByPKs($categoryIds); if (!count($categories)) { KalturaLog::debug("No categories found"); $response = new KalturaMetadataListResponse(); $response->objects = new KalturaMetadataArray(); $response->totalCount = 0; return $response; } $categoryIds = array(); foreach ($categories as $category) { $categoryIds[] = $category->getId(); } $this->objectIdEqual = null; $this->objectIdIn = implode(',', $categoryIds); } } $metadataFilter = $this->toObject(); $c = KalturaCriteria::create(MetadataPeer::OM_CLASS); $metadataFilter->attachToCriteria($c); $pager->attachToCriteria($c); $list = MetadataPeer::doSelect($c); $response = new KalturaMetadataListResponse(); $response->objects = KalturaMetadataArray::fromDbArray($list, $responseProfile); if ($c instanceof SphinxMetadataCriteria) { $response->totalCount = $c->getRecordsCount(); } elseif ($pager->pageIndex == 1 && count($response->objects) < $pager->pageSize) { $response->totalCount = count($response->objects); } else { $pager->detachFromCriteria($c); $response->totalCount = MetadataPeer::doCount($c); } return $response; }
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; }
/** * @param int $metadataProfileId * @param int $srcVersion * @param int $destVersion * @param string $xsl * * @return BatchJob */ private static function addTransformMetadataJob($partnerId, $metadataProfileId, $srcVersion, $destVersion, $xsl = null) { // check if any metadata objects require the transform $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $destVersion, Criteria::LESS_THAN); $c->add(MetadataPeer::STATUS, Metadata::STATUS_VALID); $metadataCount = MetadataPeer::doCount($c); if (!$metadataCount) { return null; } $job = new BatchJob(); $job->setJobType(BatchJobType::METADATA_TRANSFORM); $job->setPartnerId($partnerId); $job->setObjectId($metadataProfileId); $job->setObjectType(kPluginableEnumsManager::apiToCore('BatchJobObjectType', MetadataBatchJobObjectType::METADATA_PROFILE)); $data = new kTransformMetadataJobData(); if ($xsl) { $job->save(); $key = $job->getSyncKey(BatchJob::FILE_SYNC_BATCHJOB_SUB_TYPE_CONFIG); kFileSyncUtils::file_put_contents($key, $xsl); $xslPath = kFileSyncUtils::getLocalFilePathForKey($key); $data->setSrcXslPath($xslPath); } $data->setMetadataProfileId($metadataProfileId); $data->setSrcVersion($srcVersion); $data->setDestVersion($destVersion); return kJobsManager::addJob($job, $data, BatchJobType::METADATA_TRANSFORM); }
/** * batch getTransformMetadataObjects action retrieve all metadata objects that requires upgrade and the total count * * @action upgradeMetadataObjects * @param int $metadataProfileId The id of the metadata profile * @param int $srcVersion The old metadata profile version * @param int $destVersion The new metadata profile version * @return KalturaUpgradeMetadataResponse */ function upgradeMetadataObjectsAction($metadataProfileId, $srcVersion, $destVersion, KalturaFilterPager $pager = null) { $response = new KalturaUpgradeMetadataResponse(); $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion, Criteria::LESS_THAN); $c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID); $response->lowerVersionCount = MetadataPeer::doCount($c); $c = new Criteria(); $c->add(MetadataPeer::METADATA_PROFILE_ID, $metadataProfileId); $c->add(MetadataPeer::METADATA_PROFILE_VERSION, $srcVersion); $c->add(MetadataPeer::STATUS, KalturaMetadataStatus::VALID); $update = new Criteria(); $update->add(MetadataPeer::METADATA_PROFILE_VERSION, $destVersion); $con = Propel::getConnection(MetadataPeer::DATABASE_NAME, Propel::CONNECTION_READ); $response->totalCount = BasePeer::doUpdate($c, $update, $con); return $response; }
public static function doCountOnPeer(Criteria $c) { return MetadataPeer::doCount($c); }
public function getFieldNameFromPeer($field_name) { $res = MetadataPeer::translateFieldName($field_name, $this->field_name_translation_type, BasePeer::TYPE_COLNAME); return $res; }
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); }
public function validateForSubmission(EntryDistribution $entryDistribution, $action) { $missingDesc = false; $missingTags = false; $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; } if (strlen($entry->getName()) > self::ENTRY_NAME_MAXIMUM_LENGTH) { $description = 'entry name length must be between ' . self::ENTRY_NAME_MINIMUM_LENGTH . ' and ' . self::ENTRY_NAME_MAXIMUM_LENGTH; $validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, $description); $validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG); $validationError->setValidationErrorParam(self::ENTRY_NAME_MAXIMUM_LENGTH); $validationErrors[] = $validationError; } if (strlen($entry->getDescription()) < self::ENTRY_DESC_MINIMUM_LENGTH) { $missingDesc = true; } if (strlen($entry->getTags()) < self::ENTRY_DESC_MINIMUM_LENGTH) { $missingTags = true; } if (!class_exists('MetadataProfile')) { return $validationErrors; } $metadataFields = array(self::METADATA_FIELD_KEYWORDS, self::METADATA_FIELD_DESCRIPTION); $metadataProfileId = $this->getMetadataProfileId(); $metadatas = MetadataPeer::retrieveAllByObject(MetadataObjectType::ENTRY, $entryDistribution->getEntryId()); foreach ($metadataFields as $index => $metadataField) { $values = $this->findMetadataValue($metadatas, $metadataField); if (!count($values)) { switch ($metadataField) { case self::METADATA_FIELD_DESCRIPTION: if ($missingDesc) { $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::DESCRIPTION, ""); } break; case self::METADATA_FIELD_KEYWORDS: if ($missingTags) { $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, entryPeer::TAGS, ""); } break; default: $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, $metadataField); } } foreach ($values as $value) { if (!strlen($value)) { $validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, $metadataField, ""); $validationError->setValidationErrorType(DistributionValidationErrorType::STRING_EMPTY); $validationError->setMetadataProfileId($metadataProfileId); $validationErrors[] = $validationError; break; } } } return $validationErrors; }
/** * @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; } } }