/**
* List metadata profile fields by metadata profile id
*
* @action listFields
* @param int $metadataProfileId
* @return KalturaMetadataProfileFieldListResponse
*/
function listFieldsAction($metadataProfileId)
{
$dbFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($metadataProfileId);
$response = new KalturaMetadataProfileFieldListResponse();
$response->objects = KalturaMetadataProfileFieldArray::fromMetadataProfileFieldArray($dbFields);
$response->totalCount = count($dbFields);
return $response;
}
/**
* @param int $partnerId
* @param PropelPDO $con the connection to use
* @return array<string> keys
*/
public static function retrievePartnerKeys($partnerId, PropelPDO $con = null)
{
$criteria = new Criteria();
$criteria->addSelectColumn(MetadataProfileFieldPeer::KEY);
$criteria->add(MetadataProfileFieldPeer::PARTNER_ID, $partnerId);
$criteria->add(MetadataProfileFieldPeer::STATUS, MetadataProfileField::STATUS_ACTIVE);
$stmt = MetadataProfileFieldPeer::doSelectStmt($criteria, $con);
return $stmt->fetchAll(PDO::FETCH_COLUMN);
}
public function doGetCondition($xPaths = null)
{
if ($this->condition) {
return $this->condition;
}
if (is_null($xPaths)) {
$xPaths = array();
$profileFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($this->metadataProfileId);
foreach ($profileFields as $profileField) {
$xPaths[$profileField->getXpath()] = $profileField->getId();
}
}
$conditions = array();
$pluginName = MetadataPlugin::PLUGIN_NAME;
if (count($this->items)) {
foreach ($this->items as $item) {
$condition = null;
if ($item instanceof AdvancedSearchFilterCondition) {
$field = $item->getField();
if (isset($xPaths[$field])) {
$value = $item->getValue();
$value = SphinxUtils::escapeString($value);
$fieldId = $xPaths[$field];
$condition = "\"{$pluginName}_{$fieldId} {$value} " . kMetadataManager::SEARCH_TEXT_SUFFIX . "\"";
}
} elseif ($item instanceof MetadataSearchFilter) {
$condition = $item->doGetCondition($xPaths);
}
KalturaLog::debug("Append item [" . get_class($item) . "] condition [{$condition}]");
if ($condition) {
$conditions[] = "({$condition})";
}
}
}
if (!count($conditions)) {
return null;
}
$glue = $this->type == MetadataSearchFilter::SEARCH_AND ? ' & ' : ' | ';
$this->condition = implode($glue, $conditions);
return $this->condition;
}
/**
* @param int $fromPartnerId
* @param int $toPartnerId
*/
protected function copyMetadataProfiles($fromPartnerId, $toPartnerId)
{
KalturaLog::debug("Copy metadata profiles from [{$fromPartnerId}] to [{$toPartnerId}]");
$c = new Criteria();
$c->add(MetadataProfilePeer::PARTNER_ID, $fromPartnerId);
$metadataProfiles = MetadataProfilePeer::doSelect($c);
foreach ($metadataProfiles as $metadataProfile) {
$newMetadataProfile = $metadataProfile->copy();
$newMetadataProfile->setPartnerId($toPartnerId);
$newMetadataProfile->save();
kFileSyncUtils::createSyncFileLinkForKey($newMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION), $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION), false);
kFileSyncUtils::createSyncFileLinkForKey($newMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS), $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS), false);
$metadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfile->getId());
foreach ($metadataProfileFields as $metadataProfileField) {
$newMetadataProfileField = $metadataProfileField->copy();
$newMetadataProfileField->setMetadataProfileId($newMetadataProfile->getId());
$newMetadataProfileField->setPartnerId($toPartnerId);
$newMetadataProfileField->save();
}
}
}
/**
* Delete an existing metadata profile
*
* @action delete
* @param int $id
* @throws MetadataErrors::METADATA_PROFILE_NOT_FOUND
*/
function deleteAction($id)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(MetadataErrors::METADATA_PROFILE_NOT_FOUND, $id);
}
// if this profile is a dynamic object, check for references in other profiles
if ($dbMetadataProfile->getObjectType() == MetadataObjectType::DYNAMIC_OBJECT) {
$referencedFields = MetadataProfileFieldPeer::retrieveByPartnerAndRelatedMetadataProfileId(kCurrentContext::getCurrentPartnerId(), $dbMetadataProfile->getId());
if (count($referencedFields)) {
/** @var MetadataProfileField $referencedField */
$referencedField = $referencedFields[0];
throw new KalturaAPIException(MetadataErrors::METADATA_PROFILE_REFERENCE_EXISTS, $referencedField->getMetadataProfileId(), $referencedField->getKey());
}
}
$dbMetadataProfile->setStatus(KalturaMetadataProfileStatus::DEPRECATED);
$dbMetadataProfile->save();
$c = new Criteria();
$c->add(MetadataProfileFieldPeer::METADATA_PROFILE_ID, $id);
$c->add(MetadataProfileFieldPeer::STATUS, MetadataProfileField::STATUS_DEPRECATED, Criteria::NOT_EQUAL);
$MetadataProfileFields = MetadataProfileFieldPeer::doSelect($c);
foreach ($MetadataProfileFields as $MetadataProfileField) {
$MetadataProfileField->setStatus(MetadataProfileField::STATUS_DEPRECATED);
$MetadataProfileField->save();
}
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $id);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED, Criteria::NOT_EQUAL);
$peer = null;
MetadataPeer::setUseCriteriaFilter(false);
$metadatas = MetadataPeer::doSelect($c);
foreach ($metadatas as $metadata) {
kEventsManager::raiseEvent(new kObjectDeletedEvent($metadata));
}
$update = new Criteria();
$update->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED);
$con = Propel::getConnection(MetadataPeer::DATABASE_NAME);
BasePeer::doUpdate($c, $update, $con);
}
public static function validateMetadataProfileField($partnerId, $xsdData, $isPath, $obejctType, $metadataProfileId = null)
{
$additionalSearchableFieldsCounter = 0;
$profileFields = MetadataProfileFieldPeer::retrieveIndexableByPartnerAndType($partnerId, $obejctType);
foreach ($profileFields as $profileField) {
if ($profileField->getMetadataProfileId() == $metadataProfileId) {
continue;
}
$type = $profileField->getType();
if ($type == MetadataSearchFilter::KMC_FIELD_TYPE_DATE || $type == MetadataSearchFilter::KMC_FIELD_TYPE_INT) {
$additionalSearchableFieldsCounter++;
}
}
$xPaths = kXsd::findXpathsByAppInfo($xsdData, kMetadataManager::APP_INFO_SEARCH, 'true', $isPath);
foreach ($xPaths as $xPath => $xPathData) {
if (isset($xPathData['type']) && ($xPathData['type'] == MetadataSearchFilter::KMC_FIELD_TYPE_DATE || $xPathData['type'] == MetadataSearchFilter::KMC_FIELD_TYPE_INT)) {
$additionalSearchableFieldsCounter++;
}
}
$partnerLimit = MetadataPlugin::getAdditionalSearchableFieldsLimit($partnerId, $obejctType);
if ($additionalSearchableFieldsCounter > $partnerLimit) {
throw new APIException(MetadataErrors::EXCEEDED_ADDITIONAL_SEARCHABLE_FIELDS_LIMIT, $partnerLimit);
}
}
/**
* Populates the object using an array.
*
* This is particularly useful when populating an object from one of the
* request arrays (e.g. $_POST). This method goes through the column
* names, checking to see whether a matching key exists in populated
* array. If so the setByName() method is called for that column.
*
* You can specify the key type of the array by additionally passing one
* of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
* BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
* The default key type is the column's phpname (e.g. 'AuthorId')
*
* @param array $arr An array to populate the object from.
* @param string $keyType The type of keys the array uses.
* @return void
*/
public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
{
$keys = MetadataProfileFieldPeer::getFieldNames($keyType);
if (array_key_exists($keys[0], $arr)) {
$this->setId($arr[$keys[0]]);
}
if (array_key_exists($keys[1], $arr)) {
$this->setCreatedAt($arr[$keys[1]]);
}
if (array_key_exists($keys[2], $arr)) {
$this->setUpdatedAt($arr[$keys[2]]);
}
if (array_key_exists($keys[3], $arr)) {
$this->setMetadataProfileId($arr[$keys[3]]);
}
if (array_key_exists($keys[4], $arr)) {
$this->setMetadataProfileVersion($arr[$keys[4]]);
}
if (array_key_exists($keys[5], $arr)) {
$this->setPartnerId($arr[$keys[5]]);
}
if (array_key_exists($keys[6], $arr)) {
$this->setLabel($arr[$keys[6]]);
}
if (array_key_exists($keys[7], $arr)) {
$this->setKey($arr[$keys[7]]);
}
if (array_key_exists($keys[8], $arr)) {
$this->setType($arr[$keys[8]]);
}
if (array_key_exists($keys[9], $arr)) {
$this->setXpath($arr[$keys[9]]);
}
if (array_key_exists($keys[10], $arr)) {
$this->setStatus($arr[$keys[10]]);
}
}
/**
* @param EntryDistribution $entryDistribution
* @param int $action enum from DistributionAction
* @param array $validationErrors
* @param bool $validateDescription
* @param bool $validateTags
* @return array
*/
public function validateMetadataForSubmission(EntryDistribution $entryDistribution, $action, array $validationErrors, &$validateDescription, &$validateTags)
{
$validateDescription = true;
$validateTags = true;
if (!class_exists('MetadataProfile')) {
return $validationErrors;
}
$metadataProfileId = $this->getMetadataProfileId();
if (!$metadataProfileId) {
return $validationErrors;
}
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, Metadata::TYPE_ENTRY, $entryDistribution->getEntryId());
if (!$metadata) {
return $validationErrors;
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_DESCRIPTION);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_DESCRIPTION);
if (count($values)) {
foreach ($values as $value) {
if (!strlen($value)) {
continue;
}
$validateDescription = false;
// validate entry description minumum length of 1 character
if (strlen($value) < self::ENTRY_DESCRIPTION_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'YouTube description is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// validate entry description maximum length of 60 characters
if (strlen($value) > self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'YouTube description is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
}
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_TAGS);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_TAGS);
if (count($values)) {
foreach ($values as $value) {
if (!strlen($value)) {
continue;
}
$validateTags = false;
// validate entry tags minumum length of 1 character
if (strlen($value) < self::ENTRY_TAGS_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'YouTube tags is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// validate entry tags maximum length of 60 characters
if (strlen($value) > self::ENTRY_TAGS_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'YouTube tags is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
}
}
return $validationErrors;
}
/**
* Retrieve multiple objects by pkey.
*
* @param array $pks List of primary keys
* @param PropelPDO $con the connection to use
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function retrieveByPKs($pks, PropelPDO $con = null)
{
$objs = null;
if (empty($pks)) {
$objs = array();
} else {
$criteria = new Criteria(MetadataProfileFieldPeer::DATABASE_NAME);
$criteria->add(MetadataProfileFieldPeer::ID, $pks, Criteria::IN);
$objs = MetadataProfileFieldPeer::doSelect($criteria, $con);
}
return $objs;
}
protected static function validateMetadataObjects($metadataProfileId, KDOMDocument $xml, &$errorMessage)
{
$profileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId);
$xPath = new DOMXPath($xml);
foreach ($profileFields as $profileField) {
/** @var MetadataProfileField $profileField */
if (!in_array($profileField->getType(), self::$metadataFieldTypesToValidate)) {
continue;
}
$objectPeer = self::getObjectPeerByFieldType($profileField->getType());
if (!$objectPeer) {
$errorMessage = "Peer not found for field of type " . $profileField->getType();
return false;
}
$objectIds = array();
$nodes = $xPath->query($profileField->getXpath());
foreach ($nodes as $node) {
$objectIds[] = $node->nodeValue;
}
$objectIds = array_unique($objectIds);
if (!$objectPeer->validateMetadataObjects($profileField, $objectIds, $errorMessage)) {
return false;
}
}
return true;
}
/**
* Parse the XML and update the list of search values
*
* @param Metadata $metadata
*
* @return array
*/
public static function getSearchValues(Metadata $metadata, $searchTexts = array())
{
KalturaLog::debug("Parsing metadata [" . $metadata->getId() . "] search values");
$key = $metadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
$xmlPath = kFileSyncUtils::getLocalFilePathForKey($key);
$xml = new DOMDocument();
$xml->load($xmlPath);
$xPath = new DOMXPath($xml);
$profileFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($metadata->getMetadataProfileId());
KalturaLog::debug("Metadata fields [" . count($profileFields) . "] found");
$searchItems = array();
$textItems = array();
foreach ($profileFields as $profileField) {
$nodes = $xPath->query($profileField->getXpath());
if (!$nodes->length) {
continue;
}
if ($profileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE) {
continue;
}
$searchItemValues = array();
foreach ($nodes as $node) {
$searchItemValues[] = $node->nodeValue;
}
if (!count($searchItemValues)) {
continue;
}
if ($profileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_TEXT) {
$textItem = implode(' ', $searchItemValues);
$textItems[] = $textItem;
if (iconv_strlen($textItem, 'UTF-8') < 128) {
$searchItems[$profileField->getId()] = $searchItemValues;
}
} else {
$searchItems[$profileField->getId()] = $searchItemValues;
}
}
foreach ($searchItems as $key => $searchItem) {
foreach ($searchItem as $searchPhrase) {
$searchTexts[] = MetadataPlugin::PLUGIN_NAME . '_' . "{$key} {$searchPhrase} " . kMetadataManager::SEARCH_TEXT_SUFFIX;
}
}
if (count($textItems)) {
if (!isset($searchTexts['text'])) {
$searchTexts['text'] = MetadataPlugin::PLUGIN_NAME . '_text';
}
$searchTexts['text'] .= ' ' . implode(' ', $textItems);
}
$searchTexts['text'] .= ' ' . kMetadataManager::SEARCH_TEXT_SUFFIX;
// KalturaLog::debug('Search Texts: ' . print_r($searchTexts, true));
$ret = array();
foreach ($searchTexts as $index => $value) {
if (is_int($index)) {
$ret[$index] = $value;
}
}
if (isset($searchTexts['text'])) {
$ret['text'] = $searchTexts['text'];
}
return $ret;
}
/**
* @param EntryDistribution $entryDistribution
* @param int $action enum from DistributionAction
* @param array $validationErrors
* @param bool $validateDescription
* @param bool $validateTags
* @return array
*/
public function validateMetadataForSubmission(EntryDistribution $entryDistribution, $action, array $validationErrors, &$validateDescription, &$validateTags)
{
$validateDescription = true;
$validateTags = true;
if (!class_exists('MetadataProfile')) {
return $validationErrors;
}
$metadataProfileId = $this->getMetadataProfileId();
if (!$metadataProfileId) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_CATEGORY);
if (!$metadataProfileCategoryField) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
$metadata = MetadataPeer::retrieveByObject($metadataProfileId, Metadata::TYPE_ENTRY, $entryDistribution->getEntryId());
if (!$metadata) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY);
return $validationErrors;
}
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_CATEGORY);
if (!count($values)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_CATEGORY, '');
}
foreach ($values as $value) {
if (!strlen($value)) {
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_CATEGORY, '');
return $validationErrors;
}
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_DESCRIPTION);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_DESCRIPTION);
if (count($values)) {
foreach ($values as $value) {
if (!strlen($value)) {
continue;
}
$validateDescription = false;
// validate entry description minumum length of 1 character
if (strlen($value) < self::ENTRY_DESCRIPTION_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'Dailymotion description is too short');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// validate entry description minumum length of 1 character
if (strlen($value) > self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_DESCRIPTION, 'Dailymotion description is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_DESCRIPTION_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
}
}
}
$metadataProfileCategoryField = MetadataProfileFieldPeer::retrieveByMetadataProfileAndKey($metadataProfileId, self::METADATA_FIELD_TAGS);
if ($metadataProfileCategoryField) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_TAGS);
if (count($values) && strlen(implode('', $values))) {
$tags = implode(',', $values);
$tags = explode(',', $tags);
$tagsStr = implode(' , ', $tags);
$validateTags = false;
if (strlen($tagsStr) > self::ENTRY_TAGS_MAXIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tags is too long');
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_TAGS_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (count($tags) < self::ENTRY_TAGS_MINIMUM_COUNT) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tags must contain at least ' . self::ENTRY_TAGS_MINIMUM_COUNT . ' tags');
$validationError->setValidationErrorType(DistributionValidationErrorType::CUSTOM_ERROR);
$validationError->setValidationErrorParam('Dailymotion tags must contain at least ' . self::ENTRY_TAGS_MINIMUM_COUNT . ' tags');
$validationErrors[] = $validationError;
}
foreach ($tags as $tag) {
if (strlen($tag) < self::ENTRY_TAG_MINIMUM_LENGTH) {
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TAGS, 'Dailymotion tag [$tag] must contain at least ' . self::ENTRY_TAG_MINIMUM_LENGTH . ' characters');
$validationError->setValidationErrorType(DistributionValidationErrorType::CUSTOM_ERROR);
$validationError->setValidationErrorParam('Dailymotion tag [$tag] must contain at least ' . self::ENTRY_TAG_MINIMUM_LENGTH . ' characters');
$validationErrors[] = $validationError;
}
}
}
}
return $validationErrors;
}
public function objectDataChanged(BaseObject $object, $previousVersion = null, BatchJob $raisedJob = null)
{
// updated in the indexing server (sphinx)
$relatedObject = kMetadataManager::getObjectFromPeer($object);
if ($relatedObject && $relatedObject instanceof IIndexable) {
$relatedObject->setUpdatedAt(time());
$relatedObject->save();
$relatedObject->indexToSearchIndex();
}
/** @var Metadata $object */
if ($object->getObjectType() == MetadataObjectType::DYNAMIC_OBJECT && !$object->isLikeNew()) {
/**
* when dynamic object is modified, we need to reindex the metadata and the objects (users, entries)
* that are referencing it
*/
$profileFields = MetadataProfileFieldPeer::retrieveByPartnerAndRelatedMetadataProfileId($object->getPartnerId(), $object->getMetadataProfileId());
$relatedMetadataProfiles = array();
foreach ($profileFields as $profileField) {
/** @var MetadataProfileField $profileField */
if (in_array($profileField->getMetadataProfileId(), $relatedMetadataProfiles)) {
continue;
}
$filter = new MetadataFilter();
$filter->set('_eq_metadata_profile_id', $profileField->getMetadataProfileId());
$indexObjectType = kPluginableEnumsManager::apiToCore('IndexObjectType', MetadataPlugin::getApiValue(MetadataIndexObjectType::METADATA));
kJobsManager::addIndexJob($object->getPartnerId(), $indexObjectType, $filter, true);
$relatedMetadataProfiles[] = $profileField->getMetadataProfileId();
}
}
if ($relatedObject instanceof entry) {
kStorageExporter::reExportEntry($relatedObject);
}
return true;
}
/**
* Builds a Criteria object containing the primary key for this object.
*
* Unlike buildCriteria() this method includes the primary key values regardless
* of whether or not they have been modified.
*
* @return Criteria The Criteria object containing value(s) for primary key(s).
*/
public function buildPkeyCriteria()
{
$criteria = new Criteria(MetadataProfileFieldPeer::DATABASE_NAME);
$criteria->add(MetadataProfileFieldPeer::ID, $this->id);
if ($this->alreadyInSave && count($this->modifiedColumns) == 2 && $this->isColumnModified(MetadataProfileFieldPeer::UPDATED_AT)) {
$theModifiedColumn = null;
foreach ($this->modifiedColumns as $modifiedColumn) {
if ($modifiedColumn != MetadataProfileFieldPeer::UPDATED_AT) {
$theModifiedColumn = $modifiedColumn;
}
}
$atomicColumns = MetadataProfileFieldPeer::getAtomicColumns();
if (in_array($theModifiedColumn, $atomicColumns)) {
$criteria->add($theModifiedColumn, $this->getByName($theModifiedColumn, BasePeer::TYPE_COLNAME), Criteria::NOT_EQUAL);
}
}
return $criteria;
}
/**
* Read multiple metadata schemas
* @param BaseObject $object
* @param array $data
*/
protected static function addMetadataWithProfilesSystemNames(BaseObject $object, array $data)
{
$newFieldValuesMap = array();
$xmlDataArray = array();
//Construct mapping of all metadata profile system names, their fields and the field values.
foreach ($data as $key => $value) {
if (strpos($key, self::BULK_UPLOAD_METADATA_FIELD_PREFIX) === 0) {
$prefix = null;
$metadataProfileSystemName = null;
$metadataProfileFieldName = null;
list($prefix, $metadataProfileSystemName, $metadataProfileFieldName) = explode(self::BULK_UPLOAD_METADATA_SYSTEMNAME_SEPARATOR, $key);
if (!$prefix || !$metadataProfileSystemName || !$metadataProfileFieldName) {
$errorMessage = "Unexpected key structure. Expected metadata::ProfileSystemName::FieldSystemName.";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
if (!isset($newFieldValuesMap[$metadataProfileSystemName])) {
$newFieldValuesMap[$metadataProfileSystemName] = array();
}
$newFieldValuesMap[$metadataProfileSystemName][$metadataProfileFieldName] = $value;
}
}
foreach ($newFieldValuesMap as $metadataProfileSystemName => $fieldsArray) {
/* @var array $fieldsArray */
if (!$fieldsArray || !count($fieldsArray)) {
continue;
}
$metadataProfile = MetadataProfilePeer::retrieveBySystemName($metadataProfileSystemName, $object->getPartnerId());
if (!$metadataProfile) {
$errorMessage = "Metadata profile with system name [{$metadataProfileSystemName}] could not be found.";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
if ($metadataProfile->getObjectType() != kMetadataManager::getTypeNameFromObject($object)) {
$errorMessage = "Metadata profile [{$metadataProfileSystemName}] object type [" . $metadataProfile->getObjectType() . "] is not compatible with object type [" . kMetadataManager::getTypeNameFromObject($object) . "]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileId = $metadataProfile->getId();
$xml = new DOMDocument();
$metadataProfileFields = array();
MetadataProfileFieldPeer::setUseCriteriaFilter(false);
$tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId);
MetadataProfileFieldPeer::setUseCriteriaFilter(true);
foreach ($tmpMetadataProfileFields as $metadataProfileField) {
/* @var $metadataProfileField MetadataProfileField */
$metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField;
}
foreach ($fieldsArray as $fieldSysName => $fieldValue) {
if (!isset($metadataProfileFields[$fieldSysName])) {
$errorMessage = "Metadata profile field with system name [{$fieldSysName}] missing from metadata profile with id [{$metadataProfileId}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileField = $metadataProfileFields[$fieldSysName];
KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$fieldValue}]");
$fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $fieldValue);
foreach ($fieldValues as $fieldSingleValue) {
if ($fieldSingleValue) {
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldSingleValue)) {
$valueAsDate = self::parseFormatedDate($fieldSingleValue);
if (!$valueAsDate || !strlen($valueAsDate)) {
$errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$fieldSingleValue = $valueAsDate;
}
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_INT && !is_numeric($fieldSingleValue)) {
$errorMessage = "Could not parse int format [{$fieldSingleValue}] for field [{$key}]";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
self::addXpath($xml, $metadataProfileField->getXpath(), $fieldSingleValue);
}
}
$dataFound = true;
if ($dataFound && $xml->hasChildNodes()) {
$xmlDataArray[$metadataProfileId] = $xml->saveXML($xml->firstChild);
$xmlDataArray[$metadataProfileId] = trim($xmlDataArray[$metadataProfileId], " \n\r\t");
}
}
}
foreach ($xmlDataArray as $metadataProfileId => $xmlData) {
$errorMessage = '';
if (!kMetadataManager::validateMetadata($metadataProfileId, $xmlData, $errorMessage)) {
self::addBulkUploadResultDescription($object, $object->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfile = MetadataProfilePeer::retrieveByPK($metadataProfileId);
$dbMetadata = self::createOrFindMetadataObject($object, $metadataProfile);
KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]");
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata));
}
}
/**
* Builds a Criteria object containing the primary key for this object.
*
* Unlike buildCriteria() this method includes the primary key values regardless
* of whether or not they have been modified.
*
* @return Criteria The Criteria object containing value(s) for primary key(s).
*/
public function buildPkeyCriteria()
{
$criteria = new Criteria(MetadataProfileFieldPeer::DATABASE_NAME);
$criteria->add(MetadataProfileFieldPeer::ID, $this->id);
if ($this->alreadyInSave) {
if ($this->isColumnModified(MetadataProfileFieldPeer::CUSTOM_DATA)) {
if (!is_null($this->custom_data_md5)) {
$criteria->add(MetadataProfileFieldPeer::CUSTOM_DATA, "MD5(cast(" . MetadataProfileFieldPeer::CUSTOM_DATA . " as char character set latin1)) = '{$this->custom_data_md5}'", Criteria::CUSTOM);
} else {
$criteria->add(MetadataProfileFieldPeer::CUSTOM_DATA, NULL, Criteria::ISNULL);
}
}
if (count($this->modifiedColumns) == 2 && $this->isColumnModified(MetadataProfileFieldPeer::UPDATED_AT)) {
$theModifiedColumn = null;
foreach ($this->modifiedColumns as $modifiedColumn) {
if ($modifiedColumn != MetadataProfileFieldPeer::UPDATED_AT) {
$theModifiedColumn = $modifiedColumn;
}
}
$atomicColumns = MetadataProfileFieldPeer::getAtomicColumns();
if (in_array($theModifiedColumn, $atomicColumns)) {
$criteria->add($theModifiedColumn, $this->getByName($theModifiedColumn, BasePeer::TYPE_COLNAME), Criteria::NOT_EQUAL);
}
}
}
return $criteria;
}
/**
*
* @param string $field - xPath (metadataProfileField)
*/
public function getMetadataSearchField($field = null, $xPaths = array())
{
if (!$field) {
return MetadataPlugin::getSphinxFieldName(MetadataPlugin::SPHINX_EXPANDER_FIELD_DATA);
}
if (!count($xPaths)) {
$profileFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($this->metadataProfileId);
foreach ($profileFields as $profileField) {
$xPaths[$profileField->getXpath()] = $profileField;
}
}
if (!isset($xPaths[$field])) {
KalturaLog::ERR("Missing field: " . $field);
return null;
}
if (is_null($xPaths[$field]->getSearchIndex())) {
KalturaLog::ERR("Missing field search index: " . $field);
return null;
}
switch ($xPaths[$field]->getType()) {
case MetadataSearchFilter::KMC_FIELD_TYPE_DATE:
case MetadataSearchFilter::KMC_FIELD_TYPE_INT:
$metadataField = MetadataPlugin::getSphinxFieldName(MetadataPlugin::SPHINX_EXPENDER_FIELD_INT) . $xPaths[$field]->getSearchIndex();
break;
default:
KalturaLog::ERR("Missing field type: " . $xPaths[$field]->getType());
return null;
}
return $metadataField;
}
/**
* @param string $entryId the new created entry
* @param array $data key => value pairs
*/
public static function handleBulkUploadData($entryId, array $data)
{
KalturaLog::debug("Handle metadata bulk upload data:\n" . print_r($data, true));
if (!isset($data[self::BULK_UPLOAD_COLUMN_PROFILE_ID])) {
return;
}
$metadataProfileId = $data[self::BULK_UPLOAD_COLUMN_PROFILE_ID];
$xmlData = null;
$entry = entryPeer::retrieveByPK($entryId);
if (!$entry) {
return;
}
// $criteriaFilter = FileSyncPeer::getCriteriaFilter();
// $criteria = $criteriaFilter->getFilter();
// $criteria->add(FileSyncPeer::PARTNER_ID, $entry->getPartnerId());
$metadataProfile = MetadataProfilePeer::retrieveById($metadataProfileId);
if (!$metadataProfile) {
$errorMessage = "Metadata profile [{$metadataProfileId}] not found";
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
return;
}
if (isset($data[self::BULK_UPLOAD_COLUMN_URL])) {
try {
$xmlData = file_get_contents($data[self::BULK_UPLOAD_COLUMN_URL]);
KalturaLog::debug("Metadata downloaded [" . $data[self::BULK_UPLOAD_COLUMN_URL] . "]");
} catch (Exception $e) {
$errorMessage = "Download metadata[" . $data[self::BULK_UPLOAD_COLUMN_URL] . "] error: " . $e->getMessage();
KalturaLog::err($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
$xmlData = null;
}
} elseif (isset($data[self::BULK_UPLOAD_COLUMN_XML])) {
$xmlData = $data[self::BULK_UPLOAD_COLUMN_XML];
} else {
$metadataProfileFields = array();
MetadataProfileFieldPeer::setUseCriteriaFilter(false);
$tmpMetadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfileId);
MetadataProfileFieldPeer::setUseCriteriaFilter(true);
foreach ($tmpMetadataProfileFields as $metadataProfileField) {
$metadataProfileFields[$metadataProfileField->getKey()] = $metadataProfileField;
}
KalturaLog::debug("Found fields [" . count($metadataProfileFields) . "] for metadata profile [{$metadataProfileId}]");
$xml = new DOMDocument();
$dataFound = false;
foreach ($data as $key => $value) {
if (!$value || !strlen($value)) {
continue;
}
if (!preg_match('/^' . self::BULK_UPLOAD_COLUMN_FIELD_PREFIX . '(.+)$/', $key, $matches)) {
continue;
}
$key = $matches[1];
if (!isset($metadataProfileFields[$key])) {
$errorMessage = "Field [{$key}] does not exist";
KalturaLog::debug($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
continue;
}
$metadataProfileField = $metadataProfileFields[$key];
KalturaLog::debug("Found field [" . $metadataProfileField->getXpath() . "] for value [{$value}]");
$fieldValues = explode(self::BULK_UPLOAD_MULTI_VALUES_DELIMITER, $value);
foreach ($fieldValues as $fieldValue) {
if ($metadataProfileField->getType() == MetadataSearchFilter::KMC_FIELD_TYPE_DATE && !is_numeric($fieldValue)) {
$value = self::parseFormatedDate($fieldValue);
if (!$value || !strlen($value)) {
$errorMessage = "Could not parse date format [{$fieldValue}] for field [{$key}]";
KalturaLog::debug($errorMessage);
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
continue;
}
$fieldValue = $value;
}
self::addXpath($xml, $metadataProfileField->getXpath(), $fieldValue);
}
$dataFound = true;
}
if ($dataFound) {
$xmlData = $xml->saveXML($xml->firstChild);
$xmlData = trim($xmlData, " \n\r\t");
}
}
if (!$xmlData) {
return;
}
$dbMetadata = new Metadata();
$dbMetadata->setPartnerId($entry->getPartnerId());
$dbMetadata->setMetadataProfileId($metadataProfileId);
$dbMetadata->setMetadataProfileVersion($metadataProfile->getVersion());
$dbMetadata->setObjectType(Metadata::TYPE_ENTRY);
$dbMetadata->setObjectId($entryId);
$dbMetadata->setStatus(Metadata::STATUS_INVALID);
$dbMetadata->save();
KalturaLog::debug("Metadata [" . $dbMetadata->getId() . "] saved [{$xmlData}]");
$key = $dbMetadata->getSyncKey(Metadata::FILE_SYNC_METADATA_DATA);
kFileSyncUtils::file_put_contents($key, $xmlData);
$errorMessage = '';
$status = kMetadataManager::validateMetadata($dbMetadata, $errorMessage);
if ($status == Metadata::STATUS_VALID) {
kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbMetadata));
} else {
self::addBulkUploadResultDescription($entryId, $entry->getBulkUploadId(), $errorMessage);
}
}
$dbConf = kConf::getDB();
DbManager::setConfig($dbConf);
DbManager::initialize();
$c = new Criteria();
if ($argc > 1 && is_numeric($argv[1])) {
$c->add(entryPeer::INT_ID, $argv[1], Criteria::GREATER_EQUAL);
}
$c->addAscendingOrderByColumn(entryPeer::INT_ID);
$c->setLimit(10000);
$con = myDbHelper::getConnection(myDbHelper::DB_HELPER_CONN_PROPEL2);
//$sphinxCon = DbManager::getSphinxConnection();
$entries = entryPeer::doSelect($c, $con);
$sphinx = new kSphinxSearchManager();
while (count($entries)) {
foreach ($entries as $entry) {
KalturaLog::log('entry id ' . $entry->getId() . ' int id[' . $entry->getIntId() . '] crc id[' . $sphinx->getSphinxId($entry) . ']');
try {
$ret = $sphinx->saveToSphinx($entry, true);
} catch (Exception $e) {
KalturaLog::err($e->getMessage());
exit - 1;
}
}
$c->setOffset($c->getOffset() + count($entries));
entryPeer::clearInstancePool();
MetadataPeer::clearInstancePool();
MetadataProfilePeer::clearInstancePool();
MetadataProfileFieldPeer::clearInstancePool();
$entries = entryPeer::doSelect($c, $con);
}
KalturaLog::log('Done');
protected function loadFields($metadataProfileId)
{
$xPaths = array();
$profileFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($metadataProfileId);
foreach ($profileFields as $profileField) {
/** @var MetadataProfileField $profileField */
$xPaths[$profileField->getXpath()] = $profileField;
}
return $xPaths;
}
public function validateForSubmission(EntryDistribution $entryDistribution, $action)
{
// get validation errors from parent class
$validationErrors = parent::validateForSubmission($entryDistribution, $action);
// get the entry object
$entry = entryPeer::retrieveByPK($entryDistribution->getEntryId());
if (!$entry) {
KalturaLog::err("Entry [" . $entryDistribution->getEntryId() . "] not found");
return $validationErrors;
}
// validate entry name length
if (strlen($entry->getName()) < self::ENTRY_NAME_MINIMUM_LENGTH) {
$description = 'entry name length must be between ' . self::ENTRY_NAME_MINIMUM_LENGTH . ' and ' . self::ENTRY_NAME_MAXIMUM_LENGTH;
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_SHORT);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MINIMUM_LENGTH);
$validationErrors[] = $validationError;
}
if (strlen($entry->getName()) > self::ENTRY_NAME_MAXIMUM_LENGTH) {
$description = 'entry name length must be between ' . self::ENTRY_NAME_MINIMUM_LENGTH . ' and ' . self::ENTRY_NAME_MAXIMUM_LENGTH;
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, entryPeer::NAME, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_TOO_LONG);
$validationError->setValidationErrorParam(self::ENTRY_NAME_MAXIMUM_LENGTH);
$validationErrors[] = $validationError;
}
// get all metadata objects that related to the entry
$metadatas = MetadataPeer::retrieveAllByObject(MetadataObjectType::ENTRY, $entryDistribution->getEntryId());
if (!count($metadatas)) {
$description = 'field is missing because there is no metadata object defined';
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_TEST_DATA, $description);
}
// get all fields from all metadata profile for the testData key
$metadataProfileFields = MetadataProfileFieldPeer::retrieveByPartnerAndKey($this->getPartnerId(), self::METADATA_FIELD_TEST_DATA);
if (!count($metadataProfileFields)) {
$description = 'field is not defined in any of the metadata profiles';
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_TEST_DATA, $description);
} elseif (count($metadatas)) {
// get the values for the testData key from all metadata objects
$values = $this->findMetadataValue($metadatas, self::METADATA_FIELD_TEST_DATA);
if (!count($values)) {
$description = 'field is not defined in any of the metadata objects';
$validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_METADATA, self::METADATA_FIELD_TEST_DATA, $description);
continue;
} else {
foreach ($metadatas as $metadata) {
$values = $this->findMetadataValue(array($metadata), self::METADATA_FIELD_TEST_DATA);
foreach ($values as $value) {
// validate that the field is not empty
if (!strlen($value)) {
$description = 'field is empty';
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TEST_DATA, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::STRING_EMPTY);
$validationError->setMetadataProfileId($metadata->getMetadataProfileId());
$validationErrors[] = $validationError;
continue;
}
// match the value to the required format
$matches = null;
$isMatched = preg_match('/' . self::METADATA_FIELD_TEST_DATA_FORMAT . '/', $value, $matches);
if (!$isMatched) {
$description = 'test data must match the required format';
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TEST_DATA, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::INVALID_FORMAT);
$validationError->setValidationErrorParam(self::METADATA_FIELD_TEST_DATA_FORMAT);
$validationError->setMetadataProfileId($metadata->getMetadataProfileId());
$validationErrors[] = $validationError;
}
$formatNumber = (int) $matches[1];
if ($formatNumber < self::METADATA_FIELD_TEST_DATA_MINIMUM_FORMAT || $formatNumber > self::METADATA_FIELD_TEST_DATA_MAXIMUM_FORMAT) {
$description = 'format number must be between ' . self::METADATA_FIELD_TEST_DATA_MINIMUM_FORMAT . ' and ' . self::METADATA_FIELD_TEST_DATA_MAXIMUM_FORMAT;
$validationError = $this->createValidationError($action, DistributionErrorType::INVALID_DATA, self::METADATA_FIELD_TEST_DATA, $description);
$validationError->setValidationErrorType(DistributionValidationErrorType::CUSTOM_ERROR);
$validationError->setMetadataProfileId($metadata->getMetadataProfileId());
$validationErrors[] = $validationError;
}
}
}
}
}
return $validationErrors;
}
public function getFreeTextConditions($partnerScope, $freeTexts)
{
$metadataProfileFieldIds = array();
$metadataProfileId = $this->getMetadataProfileId();
if ($metadataProfileId) {
$metadataProfileFields = MetadataProfileFieldPeer::retrieveActiveByMetadataProfileId($metadataProfileId);
foreach ($metadataProfileFields as $metadataProfileField) {
$metadataProfileFieldIds[] = $metadataProfileField->getId();
}
}
KalturaLog::debug("freeText [{$freeTexts}]");
$additionalConditions = array();
if (preg_match('/^"[^"]+"$/', $freeTexts)) {
$freeText = str_replace('"', '', $freeTexts);
$freeText = SphinxUtils::escapeString($freeText);
$freeText = "^{$freeText}\$";
$additionalConditions[] = $this->createSphinxSearchPhrase($partnerScope, $freeTexts);
return $additionalConditions;
}
if (strpos($freeTexts, baseObjectFilter::IN_SEPARATOR) > 0) {
str_replace(baseObjectFilter::AND_SEPARATOR, baseObjectFilter::IN_SEPARATOR, $freeTexts);
$freeTextsArr = explode(baseObjectFilter::IN_SEPARATOR, $freeTexts);
foreach ($freeTextsArr as $valIndex => $valValue) {
if (!is_numeric($valValue) && strlen($valValue) <= 0) {
unset($freeTextsArr[$valIndex]);
}
}
foreach ($freeTextsArr as $freeText) {
$freeText = SphinxUtils::escapeString($freeText);
$additionalConditions[] = $this->createSphinxSearchPhrase($partnerScope, $freeText);
foreach ($metadataProfileFieldIds as $metadataProfileFieldId) {
$additionalConditions[] = $this->createSphinxSearchPhrase($partnerScope, $freeText, $metadataProfileFieldId);
}
}
return $additionalConditions;
}
$freeTextsArr = explode(baseObjectFilter::AND_SEPARATOR, $freeTexts);
foreach ($freeTextsArr as $valIndex => $valValue) {
if (!is_numeric($valValue) && strlen($valValue) <= 0) {
unset($freeTextsArr[$valIndex]);
}
}
$freeTextsArr = array_unique($freeTextsArr);
$freeTextExpr = implode(baseObjectFilter::AND_SEPARATOR, $freeTextsArr);
$freeTextExpr = SphinxUtils::escapeString($freeTextExpr);
$additionalConditions[] = $this->createSphinxSearchPhrase($partnerScope, $freeTextExpr);
foreach ($metadataProfileFieldIds as $metadataProfileFieldId) {
$additionalConditions[] = $this->createSphinxSearchPhrase($partnerScope, $freeTextExpr, $metadataProfileFieldId);
}
return $additionalConditions;
}
/**
* Delete an existing metadata profile
*
* @action delete
* @param int $id
* @throws KalturaErrors::INVALID_OBJECT_ID
*/
function deleteAction($id)
{
$dbMetadataProfile = MetadataProfilePeer::retrieveByPK($id);
if (!$dbMetadataProfile) {
throw new KalturaAPIException(KalturaErrors::INVALID_OBJECT_ID, $id);
}
$dbMetadataProfile->setStatus(KalturaMetadataProfileStatus::DEPRECATED);
$dbMetadataProfile->save();
$c = new Criteria();
$c->add(MetadataProfileFieldPeer::METADATA_PROFILE_ID, $id);
$c->add(MetadataProfileFieldPeer::STATUS, MetadataProfileField::STATUS_DEPRECATED, Criteria::NOT_EQUAL);
$MetadataProfileFields = MetadataProfileFieldPeer::doSelect($c);
foreach ($MetadataProfileFields as $MetadataProfileField) {
$MetadataProfileField->setStatus(MetadataProfileField::STATUS_DEPRECATED);
$MetadataProfileField->save();
}
$c = new Criteria();
$c->add(MetadataPeer::METADATA_PROFILE_ID, $id);
$c->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED, Criteria::NOT_EQUAL);
$peer = null;
MetadataPeer::setUseCriteriaFilter(false);
$metadatas = MetadataPeer::doSelect($c);
foreach ($metadatas as $metadata) {
kEventsManager::raiseEvent(new kObjectDeletedEvent($metadata));
}
$update = new Criteria();
$update->add(MetadataPeer::STATUS, KalturaMetadataStatus::DELETED);
$con = Propel::getConnection(MetadataPeer::DATABASE_NAME);
BasePeer::doUpdate($c, $update, $con);
}
/**
* @param Partner $fromPartner
* @param Partner $toPartner
*/
protected function copyMetadataProfiles(Partner $fromPartner, Partner $toPartner, $permissionRequiredOnly = false)
{
$fromPartnerId = $fromPartner->getId();
$toPartnerId = $toPartner->getId();
KalturaLog::debug("Copy metadata profiles from [{$fromPartnerId}] to [{$toPartnerId}]");
$c = new Criteria();
$c->add(MetadataProfilePeer::PARTNER_ID, $fromPartnerId);
$systemNameCriteria = new Criteria();
$systemNameCriteria->add(MetadataProfilePeer::PARTNER_ID, $toPartnerId);
$systemNameCriteria->add(MetadataProfilePeer::STATUS, MetadataProfile::STATUS_ACTIVE);
$metadataProfiles = MetadataProfilePeer::doSelect($c);
foreach ($metadataProfiles as $metadataProfile) {
/* @var $metadataProfile MetadataProfile */
if ($permissionRequiredOnly && !count($metadataProfile->getRequiredCopyTemplatePermissions())) {
continue;
}
if (!myPartnerUtils::isPartnerPermittedForCopy($toPartner, $metadataProfile->getRequiredCopyTemplatePermissions())) {
continue;
}
if ($metadataProfile->getSystemName()) {
$c = clone $systemNameCriteria;
$c->add(MetadataProfilePeer::SYSTEM_NAME, $metadataProfile->getSystemName());
if (MetadataProfilePeer::doCount($c)) {
continue;
}
}
$newMetadataProfile = $metadataProfile->copy();
$newMetadataProfile->setPartnerId($toPartnerId);
$newMetadataProfile->save();
kFileSyncUtils::createSyncFileLinkForKey($newMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION), $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_DEFINITION));
kFileSyncUtils::createSyncFileLinkForKey($newMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS), $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_VIEWS));
kFileSyncUtils::createSyncFileLinkForKey($newMetadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_XSLT), $metadataProfile->getSyncKey(MetadataProfile::FILE_SYNC_METADATA_XSLT));
$metadataProfileFields = MetadataProfileFieldPeer::retrieveByMetadataProfileId($metadataProfile->getId());
foreach ($metadataProfileFields as $metadataProfileField) {
$newMetadataProfileField = $metadataProfileField->copy();
$newMetadataProfileField->setMetadataProfileId($newMetadataProfile->getId());
$newMetadataProfileField->setPartnerId($toPartnerId);
$newMetadataProfileField->save();
}
}
}
public static function cleanMemory()
{
MetadataProfilePeer::clearInstancePool();
MetadataProfileFieldPeer::clearInstancePool();
MetadataPeer::clearInstancePool();
}
