public function checkIsLive($url) { KalturaLog::info('url to check:' . $url); $parts = parse_url($url); parse_str($parts['query'], $query); $token = $query[$this->getParamName()]; $data = $this->urlExists($url, array($this->getHdsManifestContentType())); if (!$data) { KalturaLog::Info("URL [{$url}] returned no valid data. Exiting."); return false; } KalturaLog::info('Velocix HDS manifest data:' . $data); $dom = new KDOMDocument(); $dom->loadXML($data); $element = $dom->getElementsByTagName('baseURL')->item(0); if (!$element) { KalturaLog::Info("No base url was given"); return false; } $baseUrl = $element->nodeValue; foreach ($dom->getElementsByTagName('media') as $media) { $href = $media->getAttribute('href'); $streamUrl = $baseUrl . $href; $streamUrl .= $token ? '?' . $this->getParamName() . "={$token}" : ''; if ($this->urlExists($streamUrl, array(), '0-0') !== false) { KalturaLog::info('is live:' . $streamUrl); return true; } } return false; }
public function apply(KalturaRelatedFilter $filter, KalturaObject $parentObject) { $filterProperty = $this->filterProperty; $parentProperty = $this->parentProperty; KalturaLog::debug("Mapping XPath {$parentProperty} to " . get_class($filter) . "::{$filterProperty}"); if (!$parentObject instanceof KalturaMetadata) { throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_TYPE, get_class($parentObject)); } if (!property_exists($filter, $filterProperty)) { throw new KalturaAPIException(KalturaErrors::PROPERTY_IS_NOT_DEFINED, $filterProperty, get_class($filter)); } $xml = $parentObject->xml; $doc = new KDOMDocument(); $doc->loadXML($xml); $xpath = new DOMXPath($doc); $metadataElements = $xpath->query($parentProperty); if ($metadataElements->length == 1) { $filter->{$filterProperty} = $metadataElements->item(0)->nodeValue; } elseif ($metadataElements->length > 1) { $values = array(); foreach ($metadataElements as $element) { $values[] = $element->nodeValue; } $filter->{$filterProperty} = implode(',', $values); } elseif (!$this->allowNull) { return false; } return true; }
function check(&$msg, $url) { $service = 'session'; $action = 'start'; $secret = '@BATCH_PARTNER_ADMIN_SECRET@'; $partnerId = -1; $userId = 'xymon'; $type = 2; $getKS = "http://{$url}/api_v3/index.php?service={$service}&action={$action}&secret={$secret}&partnerId={$partnerId}&userId={$userId}&type={$type}&nocache"; try { $content = @file_get_contents($getKS); } catch (Exception $e) { $msg = $e->getMessage(); return false; } if (!$content) { $msg = "unable to get data"; return false; } $arr = null; if (!preg_match('/<result>([^<]+)<\\/result>/', $content, $arr)) { $msg = "invalid return data\n{$content}"; return false; } $ks = $arr[1]; $service = 'batchControl'; $action = 'getFullStatus'; $getStatus = "http://{$url}/api_v3/index.php?service={$service}&action={$action}&ks={$ks}&nocache"; // Load the XML source if (class_exists('DOMDocument') && class_exists('XSLTProcessor')) { $xml = new KDOMDocument(); $xml->load($getStatus); //file_put_contents('fullStatus.xml', $xml->saveXML()); $resultElements = $xml->getElementsByTagName("result"); $resultElement = $resultElements->item(0); $resultElement->setAttribute('timestamp', time()); $xsl = new KDOMDocument(); $xsl->load(dirname(__FILE__) . '/fullstatus.xsl'); // Configure the transformer $proc = new XSLTProcessor(); $proc->importStyleSheet($xsl); // attach the xsl rules $msg = $proc->transformToXML($xml); } else { $msg = "batches are ok\nXSL is required to parse the XML data."; } // echo "'$msg'\n"; // echo "-----------------------------------------------\n\n"; // echo $xml->saveHTML(); // exit; return true; }
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; }
public function checkIsLive($url) { $data = $this->urlExists($url, array('video/f4m')); if (is_bool($data)) { return $data; } $element = new KDOMDocument(); $element->loadXML($data); $streamType = $element->getElementsByTagName('streamType')->item(0); if ($streamType->nodeValue == 'live') { return true; } return false; }
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser) { if (!$puser_kuser) { $this->addError(APIErrors::INVALID_USER_ID, $puser_id); return; } $entry_id = $this->getPM("entry_id"); $entry = entryPeer::retrieveByPK($entry_id); // TODO - verify the user is allowed to modify the entry $source_entry_id = $this->getP("source_entry_id"); if ($source_entry_id) { $source_entry = entryPeer::retrieveByPK($source_entry_id); if (!$source_entry) { return; } } else { $source_entry = $entry; } $time_offset = $this->getP("time_offset", -1); if (!myEntryUtils::createThumbnailFromEntry($entry, $source_entry, $time_offset)) { $this->addError(APIErrors::INVALID_ENTRY_TYPE, "ENTRY_TYPE_MEDIACLIP"); return; } if ($entry->getType() == entryType::MIX) { /* $roughcutPath = myContentStorage::getFSContentRootPath() . $entry->getDataPath(); // replaced__getDataPath $xml_doc = new KDOMDocument(); $xml_doc->load( $roughcutPath ); if (myMetadataUtils::updateThumbUrl($xml_doc, $entry->getThumbnailUrl())) $xml_doc->save($roughcutPath); */ $sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); $xml_doc = new KDOMDocument(); $xml_doc->loadXML(kFileSyncUtils::file_get_contents($sync_key)); if (myMetadataUtils::updateThumbUrl($xml_doc, $entry->getThumbnailUrl())) { $entry->setMetadata(null, $xml_doc->saveXML(), true, null, null); //$entry->getVersion() ); } myNotificationMgr::createNotification(kNotificationJobData::NOTIFICATION_TYPE_ENTRY_UPDATE_THUMBNAIL, $entry); } $wrapper = objectWrapperBase::getWrapperClass($entry, objectWrapperBase::DETAIL_LEVEL_DETAILED); $wrapper->removeFromCache("entry", $entry->getId()); $this->addMsg("entry", $wrapper); }
/** * 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 modifiedByKeditor($content) { $xml_doc = new KDOMDocument(); $xml_doc->loadXML($content); $xpath = new DOMXPath($xml_doc); $metadata_elem = $xpath->query("//Metadata"); $modified_by_keditor_list = $metadata_elem->getElementsByTagName("Modified"); if ($modified_by_keditor_list != null && $modified_by_keditor_list->length > 0) { $modified_by_keditor = $modified_by_keditor_list->item(0)->nodeValue; return $content; //$modified_by_keditor->setValue } else { $newTextNode = $xml_doc->createTextNode("keditor"); $modified = $xml_doc->createElement("Modified"); //, "keditor" ); $modified->appendChild($newTextNode); $metadata_elem->appendChild($modified); } return $xml_doc->saveXML(); }
/** * @param string $xsd * @return array */ protected function getAvnCategoriesFromXsd($xsd) { $categories = array(); $doc = new KDOMDocument(); $doc->loadXML($xsd); $xpath = new DOMXPath($doc); $xpath->registerNamespace('xsd', 'http://www.w3.org/2001/XMLSchema'); $categoryNodes = $xpath->query("//xsd:element[@name='AVNCategory']/xsd:simpleType/xsd:restriction[@base='listType']/xsd:enumeration/@value"); foreach ($categoryNodes as $categoryNode) { $categories[] = $categoryNode->nodeValue; } return $categories; }
/** * @param string $xml * @param string $xslt * @param array $xsltParams * @return string */ public static function transformXmlUsingXslt($xmlStr, $xslt, $xsltParams = array(), &$xsltErrors = array()) { $xml = new KDOMDocument(); if (!$xml->loadXML($xmlStr)) { KalturaLog::debug("Could not load xmlStr"); return null; } $xsl = new KDOMDocument(); if (!$xsl->loadXML($xslt)) { KalturaLog::debug("Could not load xslt"); return null; } $proc = new XSLTProcessor(); foreach ($xsltParams as $key => $value) { $proc->setParameter('', $key, $value); } $proc->registerPHPFunctions(kXml::getXslEnabledPhpFunctions()); @$proc->importStyleSheet($xsl); $errorHandler = new XSLTErrorCollector(); $xml = @$proc->transformToDoc($xml); $errorHandler->restoreErrorHandler(); $xsltErrors = $errorHandler->errors; if (!$xml) { KalturaLog::err("XML Transformation failed"); return null; } if (isset($xml->documentElement)) { $xml->documentElement->removeAttributeNS('http://php.net/xsl', 'php'); } return $xml->saveXML(); }
/** * @param string $xsdPath * @param string $appInfoField * @param string $appInfoValue * @return array of xPaths */ public static function findXpathsByAppInfo($xsdPath, $appInfoField, $appInfoValue, $isPath = true) { $xsd = new KDOMDocument(); if ($isPath) { $xsd->load($xsdPath); } else { $xsd->loadXML($xsdPath); } $xPaths = array(); $appInfos = $xsd->getElementsByTagName('appinfo'); foreach ($appInfos as $appInfo) { $fields = $appInfo->getElementsByTagName($appInfoField); $found = false; foreach ($fields as $field) { if ($field->nodeValue == $appInfoValue) { $found = true; } } if (!$found) { continue; } $name = self::getXsdElementName($appInfo); $type = self::getXsdNodeType($appInfo); $xPath = self::getXsdXpath($appInfo); $data = array(); if ($name) { $data['name'] = $name; } if ($type) { $data['type'] = $type; } foreach ($appInfo->childNodes as $childNode) { if ($childNode->nodeType == XML_TEXT_NODE || $childNode->nodeType == XML_COMMENT_NODE) { continue; } $data[$childNode->localName] = $childNode->nodeValue; } $xPaths[$xPath] = $data; } return $xPaths; }
/** * Validate the XML against the profile XSD and set the metadata status * * @param int $metadataProfileId * @param string $metadata * @param string $errorMessage * @param int $compareAgainstPreviousVersion leave it false to use the latest metadata profile version * * returns bool */ public static function validateMetadata($metadataProfileId, $metadata, &$errorMessage, $compareAgainstPreviousVersion = false) { KalturaLog::debug("Validating metadata [{$metadata}]"); $metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId); if (!$metadataProfile) { $errorMessage = "Metadata profile [{$metadataProfileId}] not found"; KalturaLog::err($errorMessage); return false; } $metadataProfileFSVersion = null; if ($compareAgainstPreviousVersion) { $metadataProfileFSVersion = $metadataProfile->getPreviousFileSyncVersion(); } $metadataProfileKey = $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION, $metadataProfileFSVersion); $xsdData = kFileSyncUtils::file_get_contents($metadataProfileKey, true, false); if (!$xsdData) { $errorMessage = "Metadata profile xsd not found"; KalturaLog::err($errorMessage); return false; } libxml_use_internal_errors(true); libxml_clear_errors(); $xml = new KDOMDocument(); $xml->loadXML($metadata); if ($xml->schemaValidateSource($xsdData)) { if (!self::validateMetadataObjects($metadataProfileId, $xml, $errorMessage)) { KalturaLog::err($errorMessage); return false; } KalturaLog::debug("Metadata is valid"); return true; } $errorMessage = kXml::getLibXmlErrorDescription($metadata); KalturaLog::err("Metadata is invalid:\n{$errorMessage}"); return false; }
<?php $downloadUrl = 'http://' . kConf::get('www_host') . "/api_v3/index.php/service/schema/action/serve/type/{$schemaType}/name/{$schemaType}.xsd"; echo "Download URL: <a href=\"{$downloadUrl};\" target=\"_blank\">{$downloadUrl}</a><br/>\n"; $schemaPath = SchemaService::getSchemaPath($schemaType); $xslPath = dirname(__FILE__) . '/xsl/type.xsl'; // Load the XML source $xml = new KDOMDocument(); $xml->load($schemaPath); if ($xml->firstChild->hasAttribute('version')) { echo "Version: " . $xml->firstChild->getAttribute('version') . "<br/>\n"; } $xsl = new KDOMDocument(); $xsl->load($xslPath); // Configure the transformer $proc = new XSLTProcessor(); $proc->importStyleSheet($xsl); // attach the xsl rules echo "<br/>\n"; echo $proc->transformToXML($xml);
protected function executeImpl(kshow $kshow, entry &$entry) { $this->res = ""; $likuser_id = $this->getLoggedInUserId(); // if we allow multiple rouchcuts - there is no reason for one suer to override someone else's thumbnail if ($this->allowMultipleRoughcuts()) { if ($likuser_id != $entry->getKuserId()) { // ERROR - attempting to update an entry which doesnt belong to the user return "<xml>!!</xml>"; //$this->securityViolation( $kshow->getId() ); } } $debug = @$_GET["debug"]; /* $kshow_id = @$_GET["kshow_id"]; $debug = @$_GET["debug"]; $this->kshow_id = $kshow_id; if ( $kshow_id == NULL || $kshow_id == 0 ) return; $kshow = kshowPeer::retrieveByPK( $kshow_id ); if ( ! $kshow ) { $this->res = "No kshow " . $kshow_id ; return; } // is the logged-in-user is not an admin or the producer - check if show can be published $likuser_id = $this->getLoggedInUserId(); $viewer_type = myKshowUtils::getViewerType($kshow, $likuser_id); if ( $viewer_type != KshowKuser::KSHOWKUSER_VIEWER_PRODUCER && ( ! $kshow->getCanPublish() ) ) { // ERROR - attempting to publish a non-publishable show return "<xml>!</xml>";//$this->securityViolation( $kshow->getId() ); } // ASSUME - the kshow & roughcut already exist $show_entry_id = $kshow->getShowEntryId(); $roughcut = entryPeer::retrieveByPK( $show_entry_id ); $roughcut = entryPeer::retrieveByPK( $entry_id ); if ( ! $roughcut) { $this->res = "No roughcut for kshow " . $kshow->getId() ; return; } */ // echo "for entry: $show_entry_id current thumb path: " . $entry->getThumbnail() ; $entry->setThumbnail(".jpg"); $entry->setCreateThumb(false); $entry->save(); //$thumb_data = $_REQUEST["ThumbData"]; if (isset($HTTP_RAW_POST_DATA)) { $thumb_data = $HTTP_RAW_POST_DATA; } else { $thumb_data = file_get_contents("php://input"); } // $thumb_data = $GLOBALS["HTTP_RAW_POST_DATA"]; $thumb_data_size = strlen($thumb_data); $bigThumbPath = myContentStorage::getFSContentRootPath() . $entry->getBigThumbnailPath(); kFile::fullMkdir($bigThumbPath); kFile::setFileContent($bigThumbPath, $thumb_data); $path = myContentStorage::getFSContentRootPath() . $entry->getThumbnailPath(); kFile::fullMkdir($path); myFileConverter::createImageThumbnail($bigThumbPath, $path); $roughcutPath = myContentStorage::getFSContentRootPath() . $entry->getDataPath(); $xml_doc = new KDOMDocument(); $xml_doc->load($roughcutPath); if (myMetadataUtils::updateThumbUrl($xml_doc, $entry->getBigThumbnailUrl())) { $xml_doc->save($roughcutPath); } $this->res = $entry->getBigThumbnailUrl(); }
function writeCsproj() { $csprojDoc = new KDOMDocument(); $csprojDoc->formatOutput = true; $csprojDoc->load($this->_sourcePath . "/KalturaClient/KalturaClient.csproj"); $csprojXPath = new DOMXPath($csprojDoc); $csprojXPath->registerNamespace("m", "http://schemas.microsoft.com/developer/msbuild/2003"); $compileNodes = $csprojXPath->query("//m:ItemGroup/m:Compile/.."); $compileItemGroupElement = $compileNodes->item(0); foreach ($this->_csprojIncludes as $include) { $compileElement = $csprojDoc->createElement("Compile"); $compileElement->setAttribute("Include", str_replace("/", "\\", $include)); $compileItemGroupElement->appendChild($compileElement); } $this->addFile("KalturaClient/KalturaClient.csproj", $csprojDoc->saveXML(), false); }
/** * @param Metadata $metadata */ public static function onMetadataChanged(Metadata $metadata, $previousVersion) { if (!ContentDistributionPlugin::isAllowedPartner($metadata->getPartnerId())) { return true; } if ($metadata->getObjectType() != MetadataObjectType::ENTRY) { return true; } KalturaLog::log("Metadata [" . $metadata->getId() . "] for entry [" . $metadata->getObjectId() . "] changed"); $syncKey = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA); $xmlPath = kFileSyncUtils::getLocalFilePathForKey($syncKey); if (!$xmlPath) { KalturaLog::log("Entry metadata xml not found"); return true; } $xml = new KDOMDocument(); $xml->load($xmlPath); $previousXml = null; if ($previousVersion) { $syncKey = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA, $previousVersion); $xmlPath = kFileSyncUtils::getLocalFilePathForKey($syncKey); if ($xmlPath) { $previousXml = new KDOMDocument(); $previousXml->load($xmlPath); } else { KalturaLog::log("Entry metadata previous version xml not found"); } } $entryDistributions = EntryDistributionPeer::retrieveByEntryId($metadata->getObjectId()); foreach ($entryDistributions as $entryDistribution) { if ($entryDistribution->getStatus() != EntryDistributionStatus::QUEUED && $entryDistribution->getStatus() != EntryDistributionStatus::PENDING && $entryDistribution->getStatus() != EntryDistributionStatus::READY) { continue; } $distributionProfileId = $entryDistribution->getDistributionProfileId(); $distributionProfile = DistributionProfilePeer::retrieveByPK($distributionProfileId); if (!$distributionProfile) { KalturaLog::err("Entry distribution [" . $entryDistribution->getId() . "] profile [{$distributionProfileId}] not found"); continue; } $distributionProvider = $distributionProfile->getProvider(); if (!$distributionProvider) { KalturaLog::err("Entry distribution [" . $entryDistribution->getId() . "] provider [" . $distributionProfile->getProviderType() . "] not found"); continue; } if ($entryDistribution->getStatus() == EntryDistributionStatus::PENDING || $entryDistribution->getStatus() == EntryDistributionStatus::QUEUED) { $validationErrors = $distributionProfile->validateForSubmission($entryDistribution, DistributionAction::SUBMIT); $entryDistribution->setValidationErrorsArray($validationErrors); $entryDistribution->save(); if ($entryDistribution->getStatus() == EntryDistributionStatus::QUEUED) { if ($entryDistribution->getDirtyStatus() != EntryDistributionDirtyStatus::SUBMIT_REQUIRED) { self::submitAddEntryDistribution($entryDistribution, $distributionProfile); } } continue; } if ($entryDistribution->getStatus() == EntryDistributionStatus::READY) { if ($entryDistribution->getDirtyStatus() == EntryDistributionDirtyStatus::UPDATE_REQUIRED) { KalturaLog::log("Entry distribution [" . $entryDistribution->getId() . "] already flaged for updating"); // continue; } if (!$distributionProvider->isUpdateEnabled()) { KalturaLog::log("Entry distribution [" . $entryDistribution->getId() . "] provider [" . $distributionProvider->getName() . "] does not support update"); continue; } $updateRequiredMetadataXPaths = $distributionProvider->getUpdateRequiredMetadataXPaths($distributionProfileId); $updateRequired = false; foreach ($updateRequiredMetadataXPaths as $updateRequiredMetadataXPath) { $xPath = new DOMXpath($xml); $newElements = $xPath->query($updateRequiredMetadataXPath); $oldElements = null; if ($previousXml) { $xPath = new DOMXpath($previousXml); $oldElements = $xPath->query($updateRequiredMetadataXPath); } if (is_null($newElements) && is_null($oldElements)) { continue; } if (is_null($newElements) xor is_null($oldElements)) { $updateRequired = true; } elseif ($newElements->length == $oldElements->length) { for ($index = 0; $index < $newElements->length; $index++) { $newValue = $newElements->item($index)->textContent; $oldValue = $oldElements->item($index)->textContent; if ($newValue != $oldValue) { $updateRequired = true; break; } } } if ($updateRequired) { break; } } $validationErrors = $distributionProfile->validateForSubmission($entryDistribution, DistributionAction::UPDATE); $entryDistribution->setValidationErrorsArray($validationErrors); $entryDistribution->save(); if (!$updateRequired) { KalturaLog::log("Entry distribution [" . $entryDistribution->getId() . "] update not required"); continue; } if (!count($validationErrors) && $distributionProfile->getUpdateEnabled() == DistributionProfileActionStatus::AUTOMATIC) { self::submitUpdateEntryDistribution($entryDistribution, $distributionProfile); } else { KalturaLog::log("Entry distribution [" . $entryDistribution->getId() . "] should not be updated automatically"); $entryDistribution->setDirtyStatus(EntryDistributionDirtyStatus::UPDATE_REQUIRED); $entryDistribution->save(); continue; } } } return true; }
protected function getOriginalOrTransformIfNeeded(DropFolder $folder, $xmlPath) { if (!file_exists($xmlPath) || !filesize($xmlPath)) { throw new Exception('Empty file supplied as input'); } if (!$folder->getConversionProfileId()) { KalturaLog::debug('No conversion profile found on drop folder [' . $folder->getId() . '] assuming no xsl transformation is needed'); return file_get_contents($xmlPath); } $conversionProfile = conversionProfile2Peer::retrieveByPK($folder->getConversionProfileId()); if (!$conversionProfile || strlen($conversionProfile->getXsl()) == 0) { KalturaLog::debug('No conversion profile found Or no xsl transform found'); return file_get_contents($xmlPath); } $originalXmlDoc = file_get_contents($xmlPath); $origianlXml = new KDOMDocument(); if (!$origianlXml->loadXML($originalXmlDoc)) { KalturaLog::debug('Could not load original xml'); $errorMessage = kXml::getLibXmlErrorDescription($originalXmlDoc); throw new Exception(DropFolderXmlBulkUploadPlugin::MALFORMED_XML_FILE_MESSAGE, DropFolderXmlBulkUploadPlugin::getErrorCodeCoreValue(DropFolderXmlBulkUploadErrorCode::MALFORMED_XML_FILE)); } libxml_clear_errors(); $proc = new XSLTProcessor(); $xsl = new KDOMDocument(); if (!$xsl->loadXML($conversionProfile->getXsl())) { KalturaLog::debug('Could not load xsl ' . $conversionProfile->getXsl()); $errorMessage = kXml::getLibXmlErrorDescription($conversionProfile->getXsl()); throw new Exception(DropFolderXmlBulkUploadPlugin::MALFORMED_XML_FILE_MESSAGE, DropFolderXmlBulkUploadPlugin::getErrorCodeCoreValue(DropFolderXmlBulkUploadErrorCode::MALFORMED_XML_FILE)); } $proc->importStyleSheet($xsl); libxml_clear_errors(); $transformedXml = $proc->transformToXML($origianlXml); if (!$transformedXml) { KalturaLog::debug('Could not transform xml ' . $conversionProfile->getXsl()); $errorMessage = kXml::getLibXmlErrorDescription($conversionProfile->getXsl()); throw new Exception(DropFolderXmlBulkUploadPlugin::MALFORMED_XML_FILE_MESSAGE, DropFolderXmlBulkUploadPlugin::getErrorCodeCoreValue(DropFolderXmlBulkUploadErrorCode::MALFORMED_XML_FILE)); } $xmlDoc = new KDOMDocument(); $res = $xmlDoc->loadXML($transformedXml); if (!$res) { throw new Exception(DropFolderXmlBulkUploadPlugin::MALFORMED_XML_FILE_MESSAGE, DropFolderXmlBulkUploadPlugin::getErrorCodeCoreValue(DropFolderXmlBulkUploadErrorCode::MALFORMED_XML_FILE)); } return $transformedXml; }
/** * @param asset $asset * @param string $class * @param string $encodingProfile * @param string $duration * @param string $url */ protected function createEnclosureXml(asset $asset, $class, $encodingProfile, $duration) { /** * * In QuickPlay's XML example, the namespace "http://www.quickplaymedia.com" is added to the "enclosure" * element regardless to the fact that it was registerted with the prefix "qpm" on the root element. * We cannot set a namespace that was already defined with a prefix because DOMDocument will add the element * as "qpm:enclosure" and won't set the namespace explicitly. * * The hack is to create a new KDOMDocument with default namespace "http://www.quickplaymedia.com" and then * add it to the xml manually (see getXml() method) * */ $syncKey = $asset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET); $fileSync = kFileSyncUtils::getLocalFileSyncForKey($syncKey); $contentNode = $this->_enclosureNode->cloneNode(true); kXml::setNodeValue($this->_xpath, '@encodingProfile', $encodingProfile, $contentNode); $url = $this->getAssetUrl($asset); $mimeType = $this->getContentTypeFromUrl($url); $enclosureDoc = new KDOMDocument(); $enclosureElement = $enclosureDoc->createElementNS('http://www.quickplaymedia.com', 'enclosure'); $xmlElement = $enclosureDoc->createElement('xml'); $enclosureDoc->appendChild($xmlElement); $enclosureNode = $enclosureDoc->importNode($contentNode, true); $enclosureNode->setAttribute('class', $class); $link = $enclosureNode->getElementsByTagName('link')->item(0); $link->setAttribute('type', $mimeType); $link->setAttribute('length', $fileSync->getFileSize()); $link->setAttribute('duration', $duration); $link->setAttribute('url', pathinfo($fileSync->getFilePath(), PATHINFO_BASENAME)); $xmlElement->appendChild($enclosureNode); return $enclosureDoc->saveXML($enclosureNode); }
public function loadProperties(KalturaDistributionJobData $distributionJobData, KalturaGenericDistributionProfile $distributionProfile, $action) { $actionName = self::$actionAttributes[$action]; $genericProviderAction = GenericDistributionProviderActionPeer::retrieveByProviderAndAction($distributionProfile->genericProviderId, $action); if (!$genericProviderAction) { KalturaLog::err("Generic provider [{$distributionProfile->genericProviderId}] action [{$actionName}] not found"); return; } if (!$distributionJobData->entryDistribution) { KalturaLog::err("Entry Distribution object not provided"); return; } if (!$distributionProfile->{$actionName}->protocol) { $distributionProfile->{$actionName}->protocol = $genericProviderAction->getProtocol(); } if (!$distributionProfile->{$actionName}->serverUrl) { $distributionProfile->{$actionName}->serverUrl = $genericProviderAction->getServerAddress(); } if (!$distributionProfile->{$actionName}->serverPath) { $distributionProfile->{$actionName}->serverPath = $genericProviderAction->getRemotePath(); } if (!$distributionProfile->{$actionName}->username) { $distributionProfile->{$actionName}->username = $genericProviderAction->getRemoteUsername(); } if (!$distributionProfile->{$actionName}->password) { $distributionProfile->{$actionName}->password = $genericProviderAction->getRemotePassword(); } if (!$distributionProfile->{$actionName}->ftpPassiveMode) { $distributionProfile->{$actionName}->ftpPassiveMode = $genericProviderAction->getFtpPassiveMode(); } if (!$distributionProfile->{$actionName}->httpFieldName) { $distributionProfile->{$actionName}->httpFieldName = $genericProviderAction->getHttpFieldName(); } if (!$distributionProfile->{$actionName}->httpFileName) { $distributionProfile->{$actionName}->httpFileName = $genericProviderAction->getHttpFileName(); } $entry = entryPeer::retrieveByPKNoFilter($distributionJobData->entryDistribution->entryId); if (!$entry) { KalturaLog::err("Entry [" . $distributionJobData->entryDistribution->entryId . "] not found"); return; } $mrss = kMrssManager::getEntryMrss($entry); if (!$mrss) { KalturaLog::err("MRSS not returned for entry [" . $entry->getId() . "]"); return; } $xml = new KDOMDocument(); if (!$xml->loadXML($mrss)) { KalturaLog::err("MRSS not is not valid XML:\n{$mrss}\n"); return; } $key = $genericProviderAction->getSyncKey(GenericDistributionProviderAction::FILE_SYNC_DISTRIBUTION_PROVIDER_ACTION_MRSS_TRANSFORMER); if (kFileSyncUtils::fileSync_exists($key)) { $xslPath = kFileSyncUtils::getLocalFilePathForKey($key); if ($xslPath) { $xsl = new KDOMDocument(); $xsl->load($xslPath); // set variables in the xsl $varNodes = $xsl->getElementsByTagName('variable'); foreach ($varNodes as $varNode) { $nameAttr = $varNode->attributes->getNamedItem('name'); if (!$nameAttr) { continue; } $name = $nameAttr->value; if ($name && $distributionJobData->{$name}) { $varNode->textContent = $distributionJobData->{$name}; $varNode->appendChild($xsl->createTextNode($distributionJobData->{$name})); } } $proc = new XSLTProcessor(); $proc->registerPHPFunctions(kXml::getXslEnabledPhpFunctions()); $proc->importStyleSheet($xsl); $xml = $proc->transformToDoc($xml); if (!$xml) { KalturaLog::err("Transform returned false"); return; } } } $key = $genericProviderAction->getSyncKey(GenericDistributionProviderAction::FILE_SYNC_DISTRIBUTION_PROVIDER_ACTION_MRSS_VALIDATOR); if (kFileSyncUtils::fileSync_exists($key)) { $xsdPath = kFileSyncUtils::getLocalFilePathForKey($key); if ($xsdPath && !$xml->schemaValidate($xsdPath)) { KalturaLog::err("Inavlid XML:\n" . $xml->saveXML()); KalturaLog::err("Schema [{$xsdPath}]:\n" . file_get_contents($xsdPath)); return; } } $this->xml = $xml->saveXML(); $key = $genericProviderAction->getSyncKey(GenericDistributionProviderAction::FILE_SYNC_DISTRIBUTION_PROVIDER_ACTION_RESULTS_TRANSFORMER); if (kFileSyncUtils::fileSync_exists($key)) { $this->resultParseData = kFileSyncUtils::file_get_contents($key, true, false); } $this->resultParserType = $genericProviderAction->getResultsParser(); }
/** * @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; }
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser) { $kshowId = $this->getP("kshow_id"); $numberOfVersions = $this->getP("number_of_versions", 5); // must be int and not more than 50 $numberOfVersions = (int) $numberOfVersions; $numberOfVersions = min($numberOfVersions, 50); $kshow = kshowPeer::retrieveByPK($kshowId); if (!$kshow) { $this->addError(APIErrors::KSHOW_DOES_NOT_EXISTS); return; } $showEntry = $kshow->getShowEntry(); if (!$showEntry) { $this->addError(APIErrors::ROUGHCUT_NOT_FOUND); return; } $sync_key = $showEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA); $showEntryDataPath = kFileSyncUtils::getLocalFilePathForKey($sync_key); $versionsInfoFilePath = $showEntryDataPath . '.info'; $lastVersionDoc = new KDOMDocument(); $lastVersionDoc->loadXML(kFileSyncUtils::file_get_contents($sync_key, true, false)); $lastVersion = myContentStorage::getVersion($showEntryDataPath); // check if we need to refresh the data in the info file $refreshInfoFile = true; if (file_exists($versionsInfoFilePath)) { $versionsInfoDoc = new KDOMDocument(); $versionsInfoDoc->load($versionsInfoFilePath); $lastVersionInInfoFile = kXml::getLastElementAsText($versionsInfoDoc, "ShowVersion"); if ($lastVersionInInfoFile && $lastVersion == $lastVersionInInfoFile) { $refreshInfoFile = false; } else { $refreshInfoFile = true; } } else { $refreshInfoFile = true; } // refresh or create the data in the info file if ($refreshInfoFile) { $versionsInfoDoc = new KDOMDocument(); $xmlElement = $versionsInfoDoc->createElement("xml"); // start from the first edited version (100001) and don't use 100000 for ($i = myContentStorage::MIN_OBFUSCATOR_VALUE + 1; $i <= $lastVersion; $i++) { $version_sync_key = $showEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $i); if (kFileSyncUtils::file_exists($version_sync_key, false)) { $xmlContent = kFileSyncUtils::file_get_contents($version_sync_key); //echo "[" . htmlspecialchars( $xmlContent ) . "]<br>"; $xmlDoc = new KDOMDocument(); $xmlDoc->loadXML($xmlContent); $elementToCopy = kXml::getFirstElement($xmlDoc, "MetaData"); //echo "[$i]"; $elementCloned = $elementToCopy->cloneNode(true); $elementImported = $versionsInfoDoc->importNode($elementCloned, true); $xmlElement->appendChild($elementImported); } } $versionsInfoDoc->appendChild($xmlElement); kFile::setFileContent($versionsInfoFilePath, $versionsInfoDoc->saveXML()); // FileSync OK - created a temp file on DC's disk } $metadataNodes = $versionsInfoDoc->getElementsByTagName("MetaData"); $count = 0; $versionsInfo = array(); for ($i = $metadataNodes->length - 1; $i >= 0; $i--) { $metadataNode = $metadataNodes->item($i); $node = kXml::getFirstElement($metadataNode, "ShowVersion"); $showVersion = $node ? $node->nodeValue : ""; $node = kXml::getFirstElement($metadataNode, "PuserId"); $puserId = $node ? $node->nodeValue : ""; $node = kXml::getFirstElement($metadataNode, "ScreenName"); $screenName = $node ? $node->nodeValue : ""; $node = kXml::getFirstElement($metadataNode, "UpdatedAt"); $updatedAt = $node ? $node->nodeValue : ""; $versionsInfo[] = array("version" => $showVersion, "puserId" => $puserId, "screenName" => $screenName, "updatedAt" => $updatedAt); $count++; if ($count >= $numberOfVersions) { break; } } $this->addMsg("show_versions", $versionsInfo); }
/** * @param string $entryId * @param KalturaIdeticDistributionJobProviderData $providerData * @return DOMDocument */ public static function generateXML($entryId, KalturaIdeticDistributionJobProviderData $providerData) { $entry = entryPeer::retrieveByPKNoFilter($entryId); $mrss = kMrssManager::getEntryMrss($entry); if (!$mrss) { KalturaLog::err("No MRSS returned for entry [{$entryId}]"); return null; } $xml = new KDOMDocument(); if (!$xml->loadXML($mrss)) { KalturaLog::err("Could not load MRSS as XML for entry [{$entryId}]"); return null; } $xslPath = realpath(dirname(__FILE__) . '/../') . '/xml/submit.xsl'; if (!file_exists($xslPath)) { KalturaLog::err("XSL file not found [{$xslPath}]"); return null; } $xsl = new KDOMDocument(); $xsl->load($xslPath); // set variables in the xsl $varNodes = $xsl->getElementsByTagName('variable'); foreach ($varNodes as $varNode) { $nameAttr = $varNode->attributes->getNamedItem('name'); if (!$nameAttr) { continue; } $name = $nameAttr->value; if ($name && $providerData->{$name}) { $varNode->textContent = $providerData->{$name}; $varNode->appendChild($xsl->createTextNode($providerData->{$name})); KalturaLog::debug("Set variable [{$name}] to [{$providerData->{$name}}]"); } } $proc = new XSLTProcessor(); $proc->registerPHPFunctions(); $proc->importStyleSheet($xsl); $xml = $proc->transformToDoc($xml); if (!$xml) { KalturaLog::err("XML Transformation failed"); return null; } // TODO create validation XSD $xsdPath = realpath(dirname(__FILE__) . '/../') . '/xml/submit.xsd'; if (file_exists($xsdPath) && !$xml->schemaValidate($xsdPath)) { KalturaLog::err("Schema validation failed"); return null; } return $xml; }
public function addItemXml($xml) { $tempDoc = new KDOMDocument('1.0', 'UTF-8'); $tempDoc->loadXML($xml); $importedItem = $this->doc->importNode($tempDoc->firstChild, true); $channelNode = $this->xpath->query('/rss/channel')->item(0); $channelNode->appendChild($importedItem); }
/** * @param KalturaDistributionJobData $data * @param KalturaExampleDistributionProfile $distributionProfile * @param KalturaExampleDistributionJobProviderData $providerData */ protected function handleUpdate(KalturaDistributionJobData $data, KalturaExampleDistributionProfile $distributionProfile, KalturaExampleDistributionJobProviderData $providerData) { $entryId = $data->entryDistribution->entryId; $partnerId = $distributionProfile->partnerId; $entry = $this->getEntry($partnerId, $entryId); $feed = new KDOMDocument(); $feed->load($this->updateXmlTemplate); $feed->documentElement->setAttribute('mediaId', $data->remoteId); $nodes = array('title' => 'name', 'description' => 'description', 'width' => 'width', 'height' => 'height'); foreach ($nodes as $nodeName => $entryAttribute) { $nodeElements = $feed->getElementsByTagName($nodeName); foreach ($nodeElements as $nodeElement) { $nodeElement->textContent = $entry->{$entryAttribute}; } } // get the first asset id $thumbAssetIds = explode(',', $data->entryDistribution->thumbAssetIds); $thumbAssetId = reset($thumbAssetIds); $thumbElements = $feed->getElementsByTagName('thumb'); $thumbElement = reset($thumbElements); $thumbElement->textContent = $this->getThumbAssetUrl($thumbAssetId); $videosElements = $feed->getElementsByTagName('videos'); $videosElement = reset($videosElements); $flavorAssets = $this->getFlavorAssets($partnerId, $data->entryDistribution->flavorAssetIds); KBatchBase::impersonate($partnerId); foreach ($flavorAssets as $flavorAsset) { $url = $this->getFlavorAssetUrl($flavorAsset->id); $videoElement = $feed->createElement('video'); $videoElement->textContent = $url; $videosElement->appendChild($videoElement); } KBatchBase::unimpersonate(); $localFile = tempnam(sys_get_temp_dir(), 'example-update-'); $feed->save($localFile); // loads ftp manager $engineOptions = isset(KBatchBase::$taskConfig->engineOptions) ? KBatchBase::$taskConfig->engineOptions->toArray() : array(); $ftpManager = kFileTransferMgr::getInstance(kFileTransferMgrType::FTP, $engineOptions); $ftpManager->login(self::FTP_SERVER_URL, $distributionProfile->username, $distributionProfile->password); // put the XML file on the FTP $remoteFile = $entryId . '.xml'; $ftpManager->putFile($remoteFile, $localFile); return true; }
public function getContent($content) { $xml = new KDOMDocument(); try { $xml->loadXML($content); } catch (Exception $e) { KalturaLog::err($e->getMessage()); return null; } return trim(preg_replace('/\\s+/', ' ', $xml->textContent)); }
/** * Transform Xml file with conversion profile xsl * If xsl is not found, original Xml returned * @param string $filePath the original xml that was taken from partner file path * @return string - transformed Xml */ protected function xslTransform($filePath) { $xdoc = file_get_contents($filePath); if (is_null($xdoc) || is_null($this->conversionProfileXsl)) { return $xdoc; } libxml_clear_errors(); $xml = new KDOMDocument(); if (!$xml->loadXML($xdoc)) { KalturaLog::debug("Could not load xml"); $errorMessage = kXml::getLibXmlErrorDescription($xdoc); throw new KalturaBatchException("Could not load xml [{$this->job->id}], {$errorMessage}", KalturaBatchJobAppErrors::BULK_VALIDATION_FAILED); } libxml_clear_errors(); $proc = new XSLTProcessor(); $proc->registerPHPFunctions(kXml::getXslEnabledPhpFunctions()); $xsl = new KDOMDocument(); if (!$xsl->loadXML($this->conversionProfileXsl)) { KalturaLog::debug("Could not load xsl" . $this->conversionProfileXsl); $errorMessage = kXml::getLibXmlErrorDescription($this->conversionProfileXsl); throw new KalturaBatchException("Could not load xsl [{$this->job->id}], {$errorMessage}", KalturaBatchJobAppErrors::BULK_VALIDATION_FAILED); } $proc->importStyleSheet($xsl); libxml_clear_errors(); $transformedXml = $proc->transformToXML($xml); if (!$transformedXml) { KalturaLog::debug("Could not transform xml" . $this->conversionProfileXsl); $errorMessage = kXml::getLibXmlErrorDescription($this->conversionProfileXsl); throw new KalturaBatchException("Could not transform xml [{$this->job->id}], {$errorMessage}", KalturaBatchJobAppErrors::BULK_VALIDATION_FAILED); } return $transformedXml; }
public function handle() { $this->tempDirectory = sys_get_temp_dir(); if (!is_dir($this->tempDirectory)) { KalturaLog::err('Missing temporary directory'); return false; } // check prerequisites $checkConfig = $this->checkConfig(); if (!$checkConfig) { KalturaLog::err('Missing required configurations'); return false; } $this->fileTransferMgr = DropFolderBatchUtils::getFileTransferManager($this->dropFolder); if (!$this->fileTransferMgr) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::INTERNAL_ERROR; $this->dropFolderFile->errorDescription = 'Internal server error - cannot initiate file transfer manager'; KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $xmlPath = $this->getLocalXmlFilePath(); if (!$xmlPath) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::ERROR_READING_FILE; $this->dropFolderFile->errorDescription = 'Cannot read file at path [' . $this->dropFolder->path . '/' . $this->dropFolderFile->fileName . ']'; KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $xmlDoc = new KDOMDocument(); $xmlDoc->load($xmlPath); if (!$xmlDoc) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::ERROR_READING_FILE; $this->dropFolderFile->errorDescription = "Cannot parse XML file at [{$xmlPath}]"; KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $localResources = $xmlDoc->getElementsByTagName(self::DROP_FOLDER_RESOURCE_NODE_NAME); if (!$localResources) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::ERROR_READING_FILE; $this->dropFolderFile->errorDescription = "Cannot parse XML file at [{$xmlPath}]"; KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $replaceResources = array(); $localResourcesLength = $localResources->length; foreach ($localResources as $local) { // already have drop folder file id if (!is_null($this->getDropFolderFileId($local))) { continue; } // replacement/modification of $local must not happen inside this foreach loop $dropFolderFileId = $this->checkFileExists($local); if (is_null($dropFolderFileId)) { KalturaLog::debug('Some required files do not exist in the drop folder - changing status to WAITING'); $this->dropFolderFile->status = KalturaDropFolderFileStatus::WAITING; KalturaLog::debug('Changing status to WAITING'); $this->updateDropFolderFile(); return false; } $localVerified = $this->verifyLocalResource($local); if (!$localVerified) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; // error code and description already set KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $replaceResources[] = array($local, $dropFolderFileId); } foreach ($replaceResources as $replace) { $this->replaceResource($replace[0], $replace[1], $xmlDoc); } // create a temporary XML file from the modified $xmlDoc $tempFile = $this->tempDirectory . DIRECTORY_SEPARATOR . uniqid() . '_' . $this->dropFolderFile->fileName; $xmlDoc->save($tempFile); $tempFileRealPath = realpath($tempFile); if (!$tempFileRealPath || !is_file($tempFileRealPath)) { $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::ERROR_WRITING_TEMP_FILE; $this->dropFolderFile->errorDescription = "Error writing temporary file [{$tempFileRealPath}]"; KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); return false; } $conversionProfile = $this->getConversionProfile(); // add bulk upload of type KalturaBulkUploadType::DROP_FOLDER_XML try { $this->impersonate($this->dropFolderFile->partnerId); $this->kClient->bulkUpload->add($conversionProfile->id, $tempFileRealPath, KalturaBulkUploadType::DROP_FOLDER_XML, $this->uploadedBy, $this->dropFolderFile->fileName); $this->unimpersonate(); } catch (Exception $e) { $this->unimpersonate(); $this->dropFolderFile->status = KalturaDropFolderFileStatus::ERROR_HANDLING; $this->dropFolderFile->errorCode = KalturaDropFolderFileErrorCode::ERROR_ADDING_BULK_UPLOAD; $this->dropFolderFile->errorDescription = 'Error adding bulk upload - ' . $e->getMessage(); KalturaLog::err($this->dropFolderFile->errorDescription); $this->updateDropFolderFile(); KalturaLog::err($this->dropFolderFile->errorDescription); return false; } //delete the temporary file @unlink($tempFileRealPath); $dropFolderFilePlugin = KalturaDropFolderClientPlugin::get($this->kClient); $dropFolderFilePlugin->dropFolderFile->updateStatus($this->dropFolderFile->id, KalturaDropFolderFileStatus::HANDLED); KalturaLog::debug('Drop folder file [' . $this->dropFolderFile->id . '] handled successfully'); return true; // file handled }