mirror of https://github.com/MISP/MISP
543 lines
25 KiB
PHP
543 lines
25 KiB
PHP
<?php
|
|
App::uses('AppModel', 'Model');
|
|
|
|
/**
|
|
* @property GalaxyClusterRelationTag $GalaxyClusterRelationTag
|
|
* @property GalaxyCluster $TargetCluster
|
|
* @property SharingGroup $SharingGroup
|
|
*/
|
|
class GalaxyClusterRelation extends AppModel
|
|
{
|
|
public $useTable = 'galaxy_cluster_relations';
|
|
|
|
public $recursive = -1;
|
|
|
|
public $actsAs = array(
|
|
'AuditLog',
|
|
'SysLogLogable.SysLogLogable' => array( // TODO Audit, logable
|
|
'userModel' => 'User',
|
|
'userKey' => 'user_id',
|
|
'change' => 'full'),
|
|
'Containable',
|
|
);
|
|
|
|
public $validate = array(
|
|
'referenced_galaxy_cluster_type' => array(
|
|
'stringNotEmpty' => array(
|
|
'rule' => array('stringNotEmpty')
|
|
)
|
|
),
|
|
'galaxy_cluster_uuid' => array(
|
|
'uuid' => array(
|
|
'rule' => 'uuid',
|
|
'message' => 'Please provide a valid RFC 4122 UUID'
|
|
),
|
|
),
|
|
'referenced_galaxy_cluster_uuid' => array(
|
|
'uuid' => array(
|
|
'rule' => 'uuid',
|
|
'message' => 'Please provide a valid RFC 4122 UUID'
|
|
),
|
|
),
|
|
'distribution' => array(
|
|
'rule' => array('inList', array('0', '1', '2', '3', '4')),
|
|
'message' => 'Options: Your organisation only, This community only, Connected communities, All communities, Sharing group',
|
|
'required' => true
|
|
)
|
|
);
|
|
|
|
public $belongsTo = array(
|
|
'SourceCluster' => array(
|
|
'className' => 'GalaxyCluster',
|
|
'foreignKey' => 'galaxy_cluster_id',
|
|
),
|
|
'TargetCluster' => array(
|
|
'className' => 'GalaxyCluster',
|
|
'foreignKey' => 'referenced_galaxy_cluster_id',
|
|
),
|
|
'SharingGroup' => array(
|
|
'className' => 'SharingGroup',
|
|
'foreignKey' => 'sharing_group_id'
|
|
),
|
|
);
|
|
|
|
public $hasMany = array(
|
|
'GalaxyClusterRelationTag' => array('dependent' => true),
|
|
);
|
|
|
|
public function afterFind($results, $primary = false)
|
|
{
|
|
foreach ($results as $k => $result) {
|
|
if (isset($result['TargetCluster']) && key_exists('id', $result['TargetCluster']) && is_null($result['TargetCluster']['id'])) {
|
|
$results[$k]['TargetCluster'] = array();
|
|
}
|
|
if (isset($result['GalaxyClusterRelation']['distribution']) && $result['GalaxyClusterRelation']['distribution'] != 4) {
|
|
unset($results[$k]['SharingGroup']);
|
|
}
|
|
}
|
|
return $results;
|
|
}
|
|
|
|
public function buildConditions($user, $clusterConditions = true)
|
|
{
|
|
$conditions = [];
|
|
if (!$user['Role']['perm_site_admin']) {
|
|
$alias = $this->alias;
|
|
$sgids = $this->SharingGroup->authorizedIds($user);
|
|
$gcOwnerIds = $this->SourceCluster->cacheGalaxyClusterOwnerIDs($user);
|
|
$conditionsRelations['AND']['OR'] = [
|
|
"${alias}.galaxy_cluster_id" => $gcOwnerIds,
|
|
[
|
|
'AND' => [
|
|
"${alias}.distribution >" => 0,
|
|
"${alias}.distribution <" => 4
|
|
],
|
|
],
|
|
[
|
|
'AND' => [
|
|
"${alias}.sharing_group_id" => $sgids,
|
|
"${alias}.distribution" => 4
|
|
]
|
|
]
|
|
];
|
|
$conditionsSourceCluster = $clusterConditions ? $this->SourceCluster->buildConditions($user) : [];
|
|
$conditions = [
|
|
'AND' => [
|
|
$conditionsRelations,
|
|
$conditionsSourceCluster
|
|
]
|
|
];
|
|
}
|
|
return $conditions;
|
|
}
|
|
|
|
public function fetchRelations($user, $options, $full=false)
|
|
{
|
|
$params = array(
|
|
'conditions' => $this->buildConditions($user),
|
|
'recursive' => -1
|
|
);
|
|
if (!empty($options['contain'])) {
|
|
$params['contain'] = $options['contain'];
|
|
} elseif ($full) {
|
|
$params['contain'] = array('SharingGroup', 'SourceCluster', 'TargetCluster');
|
|
}
|
|
if (empty($params['contain'])) {
|
|
$params['contain'] = ['SourceCluster'];
|
|
}
|
|
if (!in_array('SourceCluster', $params['contain'])) {
|
|
$params['contain'][] = 'SourceCluster';
|
|
}
|
|
if (isset($options['fields'])) {
|
|
$params['fields'] = $options['fields'];
|
|
}
|
|
if (isset($options['conditions'])) {
|
|
$params['conditions']['AND'][] = $options['conditions'];
|
|
}
|
|
if (isset($options['group'])) {
|
|
$params['group'] = empty($options['group']) ? $options['group'] : false;
|
|
}
|
|
$relations = $this->find('all', $params);
|
|
return $relations;
|
|
}
|
|
|
|
public function getExistingRelationships()
|
|
{
|
|
$existingRelationships = $this->find('column', array(
|
|
'recursive' => -1,
|
|
'fields' => array('referenced_galaxy_cluster_type'),
|
|
'unique' => true,
|
|
));
|
|
$this->ObjectRelationship = ClassRegistry::init('ObjectRelationship');
|
|
$objectRelationships = $this->ObjectRelationship->find('column', array(
|
|
'recursive' => -1,
|
|
'fields' => array('name'),
|
|
'unique' => true,
|
|
));
|
|
return array_unique(array_merge($existingRelationships, $objectRelationships));
|
|
}
|
|
|
|
/**
|
|
* saveRelations
|
|
*
|
|
* @see saveRelation
|
|
* @return array List of errors if any
|
|
*/
|
|
public function saveRelations(array $user, array $cluster, array $relations, $captureTag=false, $force=false)
|
|
{
|
|
$errors = array();
|
|
foreach ($relations as $k => $relation) {
|
|
$saveResult = $this->saveRelation($user, $cluster, $relation, $captureTag=$captureTag, $force=$force);
|
|
$errors = array_merge($errors, $saveResult);
|
|
}
|
|
return $errors;
|
|
}
|
|
|
|
/**
|
|
* saveRelation Respecting ACL saves a relation and set correct fields where applicable.
|
|
* Contrary to its capture equivalent, trying to save a relation for a unknown target cluster will fail.
|
|
*
|
|
* @param array $user
|
|
* @param array $cluster The cluster from which the relation is originating
|
|
* @param array $relation The relation to save
|
|
* @param bool $captureTag Should the tag be captured if it doesn't exists
|
|
* @param bool $force Should the relation be edited if it exists
|
|
* @return array List errors if any
|
|
*/
|
|
public function saveRelation(array $user, array $cluster, array $relation, $captureTag=false, $force=false)
|
|
{
|
|
$errors = array();
|
|
if (!isset($relation['GalaxyClusterRelation']) && !empty($relation)) {
|
|
$relation = array('GalaxyClusterRelation' => $relation);
|
|
}
|
|
$authorizationCheck = $this->SourceCluster->fetchIfAuthorized($user, $cluster, array('edit'), $throwErrors=false, $full=false);
|
|
if (isset($authorizationCheck['authorized']) && !$authorizationCheck['authorized']) {
|
|
$errors[] = $authorizationCheck['error'];
|
|
return $errors;
|
|
}
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_uuid'] = $cluster['uuid'];
|
|
|
|
$existingRelation = $this->find('first', [
|
|
'conditions' => [
|
|
'galaxy_cluster_uuid' => $relation['GalaxyClusterRelation']['galaxy_cluster_uuid'],
|
|
'referenced_galaxy_cluster_uuid' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'],
|
|
'referenced_galaxy_cluster_type' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_type'],
|
|
],
|
|
'fields' => ['id'],
|
|
'recursive' => -1,
|
|
]);
|
|
if (!empty($existingRelation)) {
|
|
if (!$force) {
|
|
$errors[] = __('Relation already exists');
|
|
return $errors;
|
|
} else {
|
|
$relation['GalaxyClusterRelation']['id'] = $existingRelation['GalaxyClusterRelation']['id'];
|
|
}
|
|
} else {
|
|
$this->create();
|
|
}
|
|
if (empty($errors)) {
|
|
if (!isset($relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'])) {
|
|
$errors[] = __('referenced_galaxy_cluster_uuid not provided');
|
|
return $errors;
|
|
}
|
|
if (!$force) {
|
|
$targetCluster = $this->TargetCluster->fetchIfAuthorized($user, $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'], 'view', $throwErrors=false, $full=false);
|
|
if (isset($targetCluster['authorized']) && !$targetCluster['authorized']) { // do not save the relation if referenced cluster is not accessible by the user (or does not exist)
|
|
$errors[] = array(__('Invalid referenced galaxy cluster'));
|
|
return $errors;
|
|
}
|
|
}
|
|
$relation = $this->syncUUIDsAndIDs($user, $relation);
|
|
$saveSuccess = $this->save($relation);
|
|
if ($saveSuccess) {
|
|
$savedRelation = $this->find('first', array(
|
|
'conditions' => array('id' => $this->id),
|
|
'recursive' => -1
|
|
));
|
|
$tags = array();
|
|
if (!empty($relation['GalaxyClusterRelation']['tags'])) {
|
|
$tags = $relation['GalaxyClusterRelation']['tags'];
|
|
} elseif (!empty($relation['GalaxyClusterRelation']['GalaxyClusterRelationTag'])) {
|
|
$tags = $relation['GalaxyClusterRelation']['GalaxyClusterRelationTag'];
|
|
$tags = Hash::extract($tags, '{n}.name');
|
|
} elseif (!empty($relation['GalaxyClusterRelation']['Tag'])) {
|
|
$tags = $relation['GalaxyClusterRelation']['Tag'];
|
|
$tags = Hash::extract($tags, '{n}.name');
|
|
}
|
|
|
|
if (!empty($tags)) {
|
|
$tagSaveResults = $this->GalaxyClusterRelationTag->attachTags($user, $this->id, $tags, $capture=$captureTag);
|
|
if (!$tagSaveResults) {
|
|
$errors[] = __('Tags could not be saved for relation (%s)', $this->id);
|
|
}
|
|
}
|
|
} else {
|
|
foreach ($this->validationErrors as $validationError) {
|
|
$errors[] = $validationError[0];
|
|
}
|
|
}
|
|
}
|
|
return $errors;
|
|
}
|
|
|
|
/**
|
|
* editRelation Respecting ACL edits a relation and set correct fields where applicable.
|
|
* Contrary to its capture equivalent, trying to save a relation for a unknown target cluster will fail.
|
|
*
|
|
* @param array $user
|
|
* @param array $relation The relation to be saved
|
|
* @param array $fieldList Only edit the fields provided
|
|
* @param bool $captureTag Should the tag be captured if it doesn't exists
|
|
* @return array List of errors if any
|
|
*/
|
|
public function editRelation(array $user, array $relation, array $fieldList=array(), $captureTag=false)
|
|
{
|
|
$this->SharingGroup = ClassRegistry::init('SharingGroup');
|
|
$errors = array();
|
|
if (!isset($relation['GalaxyClusterRelation']['galaxy_cluster_id'])) {
|
|
$errors[] = __('galaxy_cluster_id not provided');
|
|
return $errors;
|
|
}
|
|
$authorizationCheck = $this->SourceCluster->fetchIfAuthorized($user, $relation['GalaxyClusterRelation']['galaxy_cluster_id'], array('edit'), $throwErrors=false, $full=false);
|
|
if (isset($authorizationCheck['authorized']) && !$authorizationCheck['authorized']) {
|
|
$errors[] = $authorizationCheck['error'];
|
|
return $errors;
|
|
}
|
|
|
|
if (isset($relation['GalaxyClusterRelation']['id'])) {
|
|
$existingRelation = $this->find('first', array('conditions' => array('GalaxyClusterRelation.id' => $relation['GalaxyClusterRelation']['id'])));
|
|
} else {
|
|
$errors[] = __('UUID not provided');
|
|
}
|
|
if (empty($existingRelation)) {
|
|
$errors[] = __('Unkown ID');
|
|
} else {
|
|
$options = array('conditions' => array(
|
|
'uuid' => $relation['GalaxyClusterRelation']['galaxy_cluster_uuid']
|
|
));
|
|
$cluster = $this->SourceCluster->fetchGalaxyClusters($user, $options);
|
|
if (empty($cluster)) {
|
|
$errors[] = __('Invalid source galaxy cluster');
|
|
}
|
|
$cluster = $cluster[0];
|
|
$relation['GalaxyClusterRelation']['id'] = $existingRelation['GalaxyClusterRelation']['id'];
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_id'] = $cluster['SourceCluster']['id'];
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_uuid'] = $cluster['SourceCluster']['uuid'];
|
|
|
|
if (isset($relation['GalaxyClusterRelation']['distribution']) && $relation['GalaxyClusterRelation']['distribution'] == 4 && !$this->SharingGroup->checkIfAuthorised($user, $relation['GalaxyClusterRelation']['sharing_group_id'])) {
|
|
$errors[] = array(__('Galaxy Cluster Relation could not be saved: The user has to have access to the sharing group in order to be able to edit it.'));
|
|
}
|
|
|
|
if (empty($errors)) {
|
|
if (!isset($relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'])) {
|
|
$errors[] = __('referenced_galaxy_cluster_uuid not provided');
|
|
return $errors;
|
|
}
|
|
$targetCluster = $this->TargetCluster->fetchIfAuthorized($user, $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'], 'view', $throwErrors=false, $full=false);
|
|
if (isset($targetCluster['authorized']) && !$targetCluster['authorized']) { // do not save the relation if referenced cluster is not accessible by the user (or does not exist)
|
|
$errors[] = array(__('Invalid referenced galaxy cluster'));
|
|
return $errors;
|
|
}
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_id'] = $targetCluster['TargetCluster']['id'];
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'] = $targetCluster['TargetCluster']['uuid'];
|
|
$relation['GalaxyClusterRelation']['default'] = false;
|
|
if (empty($fieldList)) {
|
|
$fieldList = array('galaxy_cluster_id', 'galaxy_cluster_uuid', 'referenced_galaxy_cluster_id', 'referenced_galaxy_cluster_uuid', 'referenced_galaxy_cluster_type', 'distribution', 'sharing_group_id', 'default');
|
|
}
|
|
|
|
$saveSuccess = $this->save($relation, array('fieldList' => $fieldList));
|
|
if (!$saveSuccess) {
|
|
foreach ($this->validationErrors as $validationError) {
|
|
$errors[] = $validationError[0];
|
|
}
|
|
} else {
|
|
$this->GalaxyClusterRelationTag->deleteAll(array('GalaxyClusterRelationTag.galaxy_cluster_relation_id' => $relation['GalaxyClusterRelation']['id']));
|
|
$this->GalaxyClusterRelationTag->attachTags($user, $relation['GalaxyClusterRelation']['id'], $relation['GalaxyClusterRelation']['tags'], $capture=$captureTag);
|
|
}
|
|
}
|
|
}
|
|
return $errors;
|
|
}
|
|
|
|
public function bulkSaveRelations(array $relations)
|
|
{
|
|
// Fetch existing tags Name => ID mapping
|
|
$tagNameToId = $this->GalaxyClusterRelationTag->Tag->find('list', [
|
|
'fields' => ['Tag.name', 'Tag.id'],
|
|
'callbacks' => false,
|
|
]);
|
|
|
|
// Fetch all cluster UUID => ID mapping
|
|
$galaxyClusterUuidToId = $this->TargetCluster->find('list', [
|
|
'fields' => ['uuid', 'id'],
|
|
'callbacks' => false,
|
|
]);
|
|
|
|
$lookupSavedIds = [];
|
|
$relationTagsToSave = [];
|
|
foreach ($relations as &$relation) {
|
|
if (isset($galaxyClusterUuidToId[$relation['referenced_galaxy_cluster_uuid']])) {
|
|
$relation['referenced_galaxy_cluster_id'] = $galaxyClusterUuidToId[$relation['referenced_galaxy_cluster_uuid']];
|
|
} else {
|
|
$relation['referenced_galaxy_cluster_id'] = 0; // referenced cluster doesn't exists
|
|
}
|
|
if (!empty($relation['tags'])) {
|
|
$lookupSavedIds[$relation['galaxy_cluster_id']] = true;
|
|
foreach ($relation['tags'] as $tag) {
|
|
if (!isset($tagNameToId[$tag])) {
|
|
$tagNameToId[$tag] = $this->GalaxyClusterRelationTag->Tag->quickAdd($tag);
|
|
}
|
|
$relationTagsToSave[$relation['galaxy_cluster_uuid']][$relation['referenced_galaxy_cluster_uuid']][] = $tagNameToId[$tag];
|
|
}
|
|
}
|
|
}
|
|
unset($galaxyClusterUuidToId, $tagNameToId);
|
|
|
|
$this->saveMany($relations, ['validate' => false]); // Some clusters uses invalid UUID :/
|
|
|
|
// Insert tags
|
|
$savedRelations = $this->find('all', [
|
|
'recursive' => -1,
|
|
'conditions' => ['galaxy_cluster_id' => array_keys($lookupSavedIds)],
|
|
'fields' => ['id', 'galaxy_cluster_uuid', 'referenced_galaxy_cluster_uuid']
|
|
]);
|
|
$relation_tags = [];
|
|
foreach ($savedRelations as $savedRelation) {
|
|
$uuid1 = $savedRelation['GalaxyClusterRelation']['galaxy_cluster_uuid'];
|
|
$uuid2 = $savedRelation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'];
|
|
if (isset($relationTagsToSave[$uuid1][$uuid2])) {
|
|
foreach ($relationTagsToSave[$uuid1][$uuid2] as $tagId) {
|
|
$relation_tags[] = [$savedRelation['GalaxyClusterRelation']['id'], $tagId];
|
|
}
|
|
}
|
|
}
|
|
if (!empty($relation_tags)) {
|
|
$db = $this->getDataSource();
|
|
$fields = array('galaxy_cluster_relation_id', 'tag_id');
|
|
$db->insertMulti('galaxy_cluster_relation_tags', $fields, $relation_tags);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets a relation then save it.
|
|
*
|
|
* @param array $user
|
|
* @param array $cluster The cluster for which the relation is being saved
|
|
* @param array $relation The relation to be saved
|
|
* @param bool $fromPull If the current capture is performed from a PULL sync. If set, it allows edition of existing relations
|
|
* @return array The capture success results
|
|
*/
|
|
public function captureRelations(array $user, array $cluster, array $relations, $fromPull=false)
|
|
{
|
|
$results = array('success' => false, 'imported' => 0, 'failed' => 0);
|
|
$this->Log = ClassRegistry::init('Log');
|
|
$clusterUuid = $cluster['GalaxyCluster']['uuid'];
|
|
|
|
foreach ($relations as $k => $relation) {
|
|
if (!isset($relation['GalaxyClusterRelation'])) {
|
|
$relation = array('GalaxyClusterRelation' => $relation);
|
|
}
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_uuid'] = $clusterUuid;
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_id'] = $cluster['GalaxyCluster']['id'];
|
|
|
|
if (empty($relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'])) {
|
|
$this->Log->createLogEntry($user, 'captureRelations', 'GalaxyClusterRelation', 0, __('No referenced cluster UUID provided'), __('relation for cluster (%s)', $clusterUuid));
|
|
$results['failed']++;
|
|
continue;
|
|
} else {
|
|
$options = array(
|
|
'conditions' => array(
|
|
'uuid' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'],
|
|
),
|
|
'fields' => array(
|
|
'id', 'uuid',
|
|
)
|
|
);
|
|
$referencedCluster = $this->SourceCluster->fetchGalaxyClusters($user, $options);
|
|
if (empty($referencedCluster)) {
|
|
if (!$fromPull) {
|
|
$this->Log->createLogEntry($user, 'captureRelations', 'GalaxyClusterRelation', 0, __('Referenced cluster not found'), __('relation to (%s) for cluster (%s)', $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'], $clusterUuid));
|
|
}
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_id'] = 0;
|
|
} else {
|
|
$referencedCluster = $referencedCluster[0];
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_id'] = $referencedCluster['SourceCluster']['id'];
|
|
}
|
|
}
|
|
|
|
$existingRelation = $this->find('first', array('conditions' => array(
|
|
'GalaxyClusterRelation.galaxy_cluster_uuid' => $relation['GalaxyClusterRelation']['galaxy_cluster_uuid'],
|
|
'GalaxyClusterRelation.referenced_galaxy_cluster_uuid' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'],
|
|
'GalaxyClusterRelation.referenced_galaxy_cluster_type' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_type'],
|
|
)));
|
|
if (!empty($existingRelation)) {
|
|
if (!$fromPull) {
|
|
$this->Log->createLogEntry($user, 'captureRelations', 'GalaxyClusterRelation', 0, __('Relation already exists'), __('relation to (%s) for cluster (%s)', $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'], $clusterUuid));
|
|
$results['failed']++;
|
|
continue;
|
|
} else {
|
|
$relation['GalaxyClusterRelation']['id'] = $existingRelation['GalaxyClusterRelation']['id'];
|
|
}
|
|
} else {
|
|
unset($relation['GalaxyClusterRelation']['id']);
|
|
$this->create();
|
|
}
|
|
|
|
$this->Event = ClassRegistry::init('Event');
|
|
if (isset($relation['GalaxyClusterRelation']['distribution']) && $relation['GalaxyClusterRelation']['distribution'] == 4) {
|
|
$relation['GalaxyClusterRelation'] = $this->Event->captureSGForElement($relation['GalaxyClusterRelation'], $user);
|
|
}
|
|
|
|
$saveSuccess = $this->save($relation);
|
|
if ($saveSuccess) {
|
|
$results['imported']++;
|
|
$modelKey = false;
|
|
if (!empty($relation['GalaxyClusterRelation']['GalaxyClusterRelationTag'])) {
|
|
$modelKey = 'GalaxyClusterRelationTag';
|
|
} elseif (!empty($relation['GalaxyClusterRelation']['Tag'])) {
|
|
$modelKey = 'Tag';
|
|
}
|
|
if ($modelKey !== false) {
|
|
$tagNames = Hash::extract($relation['GalaxyClusterRelation'][$modelKey], '{n}.name');
|
|
// Similar behavior as for AttributeTags: Here we only attach tags. If they were removed at some point it's not taken into account.
|
|
// Since we don't have tag soft-deletion, tags added by users will be kept.
|
|
$this->GalaxyClusterRelationTag->attachTags($user, $this->id, $tagNames, $capture=true);
|
|
}
|
|
} else {
|
|
$results['failed']++;
|
|
}
|
|
}
|
|
|
|
$results['success'] = $results['imported'] > 0;
|
|
return $results;
|
|
}
|
|
|
|
public function removeNonAccessibleTargetCluster($user, $relations)
|
|
{
|
|
$availableTargetClusterIDs = $this->TargetCluster->cacheGalaxyClusterIDs($user);
|
|
$availableTargetClusterIDsKeyed = array_flip($availableTargetClusterIDs);
|
|
foreach ($relations as $i => $relation) {
|
|
if (
|
|
isset($relation['TargetCluster']['id']) &&
|
|
!isset($availableTargetClusterIDsKeyed[$relation['TargetCluster']['id']])
|
|
) {
|
|
$relations[$i]['TargetCluster'] = null;
|
|
}
|
|
}
|
|
return $relations;
|
|
}
|
|
|
|
/**
|
|
* syncUUIDsAndIDs Adapt IDs of source and target cluster inside the relation based on the provided two UUIDs
|
|
*
|
|
* @param array $user
|
|
* @param array $relation
|
|
* @return array The adpated relation
|
|
*/
|
|
private function syncUUIDsAndIDs(array $user, array $relation)
|
|
{
|
|
$options = array('conditions' => array(
|
|
'uuid' => $relation['GalaxyClusterRelation']['galaxy_cluster_uuid']
|
|
));
|
|
$sourceCluster = $this->SourceCluster->fetchGalaxyClusters($user, $options);
|
|
if (!empty($sourceCluster)) {
|
|
$sourceCluster = $sourceCluster[0];
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_id'] = $sourceCluster['SourceCluster']['id'];
|
|
$relation['GalaxyClusterRelation']['galaxy_cluster_uuid'] = $sourceCluster['SourceCluster']['uuid'];
|
|
}
|
|
$options = array('conditions' => array(
|
|
'uuid' => $relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid']
|
|
));
|
|
$targetCluster = $this->TargetCluster->fetchGalaxyClusters($user, $options);
|
|
if (!empty($targetCluster)) {
|
|
$targetCluster = $targetCluster[0];
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_id'] = $targetCluster['TargetCluster']['id'];
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_uuid'] = $targetCluster['TargetCluster']['uuid'];
|
|
} else {
|
|
$relation['GalaxyClusterRelation']['referenced_galaxy_cluster_id'] = 0;
|
|
}
|
|
return $relation;
|
|
}
|
|
}
|