mirror of
https://github.com/EGroupware/egroupware.git
synced 2024-11-15 20:44:28 +01:00
523 lines
14 KiB
JavaScript
523 lines
14 KiB
JavaScript
/**
|
|
* EGroupware clientside API: link-registry, link-titles, generation links
|
|
*
|
|
* @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
|
|
* @package etemplate
|
|
* @subpackage api
|
|
* @link http://www.egroupware.org
|
|
* @author Andreas Stöckel (as AT stylite.de)
|
|
* @author Ralf Becker <RalfBecker@outdoor-training.de>
|
|
*/
|
|
|
|
/*egw:uses
|
|
egw_core;
|
|
*/
|
|
import './egw_core.js';
|
|
|
|
/**
|
|
* @augments Class
|
|
*/
|
|
egw.extend('links', egw.MODULE_GLOBAL, function()
|
|
{
|
|
"use strict";
|
|
|
|
/**
|
|
* Link registry
|
|
*
|
|
* @access: private, use egw.open() or egw.set_link_registry()
|
|
*/
|
|
let link_registry = undefined;
|
|
|
|
/**
|
|
* Local cache for link-titles
|
|
*
|
|
* @access private, use egw.link_title(_app, _id[, _callback, _context])
|
|
*/
|
|
let title_cache = {};
|
|
|
|
/**
|
|
* Queue for link_title requests
|
|
*
|
|
* @access private, use egw.link_title(_app, _id[, _callback, _context])
|
|
* @var object _app._id.[{callback: _callback, context: _context}[, ...]]
|
|
*/
|
|
let title_queue = {};
|
|
|
|
/**
|
|
* Uid of active jsonq request, to not start another one, as we get notified
|
|
* before it's actually send to the server via our link_title_before_send callback.
|
|
* @access private
|
|
*/
|
|
let title_uid = null;
|
|
|
|
return {
|
|
/**
|
|
* Check if $app is in the registry and has an entry for $name
|
|
*
|
|
* @param {string} _app app-name
|
|
* @param {string} _name name / key in the registry, eg. 'view'
|
|
* @return {boolean|string} false if $app is not registered, otherwise string with the value for $name
|
|
* @memberOf egw
|
|
*/
|
|
link_get_registry: function(_app, _name)
|
|
{
|
|
if (typeof link_registry !== 'object')
|
|
{
|
|
alert('egw.open() link registry is NOT defined!');
|
|
return false;
|
|
}
|
|
if (typeof link_registry[_app] === 'undefined')
|
|
{
|
|
return false;
|
|
}
|
|
const reg = link_registry[_app];
|
|
|
|
// some defaults (we set them directly in the registry, to do this only once)
|
|
if (typeof reg[_name] === 'undefined')
|
|
{
|
|
switch(_name)
|
|
{
|
|
case 'name':
|
|
reg.name = _app;
|
|
break;
|
|
case 'icon':
|
|
const app_data = this.app(_app);
|
|
if (typeof app_data !== 'undefined' &&
|
|
typeof app_data.icon !== 'undefined' && app_data.icon !== null)
|
|
{
|
|
reg.icon = (typeof app_data.icon_app != 'undefined' ? app_data.icon_app : _app)+'/'+app_data.icon;
|
|
}
|
|
else
|
|
{
|
|
reg.icon = _app+'/navbar';
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (reg && typeof _name === 'undefined')
|
|
{
|
|
// No key requested, return the whole thing
|
|
return reg;
|
|
}
|
|
return typeof reg[_name] === 'undefined' ? false : reg[_name];
|
|
},
|
|
|
|
/**
|
|
* Get mime-type information from app-registry
|
|
*
|
|
* We prefer a full match over a wildcard like 'text/*' (written as regualr expr. "/^text\\//"
|
|
*
|
|
* @param {string} _type
|
|
* @return {object} with values for keys 'menuaction', 'mime_id' (path) or 'mime_url' and options 'mime_popup' and other values to pass one
|
|
*/
|
|
get_mime_info: function(_type)
|
|
{
|
|
let wildcard_mime;
|
|
for(var app in link_registry)
|
|
{
|
|
const reg = link_registry[app];
|
|
if (typeof reg.mime !== 'undefined')
|
|
{
|
|
for(let mime in reg.mime)
|
|
{
|
|
if (mime === _type) return reg.mime[_type];
|
|
if (mime[0] === '/' && _type.match(new RegExp(mime.substring(1, mime.length-1), 'i')))
|
|
{
|
|
wildcard_mime = reg.mime[mime];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return wildcard_mime ? wildcard_mime : null;
|
|
},
|
|
|
|
/**
|
|
* Get handler (link-data) for given path and mime-type
|
|
*
|
|
* @param {string|object} _path vfs path, egw_link::set_data() id or
|
|
* object with attr path, optinal download_url or id, app2 and id2 (path=/apps/app2/id2/id)
|
|
* @param {string} _type mime-type, if not given in _path object
|
|
* @return {string|object} string with EGw relative link, array with get-parameters for '/index.php' or null (directory and not filemanager access)
|
|
*/
|
|
mime_open: function(_path, _type)
|
|
{
|
|
let path;
|
|
if (typeof _path === 'object')
|
|
{
|
|
if (typeof _path.path === 'undefined')
|
|
{
|
|
path = '/apps/'+_path.app2+'/'+_path.id2+'/'+_path.id;
|
|
}
|
|
else
|
|
{
|
|
path = _path.path;
|
|
}
|
|
if (typeof _path.type === 'string')
|
|
{
|
|
_type = _path.type;
|
|
}
|
|
}
|
|
else if(_path[0] !== '/')
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
path = _path;
|
|
}
|
|
let mime_info = this.get_mime_info(_type);
|
|
let data = {};
|
|
if (mime_info)
|
|
{
|
|
for(let attr in mime_info)
|
|
{
|
|
switch(attr)
|
|
{
|
|
case 'mime_url':
|
|
data[mime_info.mime_url] = 'vfs://default' + path;
|
|
break;
|
|
case 'mime_data':
|
|
break;
|
|
case 'mime_type':
|
|
data[mime_info.mime_type] = _type;
|
|
break;
|
|
case 'mime_id':
|
|
data[mime_info.mime_id] = path;
|
|
break;
|
|
default:
|
|
data[attr] = mime_info[attr];
|
|
}
|
|
}
|
|
// if mime_info did NOT define mime_url attribute, we use a WebDAV url drived from path
|
|
if (typeof mime_info.mime_url === 'undefined')
|
|
{
|
|
data.url = typeof _path === 'object' && _path.download_url ? _path.download_url : '/webdav.php' + path;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data = typeof _path === 'object' && _path.download_url ? _path.download_url : '/webdav.php' + path;
|
|
}
|
|
return data;
|
|
},
|
|
|
|
/**
|
|
* Get list of link-aware apps the user has rights to use
|
|
*
|
|
* @param {string} _must_support capability the apps need to support, eg. 'add', default ''=list all apps
|
|
* @return {object} with app => title pairs
|
|
*/
|
|
link_app_list: function(_must_support)
|
|
{
|
|
let apps = [];
|
|
for (let type in link_registry)
|
|
{
|
|
const reg = link_registry[type];
|
|
|
|
if (typeof _must_support !== 'undefined' && _must_support && typeof reg[_must_support] === 'undefined') continue;
|
|
|
|
const app_sub = type.split('-');
|
|
if (this.app(app_sub[0]))
|
|
{
|
|
apps.push({"type": type, "label": this.lang(this.link_get_registry(type,'name'))});
|
|
}
|
|
}
|
|
// sort labels (case-insensitive) alphabetic
|
|
apps = apps.sort((_a, _b) =>
|
|
{
|
|
var al = _a.label.toUpperCase();
|
|
var bl = _b.label.toUpperCase();
|
|
return al === bl ? 0 : (al > bl ? 1 : -1);
|
|
});
|
|
// create sorted associative array / object
|
|
const sorted = {};
|
|
for(let i = 0; i < apps.length; ++i)
|
|
{
|
|
sorted[apps[i].type] = apps[i].label;
|
|
}
|
|
return sorted;
|
|
},
|
|
|
|
/**
|
|
* Set link registry
|
|
*
|
|
* @param {object} _registry whole registry or entries for just one app
|
|
* @param {string} _app
|
|
* @param {boolean} _need_clone _images need to be cloned, as it is from different window context
|
|
* and therefore will be inaccessible in IE, after that window is closed
|
|
*/
|
|
set_link_registry: function (_registry, _app, _need_clone)
|
|
{
|
|
if (typeof _app === 'undefined')
|
|
{
|
|
link_registry = _need_clone ? jQuery.extend(true, {}, _registry) : _registry;
|
|
}
|
|
else
|
|
{
|
|
link_registry[_app] = _need_clone ? jQuery.extend(true, {}, _registry) : _registry;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Generate a url which supports url or cookies based sessions
|
|
*
|
|
* Please note, the values of the query get url encoded!
|
|
*
|
|
* @param {string} _url a url relative to the egroupware install root, it can contain a query too or
|
|
* full url containing a schema and "://"
|
|
* @param {object|string} _extravars query string arguements as string or array (prefered)
|
|
* if string is used ambersands in vars have to be already urlencoded as '%26', function ensures they get NOT double encoded
|
|
* @return {string} generated url
|
|
*/
|
|
link: function(_url, _extravars)
|
|
{
|
|
if (_url.substr(0,4) === 'http' && _url.indexOf('://') <= 5)
|
|
{
|
|
// already a full url (eg. download_url of vfs), nothing to do
|
|
}
|
|
else
|
|
{
|
|
if (_url[0] != '/')
|
|
{
|
|
alert("egw.link('"+_url+"') called with url starting NOT with a slash!");
|
|
const app = window.egw_appName;
|
|
if (app != 'login' && app != 'logout') _url = app+'/'+_url;
|
|
}
|
|
// append the url to the webserver url, if not already contained or empty
|
|
if (this.webserverUrl && this.webserverUrl != '/' && _url.indexOf(this.webserverUrl+'/') != 0)
|
|
{
|
|
_url = this.webserverUrl + _url;
|
|
}
|
|
}
|
|
const vars = {};
|
|
|
|
// check if the url already contains a query and ensure that vars is an array and all strings are in extravars
|
|
const url_othervars = _url.split('?',2);
|
|
_url = url_othervars[0];
|
|
const othervars = url_othervars[1];
|
|
if (_extravars && typeof _extravars == 'object')
|
|
{
|
|
jQuery.extend(vars, _extravars);
|
|
_extravars = othervars;
|
|
}
|
|
else
|
|
{
|
|
if (!_extravars) _extravars = '';
|
|
if (othervars) _extravars += (_extravars?'&':'')+othervars;
|
|
}
|
|
|
|
// parse extravars string into the vars array
|
|
if (_extravars)
|
|
{
|
|
_extravars = _extravars.split('&');
|
|
for(let i=0; i < _extravars.length; ++i)
|
|
{
|
|
const name_val = _extravars[i].split('=', 2);
|
|
let name = name_val[0];
|
|
let val = name_val[1] || '';
|
|
if (val.indexOf('%26') !== -1) val = val.replace(/%26/g,'&'); // make sure to not double encode &
|
|
if (name.lastIndexOf('[]') == name.length-2)
|
|
{
|
|
name = name.substr(0,name.length-2);
|
|
if (typeof vars[name] === 'undefined') vars[name] = [];
|
|
vars[name].push(val);
|
|
}
|
|
else
|
|
{
|
|
vars[name] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if there are vars, we add them urlencoded to the url
|
|
let query = [];
|
|
|
|
for(let name in vars)
|
|
{
|
|
let val = vars[name] || ''; // fix error for eg. null, which is an object!
|
|
if (typeof val == 'object')
|
|
{
|
|
for(let i=0; i < val.length; ++i)
|
|
{
|
|
query.push(name+'[]='+encodeURIComponent(val[i]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
query.push(name+'='+encodeURIComponent(val));
|
|
}
|
|
}
|
|
|
|
return query.length ? _url+'?'+query.join('&') : _url;
|
|
},
|
|
|
|
/**
|
|
* Query a title of _app/_id
|
|
*
|
|
* Deprecated default of returning string or null for no callback, will change in future to always return a Promise!
|
|
*
|
|
* @param {string} _app
|
|
* @param {string|number} _id
|
|
* @param {boolean|function|undefined} _callback true to always return a promise, false: just lookup title-cache or optional callback
|
|
* NOT giving either a boolean value or a callback is deprecated!
|
|
* @param {object|undefined} _context context for the callback
|
|
* @param {boolean} _force_reload true load again from server, even if already cached
|
|
* @return {Promise|string|null} Promise for _callback given (function or true), string with title if it exists in local cache or null if not
|
|
*/
|
|
link_title: function(_app, _id, _callback, _context, _force_reload)
|
|
{
|
|
// check if we have a cached title --> return it direct
|
|
if (typeof title_cache[_app] !== 'undefined' && typeof title_cache[_app][_id] !== 'undefined' && _force_reload !== true)
|
|
{
|
|
if (typeof _callback === 'function')
|
|
{
|
|
_callback.call(_context, title_cache[_app][_id]);
|
|
}
|
|
if (_callback)
|
|
{
|
|
return Promise.resolve(title_cache[_app][_id]);
|
|
}
|
|
return title_cache[_app][_id];
|
|
}
|
|
// no callback --> return null
|
|
if (!_callback)
|
|
{
|
|
if (_callback !== false)
|
|
{
|
|
console.trace('Deprecated use of egw.link() without 3rd parameter callback!');
|
|
}
|
|
return null; // not found in local cache and can't do a synchronous request
|
|
}
|
|
// queue the request
|
|
if (typeof title_queue[_app] === 'undefined')
|
|
{
|
|
title_queue[_app] = {};
|
|
}
|
|
if (typeof title_queue[_app][_id] === 'undefined')
|
|
{
|
|
title_queue[_app][_id] = [];
|
|
}
|
|
let promise = new Promise(_resolve => {
|
|
title_queue[_app][_id].push({callback: _resolve, context: _context});
|
|
});
|
|
if (typeof _callback === 'function')
|
|
{
|
|
promise = promise.then(_data => {
|
|
_callback.bind(_context)(_data);
|
|
return _data;
|
|
});
|
|
}
|
|
// if there's no active jsonq request, start a new one
|
|
if (title_uid === null)
|
|
{
|
|
title_uid = this.jsonq('EGroupware\\Api\\Etemplate\\Widget\\Link::ajax_link_titles',[{}], undefined, this, this.link_title_before_send)
|
|
.then(_response => this.link_title_callback(_response));
|
|
}
|
|
return promise;
|
|
},
|
|
|
|
/**
|
|
* Callback to add all current title requests
|
|
*
|
|
* @param {object} _params of parameters, only first parameter is used
|
|
*/
|
|
link_title_before_send: function(_params)
|
|
{
|
|
// add all current title-requests
|
|
for(let app in title_queue)
|
|
{
|
|
for(let id in title_queue[app])
|
|
{
|
|
if (typeof _params[0][app] === 'undefined')
|
|
{
|
|
_params[0][app] = [];
|
|
}
|
|
_params[0][app].push(id);
|
|
}
|
|
}
|
|
title_uid = null; // allow next request to jsonq
|
|
},
|
|
|
|
/**
|
|
* Callback for server response
|
|
*
|
|
* @param {object} _response _app => _id => title
|
|
*/
|
|
link_title_callback: function(_response)
|
|
{
|
|
if (typeof _response !== 'object')
|
|
{
|
|
throw "Wrong parameter for egw.link_title_callback!";
|
|
}
|
|
for(let app in _response)
|
|
{
|
|
if (typeof title_cache[app] !== 'object')
|
|
{
|
|
title_cache[app] = {};
|
|
}
|
|
for (let id in _response[app])
|
|
{
|
|
const title = _response[app][id];
|
|
// cache locally
|
|
title_cache[app][id] = title;
|
|
// call callbacks waiting for title of app/id
|
|
if (typeof title_queue[app] !== 'undefined' && typeof title_queue[app][id] !== "undefined")
|
|
{
|
|
for(let i=0; i < title_queue[app][id].length; ++i)
|
|
{
|
|
const callback = title_queue[app][id][i];
|
|
callback.callback.call(callback.context, title);
|
|
}
|
|
delete title_queue[app][id];
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Create quick add selectbox
|
|
*
|
|
* @param {DOMnode} _parent parent to create selectbox in
|
|
*/
|
|
link_quick_add: function(_parent)
|
|
{
|
|
// check if quick-add selectbox is already there, only create it again if not
|
|
if (document.getElementById('quick_add_selectbox')) return;
|
|
|
|
const select = document.createElement('et2-select');
|
|
select.setAttribute('id', 'quick_add_selectbox');
|
|
document.getElementById(_parent).append(select);
|
|
// bind change handler
|
|
select.addEventListener('change', () =>
|
|
{
|
|
if (select.value) this.open('', select.value, 'add', {}, undefined, select.value, true);
|
|
select.value = '';
|
|
});
|
|
// need to load common translations for app-names
|
|
this.langRequire(window, [{app: 'common', lang: this.preference('lang')}], () =>
|
|
{
|
|
let options = [{value:'', label: this.lang('Select one...')}];
|
|
const apps = this.link_app_list('add');
|
|
for(let app in apps)
|
|
{
|
|
if(this.link_get_registry(app, 'no_quick_add'))
|
|
{
|
|
continue;
|
|
}
|
|
options.push({
|
|
value:app,
|
|
label:this.lang(this.link_get_registry(app,'entry') || apps[app]),
|
|
icon: this.image('navbar', app)
|
|
});
|
|
}
|
|
select.select_options = options;
|
|
select.updateComplete.then(() =>
|
|
{
|
|
select.dropdown.trigger.style.visibility = 'hidden';
|
|
select.dropdown.trigger.style.height = '0px';
|
|
select.querySelector('sl-menu-item[value=""]').style.display = 'none';
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}); |