2020-06-21 21:29:25 +02:00
|
|
|
<?php
|
|
|
|
|
|
|
|
namespace App\Model\Table;
|
|
|
|
|
|
|
|
use App\Model\Table\AppTable;
|
|
|
|
use Cake\ORM\Table;
|
2021-09-06 11:17:25 +02:00
|
|
|
use Cake\ORM\TableRegistry;
|
2020-06-21 21:29:25 +02:00
|
|
|
use Cake\Validation\Validator;
|
2021-02-24 11:05:23 +01:00
|
|
|
use Migrations\Migrations;
|
2021-09-18 11:21:50 +02:00
|
|
|
use Cake\Filesystem\Folder;
|
2021-09-10 11:55:54 +02:00
|
|
|
use Cake\Http\Exception\MethodNotAllowedException;
|
2020-06-21 21:29:25 +02:00
|
|
|
|
|
|
|
class InstanceTable extends AppTable
|
|
|
|
{
|
2021-10-04 11:01:20 +02:00
|
|
|
protected $activePlugins = ['Tags', 'ADmad/SocialAuth'];
|
2022-02-28 14:16:12 +01:00
|
|
|
public $seachAllTables = [];
|
2021-09-10 11:55:54 +02:00
|
|
|
|
2020-06-21 21:29:25 +02:00
|
|
|
public function initialize(array $config): void
|
|
|
|
{
|
|
|
|
parent::initialize($config);
|
2021-11-17 15:43:52 +01:00
|
|
|
$this->addBehavior('AuditLog');
|
|
|
|
$this->setDisplayField('name');
|
2022-02-28 14:16:12 +01:00
|
|
|
$this->setSearchAllTables();
|
2020-06-21 21:29:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public function validationDefault(Validator $validator): Validator
|
|
|
|
{
|
|
|
|
return $validator;
|
|
|
|
}
|
2021-02-24 11:05:23 +01:00
|
|
|
|
2022-02-28 14:16:12 +01:00
|
|
|
public function setSearchAllTables(): void
|
|
|
|
{
|
|
|
|
$this->seachAllTables = [
|
|
|
|
'Broods' => ['conditions' => false, 'afterFind' => false],
|
|
|
|
'Individuals' => ['conditions' => false, 'afterFind' => false],
|
|
|
|
'Organisations' => ['conditions' => false, 'afterFind' => false],
|
|
|
|
'SharingGroups' => [
|
2022-02-28 14:35:06 +01:00
|
|
|
'conditions' => false,
|
2022-02-28 14:16:12 +01:00
|
|
|
'afterFind' => function($result, $user) {
|
2022-02-28 14:35:06 +01:00
|
|
|
foreach ($result as $i => $row) {
|
|
|
|
if (empty($user['role']['perm_admin'])) {
|
|
|
|
$orgFound = false;
|
|
|
|
if (!empty($row['sharing_group_orgs'])) {
|
|
|
|
foreach ($row['sharing_group_orgs'] as $org) {
|
|
|
|
if ($org['id'] === $user['organisation_id']) {
|
|
|
|
$orgFound = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ($row['organisation_id'] !== $user['organisation_id'] && !$orgFound) {
|
|
|
|
unset($result[$i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-28 14:16:12 +01:00
|
|
|
return $result;
|
|
|
|
},
|
|
|
|
],
|
|
|
|
'Users' => [
|
|
|
|
'conditions' => function($user) {
|
|
|
|
$conditions = [];
|
|
|
|
if (empty($user['role']['perm_admin'])) {
|
|
|
|
$conditions['Users.organisation_id'] = $user['organisation_id'];
|
|
|
|
}
|
|
|
|
return $conditions;
|
|
|
|
},
|
|
|
|
'afterFind' => function ($result, $user) {
|
|
|
|
return $result;
|
|
|
|
},
|
|
|
|
],
|
|
|
|
'EncryptionKeys' => ['conditions' => false, 'afterFind' => false],
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
2021-11-12 15:40:03 +01:00
|
|
|
public function getStatistics(int $days=30): array
|
2021-09-06 11:17:25 +02:00
|
|
|
{
|
2021-09-28 13:32:51 +02:00
|
|
|
$models = ['Individuals', 'Organisations', 'Alignments', 'EncryptionKeys', 'SharingGroups', 'Users', 'Broods', 'Tags.Tags'];
|
2021-09-06 11:17:25 +02:00
|
|
|
foreach ($models as $model) {
|
|
|
|
$table = TableRegistry::getTableLocator()->get($model);
|
2021-11-17 17:04:39 +01:00
|
|
|
$statistics[$model] = $this->getActivityStatisticsForModel($table, $days);
|
2021-09-06 11:17:25 +02:00
|
|
|
}
|
|
|
|
return $statistics;
|
|
|
|
}
|
|
|
|
|
2022-02-28 14:16:12 +01:00
|
|
|
public function searchAll($value, $user, $limit=5, $model=null)
|
2021-09-10 11:55:54 +02:00
|
|
|
{
|
|
|
|
$results = [];
|
2021-09-13 15:56:51 +02:00
|
|
|
$models = $this->seachAllTables;
|
|
|
|
if (!is_null($model)) {
|
2022-02-28 14:16:12 +01:00
|
|
|
if (in_array($model, array_keys($this->seachAllTables))) {
|
|
|
|
$models = [$model => $this->seachAllTables[$model]];
|
2021-09-13 15:56:51 +02:00
|
|
|
} else {
|
|
|
|
return $results; // Cannot search in this model
|
|
|
|
}
|
|
|
|
}
|
2022-02-28 14:16:12 +01:00
|
|
|
|
|
|
|
// search in metafields. FIXME?: Use meta-fields type handler to search for meta-field values
|
|
|
|
if (is_null($model)) {
|
|
|
|
$metaFieldTable = TableRegistry::get('MetaFields');
|
|
|
|
$query = $metaFieldTable->find()->where([
|
|
|
|
'value LIKE' => '%' . $value . '%'
|
|
|
|
]);
|
|
|
|
$results['MetaFields']['amount'] = $query->count();
|
|
|
|
$result = $query->limit($limit)->all()->toList();
|
|
|
|
if (!empty($result)) {
|
|
|
|
$results['MetaFields']['entries'] = $result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($models as $tableName => $tableConfig) {
|
2021-09-10 11:55:54 +02:00
|
|
|
$controller = $this->getController($tableName);
|
|
|
|
$table = TableRegistry::get($tableName);
|
|
|
|
$query = $table->find();
|
2021-12-21 08:30:37 +01:00
|
|
|
$quickFilters = $this->getQuickFiltersFieldsFromController($controller);
|
2021-09-10 11:55:54 +02:00
|
|
|
$containFields = $this->getContainFieldsFromController($controller);
|
2021-12-21 08:30:37 +01:00
|
|
|
if (empty($quickFilters)) {
|
2021-09-10 11:55:54 +02:00
|
|
|
continue; // make sure we are filtering on something
|
|
|
|
}
|
|
|
|
$params = ['quickFilter' => $value];
|
2021-12-21 08:30:37 +01:00
|
|
|
$quickFilterOptions = ['quickFilters' => $quickFilters];
|
2021-09-10 11:55:54 +02:00
|
|
|
$query = $controller->CRUD->setQuickFilters($params, $query, $quickFilterOptions);
|
2022-02-28 14:16:12 +01:00
|
|
|
if (!empty($tableConfig['conditions'])) {
|
|
|
|
$whereClause = [];
|
|
|
|
if (is_callable($tableConfig['conditions'])) {
|
|
|
|
$whereClause = $tableConfig['conditions']($user);
|
|
|
|
} else {
|
|
|
|
$whereClause = $tableConfig['conditions'];
|
|
|
|
}
|
|
|
|
$query->where($whereClause);
|
|
|
|
}
|
2021-09-10 11:55:54 +02:00
|
|
|
if (!empty($containFields)) {
|
|
|
|
$query->contain($containFields);
|
|
|
|
}
|
2022-02-28 14:16:12 +01:00
|
|
|
if (!empty($tableConfig['contain'])) {
|
|
|
|
$query->contain($tableConfig['contain']);
|
|
|
|
}
|
2022-02-28 14:34:14 +01:00
|
|
|
if (empty($tableConfig['afterFind'])) {
|
|
|
|
$results[$tableName]['amount'] = $query->count();
|
|
|
|
}
|
2021-09-10 14:46:56 +02:00
|
|
|
$result = $query->limit($limit)->all()->toList();
|
2021-09-10 11:55:54 +02:00
|
|
|
if (!empty($result)) {
|
2022-02-28 14:16:12 +01:00
|
|
|
if (!empty($tableConfig['afterFind'])) {
|
|
|
|
$result = $tableConfig['afterFind']($result, $user);
|
|
|
|
}
|
2021-09-10 14:46:56 +02:00
|
|
|
$results[$tableName]['entries'] = $result;
|
2022-02-28 14:34:14 +01:00
|
|
|
$results[$tableName]['amount'] = count($result);
|
2021-09-10 11:55:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return $results;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getController($name)
|
|
|
|
{
|
|
|
|
$controllerName = "\\App\\Controller\\{$name}Controller";
|
|
|
|
if (!class_exists($controllerName)) {
|
2022-02-28 14:16:12 +01:00
|
|
|
throw new MethodNotAllowedException(__('Model `{0}` does not exists', $name));
|
2021-09-10 11:55:54 +02:00
|
|
|
}
|
|
|
|
$controller = new $controllerName;
|
|
|
|
return $controller;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getQuickFiltersFieldsFromController($controller)
|
|
|
|
{
|
|
|
|
return !empty($controller->quickFilterFields) ? $controller->quickFilterFields : [];
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getContainFieldsFromController($controller)
|
|
|
|
{
|
|
|
|
return !empty($controller->containFields) ? $controller->containFields : [];
|
|
|
|
}
|
|
|
|
|
2021-02-24 11:05:23 +01:00
|
|
|
public function getMigrationStatus()
|
|
|
|
{
|
|
|
|
$migrations = new Migrations();
|
|
|
|
$status = $migrations->status();
|
2021-09-03 09:47:13 +02:00
|
|
|
foreach ($this->activePlugins as $pluginName) {
|
|
|
|
$pluginStatus = $migrations->status([
|
|
|
|
'plugin' => $pluginName
|
|
|
|
]);
|
|
|
|
$pluginStatus = array_map(function ($entry) use ($pluginName) {
|
|
|
|
$entry['plugin'] = $pluginName;
|
|
|
|
return $entry;
|
|
|
|
}, $pluginStatus);
|
|
|
|
$status = array_merge($status, $pluginStatus);
|
|
|
|
}
|
2021-02-24 11:05:23 +01:00
|
|
|
$status = array_reverse($status);
|
|
|
|
|
|
|
|
$updateAvailables = array_filter($status, function ($update) {
|
|
|
|
return $update['status'] != 'up';
|
|
|
|
});
|
|
|
|
return [
|
|
|
|
'status' => $status,
|
|
|
|
'updateAvailables' => $updateAvailables,
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
public function migrate($version=null) {
|
|
|
|
$migrations = new Migrations();
|
|
|
|
if (is_null($version)) {
|
|
|
|
$migrationResult = $migrations->migrate();
|
|
|
|
} else {
|
|
|
|
$migrationResult = $migrations->migrate(['target' => $version]);
|
|
|
|
}
|
2021-10-04 11:01:20 +02:00
|
|
|
$command = ROOT . '/bin/cake schema_cache clear';
|
|
|
|
$output = shell_exec($command);
|
2021-02-24 11:05:23 +01:00
|
|
|
return [
|
|
|
|
'success' => true
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
public function rollback($version=null) {
|
|
|
|
$migrations = new Migrations();
|
|
|
|
if (is_null($version)) {
|
|
|
|
$migrationResult = $migrations->rollback();
|
|
|
|
} else {
|
|
|
|
$migrationResult = $migrations->rollback(['target' => $version]);
|
|
|
|
}
|
|
|
|
return [
|
|
|
|
'success' => true
|
|
|
|
];
|
|
|
|
}
|
2021-09-18 11:21:50 +02:00
|
|
|
|
|
|
|
public function getAvailableThemes()
|
|
|
|
{
|
|
|
|
$themesPath = ROOT . '/webroot/css/themes';
|
|
|
|
$dir = new Folder($themesPath);
|
|
|
|
$filesRegex = 'bootstrap-(?P<themename>\w+)\.css';
|
|
|
|
$themeRegex = '/' . 'bootstrap-(?P<themename>\w+)\.css' . '/';
|
|
|
|
$files = $dir->find($filesRegex);
|
|
|
|
$themes = [];
|
|
|
|
foreach ($files as $filename) {
|
|
|
|
$matches = [];
|
|
|
|
$themeName = preg_match($themeRegex, $filename, $matches);
|
|
|
|
if (!empty($matches['themename'])) {
|
|
|
|
$themes[] = $matches['themename'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $themes;
|
|
|
|
}
|
2020-06-21 21:29:25 +02:00
|
|
|
}
|