private static function initMetadata()
{
if (self::$modules == null) {
$meta = new Metadata();
self::$modules = $meta->getModules();
}
}
/**
* Register snapshot of entity data, for tracking changes
*
* @param \Magento\Framework\DataObject $entity
* @return void
* @SuppressWarnings(PHPMD.UnusedLocalVariable)
*/
public function registerSnapshot(\Magento\Framework\DataObject $entity)
{
$metaData = $this->metadata->getFields($entity);
$filteredData = array_intersect_key($entity->getData(), $metaData);
$data = array_merge($metaData, $filteredData);
$this->snapshotData[get_class($entity)][$entity->getId()] = $data;
}
/**
* Bearbeiten eines Dokuments (metadaten)
*
* @param string $id
* @return \yii\web\View
* @author KAS <*****@*****.**> 06.08.2015
*/
public function actionEdit($id = NULL)
{
Yii::$app->view->params['headline'] = 'Dokument bearbeiten';
// Wir laden das gewählte Document
$model = Documents::findOne(new \MongoId($id));
// Wir machen aus dem Array ein Object ---------------------------------
#$model->metadata = new Metadata($model->metadata);
// Nur wenn auch ein POST gesendet wurde -------------------------------
if (\Yii::$app->request->isPost) {
$post = \Yii::$app->request->post();
$meta = new Metadata($post['Documents']['metadata']);
// Hier werden die Daten für Mongo angepasst(convertiert) ----------
$meta->load($post['Documents']['metadata']);
//------------------------------------------------------------------
// wir belassen die originalen Metadaten
$model->metadata = $model->metadata->toArray();
// Änderungen werden in metadatanew abgelegt
$model->metadatanew = $meta->toArray();
#var_dump($model);
// Speichern der Daten
$model->update();
// daten refreshen und neu zuordnen --------------------------------
$model->refresh();
$model->metadata = new Metadata($model->metadata);
}
//----------------------------------------------------------------------
// Wenn bereits neue Daten vorhanden sind,
// laden wir diese für die Anzeige
if ($model->metadatanew !== NULL) {
#$model->metadata = new Metadata($model->metadatanew);
}
return $this->render('edit', ['model' => $model]);
}
public function getMetadata($className)
{
$metadata = new Metadata();
$columns = $fieldsMetadata = array();
foreach ($this->getDrivers() as $driver) {
$columns = array_merge($columns, $driver->getClassColumns($className));
$fieldsMetadata[] = $driver->getFieldsMetadata($className);
}
$mappings = $cols = array();
foreach ($columns as $fieldName) {
$map = array();
foreach ($fieldsMetadata as $field) {
if (isset($field[$fieldName])) {
$map = array_merge($map, $field[$fieldName]);
}
}
if (!empty($map)) {
$mappings[$fieldName] = $map;
$cols[] = $fieldName;
}
}
$metadata->setFields($cols);
$metadata->setFieldsMappings($mappings);
return $metadata;
}
/**
* @test
*/
public function shouldBeAbleToCreateMetadata()
{
// given
$m = new Metadata('White');
// then
$this->assertNotNull($m->getId());
}
public function getMetadata($className, $group = 'default')
{
$metadata = new Metadata();
$columns = $fieldsMetadata = $groupBy = array();
foreach ($this->getDrivers() as $driver) {
$columns = array_merge($columns, $driver->getClassColumns($className, $group));
$fieldsMetadata[] = $driver->getFieldsMetadata($className, $group);
$groupBy = array_merge($groupBy, $driver->getGroupBy($className, $group));
}
$mappings = $cols = array();
foreach ($columns as $fieldName) {
$map = array();
foreach ($fieldsMetadata as $field) {
if (isset($field[$fieldName]) && (!isset($field[$fieldName]['groups']) || in_array($group, (array) $field[$fieldName]['groups']))) {
$map = array_merge($map, $field[$fieldName]);
}
}
if (!empty($map)) {
$mappings[$fieldName] = $map;
$cols[] = $fieldName;
}
}
$metadata->setFields($cols);
$metadata->setFieldsMappings($mappings);
$metadata->setGroupBy($groupBy);
return $metadata;
}
/**
* @param Metadata $metadata
*/
protected function metadataDeleted(Metadata $metadata)
{
$this->syncableDeleted($metadata->getId(), FileSyncObjectType::METADATA);
// updated in the indexing server (sphinx)
$object = kMetadataManager::getObjectFromPeer($metadata);
if ($object && $object instanceof IIndexable) {
kEventsManager::raiseEvent(new kObjectUpdatedEvent($object));
}
}
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);
}
}
}
function __set($property, $value)
{
$ipn = '_' . $property;
if (in_array($property, array('Cal', 'Image', 'Activated'))) {
if ($property == 'Activated') {
$value2 = $value;
$value = (int) (bool) $value;
}
if ($value != @$this->{$ipn} && ($value || @$this->{$ipn})) {
if (@$this->{$ipn} !== false && $this->mayI(EDIT)) {
if (!$this->mayI(EDIT)) {
return false;
}
if ($property == 'Activated') {
if (!$this->mayI(PUBLISH)) {
return false;
}
} elseif ($property == 'Cal') {
$this->registerUpdate();
if (is_object($value)) {
$this->_Cal = $value;
$value = $value->ID;
}
}
Metadata::set($property, $value);
}
}
$this->{$ipn} = $property == 'Activated' && $value2 == '' ? $value2 : $value;
} elseif ($property == 'Publish') {
$this->setActive($value);
} else {
parent::__set($property, $value);
}
}
function testGetAudioMetadata()
{
$filePath = dirname(__FILE__) . "/ex1.mp3";
$metadata = Metadata::LoadFromFile($filePath);
if ($metadata["dc:description"] != "Tmu sem tam videla ..." || $metadata["audio"]["dataformat"] != "mp3" || $metadata["dc:type"] != "Speech") {
$str = " [dc:description] = " . $metadata["dc:description"] . "\n" . " [audio][dataformat] = " . $metadata["audio"]["dataformat"] . "\n" . " [dc:type] = " . $metadata["dc:type"] . "\n";
$this->fail("Metadata has unexpected values:\n" . $str);
}
//var_dump($metadata);
//$this->assertTrue(FALSE);
}
public function index()
{
if (Input::method() == 'POST') {
if (Metadata::update()) {
return Response::redirect($this->admin_url . '/metadata');
}
}
// provide a list to set for our home page and posts page
$pages = Pages::list_all(array('status' => 'published'));
Template::render('metadata/index', array('pages' => $pages, 'metadata' => (object) Config::get('metadata')));
}
public static function get_roles_for($user)
{
$res = Metadata::get("{$user}", "has.%");
if (!$res) {
return null;
}
$roles = array();
foreach ($res as $val) {
$roles[] = $val["{$user}"];
}
return $roles;
}
public function testMultiple()
{
$metadata = new Metadata();
$metadata->set('a', array('A'));
$metadata->set('b', array('B', 'BB', 'BBB'));
$this->assertCount(1, $metadata->getList('a'));
$this->assertEquals('A', $metadata->get('a'));
$this->assertCount(3, $b = $metadata->getList('b'));
$this->assertEquals(array('B', 'BB', 'BBB'), $b);
$this->assertEquals('B', $metadata->get('b'));
}
/**
* Gets all relations of the query.
*
* @return array
*/
public function getRelations()
{
$relations = [];
foreach ($this->relations as $name => $constraints) {
if (strpos($name, '.') === false) {
$mapping = $this->metadata->getRelationMapping($name);
$query = $this->manager->getRepository($mapping['targetEntity'])->query();
if ($nested = $this->getNestedRelations($name)) {
$query->related($nested);
}
call_user_func($constraints, $query);
$relations[$name] = $query;
}
}
return $relations;
}
/**
* @param Metadata $metadata
* @param SimpleXMLElement $mrss
* @return SimpleXMLElement
*/
public function contributeMetadata(Metadata $metadata, SimpleXMLElement $mrss)
{
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xml = kFileSyncUtils::file_get_contents($key, true, false);
$metadataXml = new SimpleXMLElement($xml);
$customData = $mrss->addChild('customData');
$customData->addAttribute('metadataId', $metadata->getId());
$customData->addAttribute('metadataVersion', $metadata->getVersion());
$customData->addAttribute('metadataProfileId', $metadata->getMetadataProfileId());
$customData->addAttribute('metadataProfileVersion', $metadata->getMetadataProfileVersion());
$this->contributeMetadataObject($customData, $metadataXml);
}
/**
* @param Metadata $metadata
* @param SimpleXMLElement $mrss
* @param kMrssParameters $mrssParams
* @return SimpleXMLElement
*/
public function contributeMetadata(Metadata $metadata, SimpleXMLElement $mrss, kMrssParameters $mrssParams = null)
{
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xml = kFileSyncUtils::file_get_contents($key, true, false);
if (is_null($xml)) {
KalturaLog::alert("ready file sync was not found for key[{$key}]");
return;
}
$metadataXml = new SimpleXMLElement($xml);
$customData = $mrss->addChild('customData');
$customData->addAttribute('metadataId', $metadata->getId());
$customData->addAttribute('metadataVersion', $metadata->getVersion());
$customData->addAttribute('metadataProfileId', $metadata->getMetadataProfileId());
$customData->addAttribute('metadataProfileVersion', $metadata->getMetadataProfileVersion());
$this->contributeMetadataObject($customData, $metadataXml, $mrssParams, '');
}
/**
* @param string $metabox_id
* @param Metadata $args
*/
public static function datepicker_field($metabox_id, Metadata $args)
{
$value = date('Y-m-d', strtotime(null != $args->get_value() ? $args->get_value() : 'mm/dd/yyyy'));
?>
<tr>
<td>
<p>
<label for="<?php
_e($metabox_id . '[' . $args->get_id() . ']', 'cwg-ps');
?>
">
<?php
_e($args->get_name(), 'cwg-ps');
?>
</label></p>
</td>
<td>
<p>
<input type="date" id="<?php
_e($args->get_id(), 'cwg-ps');
?>
"
class="regular-text"
name="<?php
_e($metabox_id . '[' . $args->get_id() . ']', 'cwg-ps');
?>
"
value="<?php
_e($value, 'cwg-ps');
?>
"/></p>
</td>
</tr>
<?php
}
public function toArray()
{
return parent::toArray() + array('minlatitude' => isset($this->minlatitude) ? floatval($this->minlatitude) : null, 'maxlatitude' => isset($this->maxlatitude) ? floatval($this->maxlatitude) : null, 'minlongitude' => isset($this->minlongitude) ? floatval($this->minlongitude) : null, 'maxlongitude' => isset($this->maxlongitude) ? floatval($this->maxlongitude) : null, 'uiminlatitude' => isset($this->uiminlatitude) ? floatval($this->uiminlatitude) : null, 'uimaxlatitude' => isset($this->uimaxlatitude) ? floatval($this->uimaxlatitude) : null, 'uiminlongitude' => isset($this->uiminlongitude) ? floatval($this->uiminlongitude) : null, 'uimaxlongitude' => isset($this->uimaxlongitude) ? floatval($this->uimaxlongitude) : null, 'gridspacing' => isset($this->gridspacing) ? floatval($this->gridspacing) : null);
}
/**
* Get saved values
*
* @param mixed $entity
* @return array
*/
public function getSavedValues($entity)
{
$metadata = Metadata::getMetadata($this->entity);
if ($this->isMapped($entity)) {
$data = $metadata->getValues($entity, FALSE);
$data = array_diff($data, $this->originalData[spl_object_hash($entity)]);
} else {
$data = $metadata->getValues($entity);
}
$ref = new \Nette\Reflection\PropertyReflection($this->entity, '_associations');
$ref->setAccessible(TRUE);
$associationsData = $ref->getValue($entity);
$ref->setAccessible(FALSE);
foreach (array_merge($metadata->oneToOne, $metadata->manyToOne) as $association) {
if ($association instanceof Associations\OneToOne && !empty($association->mapped)) {
continue;
}
if (!$associationsData[$association->name] instanceof Associations\LazyLoad) {
$original = $this->em->associationsMap->find($this->entity, $association->name, $metadata->getPrimaryKeyValue($entity));
if (empty($associationsData[$association->name]) && !empty($original)) {
$data[$association->sourceColumn] = NULL;
} else {
$targetMetadata = Metadata::getMetadata(get_class($associationsData[$association->name]));
$now = $targetMetadata->getPrimaryKeyValue($associationsData[$association->name]);
if ($original != $now) {
$data[$association->sourceColumn] = $now;
}
}
}
}
return $data;
}
public function test_get_returnsSameInstance()
{
$this->assertSame($this->subject, Metadata::get('Mismatch\\Metadata\\Mock'));
}
public function getMetadataKey()
{
$m = new Metadata($this->getMetadataId());
return $m->getMetadataKey();
}
/**
* This function takes a list of metadata values and synchronises
* those values into the values that already exist for the field by
* adding new values and disabling values that aren't in the new
* list.
*
* XXX: Scalability: This function
*/
function synchroniseMetadata($oField, $aNewMetadata)
{
$iFieldId = KTUtil::getId($oField);
$aCurrentAllValues = Metadata::getValuesByDocumentField($iFieldId);
$aCurrentEnabledValues = Metadata::getEnabledValuesByDocumentField($iFieldId);
$aCurrentDisabledValues = Metadata::getDisabledValuesByDocumentField($iFieldId);
$aToBeAddedValues = array_diff($aNewMetadata, $aCurrentAllValues);
$aToBeDisabledValues = array_diff($aCurrentEnabledValues, $aNewMetadata);
$aToBeEnabledValues = array_intersect($aCurrentDisabledValues, $aNewMetadata);
foreach ($aToBeAddedValues as $sValue) {
$oMetadata =& Metadata::createFromArray(array('name' => $sValue, 'docfieldid' => $iFieldId));
}
foreach ($aToBeDisabledValues as $sValue) {
$oMetadata =& Metadata::getByValueAndDocumentField($sValue, $iFieldId);
if (PEAR::isError($oMetadata)) {
var_dump($aToBeDisabledValues);
var_dump($sValue);
var_dump($iFieldId);
var_dump($oMetadata);
exit(0);
}
if (!$oMetadata->getIsStuck()) {
$oMetadata->updateFromArray(array('disabled' => true));
}
}
foreach ($aToBeEnabledValues as $sValue) {
$oMetadata =& Metadata::getByValueAndDocumentField($sValue, $iFieldId);
if (!$oMetadata->getIsStuck()) {
$oMetadata->updateFromArray(array('disabled' => 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;
}
/**
* @param Metadata $metadata
* @return int affected records
*/
protected function deleteOldVersions(Metadata $metadata)
{
$c = new Criteria();
$c->add(MetadataPeer::OBJECT_ID, $metadata->getObjectId());
$c->add(MetadataPeer::OBJECT_TYPE, $metadata->getObjectType());
$c->add(MetadataPeer::METADATA_PROFILE_ID, $metadata->getMetadataProfileId());
$c->add(MetadataPeer::METADATA_PROFILE_VERSION, $metadata->getMetadataProfileVersion(), Criteria::LESS_THAN);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED, Criteria::NOT_EQUAL);
MetadataPeer::setUseCriteriaFilter(false);
$metadatas = MetadataPeer::doSelect($c);
MetadataPeer::setUseCriteriaFilter(true);
foreach ($metadatas as $metadata) {
kEventsManager::raiseEvent(new kObjectDeletedEvent($metadata));
}
$update = new Criteria();
$update->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED);
$con = Propel::getConnection(MetadataPeer::DATABASE_NAME);
$count = BasePeer::doUpdate($c, $update, $con);
return $count;
}
/*
STEATITE - Pictures archive for qualitative analysis
Copyright (C) 2010-2012 Aurelien Benel
OFFICIAL WEB SITE
http://www.hypertopic.org/
LEGAL ISSUES
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Affero General Public License as published by the Free
Software Foundation.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU Affero General Public License for more details:
http://www.gnu.org/licenses/agpl.html
*/
include '../lib/Mustache.php';
include '../metadata.php';
$db = new PDO('sqlite:../attribute/database');
$query = $db->prepare("SELECT attribute_value FROM attributes " . "WHERE source_id=? AND attribute_name='name'");
$query->execute(array($_GET['item']));
$result = $query->fetch();
preg_match('#(.+)/item/#', $_SERVER['REQUEST_URI'], $path);
$source = "../picture/" . $_GET['item'];
$metadata = Metadata::getMetadata($source);
$data = array('corpus' => $_GET['corpus'], 'item' => $_GET['item'], 'service' => 'http://' . $_SERVER['HTTP_HOST'] . $path[1], 'name' => $result[0], 'created' => $metadata['created'], 'spatial' => $metadata['spatial']);
$renderer = new Mustache();
header('content-type: application/json');
echo $renderer->render(file_get_contents('../view/item.json'), $data);
?> /assets/css/phpTesla.css" /> <link rel="stylesheet" href="/assets/css/icomoon.css" /> <?php /* <script src="<?php echo CDN; ?>/js/modernizr.js"></script> <link rel="stylesheet" href="<?php echo CDN; ?>/assets/css/flexslider.css" type="text/css" media="screen" /> */ ?> <!-- Mobile Specific Metas --> <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <?php echo Metadata::header(); ?> </head> <body> <div id="header-bar"> <div class="container-wrap"><div class="container-inner"> <div class="left"> <ul class="menu-nav"> <!-- <li><a href="/">Single Slot</a></li> --> <li> <span class="menu-nav-top">Main</span> <ul> <li><a href="/tutorial">Intro & Tutorial</a></li> <li><a href="/mechanics">Core Mechanics</a></li>
/**
* Responds to file move events so that we can rename applicable metadata paths
*
* @param string $old The starting path name
* @param string $new The ending path name
* @return bool
**/
public function onFileMove($old, $new)
{
return Metadata::relocateByPath($old, $new);
}
public static function parseXml($objectType, SimpleXMLElement $scene, $partnerId, CuePoint $cuePoint)
{
$metadataElements = $scene->xpath('scene-customData');
if (!count($metadataElements)) {
return $cuePoint;
}
foreach ($metadataElements as $metadataElement) {
$metadata = null;
$metadataProfile = null;
if (isset($metadataElement['metadataId'])) {
$metadata = MetadataPeer::retrieveByPK($metadataElement['metadataId']);
}
if ($metadata) {
$metadataProfile = $metadata->getMetadataProfile();
} else {
if (isset($metadataElement['metadataProfileId'])) {
$metadataProfile = MetadataProfilePeer::retrieveByPK($metadataElement['metadataProfileId']);
} elseif (isset($metadataElement['metadataProfile'])) {
$metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataElement['metadataProfile']);
}
if ($metadataProfile) {
$metadata = MetadataPeer::retrieveByObject($metadataProfile->getId(), $objectType, $cuePoint->getId());
}
}
if (!$metadataProfile) {
continue;
}
if (!$metadata) {
$metadata = new Metadata();
$metadata->setPartnerId($partnerId);
$metadata->setMetadataProfileId($metadataProfile->getId());
$metadata->setMetadataProfileVersion($metadataProfile->getVersion());
$metadata->setObjectType($objectType);
$metadata->setObjectId($cuePoint->getId());
$metadata->setStatus(KalturaMetadataStatus::VALID);
foreach ($metadataElement->children() as $metadataContent) {
$xmlData = $metadataContent->asXML();
$errorMessage = '';
if (kMetadataManager::validateMetadata($metadataProfile->getId(), $xmlData, $errorMessage)) {
$metadata->save();
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($metadata));
}
break;
}
}
}
return $cuePoint;
}
/**
* Adds an object to the instance pool.
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database. In some cases -- especially when you override doSelect*()
* methods in your stub classes -- you may need to explicitly add objects
* to the cache in order to ensure that the same objects are always returned by doSelect*()
* and retrieveByPK*() calls.
*
* @param Metadata $value A Metadata object.
* @param string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
*/
public static function addInstanceToPool(Metadata $obj, $key = null)
{
if (Propel::isInstancePoolingEnabled()) {
if ($key === null) {
$key = (string) $obj->getId();
}
if (isset(self::$instances[$key]) || count(self::$instances) < kConf::get('max_num_instances_in_pool')) {
self::$instances[$key] = $obj;
kMemoryManager::registerPeer('MetadataPeer');
}
}
}
public static function assetTreeReportPageFieldValue(aohs\AssetOperationHandlerService $service, p\Child $child, $params = NULL, &$results = NULL)
{
if (!isset($params['field-value'])) {
throw new e\ReportException(S_SPAN . "The \$field-value array is not set. " . E_SPAN);
}
if (!isset($params['cache'])) {
throw new e\ReportException(S_SPAN . c\M::NULL_CACHE . E_SPAN);
}
$cache = $params['cache'];
$type = $child->getType();
// skip irrelevant children
if ($type != Page::TYPE && $type != Folder::TYPE) {
return;
}
$field_value = $params['field-value'];
if (!is_array($field_value)) {
throw new e\ReportException(S_SPAN . "The \$field-value array is not set. " . E_SPAN);
}
$count = count($field_value);
//if( self::DEBUG && self::DUMP ) { u\DebugUtility::dump( $field_value ); }
//if( self::DEBUG ) { u\DebugUtility::out( "Count: $count" ); }
if ($count == 0) {
return;
} else {
if ($count > 1) {
if (isset($params['disjunctive'])) {
$disjunctive = $params['disjunctive'];
} else {
$disjunctive = true;
}
}
}
$page = $cache->retrieveAsset($child);
$metadata = $page->getMetadata();
if ($count == 1) {
$identifier_value = $field_value[0];
$keys = array_keys($identifier_value);
$identifier = $keys[0];
$value = trim($identifier_value[$identifier]);
// wired fields
if (Metadata::isWiredField($identifier)) {
$method = Metadata::getWiredFieldMethodName($identifier);
//if( self::DEBUG ) { u\DebugUtility::out( "A wired field." ); }
//if( self::DEBUG ) { u\DebugUtility::out( $method ); }
if ($value == "") {
$value = NULL;
}
$text = $metadata->{$method}();
//if( self::DEBUG ) { u\DebugUtility::out( "Text: ". $text ); }
//if( self::DEBUG ) { u\DebugUtility::out( is_null( $metadata->$method() ) ? 'NULL' : ); }
if ($metadata->{$method}() == $value) {
if (self::DEBUG) {
u\DebugUtility::out("Found a page");
}
$results[Page::TYPE][] = $child->getPathPath();
return;
} else {
return;
}
} else {
if ($metadata->hasDynamicField($identifier)) {
//if( self::DEBUG ) { u\DebugUtility::out( "Dynamic field found" ); }
$values = $metadata->getDynamicFieldValues($identifier);
if ($value == "") {
// this is not necessary
$value = NULL;
}
if (in_array($value, $values)) {
$results[Page::TYPE][] = $child->getPathPath();
return;
} else {
return;
}
} else {
return;
}
}
} else {
//if( self::DEBUG ) { u\DebugUtility::out( "Count more than 1" ); }
if ($disjunctive) {
// pass any test
foreach ($field_value as $field_value_pair) {
if (self::DEBUG && self::DUMP) {
u\DebugUtility::dump($field_value_pair);
}
$keys = array_keys($field_value_pair);
$identifier = $keys[0];
$value = trim($field_value_pair[$identifier]);
// wired fields
if (Metadata::isWiredField($identifier)) {
$method = Metadata::getWiredFieldMethodName($identifier);
if ($metadata->{$method}() == $value) {
$results[Page::TYPE][] = $child->getPathPath();
return;
} else {
continue;
}
} else {
if ($metadata->hasDynamicField($identifier)) {
$values = $metadata->getDynamicFieldValues($identifier);
if (in_array($value, $values)) {
$results[Page::TYPE][] = $child->getPathPath();
return;
} else {
continue;
}
} else {
return;
}
}
}
} else {
//if( self::DEBUG ) { u\DebugUtility::out( "Conjunctive" ); }
//if( self::DEBUG && self::DUMP ) { u\DebugUtility::dump( $field_value ); }
// must pass all the tests
foreach ($field_value as $field_value_pair) {
//if( self::DEBUG && self::DUMP ) { u\DebugUtility::dump( $field_value_pair ); }
$keys = array_keys($field_value_pair);
$identifier = $keys[0];
$value = trim($field_value_pair[$identifier]);
//if( self::DEBUG ) { u\DebugUtility::out( "Identifier: $identifier" ); }
//if( self::DEBUG ) { u\DebugUtility::out( "Value: $value" ); }
// wired fields
if (Metadata::isWiredField($identifier)) {
$method = Metadata::getWiredFieldMethodName($identifier);
if ($metadata->{$method}() == $value) {
continue;
} else {
return;
}
} else {
if ($metadata->hasDynamicField($identifier)) {
$values = $metadata->getDynamicFieldValues($identifier);
if (in_array($value, $values)) {
continue;
} else {
return;
}
} else {
return;
}
}
}
$results[Page::TYPE][] = $child->getPathPath();
}
}
}
