mirror of https://github.com/MISP/MISP
710 lines
34 KiB
PHP
710 lines
34 KiB
PHP
<?php
|
|
|
|
App::uses('AppController', 'Controller');
|
|
|
|
class DecayingModelController extends AppController
|
|
{
|
|
public $components = array('RequestHandler');
|
|
|
|
public $paginate = array(
|
|
'limit' => 50,
|
|
'order' => array(
|
|
'DecayingModel.ID' => 'desc'
|
|
)
|
|
);
|
|
|
|
public function update($force=false)
|
|
{
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
$this->DecayingModel->update($force, $this->Auth->user());
|
|
$message = __('Default decaying models updated');
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->saveSuccessResponse('DecayingModel', 'update', false, $this->response->type(), $message);
|
|
} else {
|
|
$this->Flash->success($message);
|
|
$this->redirect(array('controller' => 'decayingModel', 'action' => 'index'));
|
|
}
|
|
} else {
|
|
throw new MethodNotAllowedException(__("This method is not allowed"));
|
|
}
|
|
}
|
|
|
|
public function export($model_id)
|
|
{
|
|
$model = $this->DecayingModel->fetchModel($this->Auth->user(), $model_id, true);
|
|
if (empty($model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
unset($model['DecayingModel']['id'], $model['DecayingModel']['uuid'], $model['DecayingModel']['org_id'], $model['DecayingModelMapping']);
|
|
return $this->RestResponse->viewData($model, $this->response->type());
|
|
}
|
|
|
|
public function import()
|
|
{
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
$data = $this->request->data['DecayingModel'];
|
|
$text = FileAccessTool::getTempUploadedFile($data['submittedjson'], $data['json']);
|
|
$json = json_decode($text, true);
|
|
if ($json === null) {
|
|
throw new MethodNotAllowedException(__('Error while decoding JSON'));
|
|
}
|
|
|
|
unset($json['id']);
|
|
unset($json['uuid']);
|
|
$json['default'] = 0;
|
|
$json['org_id'] = $this->Auth->user()['org_id'];
|
|
|
|
$attribute_types = array();
|
|
if (!empty($json['attribute_types'])) {
|
|
$attribute_types = $json['attribute_types'];
|
|
unset($json['attribute_types']);
|
|
}
|
|
|
|
if ($this->DecayingModel->save($json)) {
|
|
$saved_model = array(
|
|
'model_id' => $this->DecayingModel->id,
|
|
'attribute_types' => $attribute_types
|
|
);
|
|
if (!empty($saved_model['attribute_types'])) {
|
|
$result = $this->DecayingModel->DecayingModelMapping->resetMappingForModel($saved_model, $this->Auth->user());
|
|
} else {
|
|
$result = true;
|
|
}
|
|
if (!empty($result)) {
|
|
$this->Flash->success(__('The model has been imported.'));
|
|
} else {
|
|
$this->Flash->error(__('The model has been imported. However importing mapping failed.'));
|
|
}
|
|
} else {
|
|
$this->Flash->error(__('Error while importing model.'));
|
|
}
|
|
$this->redirect(array('action' => 'index'));
|
|
}
|
|
}
|
|
|
|
public function view($id)
|
|
{
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $id, true);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$this->set('id', $id);
|
|
$this->set('decaying_model', $decaying_model);
|
|
$available_formulas = $this->DecayingModel->listAvailableFormulas();
|
|
$this->set('available_formulas', $available_formulas);
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->viewData($decaying_model, $this->response->type());
|
|
}
|
|
}
|
|
|
|
// Sets pagination condition for url parameters
|
|
private function __setIndexFilterConditions($passedArgs)
|
|
{
|
|
$white_list_url_parameters = array('sort', 'direction');
|
|
$passedArgsArray = array();
|
|
foreach ($passedArgs as $k => $v) {
|
|
switch ($k) {
|
|
case 'my_models':
|
|
$passedArgsArray[$k] = $v;
|
|
if ($v) {
|
|
$this->paginate['conditions']['AND'] = array('DecayingModel.org_id' => $this->Auth->user('Organisation')['id']);
|
|
}
|
|
break;
|
|
case 'default_models':
|
|
$passedArgsArray[$k] = $v;
|
|
if ($v) {
|
|
$this->paginate['conditions']['AND'] = array('not' => array('DecayingModel.uuid' => null));
|
|
}
|
|
break;
|
|
case 'all_orgs':
|
|
$passedArgsArray[$k] = $v;
|
|
if ($v) {
|
|
$this->paginate['conditions']['AND'] = array('DecayingModel.all_orgs' => $v);
|
|
}
|
|
break;
|
|
default:
|
|
if (in_array($k, $white_list_url_parameters)) {
|
|
$passedArgsArray[$k] = $v;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $passedArgsArray;
|
|
}
|
|
|
|
public function index()
|
|
{
|
|
$conditions = array();
|
|
if (!$this->_isSiteAdmin()) {
|
|
$conditions['OR'] = array(
|
|
'org_id' => $this->Auth->user('Organisation')['id'],
|
|
'all_orgs' => 1
|
|
);
|
|
$this->paginate = Set::merge($this->paginate, array(
|
|
'conditions' => $conditions
|
|
));
|
|
}
|
|
$passedArgsArray = $this->__setIndexFilterConditions($this->passedArgs);
|
|
$this->set('passedArgsArray', $passedArgsArray);
|
|
$this->set('decayingModels', $this->paginate());
|
|
$available_formulas = $this->DecayingModel->listAvailableFormulas();
|
|
$this->set('available_formulas', $available_formulas);
|
|
if ($this->_isRest()) {
|
|
return $this->RestResponse->viewData($this->paginate(), $this->response->type());
|
|
}
|
|
}
|
|
|
|
public function add()
|
|
{
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
if (!isset($this->request->data['DecayingModel'])) {
|
|
$this->request->data = array('DecayingModel' => $this->request->data);
|
|
}
|
|
|
|
$this->request->data['DecayingModel']['org_id'] = $this->Auth->user()['org_id'];
|
|
unset($this->request->data['DecayingModel']['id']);
|
|
unset($this->request->data['DecayingModel']['uuid']);
|
|
$this->request->data['DecayingModel']['default'] = 0;
|
|
|
|
if (empty($this->request->data['DecayingModel']['name'])) {
|
|
throw new MethodNotAllowedException(__("The model must have a name"));
|
|
}
|
|
$this->request->data = $this->__adjustJSONData($this->request->data);
|
|
if ($this->request->data === false) {
|
|
return false;
|
|
}
|
|
$attribute_types = array();
|
|
if (!empty($this->request->data['attribute_types'])) {
|
|
$attribute_types = $this->request->data['attribute_types'];
|
|
unset($this->request->data['attribute_types']);
|
|
}
|
|
if ($this->DecayingModel->save($this->request->data)) {
|
|
$success_message = __('The model has been saved.');
|
|
if (!empty($saved_model['attribute_types'])) {
|
|
if (!$this->DecayingModel->DecayingModelMapping->resetMappingForModel($saved_model, $this->Auth->user())) {
|
|
$success_message = __('The model has been saved. However importing mapping failed.');
|
|
}
|
|
}
|
|
if ($this->request->is('ajax') || $this->_isRest()) {
|
|
$saved = $this->DecayingModel->fetchModel($this->Auth->user(), $this->DecayingModel->id, true, array(), true);
|
|
if (empty($saved)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $saved, 'action' => 'add');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->success($sucess_messaqge);
|
|
$this->redirect(array('action' => 'index'));
|
|
}
|
|
} else {
|
|
if ($this->request->is('ajax') || $this->_isRest()) {
|
|
$response = array(
|
|
'action' => 'add',
|
|
'saved' => false,
|
|
'errors' => array(__('The model could not be saved. Please try again.'))
|
|
);
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->error(__('The model could not be saved. Please try again.' . $this->here));
|
|
$this->redirect($this->here);
|
|
}
|
|
}
|
|
} else {
|
|
$this->set('action', 'add');
|
|
$available_formulas = $this->DecayingModel->listAvailableFormulas();
|
|
$formulas = array();
|
|
foreach ($available_formulas as $formulaName => $f) {
|
|
$formulas[$formulaName] = $formulaName;
|
|
}
|
|
$this->set('available_formulas', $formulas);
|
|
}
|
|
}
|
|
|
|
public function edit($id)
|
|
{
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $id);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$enforceRestrictedEdition = $decaying_model['DecayingModel']['default'];
|
|
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
|
|
$this->request->data['DecayingModel']['id'] = $id;
|
|
$fieldListToSave = array('enabled', 'all_orgs');
|
|
if (!$enforceRestrictedEdition) {
|
|
$fieldListToSave = array_merge($fieldListToSave, array('name', 'description', 'parameters', 'formula'));
|
|
$this->request->data = $this->__adjustJSONData($this->request->data);
|
|
if ($this->request->data === false) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$save_result = $this->DecayingModel->save($this->request->data, true, $fieldListToSave);
|
|
if ($save_result) {
|
|
if ($this->request->is('ajax') || $this->_isRest()) {
|
|
$saved = $this->DecayingModel->fetchModel($this->Auth->user(), $this->DecayingModel->id, true, array(), true);
|
|
if (empty($saved)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $saved, 'action' => 'edit');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->success(__('The model has been saved.'));
|
|
$this->redirect(array('action' => 'index'));
|
|
}
|
|
} else {
|
|
if ($this->request->is('ajax') || $this->_isRest()) {
|
|
$saved = $this->DecayingModel->fetchModel($this->Auth->user(), $this->DecayingModel->id);
|
|
if (empty($saved)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $saved, 'action' => 'edit', 'saved' => false);
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->error(__('The model could not be saved. Please try again.' . $this->here));
|
|
$this->redirect($this->here);
|
|
}
|
|
}
|
|
} else {
|
|
$this->request->data = $decaying_model;
|
|
$this->set('id', $id);
|
|
$this->set('decayingModel', $decaying_model);
|
|
$this->set('restrictEdition', $enforceRestrictedEdition);
|
|
$this->set('action', 'edit');
|
|
$available_formulas = $this->DecayingModel->listAvailableFormulas();
|
|
$formulas = array();
|
|
foreach ($available_formulas as $formulaName => $f) {
|
|
$formulas[$formulaName] = $formulaName;
|
|
}
|
|
$this->set('available_formulas', $formulas);
|
|
$this->render('add');
|
|
}
|
|
}
|
|
|
|
// Adjust or flash the error to the user
|
|
private function __adjustJSONData($json)
|
|
{
|
|
if (isset($json['DecayingModel']['parameters'])) {
|
|
if (isset($json['DecayingModel']['parameters']['settings']) && !is_array($json['DecayingModel']['parameters']['settings'])) {
|
|
$settings = json_decode($json['DecayingModel']['parameters']['settings'], true);
|
|
if ($settings === null) {
|
|
$this->Flash->error(__('Invalid JSON `Settings`.'));
|
|
return false;
|
|
}
|
|
$json['DecayingModel']['parameters']['settings'] = $settings;
|
|
}
|
|
if (!isset($json['DecayingModel']['parameters']['lifetime'])) {
|
|
$this->Flash->error(__('Invalid parameter `lifetime`.'));
|
|
return false;
|
|
}
|
|
if (!isset($json['DecayingModel']['parameters']['decay_speed'])) {
|
|
$this->Flash->error(__('Invalid parameter `decay_speed`.'));
|
|
return false;
|
|
}
|
|
if (!isset($json['DecayingModel']['parameters']['threshold'])) {
|
|
$this->Flash->error(__('Invalid parameter `threshold`.'));
|
|
return false;
|
|
}
|
|
if (!isset($json['DecayingModel']['parameters']['default_base_score'])) {
|
|
$this->Flash->error(__('Invalid parameter `default_base_score`.'));
|
|
return false;
|
|
}
|
|
if (isset($json['DecayingModel']['parameters']['base_score_config']) && $json['DecayingModel']['parameters']['base_score_config'] != '') {
|
|
if (!is_array($json['DecayingModel']['parameters']['base_score_config'])) {
|
|
$encoded = json_decode($json['DecayingModel']['parameters']['base_score_config'], true);
|
|
if ($encoded === null) {
|
|
$this->Flash->error(__('Invalid parameter `base_score_config`.'));
|
|
return false;
|
|
}
|
|
$json['DecayingModel']['parameters']['base_score_config'] = $encoded;
|
|
}
|
|
} else {
|
|
$json['DecayingModel']['parameters']['base_score_config'] = new stdClass();
|
|
}
|
|
} else {
|
|
$this->Flash->error(__('Missing JSON key `parameters`.'));
|
|
return false;
|
|
}
|
|
$json['DecayingModel']['parameters'] = json_encode($json['DecayingModel']['parameters']);
|
|
return $json;
|
|
}
|
|
|
|
public function delete($id)
|
|
{
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $id);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
if (
|
|
!$this->DecayingModel->isEditableByCurrentUser($this->Auth->user(), $decaying_model) ||
|
|
$decaying_model['DecayingModel']['default']
|
|
) {
|
|
throw new MethodNotAllowedException(__('You are not authorised to delete this model.'));
|
|
}
|
|
|
|
if ($this->DecayingModel->delete($id, true)) {
|
|
if ($this->request->is('ajax')) {
|
|
$response = array('action' => 'delete', 'saved' => true);
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->success(__('Decaying Model deleted.'));
|
|
}
|
|
} else {
|
|
$error_message = __('The Decaying Model could not be deleted.');
|
|
if ($this->request->is('ajax')) {
|
|
$response = array('action' => 'delete', 'saved' => false, 'errors' => array($error_message));
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else {
|
|
$this->Flash->error($error_message);
|
|
}
|
|
}
|
|
$this->redirect(array('action' => 'index'));
|
|
}
|
|
}
|
|
|
|
public function enable($id)
|
|
{
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $id);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
if (!$this->DecayingModel->isEditableByCurrentUser($this->Auth->user(), $decaying_model)) {
|
|
throw new MethodNotAllowedException(__('You are not authorised to enable this model.'));
|
|
}
|
|
|
|
$decaying_model['DecayingModel']['enabled'] = 1;
|
|
if ($this->DecayingModel->save($decaying_model)) {
|
|
$model = $this->DecayingModel->fetchModel($this->Auth->user(), $id, true, array(), true);
|
|
if (empty($model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $model, 'action' => 'enable');
|
|
if ($this->request->is('ajax')) {
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else if ($this->_isRest()) {
|
|
return $this->RestResponse->successResponse($id, __('Decaying model enabled'), $model);
|
|
}
|
|
$this->Flash->success(__('Decaying Model enabled.'));
|
|
} else {
|
|
if ($this->request->is('ajax')) { // ajax caller expect data to be returned to update the DOM accordingly
|
|
$model = $this->DecayingModel->fetchModel($this->Auth->user(), $id, true, array(), true);
|
|
if (empty($model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $model, 'action' => 'enable');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} elseif ($this->_isRest()) {
|
|
$response = array('errors' => $array(__('Error while enabling decaying model')), 'action' => 'enable');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
}
|
|
$this->Flash->error(__('Error while enabling decaying model'));
|
|
}
|
|
$this->redirect(array('action' => 'index'));
|
|
} else {
|
|
$this->set('model', $decaying_model['DecayingModel']);
|
|
$this->render('ajax/enable_form');
|
|
}
|
|
}
|
|
|
|
public function disable($id)
|
|
{
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $id);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
if (!$this->DecayingModel->isEditableByCurrentUser($this->Auth->user(), $decaying_model)) {
|
|
throw new MethodNotAllowedException(__('You are not authorised to disable this model.'));
|
|
}
|
|
|
|
$decaying_model['DecayingModel']['enabled'] = 0;
|
|
if ($this->DecayingModel->save($decaying_model)) {
|
|
$model = $this->DecayingModel->fetchModel($this->Auth->user(), $id, true, array(), true);
|
|
if (empty($model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $model, 'action' => 'disable');
|
|
if ($this->request->is('ajax')) {
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} else if ($this->_isRest()) {
|
|
return $this->RestResponse->successResponse($id, __('Decaying model disabled'), $model);
|
|
}
|
|
$this->Flash->success(__('Decaying Model disabled.'));
|
|
} else {
|
|
if ($this->request->is('ajax')) { // ajax caller expect data to be returned to update the DOM accordingly
|
|
$model = $this->DecayingModel->fetchModel($this->Auth->user(), $id, true, array(), true);
|
|
if (empty($model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
$response = array('data' => $model, 'action' => 'disable');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
} elseif ($this->_isRest()) {
|
|
$response = array('errors' => $array(__('Error while enabling decaying model')), 'action' => 'disable');
|
|
return $this->RestResponse->viewData($response, $this->response->type());
|
|
}
|
|
$this->Flash->error(__('Error while disabling decaying model'));
|
|
}
|
|
$this->redirect(array('action' => 'index'));
|
|
} else {
|
|
$this->set('model', $decaying_model['DecayingModel']);
|
|
$this->render('ajax/disable_form');
|
|
}
|
|
}
|
|
|
|
public function decayingTool()
|
|
{
|
|
$parameters = array(
|
|
'lifetime' => array(
|
|
'value' => 30,
|
|
'step' => 1,
|
|
'max' => 365,
|
|
'greek' => '',
|
|
'unit' => 'days',
|
|
'name' => __('Lifetime'),
|
|
'info' => __('Lifetime of the attribute, or time after which the score will be 0')
|
|
),
|
|
'decay_speed' => array(
|
|
'value' => 0.3,
|
|
'step' => 0.1,
|
|
'max' => 10,
|
|
'greek' => '',
|
|
'name' => __('Decay speed'),
|
|
'info' => __('Decay speed at which an indicator will loose score')
|
|
),
|
|
'threshold' => array(
|
|
'value' => 30,
|
|
'step' => 1,
|
|
'max' => 100,
|
|
'greek' => '',
|
|
'name' => __('Cutoff threshold'),
|
|
'info' => __('Cutoff value at which an indicator will be marked as decayed instead of 0')
|
|
)
|
|
);
|
|
$types = $this->User->Event->Attribute->typeDefinitions;
|
|
$this->loadModel('ObjectTemplateElement');
|
|
$objectTypes = $this->ObjectTemplateElement->getAllAvailableTypes();
|
|
array_walk($objectTypes, function(&$item, $key) use ($types) {
|
|
$item["isObject"] = true;
|
|
$isAttribute = isset($types[$key]);
|
|
if ($isAttribute) {
|
|
$item["isAttribute"] = true;
|
|
$item["default_category"] = $types[$key]['default_category'];
|
|
$item["to_ids"] = $types[$key]['to_ids'];
|
|
} else {
|
|
$item["default_category"] = $item["category"];
|
|
}
|
|
});
|
|
$types = array_merge($types, $objectTypes);
|
|
ksort($types);
|
|
$savedDecayingModels = $this->DecayingModel->fetchAllAllowedModels($this->Auth->user());
|
|
$available_formulas = $this->DecayingModel->listAvailableFormulas();
|
|
|
|
$this->set('available_formulas', $available_formulas);
|
|
$this->set('parameters', $parameters);
|
|
$this->set('types', $types);
|
|
$this->set('savedModels', $savedDecayingModels);
|
|
$associated_models = $this->DecayingModel->DecayingModelMapping->getAssociatedModels($this->Auth->user()); // mapping Attribute.type => Models
|
|
$this->set('associated_models', $associated_models);
|
|
}
|
|
|
|
public function getAllDecayingModels()
|
|
{
|
|
$filters = $this->request->query;
|
|
$savedDecayingModels = $this->DecayingModel->fetchAllAllowedModels($this->Auth->user(), true, $filters);
|
|
return $this->RestResponse->viewData($savedDecayingModels, $this->response->type());
|
|
}
|
|
|
|
public function decayingToolBasescore()
|
|
{
|
|
$taxonomies = $this->DecayingModel->listTaxonomiesWithNumericalValue();
|
|
$this->set('taxonomies', $taxonomies['taxonomies']);
|
|
$this->set('taxonomies_not_having_numerical_value', $taxonomies['not_having_numerical_value']);
|
|
$this->set('excluded_taxonomies', $taxonomies['excluded_taxonomies']);
|
|
}
|
|
|
|
public function decayingToolSimulation($model_id)
|
|
{
|
|
$decaying_model = $this->DecayingModel->fetchModel($this->Auth->user(), $model_id);
|
|
if (empty($decaying_model)) {
|
|
throw new NotFoundException(__('No Decaying Model with the provided ID exists'));
|
|
}
|
|
if (isset($this->request->params['named']['attribute_id'])) {
|
|
$this->set('attribute_id', $this->request->params['named']['attribute_id']);
|
|
}
|
|
$this->set('user', $this->Auth->user());
|
|
$this->set('decaying_model', $decaying_model);
|
|
$allowed_models = $this->DecayingModel->fetchAllAllowedModels($this->Auth->user());
|
|
$this->set('all_models', $allowed_models);
|
|
}
|
|
|
|
// TODO: Consider using the export tool to perform the post treatement
|
|
// as this does not mirror a complete restSearch (not using fetchAttribute)
|
|
public function decayingToolRestSearch($continue = false)
|
|
{
|
|
if ($this->request->is('post') || $this->request->is('put')) {
|
|
$body = $this->request->data['decayingToolRestSearch']['filters'];
|
|
$decoded_body = json_decode($body, true);
|
|
if (is_null($decoded_body)) {
|
|
throw new Exception(__("Error Processing Request, can't parse the body"));
|
|
}
|
|
$this->request->data = $decoded_body;
|
|
$paramArray = array(
|
|
'value' , 'type', 'category', 'org', 'tags', 'from', 'to', 'last', 'eventid', 'withAttachments', 'uuid', 'publish_timestamp',
|
|
'timestamp', 'enforceWarninglist', 'to_ids', 'deleted', 'includeEventUuid', 'event_timestamp', 'threat_level_id', 'includeEventTags',
|
|
'includeProposals', 'returnFormat', 'published', 'limit', 'page', 'requested_attributes', 'includeContext', 'headerless',
|
|
'includeWarninglistHits', 'attackGalaxy', 'object_relation', 'id', 'includeDecayScore', 'includeFullModel', 'decayingModel', 'excludeDecayed', 'modelOverrides',
|
|
'score'
|
|
);
|
|
$filterData = array(
|
|
'request' => $this->request,
|
|
'named_params' => $this->params['named'],
|
|
'paramArray' => $paramArray,
|
|
'ordered_url_params' => compact($paramArray)
|
|
);
|
|
$exception = false;
|
|
$filters = $this->_harvestParameters($filterData, $exception);
|
|
if ($filters === false) {
|
|
return $exception;
|
|
}
|
|
$filters['includeEventTags'] = 1;
|
|
if (!isset($filters['excludeDecayed'])) {
|
|
$filters['excludeDecayed'] = 0;
|
|
}
|
|
$filters['includeDecayScore'] = 1;
|
|
if (isset($filters['id'])) { // allows searching by id
|
|
if (Validation::uuid($filters['id'])) {
|
|
$filters['uuid'] = $filters['id'];
|
|
} else {
|
|
$attributes = $this->User->Event->Attribute->fetchAttributes($this->Auth->user(), array(
|
|
'conditions' => array('Attribute.id' => $filters['id']),
|
|
'flatten' => 1
|
|
));
|
|
if (!empty($attributes)) {
|
|
$filters['uuid'] = $attributes[0]['Attribute']['uuid'];
|
|
} else {
|
|
$filters['uuid'] = '-1'; // force no result
|
|
}
|
|
}
|
|
unset($filters['id']);
|
|
}
|
|
unset($filterData);
|
|
$this->Session->write('search_attributes_filters', json_encode($filters));
|
|
} elseif ($continue === 'results') {
|
|
$filters = $this->Session->read('search_attributes_filters');
|
|
if (empty($filters)) {
|
|
$filters = array();
|
|
} else {
|
|
$filters = json_decode($filters, true);
|
|
}
|
|
}
|
|
if (isset($filters)) {
|
|
$params = $this->User->Event->Attribute->restSearch($this->Auth->user(), 'json', $filters, true);
|
|
if (!isset($params['conditions']['Attribute.deleted'])) {
|
|
$params['conditions']['Attribute.deleted'] = 0;
|
|
}
|
|
$this->paginate = $params;
|
|
if (empty($this->paginate['limit'])) {
|
|
$this->paginate['limit'] = 60;
|
|
}
|
|
if (empty($this->paginate['page'])) {
|
|
$this->paginate['page'] = 1;
|
|
}
|
|
$this->paginate['recursive'] = -1;
|
|
$this->paginate['contain'] = array(
|
|
'Event' => array(
|
|
'fields' => array('Event.id', 'Event.orgc_id', 'Event.org_id', 'Event.info', 'Event.user_id', 'Event.date'),
|
|
'Orgc' => array('fields' => array('Orgc.id', 'Orgc.name')),
|
|
'Org' => array('fields' => array('Org.id', 'Org.name'))
|
|
),
|
|
'AttributeTag' => array('Tag'),
|
|
'Object' => array(
|
|
'fields' => array('Object.id', 'Object.distribution', 'Object.sharing_group_id')
|
|
)
|
|
);
|
|
$attributes = $this->paginate($this->User->Event->Attribute);
|
|
|
|
if (!empty($options['overrideLimit'])) {
|
|
$overrideLimit = true;
|
|
} else {
|
|
$overrideLimit = false;
|
|
}
|
|
$this->loadModel('GalaxyCluster');
|
|
$cluster_names = $this->GalaxyCluster->find('list', array('fields' => array('GalaxyCluster.tag_name'), 'group' => array('GalaxyCluster.tag_name', 'GalaxyCluster.id')));
|
|
$this->loadModel('Sighting');
|
|
$eventTags = array();
|
|
foreach ($attributes as $k => $attribute) {
|
|
$attributes[$k]['Attribute']['AttributeTag'] = $attributes[$k]['AttributeTag'];
|
|
$attributes[$k]['Attribute'] = $this->User->Event->massageTags($this->Auth->user(), $attributes[$k]['Attribute'], 'Attribute');
|
|
unset($attributes[$k]['AttributeTag']);
|
|
foreach ($attributes[$k]['Attribute']['AttributeTag'] as $k2 => $attributeTag) {
|
|
if (in_array($attributeTag['Tag']['name'], $cluster_names)) {
|
|
unset($attributes[$k]['Attribute']['AttributeTag'][$k2]);
|
|
}
|
|
}
|
|
if (!empty($params['includeEventTags'])) {
|
|
$tagConditions = array('EventTag.event_id' => $attribute['Event']['id']);
|
|
if (empty($params['includeAllTags'])) {
|
|
$tagConditions['Tag.exportable'] = 1;
|
|
}
|
|
$temp = $this->User->Event->EventTag->find('all', array(
|
|
'recursive' => -1,
|
|
'contain' => array('Tag'),
|
|
'conditions' => $tagConditions
|
|
));
|
|
foreach ($temp as $tag) {
|
|
$attributes[$k]['Attribute']['EventTag'][] = $tag;
|
|
}
|
|
}
|
|
if (empty($filters['decayingModel'])) {
|
|
$filters['decayingModel'] = false;
|
|
}
|
|
$model_overrides = isset($filters['modelOverrides']) ? $filters['modelOverrides'] : array();
|
|
if (isset($filters['score'])) {
|
|
$model_overrides['threshold'] = intval($filters['score']);
|
|
}
|
|
$attributes[$k]['Attribute'] = $this->DecayingModel->attachScoresToAttribute($this->Auth->user(), $attributes[$k]['Attribute'], $filters['decayingModel'], $model_overrides);
|
|
if ($filters['excludeDecayed'] && !empty($attributes[$k]['Attribute']['decay_score'])) { // filter out decayed attribute
|
|
$decayed_flag = true;
|
|
foreach ($attributes[$k]['Attribute']['decay_score'] as $decayResult) {
|
|
$decayed_flag = $decayed_flag && $decayResult['decayed'];
|
|
}
|
|
if ($decayed_flag) {
|
|
unset($attributes[$k]);
|
|
}
|
|
}
|
|
}
|
|
$this->set('sightingsData', $this->Sighting->attributesStatistics($attributes, $this->Auth->user()));
|
|
$this->set('attributes', $attributes);
|
|
$this->set('attrDescriptions', $this->User->Event->Attribute->fieldDescriptions);
|
|
$this->set('typeDefinitions', $this->User->Event->Attribute->typeDefinitions);
|
|
$this->set('categoryDefinitions', $this->User->Event->Attribute->categoryDefinitions);
|
|
$this->set('shortDist', $this->User->Event->Attribute->shortDist);
|
|
} else {
|
|
$this->render('decayingToolRestSearchForm');
|
|
}
|
|
}
|
|
|
|
public function decayingToolComputeSimulation($model_id, $attribute_id)
|
|
{
|
|
if (!$this->request->is('ajax')) {
|
|
throw new MethodNotAllowedException(__("This method is only accessible via AJAX."));
|
|
}
|
|
$model_overrides = array();
|
|
if (isset($this->params['named']['modelOverride'])) {
|
|
$model_overrides = $this->params['named']['modelOverride'];
|
|
$model_overrides = json_decode($model_overrides, true);
|
|
if ($model_overrides === null) {
|
|
$model_overrides = array();
|
|
}
|
|
}
|
|
if (isset($this->params['named']['score'])) {
|
|
$model_overrides['threshold'] = intval($this->params['named']['score']);
|
|
}
|
|
$score_overtime = $this->DecayingModel->getScoreOvertime($this->Auth->user(), $model_id, $attribute_id, $model_overrides);
|
|
return $this->RestResponse->viewData($score_overtime, $this->response->type());
|
|
}
|
|
}
|