public function watchFolder(KalturaDropFolder $folder) { $this->dropFolder = $folder; $this->fileTransferMgr = self::getFileTransferManager($this->dropFolder); KalturaLog::info('Watching folder [' . $this->dropFolder->id . ']'); $physicalFiles = $this->getDropFolderFilesFromPhysicalFolder(); if (count($physicalFiles) > 0) { $dropFolderFilesMap = $this->loadDropFolderFiles(); } else { $dropFolderFilesMap = array(); } $maxModificationTime = 0; foreach ($physicalFiles as &$physicalFile) { /* @var $physicalFile FileObject */ $physicalFileName = $physicalFile->filename; $utfFileName = kString::stripUtf8InvalidChars($physicalFileName); if ($physicalFileName != $utfFileName) { KalturaLog::info("File name [{$physicalFileName}] is not utf-8 compatible, Skipping file..."); continue; } if (!kXml::isXMLValidContent($utfFileName)) { KalturaLog::info("File name [{$physicalFileName}] contains invalid XML characters, Skipping file..."); continue; } if ($this->dropFolder->incremental && $physicalFile->modificationTime < $this->dropFolder->lastFileTimestamp) { KalturaLog::info("File modification time [" . $physicalFile->modificationTime . "] predates drop folder last timestamp [" . $this->dropFolder->lastFileTimestamp . "]. Skipping."); if (isset($dropFolderFilesMap[$physicalFileName])) { unset($dropFolderFilesMap[$physicalFileName]); } continue; } if ($this->validatePhysicalFile($physicalFileName)) { $maxModificationTime = $physicalFile->modificationTime > $maxModificationTime ? $physicalFile->modificationTime : $maxModificationTime; KalturaLog::info('Watch file [' . $physicalFileName . ']'); if (!array_key_exists($physicalFileName, $dropFolderFilesMap)) { try { $lastModificationTime = $physicalFile->modificationTime; $fileSize = $physicalFile->fileSize; $this->handleFileAdded($physicalFileName, $fileSize, $lastModificationTime); } catch (Exception $e) { KalturaLog::err("Error handling drop folder file [{$physicalFileName}] " . $e->getMessage()); } } else { $dropFolderFile = $dropFolderFilesMap[$physicalFileName]; //if file exist in the folder remove it from the map //all the files that are left in a map will be marked as PURGED unset($dropFolderFilesMap[$physicalFileName]); $this->handleExistingDropFolderFile($dropFolderFile); } } } foreach ($dropFolderFilesMap as $dropFolderFile) { $this->handleFilePurged($dropFolderFile->id); } if ($this->dropFolder->incremental && $maxModificationTime > $this->dropFolder->lastFileTimestamp) { $updateDropFolder = new KalturaDropFolder(); $updateDropFolder->lastFileTimestamp = $maxModificationTime; $this->dropFolderPlugin->dropFolder->update($this->dropFolder->id, $updateDropFolder); } }
/** * * Generates a new KalturaTestsFailures object from a given failure file path * @param string $failureFilePath */ public function fromXml($failureFilePath) { $simpleXML = kXml::openXmlFile($failureFilePath); foreach ($simpleXML->Failures->UnitTestFailures as $unitTestFailureXml) { $this->testCaseFailures[] = KalturaTestCaseFailure::generateFromXml($unitTestFailureXml); } }
/** * sets the KalturaDataGeneratorConfigFile object from simpleXMLElement (the source xml of the data) * @param SimpleXMLElement $simpleXMLElement * * @return None, sets the given object */ public function fromSourceXML(SimpleXMLElement $simpleXMLElement) { //For each test file foreach ($simpleXMLElement->TestDataFile as $xmlTestDataFile) { //Create new test file obejct $testDataFile = new KalturaUnitTestDataFile(); //For each UnitTest data (in this file) foreach ($xmlTestDataFile->UnitTestsData->UnitTestData as $xmlUnitTestData) { //Create new unit test data $unitTestData = new KalturaUnitTestData(); //For each input create the needed Kaltura object identifier foreach ($xmlUnitTestData->Inputs->Input as $input) { $additionalData = kXml::getAttributesAsArray($input); $unitTestDataObjectIdentifier = new KalturaUnitTestDataObject((string) $input["type"], $additionalData); $unitTestData->input[] = $unitTestDataObjectIdentifier; } //And for each output reference create the needed kaltura object identifier foreach ($xmlUnitTestData->OutputReferences->OutputReference as $outputReference) { $additionalData = kXml::getAttributesAsArray($outputReference); $unitTestDataObjectIdentifier = new KalturaUnitTestDataObject((string) $outputReference["type"], $additionalData); $unitTestData->outputReference[] = $unitTestDataObjectIdentifier; } //Add the new unit test into the tests array. $testDataFile->unitTestsData[] = $unitTestData; } $testDataFile->fileName = trim((string) $xmlTestDataFile->FileName); $this->testFiles[] = $testDataFile; } }
private function parseStrTTTime($timeStr) { $matches = null; if (preg_match('/(\\d+)s/', $timeStr)) { return intval($matches[1]) * 1000; } return kXml::timeToInteger($timeStr); }
public function execute() { $this->forceSystemAuthentication(); $kshow_id = @$_REQUEST["kshow_id"]; $this->kshow_id = $kshow_id; $this->kshow = NULL; $entry_id = @$_REQUEST["entry_id"]; $this->entry_id = $entry_id; $this->entry = NULL; $this->message = ""; if (!empty($kshow_id)) { $this->kshow = kshowPeer::retrieveByPK($kshow_id); if (!$this->kshow) { $this->message = "Cannot find kshow [{$kshow_id}]"; } else { $this->entry = $this->kshow->getShowEntry(); } } elseif (!empty($kshow_id)) { $this->entry = entryPeer::retrieveByPK($entry_id); if (!$this->entry) { $this->message = "Cannot find entry [{$entry_id}]"; } else { $this->kshow = $this->{$this}->entry->getKshow(); } } if ($this->kshow) { $this->metadata = $this->kshow->getMetadata(); } else { $this->metadata = ""; } $pending_str = $this->getP("pending"); $remove_pending = $this->getP("remove_pending"); if ($this->metadata && ($remove_pending || $pending_str)) { if ($remove_pending) { $pending_str = ""; } $xml_doc = new DOMDocument(); $xml_doc->loadXML($this->metadata); $metadata = kXml::getFirstElement($xml_doc, "MetaData"); $should_save = kXml::setChildElement($xml_doc, $metadata, "Pending", $pending_str, true); if ($remove_pending) { $should_save = kXml::setChildElement($xml_doc, $metadata, "LastPendingTimeStamp", "", true); } if ($should_save) { $fixed_content = $xml_doc->saveXML(); $content_dir = myContentStorage::getFSContentRootPath(); $file_name = realpath($content_dir . $this->entry->getDataPath()); $res = file_put_contents($file_name, $fixed_content); // sync - NOTOK $this->metadata = $fixed_content; } } $this->pending = $pending_str; $this->kshow_id = $kshow_id; $this->entry_id = $entry_id; }
public function handleFooter() { $mrss = $this->getKalturaMrssXml($this->syndicationFeed->name, $this->syndicationFeed->feedLandingPage, $this->syndicationFeed->feedDescription); if ($this->kalturaXslt) { $mrss = kXml::transformXmlUsingXslt($mrss, $this->kalturaXslt); } $divideHeaderFromFooter = strpos($mrss, self::ITEMS_PLACEHOLDER) + strlen(self::ITEMS_PLACEHOLDER); $mrss = substr($mrss, $divideHeaderFromFooter); return $mrss; }
/** * * Generates a new testCaseFailure object from a given simpleXmlElement (failure file xml) * @param SimpleXMlElement $unitTestFailureXml */ public function fromXml(SimpleXMlElement $unitTestFailureXml) { //Sets the inputs as key => value byt the xml attributes foreach ($unitTestFailureXml->Inputs->Input as $inputXml) { $this->testCaseInput[] = kXml::getAttributesAsArray($inputXml); } foreach ($unitTestFailureXml->Failures->Failure as $failureXml) { $this->testCaseFailures[] = KalturaFailure::generateFromXml($failureXml); } }
public static function validateXsdData($xsdData, &$errorMessage) { // validates the xsd libxml_use_internal_errors(true); libxml_clear_errors(); $xml = new KDOMDocument(); if (!$xml->loadXML($xsdData)) { $errorMessage = kXml::getLibXmlErrorDescription($xsdData); return false; } libxml_clear_errors(); libxml_use_internal_errors(false); return true; }
protected function parseOutput($output) { $output = kXml::stripXMLInvalidChars($output); $tokenizer = new KStringTokenizer($output, "\t\n"); $mediaInfo = new KalturaMediaInfo(); $mediaInfo->rawData = $output; $fieldCnt = 0; $section = self::SrteamGeneral; $sectionID = 0; $mediaInfo->streamArray = array(); $streamMediaInfo = null; while ($tokenizer->hasMoreTokens()) { $tok = strtolower(trim($tokenizer->nextToken())); if (strrpos($tok, ":") == false) { if (isset($streamMediaInfo)) { $mediaInfo->streamArray[$section][] = $streamMediaInfo; } $streamMediaInfo = new KalturaMediaInfo(); $sectionID = strchr($tok, "#"); if ($sectionID) { $sectionID = trim($sectionID, "#"); } else { $sectionID = 0; } if (strstr($tok, self::SrteamGeneral) == true) { $section = self::SrteamGeneral; } else { if (strstr($tok, self::SrteamVideo) == true) { $section = self::SrteamVideo; } else { if (strstr($tok, self::SrteamAudio) == true) { $section = self::SrteamAudio; } else { $section = $tok; } } } } else { if ($sectionID <= 1) { self::loadStreamMedia($mediaInfo, $section, $tok); $fieldCnt++; } } self::loadStreamMedia($streamMediaInfo, $section, $tok); } if (isset($streamMediaInfo)) { $mediaInfo->streamArray[$section][] = $streamMediaInfo; } return $mediaInfo; }
public function doTest($xmlPath, $type) { echo "\tTesting File [{$xmlPath}]\n"; $serviceUrl = $this->client->getConfig()->serviceUrl; $xsdPath = "{$serviceUrl}/api_v3/index.php/service/schema/action/serve/type/{$type}"; // libxml_use_internal_errors(true); // libxml_clear_errors(); $doc = new DOMDocument(); $doc->Load($xmlPath); //Validate the XML file against the schema if (!$doc->schemaValidate($xsdPath)) { $description = kXml::getLibXmlErrorDescription(file_get_contents($xmlPath)); $this->fail("Type [{$type}] File [{$xmlPath}]: {$description}"); } }
public static function getAllAssetsData($filePath) { list($xml_doc, $xpath) = self::getDomAndXpath($filePath); $asset_ids = self::getElementsList($xpath, "*"); //$asset_ids = $xpath->query( "//VideoAssets/vidAsset" ); $arr = array(); foreach ($asset_ids as $asset_id) { $node = array(); $node["id"] = $asset_id->getAttribute("k_id"); $stream_info_elem = kXml::getFirstElement($asset_id, "StreamInfo"); $node["start_time"] = $stream_info_elem->getAttribute("start_time"); $node["len_time"] = $stream_info_elem->getAttribute("len_time"); //start_time="0" len_time= $arr[] = $node; } return $arr; }
protected function parseCuePoint(SimpleXMLElement $scene) { if ($scene->getName() != 'scene-code-cue-point') { return null; } $cuePoint = parent::parseCuePoint($scene); if (!$cuePoint instanceof KalturaCodeCuePoint) { return null; } if (isset($scene->sceneEndTime)) { $cuePoint->endTime = kXml::timeToInteger($scene->sceneEndTime); } if (isset($scene->code)) { $cuePoint->code = "{$scene->code}"; } if (isset($scene->description)) { $cuePoint->description = "{$scene->description}"; } return $cuePoint; }
/** * Parse content of caption asset and index it * * @action parse * @param string $captionAssetId * @throws KalturaCaptionErrors::CAPTION_ASSET_ID_NOT_FOUND */ function parseAction($captionAssetId) { $captionAsset = assetPeer::retrieveById($captionAssetId); if (!$captionAsset) { throw new KalturaAPIException(KalturaCaptionErrors::CAPTION_ASSET_ID_NOT_FOUND, $captionAssetId); } $captionAssetItems = CaptionAssetItemPeer::retrieveByAssetId($captionAssetId); foreach ($captionAssetItems as $captionAssetItem) { /* @var $captionAssetItem CaptionAssetItem */ $captionAssetItem->delete(); } // make sure that all old items are deleted from the sphinx before creating the new ones kEventsManager::flushEvents(); $syncKey = $captionAsset->getSyncKey(asset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET); $content = kFileSyncUtils::file_get_contents($syncKey, true, false); if (!$content) { return; } $captionsContentManager = kCaptionsContentManager::getCoreContentManager($captionAsset->getContainerFormat()); if (!$captionsContentManager) { return; } $itemsData = $captionsContentManager->parse($content); foreach ($itemsData as $itemData) { $item = new CaptionAssetItem(); $item->setCaptionAssetId($captionAsset->getId()); $item->setEntryId($captionAsset->getEntryId()); $item->setPartnerId($captionAsset->getPartnerId()); $item->setStartTime($itemData['startTime']); $item->setEndTime($itemData['endTime']); $content = ''; foreach ($itemData['content'] as $curChunk) { $content .= $curChunk['text']; } //Make sure there are no invalid chars in the caption asset items to avoid braking the search request by providing invalid XML $content = kString::stripUtf8InvalidChars($content); $content = kXml::stripXMLInvalidChars($content); $item->setContent($content); $item->save(); } }
protected function parseCuePoint(SimpleXMLElement $scene) { if ($scene->getName() != 'scene-annotation') { return null; } $cuePoint = parent::parseCuePoint($scene); if (!$cuePoint instanceof KalturaAnnotation) { return null; } if (isset($scene->sceneEndTime)) { $cuePoint->endTime = kXml::timeToInteger($scene->sceneEndTime); } if (isset($scene->sceneText)) { $cuePoint->text = "{$scene->sceneText}"; } if (isset($scene->parentId)) { $cuePoint->parentId = "{$scene->parentId}"; } elseif (isset($scene->parent)) { $cuePoint->parentId = $this->getCuePointId("{$scene->parent}"); } return $cuePoint; }
protected function parseCuePoint(SimpleXMLElement $scene) { if ($scene->getName() != 'scene-ad-cue-point') { return null; } $cuePoint = parent::parseCuePoint($scene); if (!$cuePoint instanceof KalturaAdCuePoint) { return null; } if (isset($scene->sceneEndTime)) { $cuePoint->endTime = kXml::timeToInteger($scene->sceneEndTime); } if (isset($scene->sceneTitle)) { $cuePoint->title = "{$scene->sceneTitle}"; } if (isset($scene->sourceUrl)) { $cuePoint->sourceUrl = "{$scene->sourceUrl}"; } $cuePoint->adType = "{$scene->adType}"; $cuePoint->protocolType = "{$scene->protocolType}"; return $cuePoint; }
/** * Allows you to add a metadata profile object and metadata profile file associated with Kaltura object type * * @action addFromFile * @param KalturaMetadataProfile $metadataProfile * @param file $xsdFile XSD metadata definition * @param file $viewsFile UI views definition * @return KalturaMetadataProfile * @throws MetadataErrors::METADATA_FILE_NOT_FOUND */ function addFromFileAction(KalturaMetadataProfile $metadataProfile, $xsdFile, $viewsFile = null) { $filePath = $xsdFile['tmp_name']; if (!file_exists($filePath)) { throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $xsdFile['name']); } // validates the xsd libxml_use_internal_errors(true); libxml_clear_errors(); $xml = new KDOMDocument(); if (!$xml->load($filePath)) { $errorMessage = kXml::getLibXmlErrorDescription(file_get_contents($xsdFile)); throw new KalturaAPIException(MetadataErrors::INVALID_METADATA_PROFILE_SCHEMA, $errorMessage); } libxml_clear_errors(); libxml_use_internal_errors(false); // must be validatebefore checking available searchable fields count $metadataProfile->validatePropertyNotNull('metadataObjectType'); kMetadataManager::validateMetadataProfileField($this->getPartnerId(), $xsdFile, false, $metadataProfile->metadataObjectType); $dbMetadataProfile = $metadataProfile->toInsertableObject(); $dbMetadataProfile->setStatus(KalturaMetadataProfileStatus::ACTIVE); $dbMetadataProfile->setPartnerId($this->getPartnerId()); $dbMetadataProfile->save(); $key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION); kFileSyncUtils::moveFromFile($filePath, $key); if ($viewsFile && $viewsFile['size']) { $filePath = $viewsFile['tmp_name']; if (!file_exists($filePath)) { throw new KalturaAPIException(MetadataErrors::METADATA_FILE_NOT_FOUND, $viewsFile['name']); } $key = $dbMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS); kFileSyncUtils::moveFromFile($filePath, $key); } kMetadataManager::parseProfileSearchFields($this->getPartnerId(), $dbMetadataProfile); $metadataProfile = new KalturaMetadataProfile(); $metadataProfile->fromObject($dbMetadataProfile); return $metadataProfile; }
public static function syndicate(CuePoint $cuePoint, SimpleXMLElement $scenes, SimpleXMLElement $scene = null) { if (!$cuePoint instanceof Annotation) { return $scene; } if (!$scene) { $scene = kCuePointManager::syndicateCuePointXml($cuePoint, $scenes->addChild('scene-annotation')); } $scene->addChild('sceneEndTime', kXml::integerToTime($cuePoint->getEndTime())); if ($cuePoint->getText()) { $scene->addChild('sceneText', kMrssManager::stringToSafeXml($cuePoint->getText())); } if ($cuePoint->getParentId()) { $parentCuePoint = CuePointPeer::retrieveByPK($cuePoint->getParentId()); if ($parentCuePoint) { if ($parentCuePoint->getSystemName()) { $scene->addChild('parent', kMrssManager::stringToSafeXml($parentCuePoint->getSystemName())); } $scene->addChild('parentId', $parentCuePoint->getId()); } } return $scene; }
/** * @param array<CuePoint> $cuePoints * @return string xml */ public static function generateXml(array $cuePoints) { $schemaType = CuePointPlugin::getApiValue(CuePointSchemaType::SERVE_API); $xsdUrl = "http://" . kConf::get('cdn_host') . "/api_v3/service/schema/action/serve/type/{$schemaType}"; $scenes = new SimpleXMLElement('<scenes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="' . $xsdUrl . '" />'); $pluginInstances = KalturaPluginManager::getPluginInstances('IKalturaCuePointXmlParser'); foreach ($cuePoints as $cuePoint) { $scene = null; foreach ($pluginInstances as $pluginInstance) { $scene = $pluginInstance->generateXml($cuePoint, $scenes, $scene); } } $xmlContent = $scenes->asXML(); $xml = new KDOMDocument(); libxml_use_internal_errors(true); libxml_clear_errors(); if (!$xml->loadXML($xmlContent)) { $errorMessage = kXml::getLibXmlErrorDescription($xmlContent); throw new kCuePointException("XML is invalid:\n{$errorMessage}", kCuePointException::XML_INVALID); } $xsdPath = SchemaService::getSchemaPath($schemaType); libxml_clear_errors(); if (!$xml->schemaValidate($xsdPath)) { $errorMessage = kXml::getLibXmlErrorDescription($xmlContent); throw new kCuePointException("XML is invalid:\n{$errorMessage}", kCuePointException::XML_INVALID); } return $xmlContent; }
/** * * The test data provider (gets the data for the different tests) * @param string $className - The class name * @param string $procedureName - The current method (test) name * @return array<array>(); */ public function provider($className, $procedureName) { //print("In provider for $className, $procedureName \n"); //Gets from the given class the class data file $class = get_class($this); $classFilePath = KAutoloader::getClassFilePath($class); $testClassDir = dirname($classFilePath); $dataFilePath = $testClassDir . DIRECTORY_SEPARATOR . "testsData/{$className}.data"; KalturaLog::debug("The data file path [" . $dataFilePath . "]"); if (file_exists($dataFilePath)) { $simpleXML = kXml::openXmlFile($dataFilePath); } else { //TODO: Give notice or create the file don't throw an exception throw new Exception("Data file [{$dataFilePath}] not found"); } $inputsForTestProcedure = array(); foreach ($simpleXML->TestProcedureData as $xmlTestProcedureData) { if ($xmlTestProcedureData["testProcedureName"] != $procedureName) { continue; } foreach ($xmlTestProcedureData->TestCaseData as $xmlTestCaseData) { $testCaseInstanceInputs = array(); foreach ($xmlTestCaseData->Input as $input) { $object = KalturaTestDataObject::generatefromXml($input); //Add the new input to the test case instance data $testCaseInstanceInputs[] = $object; } foreach ($xmlTestCaseData->OutputReference as $output) { $object = KalturaTestDataObject::generatefromXml($output); //Add the new output reference to the test case instance data $testCaseInstanceInputs[] = $object; } //Add the test case into the test procedure data $inputsForTestProcedure[] = $testCaseInstanceInputs; } } KalturaLog::info("Tests data provided Before transformation to objects: \n[" . print_r($inputsForTestProcedure, true) . "]"); $inputsForTestProcedure = $this->transformToObjects($inputsForTestProcedure); KalturaLog::info("Tests data provided [" . print_r($inputsForTestProcedure, true) . "]"); return $inputsForTestProcedure; }
public function setCuePoints(DOMElement $item, array $cuePoints) { foreach ($cuePoints as $cuePoint) { /* @var $cuePoint cuePoint */ $content = $this->cuePoint->cloneNode(true); $mediaGroup = $this->xpath->query('.', $item)->item(0); $mediaGroup->appendChild($content); kXml::setNodeValue($this->xpath, '@type', self::MILLISECONDS, $content); kXml::setNodeValue($this->xpath, '@startTime', $cuePoint->getStartTime(), $content); } }
/** * @param array $flavorAssets */ public function setThumbAssets(DOMElement $item, array $thumbAssets) { foreach ($thumbAssets as $thumbAsset) { /* @var $flavorAsset flavorAsset */ $content = $this->thumbnail->cloneNode(true); $mediaGroup = $this->xpath->query('media:group', $item)->item(0); $mediaGroup->appendChild($content); $url = $this->getAssetUrl($thumbAsset); kXml::setNodeValue($this->xpath, '@url', $url, $content); kXml::setNodeValue($this->xpath, '@width', $thumbAsset->getWidth(), $content); kXml::setNodeValue($this->xpath, '@height', $thumbAsset->getHeight(), $content); } }
/** * Creates a new Kaltura objects DataGenerator * Gets The file path to it's configuration file * * @param string $dataGeneratorConfigFilePath the config file path */ public function __construct($dataGeneratorConfigFilePath) { $simpleXMLElement = kXml::openXmlFile($dataGeneratorConfigFilePath); $this->dataSourceFile = KalturaTestDataSourceFile::generateFromXML($simpleXMLElement); $this->dataSourceFile->setFilePath($dataGeneratorConfigFilePath); }
/** * @param string $results * @param KalturaGenericDistributionProviderParser $resultParserType * @param string $resultParseData * @return array of parsed values */ protected function parseResults($results, $resultParserType, $resultParseData) { switch ($resultParserType) { case KalturaGenericDistributionProviderParser::XSL: $xml = new DOMDocument(); if (!$xml->loadXML($results)) { return false; } $xsl = new DOMDocument(); $xsl->loadXML($resultParseData); $proc = new XSLTProcessor(); $proc->registerPHPFunctions(kXml::getXslEnabledPhpFunctions()); $proc->importStyleSheet($xsl); $data = $proc->transformToDoc($xml); if (!$data) { return false; } return explode(',', $data); case KalturaGenericDistributionProviderParser::XPATH: $xml = new DOMDocument(); if (!$xml->loadXML($results)) { return false; } $xpath = new DOMXPath($xml); $elements = $xpath->query($resultParseData); if (is_null($elements)) { return false; } $matches = array(); foreach ($elements as $element) { $matches[] = $element->textContent; } return $matches; case KalturaGenericDistributionProviderParser::REGEX: $matches = array(); if (!preg_match("/{$resultParseData}/", $results, $matches)) { return false; } return array_shift($matches); default: return false; } }
public function getTargetUserId() { $value = $this->castSimpleType("string", $this->paramsGrouped["targetUserId"]); if (!kXml::isXMLValidContent($value)) { throw new KalturaAPIException(KalturaErrors::INVALID_PARAMETER_CHAR, 'targetUserId'); } return $value; }
public function handleCustomData($objectId, SimpleXMLElement $customData) { $action = KBulkUploadEngine::$actionsMap[KalturaBulkUploadAction::REPLACE]; if (isset($customData->action)) { $action = strtolower($customData->action); } $metadataProfileId = null; if (!empty($customData['metadataProfileId'])) { $metadataProfileId = (int) $customData['metadataProfileId']; } if (!$metadataProfileId && !empty($customData['metadataProfile'])) { $metadataProfileId = $this->getMetadataProfileId($customData['metadataProfile']); } if (!$metadataProfileId) { throw new KalturaBatchException("Missing custom data metadataProfile attribute", KalturaBatchJobAppErrors::BULK_MISSING_MANDATORY_PARAMETER); } $metadataPlugin = KalturaMetadataClientPlugin::get(KBatchBase::$kClient); $metadataFilter = new KalturaMetadataFilter(); $metadataFilter->metadataObjectTypeEqual = $this->objectType; $metadataFilter->objectIdEqual = $objectId; $metadataFilter->metadataProfileIdEqual = $metadataProfileId; $pager = new KalturaFilterPager(); $pager->pageSize = 1; $metadataListResponse = $metadataPlugin->metadata->listAction($metadataFilter, $pager); $metadataId = null; $metadata = null; if (is_array($metadataListResponse->objects) && count($metadataListResponse->objects) > 0) { $metadata = reset($metadataListResponse->objects); $metadataId = $metadata->id; } switch ($action) { case KBulkUploadEngine::$actionsMap[KalturaBulkUploadAction::TRANSFORM_XSLT]: if (!isset($customData->xslt)) { throw new KalturaBatchException($this->containerName . '->' . $this->nodeName . "->xslt element is missing", KalturaBatchJobAppErrors::BULK_ELEMENT_NOT_FOUND); } if ($metadata) { $metadataXml = $metadata->xml; } else { $metadataXml = '<metadata></metadata>'; } $decodedXslt = kXml::decodeXml($customData->xslt); $metadataXml = kXml::transformXmlUsingXslt($metadataXml, $decodedXslt); break; case KBulkUploadEngine::$actionsMap[KalturaBulkUploadAction::REPLACE]: if (!isset($customData->xmlData)) { throw new KalturaBatchException($this->containerName . '->' . $this->nodeName . "->xmlData element is missing", KalturaBatchJobAppErrors::BULK_ELEMENT_NOT_FOUND); } $metadataXmlObject = $customData->xmlData->children(); $metadataXml = $metadataXmlObject->asXML(); break; default: throw new KalturaBatchException($this->containerName . '->' . $this->nodeName . "->action: {$action} is not supported", KalturaBatchJobAppErrors::BULK_ACTION_NOT_SUPPORTED); } if ($metadataId) { $metadataPlugin->metadata->update($metadataId, $metadataXml); } else { $metadataPlugin->metadata->add($metadataProfileId, $this->objectType, $objectId, $metadataXml); } }
/** * Returns the right resource instance for the source content of the item * @param SimpleXMLElement $elementToSearchIn * @param int $conversionProfileId * @return KalturaResource - the resource located in the given element */ protected function getResourceInstance(SimpleXMLElement $elementToSearchIn, $conversionProfileId) { $resource = null; if (isset($elementToSearchIn->serverFileContentResource)) { if ($this->allowServerResource) { KalturaLog::debug("Resource is : serverFileContentResource"); $resource = new KalturaServerFileResource(); $localContentResource = $elementToSearchIn->serverFileContentResource; $resource->localFilePath = kXml::getXmlAttributeAsString($localContentResource, "filePath"); } else { KalturaLog::err("serverFileContentResource is not allowed"); } } elseif (isset($elementToSearchIn->urlContentResource)) { KalturaLog::debug("Resource is : urlContentResource"); $resource = new KalturaUrlResource(); $urlContentResource = $elementToSearchIn->urlContentResource; $resource->url = kXml::getXmlAttributeAsString($urlContentResource, "url"); } elseif (isset($elementToSearchIn->sshUrlContentResource)) { KalturaLog::debug("Resource is : sshUrlContentResource"); $resource = new KalturaSshUrlResource(); $sshUrlContentResource = $elementToSearchIn->sshUrlContentResource; $resource->url = kXml::getXmlAttributeAsString($sshUrlContentResource, "url"); $resource->keyPassphrase = kXml::getXmlAttributeAsString($sshUrlContentResource, "keyPassphrase"); $resource->privateKey = strval($sshUrlContentResource->privateKey); $resource->publicKey = strval($sshUrlContentResource->publicKey); } elseif (isset($elementToSearchIn->remoteStorageContentResource)) { KalturaLog::debug("Resource is : remoteStorageContentResource"); $resource = new KalturaRemoteStorageResource(); $remoteContentResource = $elementToSearchIn->remoteStorageContentResource; $resource->url = kXml::getXmlAttributeAsString($remoteContentResource, "url"); $resource->storageProfileId = $this->getStorageProfileId($remoteContentResource); } elseif (isset($elementToSearchIn->remoteStorageContentResources)) { KalturaLog::debug("Resource is : remoteStorageContentResources"); $resource = new KalturaRemoteStorageResources(); $resource->resources = array(); $remoteContentResources = $elementToSearchIn->remoteStorageContentResources; foreach ($remoteContentResources->remoteStorageContentResource as $remoteContentResource) { /* @var $remoteContentResource SimpleXMLElement */ KalturaLog::debug("Resources name [" . $remoteContentResource->getName() . "] url [" . $remoteContentResource['url'] . "] storage [{$remoteContentResource->storageProfile}]"); $childResource = new KalturaRemoteStorageResource(); $childResource->url = kXml::getXmlAttributeAsString($remoteContentResource, "url"); $childResource->storageProfileId = $this->getStorageProfileId($remoteContentResource); $resource->resources[] = $childResource; } } elseif (isset($elementToSearchIn->entryContentResource)) { KalturaLog::debug("Resource is : entryContentResource"); $resource = new KalturaEntryResource(); $entryContentResource = $elementToSearchIn->entryContentResource; $resource->entryId = kXml::getXmlAttributeAsString($entryContentResource, "entryId"); $resource->flavorParamsId = $this->getFlavorParamsId($entryContentResource, $conversionProfileId, false); } elseif (isset($elementToSearchIn->assetContentResource)) { KalturaLog::debug("Resource is : assetContentResource"); $resource = new KalturaAssetResource(); $assetContentResource = $elementToSearchIn->assetContentResource; $resource->assetId = kXml::getXmlAttributeAsString($assetContentResource, "assetId"); } return $resource; }
public static function syndicate(CuePoint $cuePoint, SimpleXMLElement $scenes, SimpleXMLElement $scene = null) { if (!$cuePoint instanceof ThumbCuePoint) { return $scene; } if (!$scene) { $scene = kCuePointManager::syndicateCuePointXml($cuePoint, $scenes->addChild('scene-thumb-cue-point')); } if ($cuePoint->getEndTime()) { $scene->addChild('sceneEndTime', kXml::integerToTime($cuePoint->getEndTime())); } $scene->addChild('thumbAssetId', $cuePoint->getAssetId()); return $scene; }
/** * @param SimpleXMLElement $scene * @return KalturaCuePoint */ protected function parseCuePoint(SimpleXMLElement $scene) { $cuePoint = $this->getNewInstance(); if (isset($scene['systemName']) && $scene['systemName']) { $cuePoint->systemName = $scene['systemName'] . ''; } $cuePoint->startTime = kXml::timeToInteger($scene->sceneStartTime); $tags = array(); foreach ($scene->tags->children() as $tag) { $value = "{$tag}"; if ($value) { $tags[] = $value; } } $cuePoint->tags = implode(',', $tags); return $cuePoint; }
public static function syndicate(CuePoint $cuePoint, SimpleXMLElement $scenes, SimpleXMLElement $scene = null) { if (!$cuePoint instanceof AdCuePoint) { return $scene; } if (!$scene) { $scene = kCuePointManager::syndicateCuePointXml($cuePoint, $scenes->addChild('scene-ad-cue-point')); } if ($cuePoint->getEndTime()) { $scene->addChild('sceneEndTime', kXml::integerToTime($cuePoint->getEndTime())); } if ($cuePoint->getName()) { $scene->addChild('sceneTitle', kMrssManager::stringToSafeXml($cuePoint->getName())); } if ($cuePoint->getSourceUrl()) { $scene->addChild('sourceUrl', htmlspecialchars($cuePoint->getSourceUrl())); } $scene->addChild('adType', $cuePoint->getAdType()); $scene->addChild('protocolType', $cuePoint->getSubType()); return $scene; }
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); }