mirror of https://github.com/MISP/MISP
598 lines
24 KiB
PHP
598 lines
24 KiB
PHP
<?php
|
|
App::uses('AppController', 'Controller');
|
|
|
|
/**
|
|
* @property Taxonomy $Taxonomy
|
|
*/
|
|
class TaxonomiesController extends AppController
|
|
{
|
|
public $components = array('Session', 'RequestHandler');
|
|
|
|
public $paginate = array(
|
|
'limit' => 60,
|
|
'maxLimit' => 9999, // LATER we will bump here on a problem once we have more than 9999 events <- no we won't, this is the max a user van view/page.
|
|
'contain' => array(
|
|
'TaxonomyPredicate' => array(
|
|
'fields' => array('TaxonomyPredicate.id', 'TaxonomyPredicate.value'),
|
|
'TaxonomyEntry' => array('fields' => array('TaxonomyEntry.id', 'TaxonomyEntry.value'))
|
|
)
|
|
),
|
|
'order' => array(
|
|
'Taxonomy.id' => 'DESC'
|
|
),
|
|
);
|
|
|
|
public function index()
|
|
{
|
|
$this->paginate['recursive'] = -1;
|
|
|
|
if (!empty($this->passedArgs['value'])) {
|
|
$this->paginate['conditions']['id'] = $this->__search($this->passedArgs['value']);
|
|
}
|
|
|
|
if (isset($this->passedArgs['enabled'])) {
|
|
$this->paginate['conditions']['enabled'] = $this->passedArgs['enabled'] ? 1 : 0;
|
|
}
|
|
|
|
if ($this->_isRest()) {
|
|
$keepFields = array('conditions', 'contain', 'recursive', 'sort');
|
|
$searchParams = array();
|
|
foreach ($keepFields as $field) {
|
|
if (!empty($this->paginate[$field])) {
|
|
$searchParams[$field] = $this->paginate[$field];
|
|
}
|
|
}
|
|
$taxonomies = $this->Taxonomy->find('all', $searchParams);
|
|
} else {
|
|
$taxonomies = $this->paginate();
|
|
}
|
|
|
|
$taxonomies = $this->__tagCount($taxonomies);
|
|
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->viewData($taxonomies, $this->response->type());
|
|
}
|
|
|
|
$this->set('taxonomies', $taxonomies);
|
|
$this->set('passedArgsArray', $this->passedArgs);
|
|
}
|
|
|
|
public function view($id)
|
|
{
|
|
$taxonomy = $this->Taxonomy->getTaxonomy($id, ['full' => $this->_isRest()]);
|
|
if (empty($taxonomy)) {
|
|
throw new NotFoundException(__('Taxonomy not found.'));
|
|
}
|
|
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->viewData($taxonomy, $this->response->type());
|
|
}
|
|
|
|
$this->set('taxonomy', $taxonomy['Taxonomy']);
|
|
$this->set('id', $taxonomy['Taxonomy']['id']);
|
|
}
|
|
|
|
public function taxonomy_tags($id)
|
|
{
|
|
$urlparams = '';
|
|
App::uses('CustomPaginationTool', 'Tools');
|
|
$filter = isset($this->passedArgs['filter']) ? $this->passedArgs['filter'] : false;
|
|
$options = ['full' => true, 'filter' => $filter];
|
|
if (isset($this->passedArgs['enabled'])) {
|
|
$options['enabled'] = $this->passedArgs['enabled'];
|
|
}
|
|
$taxonomy = $this->Taxonomy->getTaxonomy($id, $options);
|
|
if (empty($taxonomy)) {
|
|
throw new NotFoundException(__('Taxonomy not found.'));
|
|
}
|
|
$this->loadModel('EventTag');
|
|
$this->loadModel('AttributeTag');
|
|
|
|
$tagIds = array_column(array_column(array_column($taxonomy['entries'], 'existing_tag'), 'Tag'), 'id');
|
|
$eventCount = $this->EventTag->countForTags($tagIds, $this->Auth->user());
|
|
$attributeTags = $this->AttributeTag->countForTags($tagIds, $this->Auth->user());
|
|
|
|
foreach ($taxonomy['entries'] as $key => $value) {
|
|
$count = 0;
|
|
$count_a = 0;
|
|
if (!empty($value['existing_tag'])) {
|
|
$tagId = $value['existing_tag']['Tag']['id'];
|
|
$count = isset($eventCount[$tagId]) ? $eventCount[$tagId] : 0;
|
|
$count_a = isset($attributeTags[$tagId]) ? $attributeTags[$tagId] : 0;
|
|
}
|
|
$taxonomy['entries'][$key]['events'] = $count;
|
|
$taxonomy['entries'][$key]['attributes'] = $count_a;
|
|
}
|
|
$this->set('filter', $filter);
|
|
$customPagination = new CustomPaginationTool();
|
|
$params = $customPagination->createPaginationRules($taxonomy['entries'], $this->passedArgs, 'TaxonomyEntry');
|
|
if ($params['sort'] == 'id') {
|
|
$params['sort'] = 'tag';
|
|
}
|
|
$this->params->params['paging'] = array($this->modelClass => $params);
|
|
$params = $customPagination->applyRulesOnArray($taxonomy['entries'], $params, 'taxonomies');
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->viewData($taxonomy, $this->response->type());
|
|
}
|
|
|
|
if (isset($this->passedArgs['pages'])) {
|
|
$currentPage = $this->passedArgs['pages'];
|
|
} else {
|
|
$currentPage = 1;
|
|
}
|
|
$this->set('page', $currentPage);
|
|
|
|
$this->set('entries', $taxonomy['entries']);
|
|
$this->set('urlparams', $urlparams);
|
|
$this->set('passedArgs', json_encode($this->passedArgs));
|
|
$this->set('passedArgsArray', $this->passedArgs);
|
|
$this->set('taxonomy', $taxonomy['Taxonomy']);
|
|
$this->set('id', $taxonomy['Taxonomy']['id']);
|
|
$this->set('title_for_layout', __('%s Taxonomy Library', h(strtoupper($taxonomy['Taxonomy']['namespace']))));
|
|
$this->render('ajax/taxonomy_tags');
|
|
}
|
|
|
|
public function export($id)
|
|
{
|
|
$taxonomy = $this->Taxonomy->find('first', [
|
|
'recursive' => -1,
|
|
'contain' => ['TaxonomyPredicate' => ['TaxonomyEntry']],
|
|
'conditions' => is_numeric($id) ? ['Taxonomy.id' => $id] : ['LOWER(Taxonomy.namespace)' => mb_strtolower($id)],
|
|
]);
|
|
if (empty($taxonomy)) {
|
|
throw new NotFoundException(__('Taxonomy not found.'));
|
|
}
|
|
|
|
$data = [
|
|
'namespace' => $taxonomy['Taxonomy']['namespace'],
|
|
'description' => $taxonomy['Taxonomy']['description'],
|
|
'version' => (int)$taxonomy['Taxonomy']['version'],
|
|
'exclusive' => $taxonomy['Taxonomy']['exclusive'],
|
|
'predicates' => [],
|
|
];
|
|
|
|
foreach ($taxonomy['TaxonomyPredicate'] as $predicate) {
|
|
$predicateOutput = [];
|
|
foreach (['value', 'expanded', 'colour', 'description', 'exclusive', 'numerical_value'] as $field) {
|
|
if (isset($predicate[$field]) && !empty($predicate[$field])) {
|
|
$predicateOutput[$field] = $predicate[$field];
|
|
}
|
|
}
|
|
$data['predicates'][] = $predicateOutput;
|
|
|
|
if (!empty($predicate['TaxonomyEntry'])) {
|
|
$entries = [];
|
|
foreach ($predicate['TaxonomyEntry'] as $entry) {
|
|
$entryOutput = [];
|
|
foreach(['value', 'expanded', 'colour', 'description', 'exclusive', 'numerical_value'] as $field) {
|
|
if (isset($entry[$field]) && !empty($entry[$field])) {
|
|
$entryOutput[$field] = $entry[$field];
|
|
}
|
|
}
|
|
$entries[] = $entryOutput;
|
|
}
|
|
$data['values'][] = [
|
|
'predicate' => $predicate['value'],
|
|
'entry' => $entries,
|
|
];
|
|
}
|
|
}
|
|
|
|
return $this->RestResponse->viewData($data, 'json');
|
|
}
|
|
|
|
public function enable($id)
|
|
{
|
|
$this->request->allowMethod(['post']);
|
|
|
|
$taxonomy = $this->Taxonomy->find('first', array(
|
|
'recursive' => -1,
|
|
'conditions' => array('Taxonomy.id' => $id),
|
|
));
|
|
$taxonomy['Taxonomy']['enabled'] = true;
|
|
$this->Taxonomy->save($taxonomy);
|
|
|
|
$this->__log('enable', $id, 'Taxonomy enabled', $taxonomy['Taxonomy']['namespace'] . ' - enabled');
|
|
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveSuccessResponse('Taxonomy', 'enable', $id, $this->response->type());
|
|
} else {
|
|
$this->Flash->success(__('Taxonomy enabled.'));
|
|
$this->redirect($this->referer());
|
|
}
|
|
}
|
|
|
|
public function disable($id)
|
|
{
|
|
$this->request->allowMethod(['post']);
|
|
|
|
$taxonomy = $this->Taxonomy->find('first', array(
|
|
'recursive' => -1,
|
|
'conditions' => array('Taxonomy.id' => $id),
|
|
));
|
|
$this->Taxonomy->disableTags($id);
|
|
$taxonomy['Taxonomy']['enabled'] = 0;
|
|
$this->Taxonomy->save($taxonomy);
|
|
|
|
$this->__log('disable', $id, 'Taxonomy disabled', $taxonomy['Taxonomy']['namespace'] . ' - disabled');
|
|
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveSuccessResponse('Taxonomy', 'disable', $id, $this->response->type());
|
|
} else {
|
|
$this->Flash->success(__('Taxonomy disabled.'));
|
|
$this->redirect($this->referer());
|
|
}
|
|
}
|
|
|
|
public function import()
|
|
{
|
|
$this->request->allowMethod(['post']);
|
|
|
|
try {
|
|
$id = $this->Taxonomy->import($this->request->data);
|
|
return $this->view($id);
|
|
} catch (Exception $e) {
|
|
return $this->RestResponse->saveFailResponse('Taxonomy', 'import', false, $e->getMessage());
|
|
}
|
|
}
|
|
|
|
public function update()
|
|
{
|
|
$result = $this->Taxonomy->update();
|
|
$fails = 0;
|
|
$successes = 0;
|
|
if (!empty($result)) {
|
|
if (isset($result['success'])) {
|
|
foreach ($result['success'] as $id => $success) {
|
|
if (isset($success['old'])) {
|
|
$change = $success['namespace'] . ': updated from v' . $success['old'] . ' to v' . $success['new'];
|
|
} else {
|
|
$change = $success['namespace'] . ' v' . $success['new'] . ' installed';
|
|
}
|
|
$this->__log('update', $id, 'Taxonomy updated', $change);
|
|
$successes++;
|
|
}
|
|
}
|
|
if (isset($result['fails'])) {
|
|
foreach ($result['fails'] as $id => $fail) {
|
|
$this->__log('update', $id, 'Taxonomy failed to update', $fail['namespace'] . ' could not be installed/updated. Error: ' . $fail['fail']);
|
|
$fails++;
|
|
}
|
|
}
|
|
} else {
|
|
$this->__log('update', 0, 'Taxonomy update (nothing to update)', 'Executed an update of the taxonomy library, but there was nothing to update.');
|
|
}
|
|
if ($successes == 0 && $fails == 0) {
|
|
$flashType = 'info';
|
|
$message = __('All taxonomy libraries are up to date already.');
|
|
} elseif ($successes == 0) {
|
|
$flashType = 'error';
|
|
$message = __('Could not update any of the taxonomy libraries');
|
|
} else {
|
|
$flashType = 'success';
|
|
$message = __('Successfully updated ') . $successes . __(' taxonomy libraries.');
|
|
if ($fails != 0) {
|
|
$message .= __(' However, could not update ') . $fails . __(' taxonomy libraries.');
|
|
}
|
|
}
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveSuccessResponse('Taxonomy', 'update', false, $this->response->type(), $message);
|
|
} else {
|
|
$this->Flash->{$flashType}($message);
|
|
$this->redirect(array('controller' => 'taxonomies', 'action' => 'index'));
|
|
}
|
|
}
|
|
|
|
public function addTag($taxonomy_id = false)
|
|
{
|
|
if ($this->request->is('get')) {
|
|
if (empty($taxonomy_id) && !empty($this->request->params['named']['taxonomy_id'])) {
|
|
$taxonomy_id = $this->request->params['named']['taxonomy_id'];
|
|
}
|
|
if (
|
|
empty($taxonomy_id) ||
|
|
empty($this->request->params['named']['name'])
|
|
) {
|
|
throw new MethodNotAllowedException(__('Taxonomy ID or tag name must be provided.'));
|
|
} else {
|
|
$this->request->data['Taxonomy']['taxonomy_id'] = $taxonomy_id;
|
|
$this->request->data['Taxonomy']['name'] = $this->request->params['named']['name'];
|
|
}
|
|
} else {
|
|
if ($taxonomy_id) {
|
|
$result = $this->Taxonomy->addTags($taxonomy_id);
|
|
} else {
|
|
if (isset($this->request->data['Taxonomy'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Taxonomy'];
|
|
unset($this->request->data['Taxonomy']);
|
|
}
|
|
if (isset($this->request->data['Tag']['request'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Tag']['request'];
|
|
}
|
|
if (!isset($this->request->data['Tag']['nameList'])) {
|
|
$this->request->data['Tag']['nameList'] = array($this->request->data['Tag']['name']);
|
|
} else {
|
|
$this->request->data['Tag']['nameList'] = json_decode($this->request->data['Tag']['nameList'], true);
|
|
}
|
|
$result = $this->Taxonomy->addTags($this->request->data['Tag']['taxonomy_id'], $this->request->data['Tag']['nameList']);
|
|
}
|
|
if ($result) {
|
|
$message = __('The tag(s) has been saved.');
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveSuccessResponse('Taxonomy', 'addTag', $taxonomy_id, $this->response->type(), $message);
|
|
}
|
|
$this->Flash->success($message);
|
|
} else {
|
|
$message = __('The tag(s) could not be saved. Please, try again.');
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveFailResponse('Taxonomy', 'addTag', $taxonomy_id, $message, $this->response->type());
|
|
}
|
|
$this->Flash->error($message);
|
|
}
|
|
$this->redirect($this->referer());
|
|
}
|
|
}
|
|
|
|
public function hideTag($taxonomy_id = false)
|
|
{
|
|
$this->request->allowMethod(['post']);
|
|
|
|
if ($taxonomy_id) {
|
|
$result = $this->Taxonomy->hideTags($taxonomy_id);
|
|
} else {
|
|
if (isset($this->request->data['Taxonomy'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Taxonomy'];
|
|
unset($this->request->data['Taxonomy']);
|
|
}
|
|
if (isset($this->request->data['Tag']['request'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Tag']['request'];
|
|
}
|
|
if (!isset($this->request->data['Tag']['nameList'])) {
|
|
$this->request->data['Tag']['nameList'] = array($this->request->data['Tag']['name']);
|
|
} else {
|
|
$this->request->data['Tag']['nameList'] = json_decode($this->request->data['Tag']['nameList'], true);
|
|
}
|
|
$result = $this->Taxonomy->hideTags($this->request->data['Tag']['taxonomy_id'], $this->request->data['Tag']['nameList']);
|
|
}
|
|
if ($result) {
|
|
$this->Flash->success(__('The tag(s) has been saved.'));
|
|
} else {
|
|
$this->Flash->error(__('The tag(s) could not be saved. Please, try again.'));
|
|
}
|
|
$this->redirect($this->referer());
|
|
}
|
|
|
|
public function unhideTag($taxonomy_id = false)
|
|
{
|
|
$this->request->allowMethod(['post']);
|
|
|
|
if ($taxonomy_id) {
|
|
$result = $this->Taxonomy->unhideTags($taxonomy_id);
|
|
} else {
|
|
if (isset($this->request->data['Taxonomy'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Taxonomy'];
|
|
unset($this->request->data['Taxonomy']);
|
|
}
|
|
if (isset($this->request->data['Tag']['request'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Tag']['request'];
|
|
}
|
|
if (!isset($this->request->data['Tag']['nameList'])) {
|
|
$this->request->data['Tag']['nameList'] = array($this->request->data['Tag']['name']);
|
|
} else {
|
|
$this->request->data['Tag']['nameList'] = json_decode($this->request->data['Tag']['nameList'], true);
|
|
}
|
|
$result = $this->Taxonomy->unhideTags($this->request->data['Tag']['taxonomy_id'], $this->request->data['Tag']['nameList']);
|
|
}
|
|
if ($result) {
|
|
$this->Flash->success(__('The tag(s) has been saved.'));
|
|
} else {
|
|
$this->Flash->error(__('The tag(s) could not be saved. Please, try again.'));
|
|
}
|
|
$this->redirect($this->referer());
|
|
}
|
|
|
|
public function disableTag($taxonomy_id = false)
|
|
{
|
|
if ($this->request->is('get')) {
|
|
if (empty($taxonomy_id) && !empty($this->request->params['named']['taxonomy_id'])) {
|
|
$taxonomy_id = $this->request->params['named']['taxonomy_id'];
|
|
}
|
|
if (
|
|
empty($taxonomy_id) ||
|
|
empty($this->request->params['named']['name'])
|
|
) {
|
|
throw new MethodNotAllowedException(__('Taxonomy ID or tag name must be provided.'));
|
|
} else {
|
|
$this->request->data['Taxonomy']['taxonomy_id'] = $taxonomy_id;
|
|
$this->request->data['Taxonomy']['name'] = $this->request->params['named']['name'];
|
|
}
|
|
} else {
|
|
if ($taxonomy_id) {
|
|
$result = $this->Taxonomy->disableTags($taxonomy_id);
|
|
} else {
|
|
if (isset($this->request->data['Taxonomy'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Taxonomy'];
|
|
unset($this->request->data['Taxonomy']);
|
|
}
|
|
if (isset($this->request->data['Tag']['request'])) {
|
|
$this->request->data['Tag'] = $this->request->data['Tag']['request'];
|
|
}
|
|
if (!isset($this->request->data['Tag']['nameList'])) {
|
|
$this->request->data['Tag']['nameList'] = array($this->request->data['Tag']['name']);
|
|
} else {
|
|
$this->request->data['Tag']['nameList'] = json_decode($this->request->data['Tag']['nameList'], true);
|
|
}
|
|
$result = $this->Taxonomy->disableTags($this->request->data['Tag']['taxonomy_id'], $this->request->data['Tag']['nameList']);
|
|
}
|
|
if ($result) {
|
|
$this->Flash->success(__('The tag(s) has been hidden.'));
|
|
} else {
|
|
$this->Flash->error(__('The tag(s) could not be hidden. Please, try again.'));
|
|
}
|
|
$this->redirect($this->referer());
|
|
}
|
|
}
|
|
|
|
public function taxonomyMassConfirmation($id)
|
|
{
|
|
$this->set('id', $id);
|
|
$this->render('ajax/taxonomy_mass_confirmation');
|
|
}
|
|
|
|
public function taxonomyMassHide($id)
|
|
{
|
|
$this->set('id', $id);
|
|
$this->render('ajax/taxonomy_mass_hide');
|
|
}
|
|
|
|
public function taxonomyMassUnhide($id)
|
|
{
|
|
$this->set('id', $id);
|
|
$this->render('ajax/taxonomy_mass_unhide');
|
|
}
|
|
|
|
public function delete($id)
|
|
{
|
|
if ($this->request->is('post')) {
|
|
$result = $this->Taxonomy->delete($id, true);
|
|
if ($result) {
|
|
$this->Flash->success(__('Taxonomy successfully deleted.'));
|
|
$this->redirect(array('controller' => 'taxonomies', 'action' => 'index'));
|
|
} else {
|
|
$this->Flash->error(__('Taxonomy could not be deleted.'));
|
|
$this->redirect(array('controller' => 'taxonomies', 'action' => 'index'));
|
|
}
|
|
} else {
|
|
if ($this->request->is('ajax')) {
|
|
$this->set('id', $id);
|
|
$this->render('ajax/taxonomy_delete_confirmation');
|
|
} else {
|
|
throw new MethodNotAllowedException(__('This function can only be reached via AJAX.'));
|
|
}
|
|
}
|
|
}
|
|
|
|
public function toggleRequired($id)
|
|
{
|
|
$taxonomy = $this->Taxonomy->find('first', array(
|
|
'recursive' => -1,
|
|
'conditions' => array('Taxonomy.id' => $id)
|
|
));
|
|
if (empty($taxonomy)) {
|
|
return $this->RestResponse->saveFailResponse('Taxonomy', 'toggleRequired', $id, 'Invalid Taxonomy', $this->response->type());
|
|
}
|
|
if ($this->request->is('post')) {
|
|
$taxonomy['Taxonomy']['required'] = $this->request->data['Taxonomy']['required'];
|
|
$result = $this->Taxonomy->save($taxonomy);
|
|
if ($result) {
|
|
return $this->RestResponse->saveSuccessResponse('Taxonomy', 'toggleRequired', $id, $this->response->type());
|
|
} else {
|
|
return $this->RestResponse->saveFailResponse('Taxonomy', 'toggleRequired', $id, $this->validationError, $this->response->type());
|
|
}
|
|
}
|
|
|
|
$this->set('required', !$taxonomy['Taxonomy']['required']);
|
|
$this->set('id', $id);
|
|
$this->autoRender = false;
|
|
$this->layout = 'ajax';
|
|
$this->render('ajax/toggle_required');
|
|
}
|
|
|
|
/**
|
|
* @param string $action
|
|
* @param int $modelId
|
|
* @param string $title
|
|
* @param string $change
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
private function __log($action, $modelId, $title, $change)
|
|
{
|
|
/** @var Log $log */
|
|
$log = ClassRegistry::init('Log');
|
|
$log->createLogEntry($this->Auth->user(), $action, 'Taxonomy', $modelId, $title, $change);
|
|
}
|
|
|
|
/**
|
|
* Attach tag counts.
|
|
* @param array $taxonomies
|
|
* @return array
|
|
*/
|
|
private function __tagCount(array $taxonomies)
|
|
{
|
|
$tags = [];
|
|
foreach ($taxonomies as $taxonomyPos => $taxonomy) {
|
|
$total = 0;
|
|
foreach ($taxonomy['TaxonomyPredicate'] as $predicate) {
|
|
if (isset($predicate['TaxonomyEntry']) && !empty($predicate['TaxonomyEntry'])) {
|
|
foreach ($predicate['TaxonomyEntry'] as $entry) {
|
|
$tag = mb_strtolower($taxonomy['Taxonomy']['namespace'] . ':' . $predicate['value'] . '="' . $entry['value'] . '"');
|
|
$tags[$tag] = $taxonomyPos;
|
|
$total++;
|
|
}
|
|
} else {
|
|
$tag = mb_strtolower($taxonomy['Taxonomy']['namespace'] . ':' . $predicate['value']);
|
|
$tags[$tag] = $taxonomyPos;
|
|
$total++;
|
|
}
|
|
}
|
|
$taxonomies[$taxonomyPos]['total_count'] = $total;
|
|
$taxonomies[$taxonomyPos]['current_count'] = 0;
|
|
unset($taxonomies[$taxonomyPos]['TaxonomyPredicate']);
|
|
}
|
|
|
|
$this->loadModel('Tag');
|
|
$existingTags = $this->Tag->find('column', [
|
|
'fields' => ['Tag.name'],
|
|
'conditions' => [
|
|
'lower(Tag.name)' => array_keys($tags),
|
|
'hide_tag' => 0
|
|
],
|
|
]);
|
|
|
|
foreach ($existingTags as $existingTag) {
|
|
$existingTag = mb_strtolower($existingTag);
|
|
if (isset($tags[$existingTag])) {
|
|
$taxonomies[$tags[$existingTag]]['current_count']++;
|
|
}
|
|
}
|
|
|
|
return $taxonomies;
|
|
}
|
|
|
|
private function __search($value)
|
|
{
|
|
$value = mb_strtolower(trim($value));
|
|
$searchTerm = "%$value%";
|
|
$taxonomyPredicateIds = $this->Taxonomy->TaxonomyPredicate->TaxonomyEntry->find('column', [
|
|
'fields' => ['TaxonomyEntry.taxonomy_predicate_id'],
|
|
'conditions' => ['OR' => [
|
|
'LOWER(value) LIKE' => $searchTerm,
|
|
'LOWER(expanded) LIKE' => $searchTerm,
|
|
]],
|
|
'unique' => true,
|
|
]);
|
|
|
|
$taxonomyIds = $this->Taxonomy->TaxonomyPredicate->find('column', [
|
|
'fields' => ['TaxonomyPredicate.taxonomy_id'],
|
|
'conditions' => ['OR' => [
|
|
'id' => $taxonomyPredicateIds,
|
|
'LOWER(value) LIKE' => $searchTerm,
|
|
'LOWER(expanded) LIKE' => $searchTerm,
|
|
]],
|
|
'unique' => true,
|
|
]);
|
|
|
|
$taxonomyIds = $this->Taxonomy->find('column', [
|
|
'fields' => ['Taxonomy.id'],
|
|
'conditions' => ['OR' => [
|
|
'id' => $taxonomyIds,
|
|
'LOWER(namespace) LIKE' => $searchTerm,
|
|
'LOWER(description) LIKE' => $searchTerm,
|
|
]],
|
|
]);
|
|
|
|
return $taxonomyIds;
|
|
}
|
|
}
|