/**
* EGroupware egw_action framework - egw action framework
*
* @link https://www.egroupware.org
* @author Andreas Stöckel <as@stylite.de>
* @copyright 2011 by Andreas Stöckel
* @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
* @package egw_action
*/
import {egwActionStoreJSON, EgwFnct} from "./egw_action_common";
import {IegwAppLocal} from "../jsapi/egw_global";
import {egw_getObjectManager} from "./egw_action";
export class EgwAction {
public id: string;
public caption: string;
group: number;
order: number;
public set_caption(_value) {
this.caption = _value;
}
public iconUrl: string;
public set_iconUrl(_value) {
this.iconUrl = _value;
}
allowOnMultiple: boolean | string | number;
/**
* The allowOnMultiple property may be true, false, "only" (> 1) or number of select, e.g. 2
*
* @param {(boolean|string|number)} _value
*/
public set_allowOnMultiple(_value: boolean | string | number) {
this.allowOnMultiple = _value
}
public enabled: EgwFnct;
public set_enabled(_value) {
this.enabled.setValue(_value);
}
public hideOnDisabled = false;
public data: any = {}; // Data which can be freely assigned to the action
/**
* @deprecated just set the data parameter with '=' sign to use its setter
* @param _value
*/
public set_data(_value) {
this.data = _value
}
type = "default"; //All derived classes have to override this!
canHaveChildren: boolean | string[] = false; //Has to be overwritten by inheriting action classes
// this is not bool all the time. Can be ['popup'] e.g. List of egwActionClasses that are allowed to have children?
readonly parent: EgwAction;
children: EgwAction[] = []; //i guess
public onExecute = new EgwFnct(this, null, []);
/**
* Set to either a confirmation prompt, or TRUE to indicate that this action
* cares about large selections and to ask the confirmation prompt(s)
*
* --set in egw_action_popup--
* @param {String|Boolean} _value
*/
public confirm_mass_selection: string | boolean = undefined
/**
* The set_onExecute function is the setter function for the onExecute event of
* the EgwAction object. There are three possible types the passed "_value" may
* take:
* 1. _value may be a string with the word "javaScript:" prefixed. The function
* which is specified behind the colon and which has to be in the global scope
* will be executed.
* 2. _value may be a boolean, which specifies whether the external onExecute handler
* (passed as "_handler" in the constructor) will be used.
* 3. _value may be a JS function which will then be called.
* In all possible situation, the called function will get the following parameters:
* 1. A reference to this action
* 2. The senders, an array of all objects (JS)/object ids (PHP) which evoked the event
*
* @param {(string|function|boolean)} _value
*/
public set_onExecute(_value) {
this.onExecute.setValue(_value)
}
public hideOnMobile = false;
public disableIfNoEPL = false;
/**
* Default icons for given id
*/
public defaultIcons = {
view: 'view',
edit: 'edit',
open: 'edit', // does edit if possible, otherwise view
add: 'new',
new: 'new',
delete: 'delete',
cat: 'attach', // add as category icon to api
document: 'etemplate/merge',
print: 'print',
copy: 'copy',
move: 'move',
cut: 'cut',
paste: 'editpaste',
save: 'save',
apply: 'apply',
cancel: 'cancel',
continue: 'continue',
next: 'continue',
finish: 'finish',
back: 'back',
previous: 'back',
close: 'close'
};
/**
* Constructor for EgwAction object
*
* @param {EgwAction} _parent
* @param {string} _id
* @param {string} _caption
* @param {string} _iconUrl
* @param {(string|function)} _onExecute
* @param {boolean} _allowOnMultiple
* @returns EgwAction
**/
constructor(_parent: EgwAction, _id: string, _caption: string = "", _iconUrl: string = "", _onExecute: string | Function = null, _allowOnMultiple: boolean = true)
{
if (_parent && (typeof _id != "string" || !_id) && _parent.type !== "actionManager") {
throw "EgwAction _id must be a non-empty string!";
}
this.parent = _parent;
this.id = _id;
this.caption = _caption;
this.iconUrl = _iconUrl;
if (_onExecute !== null) {
this.set_onExecute(_onExecute)
}
this.allowOnMultiple = _allowOnMultiple;
this.enabled = new EgwFnct(this, true);
}
/**
* Clears the element and removes it from the parent container
*/
public remove() {
// Remove all references to the child elements
this.children = [];
// Remove this element from the parent list
if (this.parent) {
const idx = this.parent.children.indexOf(this);
if (idx >= 0) {
this.parent.children.splice(idx, 1);
}
}
}
/**
* Searches for a specific action with the given id
*
* @param {(string|number)} _id ID of the action to find
* @param {number} [_search_depth=Infinite] How deep into existing action children
* to search.
*
* @return {(EgwAction|null)}
*/
public getActionById(_id: string, _search_depth: number = Number.MAX_VALUE): EgwAction {
// If the current action object has the given id, return this object
if (this.id == _id) {
return this;
}
// If this element is capable of having children, search those for the given
// action id
if (this.canHaveChildren) {
for (let i = 0; i < this.children.length && _search_depth > 0; i++) {
const elem = this.children[i].getActionById(_id, _search_depth - 1);
if (elem) {
return elem;
}
}
}
return null;
};
/**
* Searches for actions having an attribute with a certain value
*
* Example: actionManager.getActionsByAttr("checkbox", true) returns all checkbox actions
*
* @param {string} _attr attribute name
* @param _val attribute value
* @return array
*/
public getActionsByAttr(_attr: string | number, _val: any = undefined) {
let _actions = [];
// If the current action object has the given attr AND value, or no value was provided, return it
if (typeof this[_attr] != "undefined" && (this[_attr] === _val || typeof _val === "undefined" && this[_attr] !== null)) {
_actions.push(this);
}
// If this element is capable of having children, search those too
if (this.canHaveChildren) {
for (let i = 0; i < this.children.length; i++) {
_actions = _actions.concat(this.children[i].getActionsByAttr(_attr, _val));
}
}
return _actions;
};
/**
* Adds a new action to the child elements.
*
* @param {string} _type
* @param {string} _id
* @param {string} _caption
* @param {string} _iconUrl
* @param {(string|function)} _onExecute
* @param {boolean} _allowOnMultiple
*/
public addAction(_type: string, _id: string, _caption: string = "", _iconUrl: string = "", _onExecute: string | Function = null, _allowOnMultiple: boolean = true): EgwAction {
//Get the constructor for the given action type
if (!(_type in window._egwActionClasses)) {
_type = "popup"
}
// Only allow adding new actions, if this action class allows it.
if (this.canHaveChildren) {
const constructor: any = window._egwActionClasses[_type]?.actionConstructor;
if (typeof constructor == "function") {
const action: EgwAction = new constructor(this, _id, _caption, _iconUrl, _onExecute, _allowOnMultiple);
this.children.push(action);
return action;
} else {
throw "Given action type not registered.";
}
} else {
throw "This action does not allow child elements!";
}
};
/**
* Updates the children of this element
*
* @param {object} _actions { id: action, ...}
* @param {string} _app defaults to egw_getAppname()
*/
public updateActions(_actions: any[] | Object, _app) {
if (this.canHaveChildren) {
if (typeof _app == "undefined") _app = window.egw(window).app_name()
/*
this is an egw Object as defined in egw_core.js
probably not because it changes on runtime
*/
const localEgw: IegwAppLocal = window.egw(_app, window);
//replaced jQuery calls
if (Array.isArray(_actions)) {
//_actions is now an object for sure
//happens in test website
_actions = {..._actions};
}
for (const i in _actions) {
let elem = _actions[i];
if (typeof elem == "string") {
//changes type of elem to Object {caption:string}
_actions[i] = elem = {caption: elem};
}
if (typeof elem == "object") // isn't this always true because of step above? Yes if elem was a string before
{
// use attr name as id, if none given
if (typeof elem.id != "string") elem.id = i;
// if no iconUrl given, check icon and default icons
if (typeof elem.iconUrl == "undefined") {
if (typeof elem.icon == "undefined") elem.icon = this.defaultIcons[elem.id]; // only works if default Icon is available
if (typeof elem.icon != "undefined") {
elem.iconUrl = localEgw.image(elem.icon);
} else //elem.icon and elem.iconUrl is still undefined
{
//if there is no icon and none can be found remove icon tag from the object
delete elem.icon;
}
}
// always add shortcut for delete
if (elem.id == "delete" && typeof elem.shortcut == "undefined") {
elem.shortcut = {
keyCode: 46, shift: false, ctrl: false, alt: false, caption: localEgw.lang('Del')
};
}
// translate caption
if (elem.caption && (typeof elem.no_lang == "undefined" || !elem.no_lang)) {
elem.caption = localEgw.lang(elem.caption);
if (typeof elem.hint == "string") elem.hint = localEgw.lang(elem.hint);
}
delete elem.no_lang;
// translate confirm messages and place '?' at the end iff not there yet
for (const attr in {confirm: '', confirm_multiple: ''}) {
if (typeof elem[attr] == "string") {
elem[attr] = localEgw.lang(elem[attr]) + ((elem[attr].substr(-1) != '?') ? '?' : '');
}
}
// set certain enabled functions iff elem.enabled is not set so false
if (typeof elem.enabled == 'undefined' || elem.enabled === true) {
if (typeof elem.enableClass != "undefined") {
elem.enabled = this.enableClass;
} else if (typeof elem.disableClass != "undefined") {
elem.enabled = this.not_disableClass;
} else if (typeof elem.enableId != "undefined") {
elem.enabled = this.enableId;
}
}
//Check whether the action already exists, and if no, add it to the
//actions list
let action = this.getActionById(elem.id);
if (!action) {
//elem will be popup on default
if (typeof elem.type == "undefined") {
elem.type = "popup";
}
let constructor = null;
// Check whether the given type is inside the "canHaveChildren"
// array // here can have children is used as array where possible types of children are stored
if (this.canHaveChildren !== true && this.canHaveChildren.indexOf(elem.type) == -1) {
throw "This child type '" + elem.type + "' is not allowed!";
}
if (typeof window._egwActionClasses[elem.type] != "undefined") {
constructor = window._egwActionClasses[elem.type].actionConstructor;
} else {
throw "Given action type \"" + elem.type + "\" not registered, because type does not exist";
}
if (typeof constructor == "function" && constructor) action = new constructor(this, elem.id); else throw "Given action type \"" + elem.type + "\" not registered.";
this.children.push(action);
}
action.updateAction(elem);
// Add sub-actions to the action
if (elem.children) {
action.updateActions(elem.children, _app);
}
}
}
} else {
throw "This action element cannot have children!";
}
};
/**
* Callback to check if none of _senders rows has disableClass set
*
* @param _action EgwAction object, we use _action.data.disableClass to check
* @param _senders array of egwActionObject objects
* @param _target egwActionObject object, gets called for every object in _senders
* @returns boolean true if none has disableClass, false otherwise
*/
public not_disableClass(_action: EgwAction, _senders: any, _target: any) {
if (_target.iface.getDOMNode()) {
return !(_target.iface.getDOMNode()).classList.contains(_action.data.disableClass);
} else if (_target.id) {
// Checking on a something that doesn't have a DOM node, like a nm row
// that's not currently rendered
const data = window.egw.dataGetUIDdata(_target.id);
if (data && data.data && data.data.class) {
return -1 === data.data.class.split(' ').indexOf(_action.data.disableClass);
}
}
};
/**
* Callback to check if all of _senders rows have enableClass set
*
* @param _action EgwAction object, we use _action.data.enableClass to check
* @param _senders array of egwActionObject objects
* @param _target egwActionObject object, gets called for every object in _senders
* @returns boolean true if none has disableClass, false otherwise
*/
public enableClass(_action: EgwAction, _senders: any[], _target: any) {
if (typeof _target == 'undefined') {
return false;
} else if (_target.iface.getDOMNode()) {
return (_target.iface.getDOMNode()).classList.contains(_action.data.enableClass);
} else if (_target.id) {
// Checking on a something that doesn't have a DOM node, like a nm row
// that's not currently rendered. Not as good as an actual DOM node check
// since things can get missed, but better than nothing.
const data = window.egw.dataGetUIDdata(_target.id);
if (data && data.data && data.data.class) {
return -1 !== data.data.class.split(' ').indexOf(_action.data.enableClass);
}
}
};
/**
* Enable an _action, if it matches a given regular expression in _action.data.enableId
*
* @param _action EgwAction object, we use _action.data.enableId to check
* @param _senders array of egwActionObject objects
* @param _target egwActionObject object, gets called for every object in _senders
* @returns boolean true if _target.id matches _action.data.enableId
*/
public enableId(_action: EgwAction, _senders: any[], _target: any) {
if (typeof _action.data.enableId == 'string') {
_action.data.enableId = new RegExp(_action.data.enableId);
}
return _target.id.match(_action.data.enableId);
};
/**
* Applies the same onExecute handler to all actions which don't have an execute
* handler set.
*
* @param {(string|function)} _value
*/
public setDefaultExecute(_value: string | Function): void {
// Check whether the onExecute handler of this action should be set
if (this.type != "actionManager" && !this.onExecute.hasHandler()) {
this.onExecute.isDefault = true;
this.onExecute.setValue(_value);
}
// Apply the value to all children
if (this.canHaveChildren) {
for (const elem of this.children) {
elem.setDefaultExecute(_value);
}
}
};
/**
* Executes this action by using the method specified in the onExecute setter.
*
* @param {array} _senders array with references to the objects which caused the action
* @param {object} _target is an optional parameter which may represent e.g. a drag drop target
*/
execute(_senders, _target = null): any {
if (!this._check_confirm_mass_selections(_senders, _target)) {
return this._check_confirm(_senders, _target);
}
};
/**
* If this action needs to confirm mass selections (attribute confirm_mass_selection = true),
* check for any checkboxes that have a confirmation prompt (confirm_mass_selection is a string)
* and are unchecked. We then show the prompt, and set the checkbox to their answer.
*
* * This is only considered if there are more than 20 entries selected.
*
* * Only the first confirmation prompt / checkbox action will be used, others
* will be ignored.
*
* @param {type} _senders
* @param {type} _target
* @returns {Boolean}
*/
public _check_confirm_mass_selections(_senders, _target) {
const obj_manager: any = egw_getObjectManager(this.getManager().parent.id, false);
if (!obj_manager) {
return false;
}
// Action needs to care about mass selection - check for parent that cares too
let confirm_mass_needed = false;
let action: EgwAction = this;
while (action && action !== obj_manager.manager && !confirm_mass_needed) {
confirm_mass_needed = !!action.confirm_mass_selection;
action = action.parent;
}
if (!confirm_mass_needed) return false;
// Check for confirm mass selection checkboxes
const confirm_mass_selections = obj_manager.manager.getActionsByAttr("confirm_mass_selection");
confirm_mass_needed = _senders.length > 20;
//no longer needed because of '=>' notation
//const self = this;
// Find & show prompt
for (let i = 0; confirm_mass_needed && i < confirm_mass_selections.length; i++) {
const check = confirm_mass_selections[i];
if (check.checkbox === false || check.checked === true) {
continue
}
// Show the mass selection prompt
const msg = window.egw.lang(check.confirm_mass_selection, obj_manager.getAllSelected() ? window.egw.lang('all') : _senders.length);
const callback = (_button) => {
// YES = unchecked, NO = checked
check.set_checked(_button === window.Et2Dialog.NO_BUTTON);
if (_button !== window.Et2Dialog.CANCEL_BUTTON) {
this._check_confirm(_senders, _target);
}
};
window.Et2Dialog.show_dialog(callback, msg, this.data.hint, {}, window.Et2Dialog.BUTTONS_YES_NO_CANCEL, window.Et2Dialog.QUESTION_MESSAGE);
return true;
}
return false;
};
/**
* Check to see if action needs to be confirmed by user before we do it
*/
public _check_confirm(_senders, _target) {
// check if actions needs to be confirmed first
if (this.data && (this.data.confirm || this.data.confirm_multiple) &&
this.onExecute.functionToPerform != window.nm_action && typeof window.Et2Dialog != 'undefined') // let old eTemplate run its own confirmation from nextmatch_action.js
{
let msg = this.data.confirm || '';
if (_senders.length > 1) {
if (this.data.confirm_multiple) {
msg = this.data.confirm_multiple;
}
// check if we have all rows selected
const obj_manager = egw_getObjectManager(this.getManager().parent.id, false);
if (obj_manager && obj_manager.getAllSelected()) {
msg += "\n\n" + window.egw.lang('Attention: action will be applied to all rows, not only visible ones!');
}
}
//no longer needed because of '=>' notation
//var self = this;
if (msg.trim().length > 0) {
if (this.data.policy_confirmation && window.egw.app('policy')) {
import(window.egw.link('/policy/js/app.min.js')).then(() => {
if (typeof window.app.policy === 'undefined' || typeof window.app.policy.confirm === 'undefined') {
window.app.policy = new window.app.classes.policy();
}
window.app.policy.confirm(this, _senders, _target);
}
);
return;
}
window.Et2Dialog.show_dialog((_button) => {
if (_button == window.Et2Dialog.YES_BUTTON) {
// @ts-ignore
return this.onExecute.exec(this, _senders, _target);
}
}, msg, this.data.hint, {}, window.Et2Dialog.BUTTONS_YES_NO, window.Et2Dialog.QUESTION_MESSAGE);
return;
}
}
// @ts-ignore
return this.onExecute.exec(this, _senders, _target);
};
public updateAction(_data: Object) {
egwActionStoreJSON(_data, this, "data")
}
/**
* Returns the parent action manager
*/
getManager(): EgwAction {
if (this.type == "actionManager") {
return this;
} else if (this.parent) {
return this.parent.getManager();
} else {
return null;
}
}
/**
* The appendToGraph function generates an action tree which automatically contains
* all parent elements. If the appendToGraph function is called for a
*
* @param {not an array} _tree contains the tree structure - pass an object containing {root:Tree}
* the empty array "root" to this function {"root": []}. The result will be stored in
* this array.
* @param {boolean} _addChildren is used internally to prevent parent elements from
* adding their children automatically to the tree.
*/
public appendToTree(_tree: { root: Tree }, _addChildren: boolean = true) {
if (typeof _addChildren == "undefined") {
_addChildren = true;
}
// Preset some variables
const root: Tree = _tree.root;
let parentNode: TreeElem = null;
let node: TreeElem = {
"action": this, "children": []
};
if (this.parent && this.type != "actionManager") {
// Check whether the parent container has already been added to the tree
parentNode = _egwActionTreeFind(root, this.parent);
if (!parentNode) {
parentNode = this.parent.appendToTree(_tree, false);
}
// Check whether this element has already been added to the parent container
let added = false;
for (const child of parentNode.children) {
if (child.action == this) {
node = child;
added = true;
break;
}
}
if (!added) {
parentNode.children.push(node);
}
} else {
let added = false;
for (const treeElem of root) {
if (treeElem.action == this) {
node = treeElem;
added = true;
break;
}
}
if (!added) {
// Add this element to the root if it has no parent
root.push(node);
}
}
if (_addChildren) {
for (const child of this.children) {
child.appendToTree(_tree, true);
}
}
return node;
};
/**
* @deprecated directly set value instead
* @param _value
*/
set_hideOnDisabled(_value) {
this.hideOnDisabled = _value;
};
/**
* @deprecated directly set value instead
* @param _value
*/
set_hideOnMobile(_value) {
this.hideOnMobile = _value;
};
/**
* @deprecated directly set value instead
* @param _value
*/
set_disableIfNoEPL(_value) {
this.disableIfNoEPL = _value;
};
set_hint(hint: string) {
}
public clone():EgwAction{
const clone:EgwAction = Object.assign(Object.create(Object.getPrototypeOf(this)), this)
clone.onExecute = this.onExecute.clone()
if(this.enabled){
clone.enabled = this.enabled.clone()
}
return clone
}
}
type TreeElem = { action: EgwAction, children: Tree }
type Tree = TreeElem[]
/**
* finds an egwAction in the given tree
* @param {Tree}_tree where to search
* @param {EgwAction}_elem elem to search
* @returns {TreeElem} the treeElement for corresponding _elem if found, null else
*/
function _egwActionTreeFind(_tree: Tree, _elem: EgwAction): TreeElem {
for (const current of _tree) {
if (current.action == _elem) {
return current;
}
if (typeof current.children != "undefined") {
const elem = _egwActionTreeFind(current.children, _elem);
if (elem) {
return elem;
}
}
}
return null;
}