.
* ---------------------------------------------------------------------
*/
use Glpi\Event;
if (!defined('GLPI_ROOT')) {
die("Sorry. You can't access this file directly");
}
class RuleCollection extends CommonDBTM {
/// Rule type
public $sub_type;
/// process collection stop on first matched rule
public $stop_on_first_match = false;
/// field used to order rules
public $orderby = "ranking";
/// Processing several rules : use result of the previous one to computer the current one
public $use_output_rule_process_as_next_input = false;
/// Rule collection can be replay (for dictionnary)
public $can_replay_rules = false;
/// List of rules of the rule collection
public $RuleList = null;
/// Menu type
public $menu_type = "rule";
/// Menu option
public $menu_option = "";
public $entity = 0;
static $rightname = 'config';
/// Tab orientation : horizontal or vertical
public $taborientation = 'horizontal';
static function getTable($classname = null) {
return parent::getTable('Rule');
}
/**
* @param $entity (default 0)
**/
function setEntity($entity = 0) {
$this->entity = $entity;
}
function canList() {
return static::canView();
}
function isEntityAssign() {
return false;
}
/**
* Get Collection Size : retrieve the number of rules
*
* @param boolean $recursive (true by default)
* @param integer $condition (0 by default)
*
* @return : number of rules
**/
function getCollectionSize($recursive = true, $condition = 0) {
global $DB;
$restrict = $this->getRuleListCriteria([
'condition' => $condition,
'active' => false
]);
$iterator = $DB->request($restrict);
return count($iterator);
}
/**
* Get rules list criteria
*
* @param array $options Options
*
* @return array
**/
function getRuleListCriteria($options = []) {
$p['active'] = true;
$p['start'] = 0;
$p['limit'] = 0;
$p['inherited'] = 1;
$p['childrens'] = 0;
$p['condition'] = 0;
foreach ($options as $key => $value) {
$p[$key] = $value;
}
$criteria = [
'SELECT' => Rule::getTable() . '.*',
'FROM' => Rule::getTable(),
'ORDER' => [
$this->orderby . ' ASC'
]
];
$where = [];
if ($p['active']) {
$where['is_active'] = 1;
}
if ($p['condition'] > 0) {
$where['condition'] = ['&', (int)$p['condition']];
}
//Select all the rules of a different type
$where['sub_type'] = $this->getRuleClassName();
if ($this->isRuleRecursive()) {
$criteria['LEFT JOIN'] = [
Entity::getTable() => [
'ON' => [
Entity::getTable() => 'id',
Rule::getTable() => 'entities_id'
]
]
];
if (!$p['childrens']) {
$where += getEntitiesRestrictCriteria(
Rule::getTable(),
'entities_id',
$this->entity,
$p['inherited']
);
} else {
$sons = getSonsOf('glpi_entities', $this->entity);
$where[Rule::getTable() . '.entities_id'] = $sons;
}
$criteria['ORDER'] = [
Entity::getTable() . '.level ASC',
$this->orderby . ' ASC'
];
}
if ($p['limit']) {
$criteria['LIMIT'] = (int)$p['limit'];
$criteria['START'] = (int)$p['start'];
}
$criteria['WHERE'] = $where;
return $criteria;
}
/**
* Get Collection Part : retrieve descriptions of a range of rules
*
* @param $options array of options may be :
* - start : first rule (in the result set - default 0)
* - limit : max number of rules to retrieve (default 0)
* - recursive : boolean get recursive rules
* - childirens : boolean get childrens rules
**/
function getCollectionPart($options = []) {
global $DB;
$p['start'] = 0;
$p['limit'] = 0;
$p['recursive'] = true;
$p['childrens'] = 0;
$p['condition'] = 0;
foreach ($options as $key => $value) {
$p[$key] = $value;
}
// no need to use SingletonRuleList::getInstance because we read only 1 page
$this->RuleList = new SingletonRuleList();
$this->RuleList->list = [];
//Select all the rules of a different type
$criteria = $this->getRuleListCriteria($p);
$iterator = $DB->request($criteria);
while ($data = $iterator->next()) {
//For each rule, get a Rule object with all the criterias and actions
$tempRule = $this->getRuleClass();
$tempRule->fields = $data;
$this->RuleList->list[] = $tempRule;
}
}
/**
* Get Collection Datas : retrieve descriptions and rules
*
* @param $retrieve_criteria Retrieve the criterias of the rules ? (default 0)
* @param $retrieve_action Retrieve the action of the rules ? (default 0)
* @param $condition Retrieve with a specific condition
**/
function getCollectionDatas($retrieve_criteria = 0, $retrieve_action = 0, $condition = 0) {
global $DB;
if ($this->RuleList === null) {
$this->RuleList = SingletonRuleList::getInstance($this->getRuleClassName(),
$this->entity);
}
$need = 1+($retrieve_criteria?2:0)+($retrieve_action?4:0)+(8*$condition);
// check if load required
if (($need & $this->RuleList->load) != $need) {
//Select all the rules of a different type
$criteria = $this->getRuleListCriteria(['condition' => $condition]);
$iterator = $DB->request($criteria);
if (count($iterator)) {
$this->RuleList->list = [];
while ($rule = $iterator->next()) {
//For each rule, get a Rule object with all the criterias and actions
$tempRule = $this->getRuleClass();
if ($tempRule->getRuleWithCriteriasAndActions($rule["id"], $retrieve_criteria,
$retrieve_action)) {
//Add the object to the list of rules
$this->RuleList->list[] = $tempRule;
}
}
$this->RuleList->load = $need;
}
}
}
function getRuleClassName() {
if (preg_match('/(.*)Collection/', get_class($this), $rule_class)) {
return $rule_class[1];
}
return "";
}
/**
* Get a instance of the class to manipulate rule of this collection
**/
function getRuleClass() {
$name = $this->getRuleClassName();
if ($name != '') {
return new $name();
}
return null;
}
/**
* Is a confirmation needed before replay on DB ?
* If needed need to send 'replay_confirm' in POST
*
* @param $target filename : where to go when done
*
* @return true if confirmtion is needed, else false
**/
function warningBeforeReplayRulesOnExistingDB($target) {
return false;
}
/**
* Replay Collection on DB
*
* @param $offset first row to work on (default 0)
* @param $maxtime float max system time to stop working (default 0)
* @param $items array containg items to replay. If empty -> all
* @param $params array additional parameters if needed
*
* @return -1 if all rows done, else offset for next run
**/
function replayRulesOnExistingDB($offset = 0, $maxtime = 0, $items = [], $params = []) {
}
/**
* Get title used in list of rules
*
* @return Title of the rule collection
**/
function getTitle() {
return __('Rules list');
}
/**
* Indicates if the rule can be affected to an entity or if it's global
**/
function isRuleEntityAssigned() {
$rule = $this->getRuleClass();
return $rule->isEntityAssign();
}
/**
* Indicates if the rule can be affected to an entity or if it's global
**/
function isRuleRecursive() {
$rule = $this->getRuleClass();
return $rule->maybeRecursive();
}
/**
* Indicates if the rule use conditions
**/
function isRuleUseConditions() {
$rule = $this->getRuleClass();
return $rule->useConditions();
}
/**
* Indicates if the rule use conditions
**/
function getDefaultRuleConditionForList() {
$rule = $this->getRuleClass();
$cond = $rule->getConditionsArray();
// Get max value
if (count($cond)) {
return max(array_keys($cond));
}
return 0;
}
function showEngineSummary() {
echo "";
//Display information about the how the rules engine process the rules
if ($this->stop_on_first_match) {
//The engine stop on the first matched rule
echo "".__('The engine stops on the first checked rule.').
"
";
} else {
//The engine process all the rules
echo "".__('The engine treats all the rules.')."
";
}
if ($this->use_output_rule_process_as_next_input) {
//The engine keep the result of a rule to be processed further
echo "".
__('The engine passes the result of a rule to the following one.')."
";
}
if ($this->isRuleUseConditions()) {
//The engine keep the result of a rule to be processed further
echo "".
__('Rules are conditionals. Each one can be used on multiple actions.');
echo "
";
}
echo " |
|---|
";
echo "
\n";
}
/**
* Show the list of rules
*
* @param $target
* @param $options array
*
* @return void
**/
function showListRules($target, $options = []) {
global $CFG_GLPI;
$p['inherited'] = 1;
$p['childrens'] = 0;
$p['active'] = false;
$p['condition'] = 0;
$rand = mt_rand();
foreach (['inherited','childrens', 'condition'] as $param) {
if (isset($options[$param])
&& $this->isRuleRecursive()) {
$p[$param] = $options[$param];
}
}
$rule = $this->getRuleClass();
$display_entities = ($this->isRuleRecursive()
&& ($p['inherited'] || $p['childrens']));
// Do not know what it is ?
$canedit = (self::canUpdate()
&& !$display_entities);
$use_conditions = false;
if ($rule->useConditions()) {
// First get saved option
$p['condition'] = Session::getSavedOption($this->getType(), 'condition', 0);
if ($p['condition'] == 0) {
$p['condition'] = $this->getDefaultRuleConditionForList();
}
$use_conditions = true;
// Mini Search engine
echo "";
echo "| ";
echo __('Rules used for')." | ";
$rule->dropdownConditions(['value' => $p['condition'],
'on_change' => 'reloadTab("start=0&inherited='.$p['inherited']
.'&childrens='.$p['childrens'].'&condition="+this.value)']);
echo " |
";
}
$nb = $this->getCollectionSize($p['inherited'], $p['condition']);
$p['start'] = (isset($options["start"]) ? $options["start"] : 0);
if ($p['start'] >= $nb) {
$p['start'] = 0;
}
$p['limit'] = $_SESSION['glpilist_limit'];
$this->getCollectionPart($p);
Html::printAjaxPager('', $p['start'], $nb);
Html::openMassiveActionsForm('mass'.__CLASS__.$rand);
echo "\n";
if ($canedit && $nb) {
$massiveactionparams = ['num_displayed' => min($p['limit'], $nb),
'container' => 'mass'.__CLASS__.$rand,
'extraparams' => ['entity' => $this->entity,
'condition' => $p['condition'],
'rule_class_name'
=> $this->getRuleClassName()]];
Html::showMassiveActions($massiveactionparams);
}
echo "
";
$colspan = 6;
if ($display_entities) {
$colspan++;
}
if ($use_conditions) {
$colspan++;
}
echo "| " . $this->getTitle() ." |
|---|
\n";
echo "";
echo "| ";
if ($canedit) {
echo Html::getCheckAllAsCheckbox('mass'.__CLASS__.$rand);
}
echo " | ";
echo "".__('Name')." | ";
echo "".__('Description')." | ";
if ($use_conditions) {
echo "".__('Use rule for')." | ";
}
echo "".__('Active')." | ";
if ($display_entities) {
echo "".Entity::getTypeName(1)." | \n";
}
if (!$display_entities) {
echo " | ";
}
echo "
\n";
if (count($this->RuleList->list)) {
$ruletype = $this->RuleList->list[0]->getType();
Session::initNavigateListItems($ruletype);
}
for ($i=$p['start'],$j=0; isset($this->RuleList->list[$j]); $i++,$j++) {
$this->RuleList->list[$j]->showMinimalForm($target, $i==0, $i==$nb-1, $display_entities, $p['condition']);
Session::addToNavigateListItems($ruletype, $this->RuleList->list[$j]->fields['id']);
}
if ($nb) {
echo "";
echo "| ";
if ($canedit) {
echo Html::getCheckAllAsCheckbox('mass'.__CLASS__.$rand);
}
echo " | ";
echo "".__('Name')." | ";
echo "".__('Description')." | ";
if ($use_conditions) {
echo "".__('Use rule for')." | ";
}
echo "".__('Active')." | ";
if ($display_entities) {
echo "".Entity::getTypeName(1)." | \n";
}
if (!$display_entities) {
echo " | ";
}
echo "
\n";
}
echo "
\n";
if ($canedit && $nb) {
$massiveactionparams['ontop'] = false;
Html::showMassiveActions($massiveactionparams);
}
echo "
";
if ($plugin = isPluginItemType($this->getType())) {
$url = $CFG_GLPI["root_doc"]."/plugins/".strtolower($plugin['plugin']);
} else {
$url = $CFG_GLPI["root_doc"];
}
echo "
".
__('Test rules engine')."";
Ajax::createIframeModalWindow('allruletest'.$rand,
$url."/front/rulesengine.test.php?".
"sub_type=".$this->getRuleClassName().
"&condition=".$p['condition'],
['title' => __('Test rules engine')]);
echo "
";
$this->showAdditionalInformationsInForm($target);
echo "
";
}
/**
* Show the list of rules
*
* @param $target
*
* @return void
**/
function showAdditionalInformationsInForm($target) {
}
/**
* Modify rule's ranking and automatically reorder all rules
*
* @param $ID the rule ID whose ranking must be modified
* @param $action up or down
* @param $condition action on a specific condition
**/
function changeRuleOrder($ID, $action, $condition = 0) {
global $DB;
$criteria = [
'SELECT' => 'ranking',
'FROM' => 'glpi_rules',
'WHERE' => ['id' => $ID]
];
$add_condition = [];
if ($condition > 0) {
$add_condition = ['condition' => ['&', (int)$condition]];
}
$iterator = $DB->request($criteria);
if (count($iterator) == 1) {
$result = $iterator->next();
$current_rank = $result['ranking'];
// Search rules to switch
$criteria = [
'SELECT' => ['id', 'ranking'],
'FROM' => 'glpi_rules',
'WHERE' => [
'sub_type' => $this->getRuleClassName()
] + $add_condition,
'LIMIT' => 1
];
switch ($action) {
case "up" :
$criteria['WHERE']['ranking'] = ['<', $current_rank];
$criteria['ORDERBY'] = 'ranking DESC';
break;
case "down" :
$criteria['WHERE']['ranking'] = ['>', $current_rank];
$criteria['ORDERBY'] = 'ranking ASC';
break;
default :
return false;
}
$iterator2 = $DB->request($criteria);
if (count($iterator2) == 1) {
$result2 = $iterator2->next();
$other_ID = $result2['id'];
$new_rank = $result2['ranking'];
echo $current_rank.' '.$ID.'
';
echo $new_rank.' '.$other_ID.'
';
$rule = $this->getRuleClass();
$result = false;
$criteria = [
'SELECT' => ['id', 'ranking'],
'FROM' => 'glpi_rules',
'WHERE' => ['sub_type' => $this->getRuleClassName()]
];
$diff = $new_rank - $current_rank;
switch ($action) {
case "up" :
$criteria['WHERE'] = array_merge(
$criteria['WHERE'], [
['ranking' => ['>', $new_rank]],
['ranking' => ['<=', $current_rank]]
]
);
$diff += 1;
break;
case "down" :
$criteria['WHERE'] = array_merge(
$criteria['WHERE'], [
['ranking' => ['>=', $current_rank]],
['ranking' => ['<', $new_rank]]
]
);
$diff -= 1;
break;
default :
return false;
}
if ($diff != 0) {
// Move several rules
$iterator3 = $DB->request($criteria);
while ($data = $iterator3->next()) {
$data['ranking'] += $diff;
$result = $rule->update($data);
}
} else {
// Only move one
$result = $rule->update([
'id' => $ID,
'ranking' => $new_rank
]);
}
// Update reference
if ($result) {
$result = $rule->update([
'id' => $other_ID,
'ranking' => $current_rank
]);
}
return $result;
}
}
return false;
}
/**
* Update Rule Order when deleting a rule
*
* @param $ranking rank of the deleted rule
*
* @return true if all ok
**/
function deleteRuleOrder($ranking) {
global $DB;
$result = $DB->update(
'glpi_rules', [
'ranking' => new \QueryExpression($DB->quoteName('ranking') . ' - 1')
], [
'sub_type' => $this->getRuleClassName(),
'ranking' => ['>', $ranking]
]
);
return $result;
}
/**
* Move a rule in an ordered collection
*
* @param $ID of the rule to move
* @param $ref_ID of the rule position (0 means all, so before all or after all)
* @param $type of move : after or before ( default 'after')
*
* @return true if all ok
**/
function moveRule($ID, $ref_ID, $type = 'after') {
global $DB;
$ruleDescription = new Rule();
// Get actual ranking of Rule to move
$ruleDescription->getFromDB($ID);
$old_rank = $ruleDescription->fields["ranking"];
// Compute new ranking
if ($ref_ID) { // Move after/before an existing rule
$ruleDescription->getFromDB($ref_ID);
$rank = $ruleDescription->fields["ranking"];
} else if ($type == "after") {
// Move after all
$result = $DB->request([
'SELECT' => ['MAX' => 'ranking AS maxi'],
'FROM' => 'glpi_rules',
'WHERE' => ['sub_type' => $this->getRuleClassName()]
])->next();
$rank = $result['maxi'];
} else {
// Move before all
$rank = 1;
}
$rule = $this->getRuleClass();
$result = false;
// Move others rules in the collection
if ($old_rank < $rank) {
if ($type == "before") {
$rank--;
}
// Move back all rules between old and new rank
$iterator = $DB->request([
'SELECT' => ['id', 'ranking'],
'FROM' => 'glpi_rules',
'WHERE' => [
'sub_type' => $this->getRuleClassName(),
['ranking' => ['>', $old_rank]],
['ranking' => ['<=', $rank]]
]
]);
while ($data = $iterator->next()) {
$data['ranking']--;
$result = $rule->update($data);
}
} else if ($old_rank > $rank) {
if ($type == "after") {
$rank++;
}
// Move forward all rule between old and new rank
$iterator = $DB->request([
'SELECT' => ['id', 'ranking'],
'FROM' => 'glpi_rules',
'WHERE' => [
'sub_type' => $this->getRuleClassName(),
['ranking' => ['=>', $rank]],
['ranking' => ['<', $old_rank]]
]
]);
while ($data = $iterator->next()) {
$data['ranking']++;
$result = $rule->update($data);
}
} else { // $old_rank == $rank : nothing to do
$result = false;
}
// Move the rule
if ($result
&& ($old_rank != $rank)) {
$result = $rule->update(['id' => $ID,
'ranking' => $rank]);
}
return ($result ? true : false);
}
/**
* Print a title for backup rules
*
* @since 0.85
*
* @return void
**/
static function titleBackup() {
global $CFG_GLPI;
$buttons = [];
$title = "";
$buttons["{$CFG_GLPI["root_doc"]}/front/rule.backup.php?action=import"] = _x('button', 'Import');
$buttons["{$CFG_GLPI["root_doc"]}/front/rule.backup.php?action=export"] = _x('button', 'Export');
echo "";
echo " | ";
foreach ($buttons as $key => $val) {
echo "".$val." | ";
}
echo "