1 /*

     2  * MyAMS

     3  * « My Application Management Skin »

     4  *

     5  * $Tag: $

     6  * A bootstrap based application/administration skin

     7  *

     8  * Custom administration and application skin tools

     9  * Released under Zope Public License ZPL 1.1

    10  * ©2014 Thierry Florac <tflorac@ulthar.net>

    11  */

    12 

    13 (function($) {

    14 

    15 	/**

    16 	 * String prototype extensions

    17 	 */

    18 	String.prototype.startsWith = function(str) {

    19 		var slen = this.length;

    20 		var dlen = str.length;

    21 		if (slen < dlen) {

    22 			return false;

    23 		}

    24 		return (this.substr(0,dlen) == str);

    25 	};

    26 

    27 	String.prototype.endsWith = function(str) {

    28 		var slen = this.length;

    29 		var dlen = str.length;

    30 		if (slen < dlen) {

    31 			return false;

    32 		}

    33 		return (this.substr(slen-dlen) == str);

    34 	};

    35 

    36 

    37 	/**

    38 	 * Array prototype extensions

    39 	 */

    40 	if (!Array.prototype.indexOf) {

    41 		Array.prototype.indexOf = function(elt /*, from*/) {

    42 			var len = this.length;

    43 

    44 			var from = Number(arguments[1]) || 0;

    45 			from = (from < 0) ? Math.ceil(from) : Math.floor(from);

    46 			if (from < 0)

    47 				from += len;

    48 

    49 			for (; from < len; from++) {

    50 				if (from in this &&

    51 					this[from] === elt)

    52 					return from;

    53 			}

    54 			return -1;

    55 		};

    56 	}

    57 

    58 

    59 	/**

    60 	 * JQuery 'econtains' expression

    61 	 * Case insensitive contains expression

    62 	 */

    63 	$.expr[":"].econtains = function(obj, index, meta, stack) {

    64 		return (obj.textContent || obj.innerText || $(obj).text() || "").toLowerCase() == meta[3].toLowerCase();

    65 	};

    66 

    67 

    68 	/**

    69 	 * JQuery 'withtext' expression

    70 	 * Case sensitive exact search expression

    71 	 */

    72 	$.expr[":"].withtext = function(obj, index, meta, stack) {

    73 		return (obj.textContent || obj.innerText || $(obj).text() || "") == meta[3];

    74 	};

    75 

    76 

    77 	/**

    78 	 * JQuery filter on parents class

    79 	 */

    80 	$.expr[':'].parents = function(obj, index, meta, stack) {

    81 		return $(obj).parents(meta[3]).length > 0;

    82 	};

    83 

    84 

    85 	/**

    86 	 * JQuery 'scrollbarWidth' function

    87 	 * Get width of vertical scrollbar

    88 	 */

    89 	if ($.scrollbarWidth === undefined) {

    90 		$.scrollbarWidth = function() {

    91 			var parent,

    92 				child,

    93 				width;

    94 			if (width === undefined) {

    95 				parent = $('<div style="width:50px;height:50px;overflow:auto"><div/></div>').appendTo('body');

    96 				child = parent.children();

    97 				width = child.innerWidth() - child.height(99).innerWidth();

    98 				parent.remove();

    99 			}

   100 			return width;

   101 		};

   102 	}

   103 

   104 

   105 	/**

   106 	 * MyAMS JQuery extensions

   107 	 */

   108 	$.fn.extend({

   109 

   110 		exists: function() {

   111 			return $(this).length > 0;

   112 		},

   113 

   114 		/*

   115 		 * CSS style function

   116 		 * Code from Aram Kocharyan on stackoverflow.com

   117 		 */

   118 		style: function(styleName, value, priority) {

   119 			// DOM node

   120 			var node = this.get(0);

   121 			// Ensure we have a DOM node

   122 			if (typeof node == 'undefined') {

   123 				return;

   124 			}

   125 			// CSSStyleDeclaration

   126 			var style = this.get(0).style;

   127 			// Getter/Setter

   128 			if (typeof styleName != 'undefined') {

   129 				if (typeof value != 'undefined') {

   130 					// Set style property

   131 					priority = typeof priority != 'undefined' ? priority : '';

   132 					style.setProperty(styleName, value, priority);

   133 					return this;

   134 				} else {

   135 					// Get style property

   136 					return style.getPropertyValue(styleName);

   137 				}

   138 			} else {

   139 				// Get CSSStyleDeclaration

   140 				return style;

   141 			}

   142 		},

   143 

   144 		removeClassPrefix: function (prefix) {

   145 			this.each(function (i, it) {

   146 				var classes = it.className.split(" ").map(function(item) {

   147 					return item.startsWith(prefix) ? "" : item

   148 				});

   149 				it.className = $.trim(classes.join(" "))

   150 			});

   151 			return this;

   152 		},

   153 

   154 		myams_menu: function(options) {

   155 			// Extend our default options with those provided

   156 			var defaults = {

   157 				accordion : 'true',

   158 				speed : 200,

   159 				closedSign : '<em class="fa fa-angle-down"></em>',

   160 				openedSign : '<em class="fa fa-angle-up"></em>'

   161 			};

   162 			var settings = $.extend({}, defaults, options);

   163 

   164 			// Assign current element to variable, in this case is UL element

   165 			var menu = $(this);

   166 

   167 			// Add a mark [+] to a multilevel menu

   168 			menu.find("LI").each(function() {

   169 				var menu_item = $(this);

   170 				if (menu_item.find("UL").size() > 0) {

   171 

   172 					// add the multilevel sign next to the link

   173 					menu_item.find("A:first")

   174 							 .append("<b class='collapse-sign'>" + settings.closedSign + "</b>");

   175 

   176 					// avoid jumping to the top of the page when the href is an #

   177 					var first_link = menu_item.find("A:first");

   178 					if (first_link.attr('href') == "#") {

   179 						first_link.click(function() {

   180 							return false;

   181 						});

   182 					}

   183 				}

   184 			});

   185 

   186 			// Open active level

   187 			menu.find("LI.active").each(function() {

   188 				var active_parent = $(this).parents('UL');

   189 				var active_item = active_parent.parent('LI');

   190 				active_parent.slideDown(settings.speed);

   191 				active_item.find("b:first").html(settings.openedSign);

   192 				active_item.addClass("open")

   193 			});

   194 

   195 			menu.find("LI A").on('click', function() {

   196 				var link = $(this);

   197 				var parent_ul = link.parent().find("UL");

   198 				if (parent_ul.size() != 0) {

   199 					if (settings.accordion) {

   200 						// Do nothing when the list is open

   201 						if (!parent_ul.is(':visible')) {

   202 							var parents = link.parent().parents("UL");

   203 							var visible = menu.find("UL:visible");

   204 							visible.each(function(visibleIndex) {

   205 								var close = true;

   206 								parents.each(function(parentIndex) {

   207 									if (parents[parentIndex] == visible[visibleIndex]) {

   208 										close = false;

   209 										return false;

   210 									}

   211 								});

   212 								if (close) {

   213 									if (parent_ul != visible[visibleIndex]) {

   214 										$(visible[visibleIndex]).slideUp(settings.speed, function() {

   215 											link.parent("LI")

   216 												.find("b:first")

   217 												.html(settings.closedSign);

   218 											link.parent("LI")

   219 												.removeClass("open");

   220 										});

   221 									}

   222 								}

   223 							});

   224 						}

   225 					}

   226 					var first_ul = link.parent().find("UL:first");

   227 					if (!link.attr('href').replace(/^#/,'') &&

   228 						first_ul.is(":visible") &&

   229 						!first_ul.hasClass("active")) {

   230 						first_ul.slideUp(settings.speed, function() {

   231 							link.parent("LI")

   232 								.removeClass("open")

   233 								.find("B:first")

   234 								.delay(settings.speed)

   235 								.html(settings.closedSign);

   236 						});

   237 					} else /*if (link.attr('href') != location.hash)*/ {

   238 						first_ul.slideDown(settings.speed, function() {

   239 							link.parent("LI")

   240 								.addClass("open")

   241 								.find("B:first")

   242 								.delay(settings.speed)

   243 								.html(settings.openedSign);

   244 						});

   245 					}

   246 				}

   247 			});

   248 		}

   249 	});

   250 

   251 

   252 	/**

   253 	 * UTF-8 encoding class

   254 	 * Mainly used by IE...

   255 	 */

   256 	$.UTF8 = {

   257 

   258 		// public method for url encoding

   259 		encode : function (string) {

   260 			string = string.replace(/\r\n/g,"\n");

   261 			var utftext = "";

   262 

   263 			for (var n = 0; n < string.length; n++) {

   264 

   265 				var c = string.charCodeAt(n);

   266 

   267 				if (c < 128) {

   268 					utftext += String.fromCharCode(c);

   269 				}

   270 				else if((c > 127) && (c < 2048)) {

   271 					utftext += String.fromCharCode((c >> 6) | 192);

   272 					utftext += String.fromCharCode((c & 63) | 128);

   273 				}

   274 				else {

   275 					utftext += String.fromCharCode((c >> 12) | 224);

   276 					utftext += String.fromCharCode(((c >> 6) & 63) | 128);

   277 					utftext += String.fromCharCode((c & 63) | 128);

   278 				}

   279 			}

   280 			return utftext;

   281 		},

   282 

   283 		// public method for url decoding

   284 		decode : function (utftext) {

   285 			var string = "";

   286 			var i = 0;

   287 			var c = c1 = c2 = 0;

   288 

   289 			while ( i < utftext.length ) {

   290 

   291 				c = utftext.charCodeAt(i);

   292 

   293 				if (c < 128) {

   294 					string += String.fromCharCode(c);

   295 					i++;

   296 				}

   297 				else if((c > 191) && (c < 224)) {

   298 					c2 = utftext.charCodeAt(i+1);

   299 					string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));

   300 					i += 2;

   301 				}

   302 				else {

   303 					c2 = utftext.charCodeAt(i+1);

   304 					c3 = utftext.charCodeAt(i+2);

   305 					string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));

   306 					i += 3;

   307 				}

   308 			}

   309 			return string;

   310 		}

   311 	}; /** $.UTF8 */

   312 

   313 

   314 	/**

   315 	 * MyAMS extensions to JQuery

   316 	 */

   317 	if (window.MyAMS === undefined) {

   318 		MyAMS = {

   319 			devmode: true,

   320 			throttle_delay: 350,

   321 			menu_speed: 235,

   322 			navbar_height: 49,

   323 			ajax_nav: true,

   324 			enable_widgets: true,

   325 			enable_mobile: false,

   326 			enable_fastclick: false,

   327 			ismobile: (/iphone|ipad|ipod|android|blackberry|mini|windows\sce|palm/i.test(navigator.userAgent.toLowerCase()))

   328 		};

   329 	}

   330 	var ams = MyAMS;

   331 

   332 	/**

   333 	 * Get MyAMS base URL

   334 	 * Copyright Andrew Davy: https://forrst.com/posts/Get_the_URL_of_the_current_javascript_file-Dst

   335 	 */

   336 	MyAMS.baseURL = (function () {

   337 		var script = $("script:last");

   338 		var src = script.attr("src");

   339 		return src.substring(0, src.lastIndexOf('/') + 1);

   340 	})();

   341 

   342 

   343 	/**

   344 	 * Extract parameter value from given query string

   345 	 */

   346 	MyAMS.getQueryVar = function(src, varName) {

   347 		// Check src

   348 		if (src.indexOf('?') < 0)

   349 			return false;

   350 		if (!src.endsWith('&'))

   351 			src += '&';

   352 		// Dynamic replacement RegExp

   353 		var regex = new RegExp('.*?[&\\?]' + varName + '=(.*?)&.*');

   354 		// Apply RegExp to the query string

   355 		var val = src.replace(regex, "$1");

   356 		// If the string is the same, we didn't find a match - return false

   357 		return val == src ? false : val;

   358 	};

   359 

   360 

   361 	/**

   362 	 * Color conversion function

   363 	 */

   364 	MyAMS.rgb2hex = function(color) {

   365 		return "#" + $.map(color.match(/\b(\d+)\b/g), function(digit) {

   366 			return ('0' + parseInt(digit).toString(16)).slice(-2)

   367 		}).join('');

   368 	};

   369 

   370 

   371 	/**

   372 	 * Get and execute a function given by name

   373 	 * Small piece of code by Jason Bunting

   374 	 */

   375 	MyAMS.getFunctionByName = function(functionName, context) {

   376 		if (functionName === undefined)

   377 			return undefined;

   378 		else if (typeof(functionName) == 'function')

   379 			return functionName;

   380 		var namespaces = functionName.split(".");

   381 		var func = namespaces.pop();

   382 		var context = (context === undefined || context === null) ? window : context;

   383 		for (var i=0; i < namespaces.length; i++) {

   384 			try {

   385 				context = context[namespaces[i]];

   386 			} catch (e) {

   387 				return undefined;

   388 			}

   389 		}

   390 		try {

   391 			return context[func];

   392 		} catch (e) {

   393 			return undefined;

   394 		}

   395 	};

   396 

   397 	MyAMS.executeFunctionByName = function(functionName, context /*, args */) {

   398 		var func = ams.getFunctionByName(functionName, window);

   399 		if (typeof(func) == 'function') {

   400 			var args = Array.prototype.slice.call(arguments, 2);

   401 			return func.apply(context, args);

   402 		}

   403 	};

   404 

   405 

   406 	/**

   407 	 * Get script or CSS file using browser cache

   408 	 * Script or CSS URLs can include variable names, given between braces, as in

   409 	 * {MyAMS.baseURL}

   410 	 */

   411 	MyAMS.getSource = function(url) {

   412 		var src = url.replace(/{[^{}]*}/g, function(match) {

   413 			return ams.getFunctionByName(match.substr(1, match.length-2));

   414 		});

   415 		return src;

   416 	};

   417 

   418 	MyAMS.getScript = function(url, callback, options) {

   419 		var defaults = {

   420 			dataType: 'script',

   421 			url: ams.getSource(url),

   422 			success: callback,

   423 			error: ams.error.show,

   424 			cache: true,

   425 			async: true

   426 		};

   427 		var settings = $.extend({}, defaults, options);

   428 		return $.ajax(settings);

   429 	};

   430 

   431 	MyAMS.getCSS = function(url, id) {

   432 		var head = $('HEAD');

   433 		var css = $('link[data-ams-id="' + id + '"]', head);

   434 		if (css.length == 0) {

   435 			$('<link />').attr({rel: 'stylesheet',

   436 								type: 'text/css',

   437 								href: ams.getSource(url),

   438 								'data-ams-id': id})

   439 						 .appendTo(head);

   440 		}

   441 	};

   442 

   443 

   444 	/**

   445 	 * Events management

   446 	 */

   447 	MyAMS.event = {

   448 

   449 		stop: function(event) {

   450 			if (!event) {

   451 				var event = window.event;

   452 			}

   453 			if (event) {

   454 				if (event.stopPropagation) {

   455 					event.stopPropagation();

   456 					event.preventDefault();

   457 				} else {

   458 					event.cancelBubble = true;

   459 					event.returnValue = false;

   460 				}

   461 			}

   462 		}

   463 	};

   464 

   465 

   466 	/**

   467 	 * Browser testing functions; mostly for IE...

   468 	 */

   469 	MyAMS.browser = {

   470 

   471 		getInternetExplorerVersion: function() {

   472 			var rv = -1;

   473 			if (navigator.appName == "Microsoft Internet Explorer") {

   474 				var ua = navigator.userAgent;

   475 				var re = new RegExp("MSIE ([0-9]{1,}[.0-9]{0,})");

   476 				if (re.exec(ua) != null)

   477 					rv = parseFloat(RegExp.$1);

   478 			}

   479 			return rv;

   480 		},

   481 

   482 		checkVersion: function() {

   483 			var msg = "You're not using Windows Internet Explorer.";

   484 			var ver = this.getInternetExplorerVersion();

   485 			if (ver > -1) {

   486 				if (ver >= 8)

   487 					msg = "You're using a recent copy of Windows Internet Explorer.";

   488 				else

   489 					msg = "You should upgrade your copy of Windows Internet Explorer.";

   490 			}

   491 			alert(msg);

   492 		},

   493 

   494 		isIE8orlower: function() {

   495 			var msg = "0";

   496 			var ver = this.getInternetExplorerVersion();

   497 			if (ver > -1) {

   498 				if (ver >= 9)

   499 					msg = 0;

   500 				else

   501 					msg = 1;

   502 			}

   503 			return msg;

   504 		}

   505 	};

   506 

   507 

   508 	/**

   509 	 * Errors management features

   510 	 */

   511 	MyAMS.error = {

   512 

   513 		/**

   514 		 * Default JQuery AJAX error handler

   515 		 */

   516 		ajax: function(event, request, settings) {

   517 			if (request.statusText == 'OK')

   518 				return;

   519 			ams.skin.messageBox('error', {

   520 				title: ams.i18n.ERROR_OCCURED,

   521 				content: '<h4>' + event.type + '</h4><p>' + request.statusText + '</p>',

   522 				icon: 'fa fa-warning animated shake',

   523 				timeout: 10000

   524 			});

   525 			if (window.console) {

   526 				console.error(event);

   527 				console.debug(request);

   528 			}

   529 		},

   530 

   531 		/**

   532 		 * Show AJAX error

   533 		 */

   534 		show: function(request, status, error) {

   535 			if (!error)

   536 				return;

   537 			ams.skin.messageBox('error', {

   538 				title: ams.i18n.ERRORS_OCCURED,

   539 				content: '<h4>' + status + '</h4><p>' + error + '</p>',

   540 				icon: "fa fa-warning animated shake",

   541 				timeout: 10000

   542 			});

   543 			if (window.console) {

   544 				console.error(error);

   545 				console.debug(request);

   546 			}

   547 		}

   548 	};

   549 

   550 

   551 	/**

   552 	 * AJAX helper functions

   553 	 */

   554 	MyAMS.ajax = {

   555 

   556 		/**

   557 		 * Check for given feature and download script if necessary

   558 		 *

   559 		 * @checker: pointer to a javascript object which will be downloaded in undefined

   560 		 * @source: URL of a javascript file containing requested feature

   561 		 * @callback: pointer to a function which will be called after the script is downloaded. The first

   562 		 *   argument of this callback is a boolean value indicating if the script was just downloaded (true)

   563 		 *   or if the requested object was already loaded (false)

   564 		 * @options: callback options

   565 		 */

   566 		check: function(checker, source, callback, options) {

   567 			if (typeof(callback) == 'object') {

   568 				var options = callback;

   569 				var callback = undefined;

   570 			}

   571 			var defaults = {

   572 				async: typeof(callback) == 'function'

   573 			};

   574 			var settings = $.extend({}, defaults, options);

   575 			if (checker === undefined) {

   576 				ams.getScript(source, function() {

   577 					if (typeof(callback) == 'function')

   578 						callback(true, options);

   579 				}, settings);

   580 			} else {

   581 				if (typeof(callback) == 'function')

   582 					callback(false, options);

   583 			}

   584 		},

   585 

   586 		/**

   587 		 * Get address relative to current page

   588 		 */

   589 		getAddr: function(addr) {

   590 			var href = addr || $('HTML HEAD BASE').attr('href') || window.location.href;

   591 			return href.substr(0, href.lastIndexOf("/") + 1);

   592 		},

   593 

   594 		/**

   595 		 * Post data to given URL

   596 		 */

   597 		post: function(url, data, options, callback) {

   598 			if (url.startsWith(window.location.protocol))

   599 				var addr = url;

   600 			else

   601 				addr = this.getAddr() + url;

   602 			if (typeof(options) == 'function') {

   603 				callback = options;

   604 				options = {}

   605 			} else if (!options) {

   606 				options = {};

   607 			}

   608 			if (typeof(callback) == 'undefined')

   609 				callback = options.callback;

   610 			if (typeof(callback) == 'string')

   611 				callback = ams.getFunctionByName(callback);

   612 			delete options.callback;

   613 

   614 			var result;

   615 			var defaults = {

   616 				url: addr,

   617 				type: 'post',

   618 				cache: false,

   619 				async: typeof(callback) == 'function',

   620 				data: $.param(data, true),

   621 				dataType: 'json',

   622 				success: callback || function(data, status) {

   623 					result = data.result;

   624 				},

   625 				error: ams.error.show

   626 			};

   627 			var settings = $.extend({}, defaults, options);

   628 			$.ajax(settings);

   629 			return result;

   630 		},

   631 

   632 		/**

   633 		 * Extract data type and result from response

   634 		 */

   635 		getResponse: function(request) {

   636 			var content_type = request.getResponseHeader('content-type');

   637 			if (content_type.startsWith('application/javascript')) {

   638 				data_type = 'script';

   639 				result = request.responseText;

   640 			} else if (content_type.startsWith('text/html')) {

   641 				data_type = 'html';

   642 				result = request.responseText;

   643 			} else if (content_type.startsWith('text/xml')) {

   644 				data_type = 'xml';

   645 				result = request.responseText;

   646 			} else {

   647 				result = request.responseJSON;

   648 				if (result)

   649 					data_type = 'json';

   650 				else {

   651 					try {

   652 						result = JSON.parse(request.responseText);

   653 						data_type = 'json';

   654 					} catch (e) {

   655 						result = request.responseText;

   656 						data_type = 'text';

   657 					}

   658 				}

   659 			}

   660 			return {content_type: data_type,

   661 					data: result};

   662 		},

   663 

   664 		/**

   665 		 * Handle server response in JSON format

   666 		 *

   667 		 * Result is made of several JSON attributes:

   668 		 *  - status: error, success, callback, callbacks, reload or redirect

   669 		 *  - close_form: boolean indicating if current modal should be closed

   670 		 *  - location: target URL for reload or redirect status

   671 		 *  - target: target container's selector for loaded content ('#content' by default)

   672 		 *  - content: available for any status producing output content:

   673 		 *        {target: target container's selector (source form by default)

   674 		 *         html: HTML result}

   675 		 *  - message: available for any status producing output message:

   676 		 *        {target: target message container's selector

   677 		 *         status: message status

   678 		 *         header: message header

   679 		 *         subtitle: message subtitle,

   680 		 *         body: message body}

   681 		 *

   682 		 * For errors data structure, please see MyAMS.form.showErrors function

   683 		 */

   684 		handleJSON: function(result, form) {

   685 			var status = result.status;

   686 			switch (status) {

   687 				case 'error':

   688 					ams.form.showErrors(form, result);

   689 					break;

   690 				case 'success':

   691 					if (result.close_form != false)

   692 						ams.dialog.close(form);

   693 					break;

   694 				case 'message':

   695 				case 'messagebox':

   696 					break;

   697 				case 'callback':

   698 				case 'callbacks':

   699 					if (result.close_form != false)

   700 						ams.dialog.close(form);

   701 					break;

   702 				case 'modal':

   703 					ams.dialog.open(result.location);

   704 					break;

   705 				case 'reload':

   706 					if (result.close_form != false)

   707 						ams.dialog.close(form);

   708 					var url = result.location;

   709 					if (url.startsWith('#'))

   710 						ams.skin.loadURL(url.substr(1), result.target || '#content');

   711 					else

   712 						ams.skin.loadURL(url, result.target || '#content');

   713 					break;

   714 				case 'redirect':

   715 					var url = result.location;

   716 					if (result.window) {

   717 						window.open(url, result.window, result.options);

   718 					} else {

   719 						window.location.href = url;

   720 					}

   721 					break;

   722 				default:

   723 					console.log("Unhandled status: " + status);

   724 					break;

   725 			}

   726 			if (result.content) {

   727 				var content = result.content;

   728 				var container = $(content.target || form || '#content');

   729 				container.html(content.html);

   730 				ams.initContent(container);

   731 			}

   732 			if (result.message) {

   733 				var message = result.message;

   734 				if (typeof(message) == 'string')

   735 					ams.skin.alert($(form || '#content'),

   736 								   status, '', message);

   737 				else

   738 					ams.skin.alert($(message.target || form || '#content'),

   739 								   message.status || 'success',

   740 								   message.header,

   741 								   message.body,

   742 								   message.subtitle);

   743 			}

   744 			if (result.messagebox) {

   745 				message = result.messagebox;

   746 				if (typeof(message) == 'string')

   747 					ams.skin.messageBox('info',

   748 										{title: ams.i18n.ERROR_OCCURED,

   749 										 content: message,

   750 										 timeout: 10000});

   751 				else

   752 					ams.skin.messageBox(message.status || 'info',

   753 										{title: message.title || ams.i18n.ERROR_OCCURED,

   754 										 content: message.content,

   755 										 icon: message.icon,

   756 										 number: message.number,

   757 										 timeout: message.timeout || 10000});

   758 			}

   759 			if (result.callback)

   760 				ams.executeFunctionByName(result.callback, form, result.options);

   761 			if (result.callbacks) {

   762 				for (var index in result.callbacks) {

   763 					if (!$.isNumeric(index))

   764 						continue;

   765 					var callback = result.callbacks[index];

   766 					ams.executeFunctionByName(callback, form, callback.options);

   767 				}

   768 			}

   769 		}

   770 	};

   771 

   772 

   773 	/**

   774 	 * JSON-RPC helper functions

   775 	 */

   776 	MyAMS.jsonrpc = {

   777 

   778 		/**

   779 		 * Get address relative to current page

   780 		 */

   781 		getAddr: function(addr) {

   782 			var href = addr || $('HTML HEAD BASE').attr('href') || window.location.href;

   783 			var target = href.replace(/\+\+skin\+\+\w+\//, '');

   784 			return target.substr(0, target.lastIndexOf("/") + 1);

   785 		},

   786 

   787 		/**

   788 		 * Execute JSON-RPC request on given method

   789 		 *

   790 		 * Query can be given as a simple "query" string or as an object containing all query parameters.

   791 		 * Parameters:

   792 		 *  - @query: query string (posted as "query" parameter) or object containing all parameters

   793 		 *  - @method: name of JSON-RPC procedure to call

   794 		 *  - @options: additional JSON-RPC procedure parameters

   795 		 *  - @callback: name of a callback which will be called on server response

   796 		 */

   797 		query: function(query, method, options, callback) {

   798 			ams.ajax.check($.jsonRpc,

   799 						   ams.baseURL + 'ext/jquery-jsonrpc' + (ams.devmode ? '.js' : '.min.js'),

   800 						   function() {

   801 								var result;

   802 								if (typeof(options) == 'function') {

   803 									callback = options;

   804 									options = {};

   805 								}

   806 								else if (!options)

   807 									options = {};

   808 								if (typeof(callback) == 'undefined')

   809 									callback = options.callback;

   810 								if (typeof(callback) == 'string')

   811 									callback = ams.getFunctionByName(callback);

   812 								delete options.callback;

   813 

   814 								var params = {};

   815 								if (typeof(query) == 'string')

   816 									params['query'] = query;

   817 								else if (typeof(query) == 'object')

   818 									$.extend(params, query);

   819 								$.extend(params, options);

   820 

   821 								var settings = {

   822 									url: ams.jsonrpc.getAddr(options.url),

   823 									type: 'post',

   824 									cache: false,

   825 									method: method,

   826 									params: params,

   827 									async: typeof(callback) == 'function',

   828 									success: callback || function(data, status) {

   829 										result = data.result;

   830 									},

   831 									error: ams.error.show

   832 								};

   833 								$.jsonRpc(settings);

   834 								return result;

   835 						   });

   836 		},

   837 

   838 		/**

   839 		 * Execute given JSON-RPC post on given method

   840 		 *

   841 		 * Parameters:

   842 		 *  - @method: name of JSON-RPC procedure to call

   843 		 *  - @options: additional JSON-RPC procedure parameters

   844 		 *  - @callback: name of a callback which will be called on server response

   845 		 */

   846 		post: function(method, options, callback) {

   847 			ams.ajax.check($.jsonRpc,

   848 						   ams.baseURL + 'ext/jquery-jsonrpc' + (ams.devmode ? '.js' : '.min.js'),

   849 						   function() {

   850 								var result;

   851 								if (typeof(options) == 'function') {

   852 									callback = options;

   853 									options = {};

   854 								}

   855 								else if (!options)

   856 									options = {};

   857 								if (typeof(callback) == 'undefined')

   858 									callback = options.callback;

   859 								if (typeof(callback) == 'string')

   860 									callback = ams.getFunctionByName(callback);

   861 								delete options.callback;

   862 

   863 								var settings = {

   864 									url: ams.jsonrpc.getAddr(options.url),

   865 									type: 'post',

   866 									cache: false,

   867 									method: method,

   868 									params: options,

   869 									async: typeof(callback) == 'function',

   870 									success: callback || function(data, status) {

   871 										result = data.result;

   872 									},

   873 									error: ams.error.show

   874 								};

   875 								$.jsonRpc(settings);

   876 								return result;

   877 						   });

   878 		}

   879 	};

   880 

   881 

   882 	/**

   883 	 * Forms helper functions

   884 	 */

   885 	MyAMS.form = {

   886 

   887 		/**

   888 		 * Submit given form

   889 		 */

   890 		submit: function(form, handler, submit_options) {

   891 			// Check params

   892 			var form = $(form);

   893 			if (!form.exists())

   894 				return false;

   895 			if (typeof(handler) == 'object') {

   896 				submit_options = handler;

   897 				handler = undefined;

   898 			}

   899 			// Prevent multiple submits of the same form

   900 			if (form.data('submitted')) {

   901 				ams.skin.messageBox('warning', {

   902 					title: ams.i18n.WAIT,

   903 					content: ams.i18n.FORM_SUBMITTED,

   904 					icon: 'fa fa-save shake animated',

   905 					timeout: 5000

   906 				});

   907 				return false;

   908 			}

   909 			// Check submit validators

   910 			if (!ams.form._checkSubmitValidators(form))

   911 				return false;

   912 			// Remove remaining status messages

   913 			$('.alert, SPAN.state-error', form).remove();

   914 			$('.state-error', form).removeClassPrefix('state-');

   915 			$(form.data('ams-submit-button')).button('loading');

   916 			ams.ajax.check($.fn.ajaxSubmit,

   917 						   ams.baseURL + 'ext/jquery-form-3.49' + (ams.devmode ? '.js' : '.min.js'),

   918 						   function() {

   919 

   920 								function _submitAjaxForm(form, options) {

   921 

   922 									var data = form.data();

   923 									var form_options = data.amsFormOptions;

   924 

   925 									if (submit_options)

   926 										var form_data_callback = submit_options.formDataInitCallback;

   927 									if (form_data_callback)

   928 										delete submit_options.formDataInitCallback;

   929 									else

   930 										form_data_callback = data.amsFormDataInitCallback;

   931 									if (form_data_callback) {

   932 										if (typeof(form_data_callback) == 'function')

   933 											var form_data = form_data_callback.call(form);

   934 										else

   935 											form_data = ams.executeFunctionByName(form_data_callback, form);

   936 									} else {

   937 										form_data = data.amsFormData || {};

   938 									}

   939 

   940 									var action = form.attr('action').replace(/#/, '');

   941 									if (action.startsWith(window.location.protocol))

   942 										var url = action;

   943 									else

   944 										url = ams.ajax.getAddr() + action;

   945 									var button = $(form.data('ams-submit-button'));

   946 									url += handler || button.data('ams-button-handler') || data.amsFormHandler || '';

   947 

   948 									if (data.amsFormInitSubmitTarget) {

   949 										var target = $(button.data('ams-form-submit-target') || data.amsFormSubmitTarget || '#content');

   950 										ams.executeFunctionByName(data.amsFormInitSubmit || 'MyAMS.form.initSubmit', form, target);

   951 									} else if (!data.amsFormHideSubmitFooter)

   952 										ams.executeFunctionByName(data.amsFormInitSubmit || 'MyAMS.form.initSubmitFooter', form);

   953 

   954 									var hasUpload = typeof(options.uuid) != 'undefined';

   955 									if (hasUpload) {

   956 										if (url.indexOf('X-Progress-ID') < 0)

   957 											url += "?X-Progress-ID=" + options.uuid;

   958 										delete options.uuid;

   959 									}

   960 

   961 									var defaults = {

   962 										url: url,

   963 										type: 'post',

   964 										cache: false,

   965 										data: form_data,

   966 										dataType: data.amsFormDatatype,

   967 										beforeSerialize: function(form, options) {

   968 											if (typeof(tinyMCE) != 'undefined')

   969 												tinyMCE.triggerSave();

   970 										},

   971 										beforeSubmit: function(data, form, options) {

   972 											form.data('submitted', true);

   973 										},

   974 										error: function(request, status, error) {

   975 											ams.error.show(request, status, error);

   976 											if (form.is(':visible')) {

   977 												var button = form.data('ams-submit-button');

   978 												if (button)

   979 													button.button('reset');

   980 												ams.form.finalizeSubmitFooter.call(form);

   981 											}

   982 											form.data('submitted', false);

   983 										},

   984 										success: function(result, status, request, form) {

   985 											var callback;

   986 											var button = form.data('ams-submit-button');

   987 											if (button)

   988 												callback = button.data('ams-form-submit-callback');

   989 											if (!callback)

   990 												callback = ams.getFunctionByName(data.amsFormSubmitCallback) || ams.form._submitCallback;

   991 											callback.call(form, result, status, request, form);

   992 											if (form.is(':visible') && button)

   993 												button.button('reset');

   994 											form.data('submitted', false);

   995 										},

   996 										iframe: hasUpload

   997 									}

   998 									var settings = $.extend({}, defaults, options, form_options, submit_options);

   999 									$(form).ajaxSubmit(settings);

  1000 								}

  1001 

  1002 								var hasUpload = $('INPUT[type="file"]', form).length > 0;

  1003 								if (hasUpload) {

  1004 									// JQuery-progressbar plug-in must be loaded synchronously!!

  1005 									// Otherwise, hidden input fields created by jquery-validate plug-in

  1006 									// and matching named buttons will be deleted (on first form submit)

  1007 									// before JQuery-form plug-in can get them when submitting the form...

  1008 									ams.ajax.check($.progressBar,

  1009 												   ams.baseURL + 'ext/jquery-progressbar' + (ams.devmode ? '.js' : '.min.js'));

  1010 									var settings = $.extend({}, {

  1011 										uuid: $.progressBar.submit(form)

  1012 									});

  1013 									_submitAjaxForm(form, settings);

  1014 								} else

  1015 									_submitAjaxForm(form, {});

  1016 						   });

  1017 			return false;

  1018 		},

  1019 

  1020 		/**

  1021 		 * Initialize AJAX submit call

  1022 		 *

  1023 		 * @param this: the submitted form

  1024 		 * @param target: the form submit container target

  1025 		 * @param message: the optional message

  1026 		 */

  1027 		initSubmit: function(target, message) {

  1028 			var form = $(this);

  1029 			var spin = '<i class="fa fa-3x fa-gear fa-spin"></i>';

  1030 			if (!message)

  1031 				message = form.data('ams-form-submit-message');

  1032 			if (message)

  1033 				spin += '<strong>' + message + '</strong>';

  1034 			$(target).html('<div class="row margin-20"><div class="text-center">' + spin + '</div></div>');

  1035 			$(target).parents('.hidden').removeClass('hidden');

  1036 		},

  1037 

  1038 		/**

  1039 		 * Initialize AJAX submit call in form footer

  1040 		 *

  1041 		 * @param this: the submitted form

  1042 		 * @param message: the optional submit message

  1043 		 */

  1044 		initSubmitFooter: function(message) {

  1045 			var form = $(this);

  1046 			var spin = '<i class="fa fa-3x fa-gear fa-spin"></i>';

  1047 			if (!message)

  1048 				message = $(this).data('ams-form-submit-message');

  1049 			if (message)

  1050 				spin += '<strong class="submit-message align-top padding-left-10 margin-top-10">' + message + '</strong>';

  1051 			var footer = $('footer', form);

  1052 			form.data('ams-form-footer', footer.html());

  1053 			footer.html('<div class="row"><div class="text-center">' + spin + '</div></div>');

  1054 		},

  1055 

  1056 		/**

  1057 		 * Finalize AJAX submit call

  1058 		 *

  1059 		 * @param this: the submitted form

  1060 		 * @param target: the form submit container target

  1061 		 */

  1062 		finalizeSubmitFooter: function(target) {

  1063 			var form = $(this);

  1064 			var footer = form.data('ams-form-footer');

  1065 			if (footer) {

  1066 				$('footer', form).html(footer);

  1067 				form.removeData('ams-form-footer');

  1068 			}

  1069 		},

  1070 

  1071 		/**

  1072 		 * Handle AJAX submit results

  1073 		 *

  1074 		 * Submit results are auto-detected via response content type, except when this content type

  1075 		 * is specified into form's data attributes.

  1076 		 * Submit response can be of several content types:

  1077 		 * - html or text: the response is directly included into a "target" container (#content by default)

  1078 		 * - json: a "status" attribute indicates how the request was handled and how the response should be

  1079 		 *   treated:

  1080 		 *     - error: indicates that an error occured; other response attributes indicate error messages

  1081 		 *     - success: basic success, no other action is requested

  1082 		 *     - callback: only call given function to handle the result

  1083 		 *     - callbacks: only call given set of functions to handle the result

  1084 		 *     - reload: page's body should be reloaded from a given URL

  1085 		 *     - redirect: redirect browser to given URL

  1086 		 *   Each JSON response can also specify an HTML content, a message and a callback (

  1087 		 */

  1088 		_submitCallback: function(result, status, request, form) {

  1089 

  1090 			if (form.is(':visible')) {

  1091 				ams.form.finalizeSubmitFooter.call(form);

  1092 				var button = form.data('ams-submit-button');

  1093 				if (button)

  1094 					button.button('reset');

  1095 			}

  1096 			var data = form.data();

  1097 			if (data.amsFormDatatype)

  1098 				var data_type = data.amsFormDatatype;

  1099 			else {

  1100 				var request_data = ams.ajax.getResponse(request);

  1101 				data_type = request_data.content_type;

  1102 				result = request_data.data;

  1103 			}

  1104 			switch (data_type) {

  1105 				case 'json':

  1106 					ams.ajax.handleJSON(result, form);

  1107 					break;

  1108 				case 'script':

  1109 					break;

  1110 				case 'xml':

  1111 					break;

  1112 				case 'html':

  1113 				case 'text':

  1114 				default:

  1115 					if (button && (button.data('ams-keep-modal') !== true))

  1116 						ams.dialog.close(form);

  1117 					if (button)

  1118 						var target = $(button.amsFormSubmitTarget || data.amsFormSubmitTarget || '#content');

  1119 					else

  1120 						target = $(data.amsFormSubmitTarget || '#content');

  1121 					if (!target.exists())

  1122 						target = $('body');

  1123 					target.parents('.hidden').removeClass('hidden');

  1124 					$('.alert', target.parents('.alerts-container')).remove();

  1125 					target.css({opacity: '0.0'})

  1126 						  .html(result)

  1127 						  .delay(50)

  1128 						  .animate({opacity: '1.0'}, 300);

  1129 					ams.initContent(target);

  1130 			}

  1131 			var callback = request.getResponseHeader('X-AMS-Callback');

  1132 			if (callback) {

  1133 				var options = request.getResponseHeader('X-AMS-Callback-Options');

  1134 				ams.executeFunctionByName(callback, form, options === undefined ? {} : JSON.parse(options));

  1135 			}