src/ztfy/myams/resources/js/myams.js
changeset 203 108498416bee
parent 196 bbeb090d73e9
child 206 02a40997d8cb
equal deleted inserted replaced
202:cc928d5f90d5 203:108498416bee
   504 		return uuid;
   504 		return uuid;
   505 	};
   505 	};
   506 
   506 
   507 
   507 
   508 	/**
   508 	/**
       
   509 	 * Get an object given by name
       
   510 	 */
       
   511 	MyAMS.getObject = function(objectName, context) {
       
   512 		if (!objectName) {
       
   513 			return undefined;
       
   514 		}
       
   515 		if (typeof(objectName) !== 'string') {
       
   516 			return objectName;
       
   517 		}
       
   518 		var namespaces = objectName.split(".");
       
   519 		context = (context === undefined || context === null) ? window : context;
       
   520 		for (var i=0; i < namespaces.length; i++) {
       
   521 			try {
       
   522 				context = context[namespaces[i]];
       
   523 			} catch (e) {
       
   524 				return undefined;
       
   525 			}
       
   526 		}
       
   527 		return context;
       
   528 	};
       
   529 
       
   530 	/**
   509 	 * Get and execute a function given by name
   531 	 * Get and execute a function given by name
   510 	 * Small piece of code by Jason Bunting
   532 	 * Small piece of code by Jason Bunting
   511 	 */
   533 	 */
   512 	MyAMS.getFunctionByName = function(functionName, context) {
   534 	MyAMS.getFunctionByName = function(functionName, context) {
   513 		if (functionName === undefined) {
   535 		if (functionName === undefined) {
   685 
   707 
   686 		/**
   708 		/**
   687 		 * Default JQuery AJAX error handler
   709 		 * Default JQuery AJAX error handler
   688 		 */
   710 		 */
   689 		ajax: function(event, response, request, error) {
   711 		ajax: function(event, response, request, error) {
   690 			if (response.statusText === 'OK') {
   712 			if (response && response.statusText && response.statusText.toUpperCase() === 'OK') {
   691 				return;
   713 				return;
   692 			}
   714 			}
   693 			var response = ams.ajax.getResponse(response);
   715 			response = ams.ajax.getResponse(response);
   694 			if (response.contentType === 'json') {
   716 			if (response.contentType === 'json') {
   695 				ams.ajax.handleJSON(response.data);
   717 				ams.ajax.handleJSON(response.data);
   696 			} else {
   718 			} else {
   697 				var title = event.statusText || event.type;
   719 				var title = event.statusText || event.type;
   698 				var message = response.responseText;
   720 				var message = response.responseText;
   699 				ams.skin.messageBox('error', {
   721 				ams.skin.messageBox('error', {
   700 					title: ams.i18n.ERROR_OCCURED,
   722 					title: ams.i18n.ERROR_OCCURED,
   701 					content: '<h4>' + title + '</h4><p>' + message + '</p>',
   723 					content: '<h4>' + title + '</h4><p>' + (message || '') + '</p>',
   702 					icon: 'fa fa-warning animated shake',
   724 					icon: 'fa fa-warning animated shake',
   703 					timeout: 10000
   725 					timeout: 10000
   704 				});
   726 				});
   705 			}
   727 			}
   706 			if (globals.console) {
   728 			if (globals.console) {
   749 		 *   argument of this callback is a boolean value indicating if the script was just downloaded (true)
   771 		 *   argument of this callback is a boolean value indicating if the script was just downloaded (true)
   750 		 *   or if the requested object was already loaded (false)
   772 		 *   or if the requested object was already loaded (false)
   751 		 * @options: callback options
   773 		 * @options: callback options
   752 		 */
   774 		 */
   753 		check: function(checker, source, callback, options) {
   775 		check: function(checker, source, callback, options) {
   754 			if (typeof(callback) === 'object') {
   776 
   755 				options = callback;
   777 			function callCallbacks(firstLoad, options) {
   756 				callback = undefined;
   778 				if (callback === undefined) {
       
   779 					return;
       
   780 				}
       
   781 				if (!(callback instanceof Array)) {
       
   782 					callback = [callback];
       
   783 				}
       
   784 				for (var index=0; index < callback.length; index++) {
       
   785 					var cb = ams.getFunctionByName(callback[index]);
       
   786 					if (typeof(cb) === 'function') {
       
   787 						cb(firstLoad, options);
       
   788 					}
       
   789 				}
       
   790 			}
       
   791 
       
   792 			if (!(callback instanceof Array)) {
       
   793 				if (typeof(callback) === 'object') {
       
   794 					options = callback;
       
   795 					callback = undefined;
       
   796 				}
   757 			}
   797 			}
   758 			var defaults = {
   798 			var defaults = {
   759 				async: typeof(callback) === 'function'
   799 				async: typeof(callback) === 'function'
   760 			};
   800 			};
   761 			var settings = $.extend({}, defaults, options);
   801 			var settings = $.extend({}, defaults, options);
   766 						deferred.push(ams.getScript(source[index], {async: true}));
   806 						deferred.push(ams.getScript(source[index], {async: true}));
   767 					}
   807 					}
   768 				}
   808 				}
   769 				if (deferred.length > 0) {
   809 				if (deferred.length > 0) {
   770 					$.when.apply($, deferred).then(function () {
   810 					$.when.apply($, deferred).then(function () {
   771 						if (typeof(callback) === 'function') {
   811 						callCallbacks(true, options);
   772 							callback(true, options);
       
   773 						}
       
   774 					});
   812 					});
   775 				} else if (typeof(callback) === 'function') {
   813 				} else {
   776 					callback(false, options);
   814 					callCallbacks(false, options);
   777 				}
   815 				}
   778 			} else if (checker === undefined) {
   816 			} else if (checker === undefined) {
   779 				if (typeof(source) === 'string') {
   817 				if (typeof(source) === 'string') {
   780 					ams.getScript(source, function () {
   818 					ams.getScript(source, function () {
   781 						if (typeof(callback) === 'function') {
   819 						callCallbacks(true, options);
   782 							callback(true, options);
       
   783 						}
       
   784 					}, settings);
   820 					}, settings);
   785 				}
   821 				}
   786 			} else {
   822 			} else {
   787 				if (typeof(callback) === 'function') {
   823 				callCallbacks(false, options);
   788 					callback(false, options);
       
   789 				}
       
   790 			}
   824 			}
   791 		},
   825 		},
   792 
   826 
   793 		/**
   827 		/**
   794 		 * Get address relative to current page
   828 		 * Get address relative to current page
  3515 				var tables = $('.datatable', element);
  3549 				var tables = $('.datatable', element);
  3516 				if (tables.length > 0) {
  3550 				if (tables.length > 0) {
  3517 					ams.ajax.check($.fn.dataTable,
  3551 					ams.ajax.check($.fn.dataTable,
  3518 								   ams.baseURL + 'ext/jquery-dataTables-1.9.4' + ams.devext + '.js',
  3552 								   ams.baseURL + 'ext/jquery-dataTables-1.9.4' + ams.devext + '.js',
  3519 								   function(first_load) {
  3553 								   function(first_load) {
  3520 										$(tables).each(function() {
  3554 										ams.ajax.check($.fn.dataTableExt.oPagination.bootstrap_full,
  3521 											ams.ajax.check($.fn.dataTableExt.oPagination.bootstrap_full,
  3555 													   ams.baseURL + 'myams-dataTables' + ams.devext + '.js',
  3522 														   ams.baseURL + 'myams-dataTables' + ams.devext + '.js');
  3556 													   function() {
  3523 											var table = $(this);
  3557 														   $(tables).each(function () {
  3524 											var data = table.data();
  3558 															   var table = $(this);
  3525 											var extensions = (data.amsDatatableExtensions || '').split(/\s+/);
  3559 															   var data = table.data();
  3526 											// Check DOM elements
  3560 															   var extensions = (data.amsDatatableExtensions || '').split(/\s+/);
  3527 											var sDom = data.amsDatatableSdom ||
  3561 															   // Check DOM elements
  3528 												"W" +
  3562 															   var sDom = data.amsDatatableSdom ||
  3529 												((extensions.indexOf('colreorder') >= 0 ||
  3563 																   "W" +
  3530 												  extensions.indexOf('colreorderwithresize') >= 0) ? 'R' : '') +
  3564 																   ((extensions.indexOf('colreorder') >= 0 ||
  3531 												"<'dt-top-row'" +
  3565 																   extensions.indexOf('colreorderwithresize') >= 0) ? 'R' : '') +
  3532 												(extensions.indexOf('colvis') >= 0 ? 'C' : '') +
  3566 																   "<'dt-top-row'" +
  3533 												((data.amsDatatablePagination === false ||
  3567 																   (extensions.indexOf('colvis') >= 0 ? 'C' : '') +
  3534 												  data.amsDatatablePaginationSize === false) ? '' : 'L') +
  3568 																   ((data.amsDatatablePagination === false ||
  3535 												(data.amsDatatableGlobalFilter === false ? '' : 'F') +
  3569 																   data.amsDatatablePaginationSize === false) ? '' : 'L') +
  3536 												">r<'dt-wrapper't" +
  3570 																   (data.amsDatatableGlobalFilter === false ? '' : 'F') +
  3537 												(extensions.indexOf('scroller') >= 0 ? 'S' : '') +
  3571 																   ">r<'dt-wrapper't" +
  3538 												"><'dt-row dt-bottom-row'<'row'<'col-sm-6'" +
  3572 																   (extensions.indexOf('scroller') >= 0 ? 'S' : '') +
  3539 												(data.amsDatatableInformation === false ? '': 'i') +
  3573 																   "><'dt-row dt-bottom-row'<'row'<'col-sm-6'" +
  3540 												"><'col-sm-6 text-right'p>>";
  3574 																   (data.amsDatatableInformation === false ? '' : 'i') +
  3541 
  3575 																   "><'col-sm-6 text-right'p>>";
  3542 											var index;
  3576 
  3543 											// Check initial sorting
  3577 															   var index;
  3544 											var sorting = data.amsDatatableSorting;
  3578 															   // Check initial sorting
  3545 											if (typeof(sorting) === 'string') {
  3579 															   var sorting = data.amsDatatableSorting;
  3546 												var sortings = sorting.split(';');
  3580 															   if (typeof(sorting) === 'string') {
  3547 												sorting = [];
  3581 																   var sortings = sorting.split(';');
  3548 												for (index=0; index < sortings.length; index++) {
  3582 																   sorting = [];
  3549 													var colSorting = sortings[index].split(',');
  3583 																   for (index = 0; index < sortings.length; index++) {
  3550 													colSorting[0] = parseInt(colSorting[0]);
  3584 																	   var colSorting = sortings[index].split(',');
  3551 													sorting.push(colSorting);
  3585 																	   colSorting[0] = parseInt(colSorting[0]);
  3552 												}
  3586 																	   sorting.push(colSorting);
  3553 											}
  3587 																   }
  3554 											// Check columns sortings
  3588 															   }
  3555 											var columns = [];
  3589 															   // Check columns sortings
  3556 											var column;
  3590 															   var columns = [];
  3557 											var sortables = $('th', table).listattr('data-ams-datatable-sortable');
  3591 															   var column;
  3558 											for (index=0; index < sortables.length; index++) {
  3592 															   var sortables = $('th', table).listattr('data-ams-datatable-sortable');
  3559 												var sortable = sortables[index];
  3593 															   for (index = 0; index < sortables.length; index++) {
  3560 												if (sortable !== undefined) {
  3594 																   var sortable = sortables[index];
  3561 													column = columns[index] || {};
  3595 																   if (sortable !== undefined) {
  3562 													column.bSortable = sortable;
  3596 																	   column = columns[index] || {};
  3563 													columns[index] = column;
  3597 																	   column.bSortable = sortable;
  3564 												}
  3598 																	   columns[index] = column;
  3565 											}
  3599 																   }
  3566 											// Check columns types
  3600 															   }
  3567 											var sortTypes = $('th', table).listattr('data-ams-datatable-stype');
  3601 															   // Check columns types
  3568 											for (index=0; index < sortTypes.length; index++) {
  3602 															   var sortTypes = $('th', table).listattr('data-ams-datatable-stype');
  3569 												var sortType = sortTypes[index];
  3603 															   for (index = 0; index < sortTypes.length; index++) {
  3570 												if (sortType) {
  3604 																   var sortType = sortTypes[index];
  3571 													column = columns[index] || {};
  3605 																   if (sortType) {
  3572 													column.sType = sortType;
  3606 																	   column = columns[index] || {};
  3573 													columns[index] = column;
  3607 																	   column.sType = sortType;
  3574 												}
  3608 																	   columns[index] = column;
  3575 											}
  3609 																   }
  3576 											// Set options
  3610 															   }
       
  3611 															   // Set options
       
  3612 															   var dataOptions = {
       
  3613 																   bJQueryUI: false,
       
  3614 																   bFilter: data.amsDatatableGlobalFilter !== false || extensions.indexOf('columnfilter') >= 0,
       
  3615 																   bPaginate: data.amsDatatablePagination !== false,
       
  3616 																   bInfo: data.amsDatatableInfo !== false,
       
  3617 																   bSort: data.amsDatatableSort !== false,
       
  3618 																   aaSorting: sorting,
       
  3619 																   aoColumns: columns.length > 0 ? columns : undefined,
       
  3620 																   bDeferRender: true,
       
  3621 																   bAutoWidth: false,
       
  3622 																   iDisplayLength: data.amsDatatableDisplayLength || 25,
       
  3623 																   sPaginationType: data.amsDatatablePaginationType || 'bootstrap_full',
       
  3624 																   sDom: sDom,
       
  3625 																   oLanguage: ams.plugins.i18n.datatables,
       
  3626 																   fnInitComplete: function (oSettings, json) {
       
  3627 																	   $('.ColVis_Button').addClass('btn btn-default btn-sm')
       
  3628 																		   .html((ams.plugins.i18n.datatables.sColumns || "Columns") +
       
  3629 																				 ' <i class="fa fa-fw fa-caret-down"></i>');
       
  3630 																   }
       
  3631 															   };
       
  3632 															   var settings = $.extend({}, dataOptions, data.amsDatatableOptions);
       
  3633 															   var checkers = [];
       
  3634 															   var sources = [];
       
  3635 															   var callbacks = [];
       
  3636 															   if (extensions.length > 0) {
       
  3637 																   for (index = 0; index < extensions.length; index++) {
       
  3638 																	   switch (extensions[index]) {
       
  3639 																		   case 'autofill':
       
  3640 																			   checkers.push($.fn.dataTable.AutoFill);
       
  3641 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-autoFill' + ams.devext + '.js');
       
  3642 																			   break;
       
  3643 																		   case 'columnfilter':
       
  3644 																			   checkers.push($.fn.columnFilter);
       
  3645 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-columnFilter' + ams.devext + '.js');
       
  3646 																			   break;
       
  3647 																		   case 'colreorder':
       
  3648 																			   checkers.push($.fn.dataTable.ColReorder);
       
  3649 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-colReorder' + ams.devext + '.js');
       
  3650 																			   break;
       
  3651 																		   case 'colreorderwithresize':
       
  3652 																			   checkers.push(window.ColReorder);
       
  3653 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-colReorderWithResize' + ams.devext + '.js');
       
  3654 																			   break;
       
  3655 																		   case 'colvis':
       
  3656 																			   checkers.push($.fn.dataTable.ColVis);
       
  3657 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-colVis' + ams.devext + '.js');
       
  3658 																			   callbacks.push(function () {
       
  3659 																				   var cvDefault = {
       
  3660 																					   activate: 'click',
       
  3661 																					   sAlign: 'right'
       
  3662 																				   };
       
  3663 																				   settings.oColVis = $.extend({}, cvDefault, data.amsDatatableColvisOptions);
       
  3664 																			   });
       
  3665 																			   break;
       
  3666 																		   case 'editable':
       
  3667 																			   checkers.push($.fn.editable);
       
  3668 																			   sources.push(ams.baseURL + 'ext/jquery-jeditable' + ams.devext + '.js');
       
  3669 																			   checkers.push($.fn.makeEditable);
       
  3670 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-editable' + ams.devext + '.js');
       
  3671 																			   break;
       
  3672 																		   case 'fixedcolumns':
       
  3673 																			   checkers.push($.fn.dataTable.FixedColumns);
       
  3674 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-fixedColumns' + ams.devext + '.js');
       
  3675 																			   break;
       
  3676 																		   case 'fixedheader':
       
  3677 																			   checkers.push($.fn.dataTable.Fixedheader);
       
  3678 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-fixedHeader' + ams.devext + '.js');
       
  3679 																			   break;
       
  3680 																		   case 'keytable':
       
  3681 																			   checkers.push(window.keyTable);
       
  3682 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-keyTable' + ams.devext + '.js');
       
  3683 																			   break;
       
  3684 																		   case 'rowgrouping':
       
  3685 																			   checkers.push($.fn.rowGrouping());
       
  3686 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-rowGrouping' + ams.devext + '.js');
       
  3687 																			   break;
       
  3688 																		   case 'rowreordering':
       
  3689 																			   checkers.push($.fn.rowReordering);
       
  3690 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-rowReordering' + ams.devext + '.js');
       
  3691 																			   break;
       
  3692 																		   case 'scroller':
       
  3693 																			   checkers.push($.fn.dataTable.Scroller);
       
  3694 																			   sources.push(ams.baseURL + 'ext/jquery-dataTables-scroller' + ams.devext + '.js');
       
  3695 																			   break;
       
  3696 																		   default:
       
  3697 																			   break;
       
  3698 																	   }
       
  3699 																   }
       
  3700 															   }
       
  3701 
       
  3702 															   function initTable() {
       
  3703 																   settings = ams.executeFunctionByName(data.amsDatatableInitCallback, table, settings) || settings;
       
  3704 																   try {  // Some settings can easily generate DataTables exceptions...
       
  3705 																	   var plugin = table.dataTable(settings);
       
  3706 																	   ams.executeFunctionByName(data.amsDatatableAfterInitCallback, table, plugin, settings);
       
  3707 																	   if (extensions.length > 0) {
       
  3708 																		   for (index = 0; index < extensions.length; index++) {
       
  3709 																			   switch (extensions[index]) {
       
  3710 																				   case 'autofill':
       
  3711 																					   var afSettings = $.extend({}, data.amsDatatableAutofillOptions, settings.autofill);
       
  3712 																					   afSettings = ams.executeFunctionByName(data.amsDatatableAutofillInitCallback, table, afSettings) || afSettings;
       
  3713 																					   table.data('ams-autofill', data.amsDatatableAutofillConstructor === undefined ?
       
  3714 																						   new $.fn.dataTable.AutoFill(table, afSettings)
       
  3715 																						   : ams.executeFunctionByName(data.amsDatatableAutofillConstructor, table, plugin, afSettings));
       
  3716 																					   break;
       
  3717 																				   case 'columnfilter':
       
  3718 																					   var cfDefault = {
       
  3719 																						   sPlaceHolder: 'head:after'
       
  3720 																					   };
       
  3721 																					   var cfSettings = $.extend({}, cfDefault, data.amsDatatableColumnfilterOptions, settings.columnfilter);
       
  3722 																					   cfSettings = ams.executeFunctionByName(data.amsDatatableColumnfilterInitCallback, table, cfSettings) || cfSettings;
       
  3723 																					   table.data('ams-columnfilter', data.amsDatatableColumnfilterConstructor === undefined ?
       
  3724 																						   plugin.columnFilter(cfSettings)
       
  3725 																						   : ams.executeFunctionByName(data.amsDatatableColumnfilterConstructor, table, plugin, cfSettings));
       
  3726 																					   break;
       
  3727 																				   case 'editable':
       
  3728 																					   var edSettings = $.extend({}, data.amsDatatableEditableOptions, settings.editable);
       
  3729 																					   edSettings = ams.executeFunctionByName(data.amsDatatableEditableInitCallback, table, edSettings) || edSettings;
       
  3730 																					   table.data('ams-editable', data.amsDatatableEditableConstructor === undefined ?
       
  3731 																						   table.makeEditable(edSettings)
       
  3732 																						   : ams.executeFunctionByName(data.amsDatatableEditableConstructor, table, plugin, edSettings));
       
  3733 																					   break;
       
  3734 																				   case 'fixedcolumns':
       
  3735 																					   var fcSettings = $.extend({}, data.amsDatatableFixedcolumnsOptions, settings.fixedcolumns);
       
  3736 																					   fcSettings = ams.executeFunctionByName(data.amsDatatableFixedcolumnsInitCallback, table, fcSettings) || fcSettings;
       
  3737 																					   table.data('ams-fixedcolumns', data.amsDatatableFixedcolumnsConstructor === undefined ?
       
  3738 																						   new $.fn.dataTable.FixedColumns(table, fcSettings)
       
  3739 																						   : ams.executeFunctionByName(data.amsDatatableFixedcolumnsConstructor, table, plugin, fcSettings));
       
  3740 																					   break;
       
  3741 																				   case 'fixedheader':
       
  3742 																					   var fhSettings = $.extend({}, data.amsDatatableFixedheaderOptions, settings.fixedheader);
       
  3743 																					   fhSettings = ams.executeFunctionByName(data.amsDatatableFixedheadeInitCallback, table, fhSettings) || fhSettings;
       
  3744 																					   table.data('ams-fixedheader', data.amsDatatableFixedheaderConstructor === undefined ?
       
  3745 																						   new $.fn.dataTable.FixedHeader(table, fhSettings)
       
  3746 																						   : ams.executeFunctionByName(data.amsDatatableFixedheaderConstructor, table, plugin, fhSettings));
       
  3747 																					   break;
       
  3748 																				   case 'keytable':
       
  3749 																					   var ktDefault = {
       
  3750 																						   table: table.get(0),
       
  3751 																						   datatable: plugin
       
  3752 																					   };
       
  3753 																					   var ktSettings = $.extend({}, ktDefault, data.amsDatatableKeytableOptions, settings.keytable);
       
  3754 																					   ktSettings = ams.executeFunctionByName(data.amsDatatableKeytableInitCallback, table, ktSettings) || ktSettings;
       
  3755 																					   table.data('ams-keytable', data.amsDatatableKeytableConstructor === undefined ?
       
  3756 																						   new KeyTable(ktSettings)
       
  3757 																						   : ams.executeFunctionByName(data.amsDatatableKeytableConstructor, table, plugin, ktSettings));
       
  3758 																					   break;
       
  3759 																				   case 'rowgrouping':
       
  3760 																					   var rgSettings = $.extend({}, data.amsDatatableRowgroupingOptions, settings.rowgrouping);
       
  3761 																					   rgSettings = ams.executeFunctionByName(data.amsDatatableRowgroupingInitCallback, table, rgSettings) || rgSettings;
       
  3762 																					   table.data('ams-rowgrouping', data.amsDatatableRowgroupingConstructor === undefined ?
       
  3763 																						   table.rowGrouping(rgSettings)
       
  3764 																						   : ams.executeFunctionByName(data.amsDatatableRowgroupingConstructor, table, plugin, rgSettings));
       
  3765 																					   break;
       
  3766 																				   case 'rowreordering':
       
  3767 																					   var rrSettings = $.extend({}, data.amsDatatableRowreorderingOptions, settings.rowreordering);
       
  3768 																					   rrSettings = ams.executeFunctionByName(data.amsDatatableRowreorderingInitCallback, table, rrSettings) || rrSettings;
       
  3769 																					   table.data('ams-rowreordering', data.amsDatatableRowreorderingConstructor === undefined ?
       
  3770 																						   table.rowReordering(rrSettings)
       
  3771 																						   : ams.executeFunctionByName(data.amsDatatableRowreorderingConstructor, table, plugin, rrSettings));
       
  3772 																					   break;
       
  3773 																				   default:
       
  3774 																					   break;
       
  3775 																			   }
       
  3776 																		   }
       
  3777 																	   }
       
  3778 																	   if (data.amsDatatableFinalizeCallback) {
       
  3779 																		   var finalizers = data.amsDatatableFinalizeCallback.split(/\s+/);
       
  3780 																		   if (finalizers.length > 0) {
       
  3781 																			   for (index = 0; index < finalizers.length; index++) {
       
  3782 																				   ams.executeFunctionByName(finalizers[index], table, plugin, settings);
       
  3783 																			   }
       
  3784 																		   }
       
  3785 																	   }
       
  3786 																   }
       
  3787 																   catch (e) {
       
  3788 																   }
       
  3789 															   }
       
  3790 
       
  3791 															   callbacks.push(initTable);
       
  3792 															   ams.ajax.check(checkers, sources, callbacks);
       
  3793 														   });
       
  3794 													   });
       
  3795 								   });
       
  3796 				}
       
  3797 			},
       
  3798 
       
  3799 			/**
       
  3800 			 * Wizard plug-in
       
  3801 			 */
       
  3802 			wizard: function(element) {
       
  3803 				var wizards = $('.wizard', element);
       
  3804 				if (wizards.length > 0) {
       
  3805 					ams.ajax.check($.fn.bootstrapWizard,
       
  3806 								   ams.baseURL + 'ext/bootstrap-wizard-1.4.2' + ams.devext + '.js',
       
  3807 								   function(first_load) {
       
  3808 										wizards.each(function() {
       
  3809 											var wizard = $(this);
       
  3810 											var data = wizard.data();
  3577 											var dataOptions = {
  3811 											var dataOptions = {
  3578 												bJQueryUI: false,
  3812 												withVisible: data.amsWizardWithVisible === undefined ? true : data.amsWizardWithVisible,
  3579 												bFilter: data.amsDatatableGlobalFilter !== false || extensions.indexOf('columnfilter') >= 0,
  3813 												tabClass: data.amsWizardTabClass,
  3580 												bPaginate: data.amsDatatablePagination !== false,
  3814 												firstSelector: data.amsWizardFirstSelector,
  3581 												bInfo: data.amsDatatableInfo !== false,
  3815 												previousSelector: data.amsWizardPreviousSelector,
  3582 												bSort: data.amsDatatableSort !== false,
  3816 												nextSelector: data.amsWizardNextSelector,
  3583 												aaSorting: sorting,
  3817 												lastSelector: data.amsWizardLastSelector,
  3584 												aoColumns: columns.length > 0 ? columns : undefined,
  3818 												finishSelector: data.amsWizardFinishSelector,
  3585 												bDeferRender: true,
  3819 												backSelector: data.amsWizardBackSelector,
  3586 												bAutoWidth: false,
  3820 												onInit: ams.getFunctionByName(data.amsWizardInit),
  3587 												iDisplayLength: data.amsDatatableDisplayLength || 25,
  3821 												onShow: ams.getFunctionByName(data.amsWizardShow),
  3588 												sPaginationType: data.amsDatatablePaginationType || 'bootstrap_full',
  3822 												onNext: ams.getFunctionByName(data.amsWizardNext),
  3589 												sDom: sDom,
  3823 												onPrevious: ams.getFunctionByName(data.amsWizardPrevious),
  3590 												oLanguage: ams.plugins.i18n.datatables,
  3824 												onFirst: ams.getFunctionByName(data.amsWizardFirst),
  3591 												fnInitComplete: function(oSettings, json) {
  3825 												onLast: ams.getFunctionByName(data.amsWizardLast),
  3592 													$('.ColVis_Button').addClass('btn btn-default btn-sm')
  3826 												onBack: ams.getFunctionByName(data.amsWizardBack),
  3593 																	   .html((ams.plugins.i18n.datatables.sColumns || "Columns") +
  3827 												onFinish: ams.getFunctionByName(data.amsWizardFinish),
  3594 																			 ' <i class="fa fa-fw fa-caret-down"></i>');
  3828 												onTabChange: ams.getFunctionByName(data.amsWizardTabChange),
  3595 												}
  3829 												onTabClick: ams.getFunctionByName(data.amsWizardTabClick),
       
  3830 												onTabShow: ams.getFunctionByName(data.amsWizardTabShow)
  3596 											};
  3831 											};
  3597 											var settings = $.extend({}, dataOptions, data.amsDatatableOptions);
  3832 											var settings = $.extend({}, dataOptions, data.amsWizardOptions);
  3598 											if (extensions.length > 0) {
  3833 											settings = ams.executeFunctionByName(data.amsWizardInitCallback, wizard, settings) || settings;
  3599 												for (index=0; index < extensions.length; index++) {
  3834 											var plugin = wizard.bootstrapWizard(settings);
  3600 													switch (extensions[index]) {
  3835 											ams.executeFunctionByName(data.amsWizardAfterInitCallback, wizard, plugin, settings);
  3601 														case 'autofill':
       
  3602 															ams.ajax.check($.fn.dataTable.AutoFill,
       
  3603 																		   ams.baseURL + 'ext/jquery-dataTables-autoFill' + ams.devext + '.js');
       
  3604 															break;
       
  3605 														case 'columnfilter':
       
  3606 															ams.ajax.check($.fn.columnFilter,
       
  3607 																		   ams.baseURL + 'ext/jquery-dataTables-columnFilter' + ams.devext + '.js');
       
  3608 															break;
       
  3609 														case 'colreorder':
       
  3610 															ams.ajax.check($.fn.dataTable.ColReorder,
       
  3611 																		   ams.baseURL + 'ext/jquery-dataTables-colReorder' + ams.devext + '.js');
       
  3612 															break;
       
  3613 														case 'colreorderwithresize':
       
  3614 															ams.ajax.check($.fn.dataTable.ColReorder,
       
  3615 																		   ams.baseURL + 'ext/jquery-dataTables-colReorderWithResize' + ams.devext + '.js');
       
  3616 															break;
       
  3617 														case 'colvis':
       
  3618 															ams.ajax.check($.fn.dataTable.ColVis,
       
  3619 																		   ams.baseURL + 'ext/jquery-dataTables-colVis' + ams.devext + '.js');
       
  3620 															var cvDefault = {
       
  3621 																activate: 'click',
       
  3622 																sAlign: 'right'
       
  3623 															};
       
  3624 															settings.oColVis = $.extend({}, cvDefault, data.amsDatatableColvisOptions);
       
  3625 															break;
       
  3626 														case 'editable':
       
  3627 															ams.ajax.check($.fn.editable,
       
  3628 																		   ams.baseURL + 'ext/jquery-jeditable' + ams.devext + '.js');
       
  3629 															ams.ajax.check($.fn.makeEditable,
       
  3630 																		   ams.baseURL + 'ext/jquery-dataTables-editable' + ams.devext + '.js');
       
  3631 															break;
       
  3632 														case 'fixedcolumns':
       
  3633 															ams.ajax.check($.fn.dataTable.FixedColumns,
       
  3634 																		   ams.baseURL + 'ext/jquery-dataTables-fixedColumns' + ams.devext + '.js');
       
  3635 															break;
       
  3636 														case 'fixedheader':
       
  3637 															ams.ajax.check($.fn.dataTable.FixedHeader,
       
  3638 																		   ams.baseURL + 'ext/jquery-dataTables-fixedHeader' + ams.devext + '.js');
       
  3639 															break;
       
  3640 														case 'keytable':
       
  3641 															ams.ajax.check(window.KeyTable,
       
  3642 																		   ams.baseURL + 'ext/jquery-dataTables-keyTable' + ams.devext + '.js');
       
  3643 															break;
       
  3644 														case 'rowgrouping':
       
  3645 															ams.ajax.check($.fn.rowGrouping,
       
  3646 																		   ams.baseURL + 'ext/jquery-dataTables-rowGrouping' + ams.devext + '.js');
       
  3647 															break;
       
  3648 														case 'rowreordering':
       
  3649 															ams.ajax.check($.fn.rowReordering,
       
  3650 																		   ams.baseURL + 'ext/jquery-dataTables-rowReordering' + ams.devext + '.js');
       
  3651 															break;
       
  3652 														case 'scroller':
       
  3653 															ams.ajax.check($.fn.dataTable.Scroller,
       
  3654 																		   ams.baseURL + 'ext/jquery-dataTables-scroller' + ams.devext + '.js');
       
  3655 															break;
       
  3656 														default:
       
  3657 															break;
       
  3658 													}
       
  3659 												}
       
  3660 											}
       
  3661 											settings = ams.executeFunctionByName(data.amsDatatableInitCallback, table, settings) || settings;
       
  3662 											try {  // Some settings can easily generate DataTables exceptions...
       
  3663 												var plugin = table.dataTable(settings);
       
  3664 												ams.executeFunctionByName(data.amsDatatableAfterInitCallback, table, plugin, settings);
       
  3665 												if (extensions.length > 0) {
       
  3666 													for (index=0; index < extensions.length; index++) {
       
  3667 														switch (extensions[index]) {
       
  3668 															case 'autofill':
       
  3669 																var afSettings = $.extend({}, data.amsDatatableAutofillOptions, settings.autofill);
       
  3670 																afSettings = ams.executeFunctionByName(data.amsDatatableAutofillInitCallback, table, afSettings) || afSettings;
       
  3671 																table.data('ams-autofill', data.amsDatatableAutofillConstructor === undefined ?
       
  3672 																							new $.fn.dataTable.AutoFill(table, afSettings)
       
  3673 																							: ams.executeFunctionByName(data.amsDatatableAutofillConstructor, table, plugin, afSettings));
       
  3674 																break;
       
  3675 															case 'columnfilter':
       
  3676 																var cfDefault = {
       
  3677 																	sPlaceHolder: 'head:after'
       
  3678 																};
       
  3679 																var cfSettings = $.extend({}, cfDefault, data.amsDatatableColumnfilterOptions, settings.columnfilter);
       
  3680 																cfSettings = ams.executeFunctionByName(data.amsDatatableColumnfilterInitCallback, table, cfSettings) || cfSettings;
       
  3681 																table.data('ams-columnfilter', data.amsDatatableColumnfilterConstructor === undefined ?
       
  3682 																							plugin.columnFilter(cfSettings)
       
  3683 																							: ams.executeFunctionByName(data.amsDatatableColumnfilterConstructor, table, plugin, cfSettings));
       
  3684 																break;
       
  3685 															case 'editable':
       
  3686 																var edSettings = $.extend({}, data.amsDatatableEditableOptions, settings.editable);
       
  3687 																edSettings = ams.executeFunctionByName(data.amsDatatableEditableInitCallback, table, edSettings) || edSettings;
       
  3688 																table.data('ams-editable', data.amsDatatableEditableConstructor === undefined ?
       
  3689 																							table.makeEditable(edSettings)
       
  3690 																							: ams.executeFunctionByName(data.amsDatatableEditableConstructor, table, plugin, edSettings));
       
  3691 																break;
       
  3692 															case 'fixedcolumns':
       
  3693 																var fcSettings = $.extend({}, data.amsDatatableFixedcolumnsOptions, settings.fixedcolumns);
       
  3694 																fcSettings = ams.executeFunctionByName(data.amsDatatableFixedcolumnsInitCallback, table, fcSettings) || fcSettings;
       
  3695 																table.data('ams-fixedcolumns', data.amsDatatableFixedcolumnsConstructor === undefined ?
       
  3696 																							new $.fn.dataTable.FixedColumns(table, fcSettings)
       
  3697 																							: ams.executeFunctionByName(data.amsDatatableFixedcolumnsConstructor, table, plugin, fcSettings));
       
  3698 																break;
       
  3699 															case 'fixedheader':
       
  3700 																var fhSettings = $.extend({}, data.amsDatatableFixedheaderOptions, settings.fixedheader);
       
  3701 																fhSettings = ams.executeFunctionByName(data.amsDatatableFixedheadeInitCallback, table, fhSettings) || fhSettings;
       
  3702 																table.data('ams-fixedheader', data.amsDatatableFixedheaderConstructor === undefined ?
       
  3703 																							new $.fn.dataTable.FixedHeader(table, fhSettings)
       
  3704 																							: ams.executeFunctionByName(data.amsDatatableFixedheaderConstructor, table, plugin, fhSettings));
       
  3705 																break;
       
  3706 															case 'keytable':
       
  3707 																var ktDefault = {
       
  3708 																	table: table.get(0),
       
  3709 																	datatable: plugin
       
  3710 																};
       
  3711 																var ktSettings = $.extend({}, ktDefault, data.amsDatatableKeytableOptions, settings.keytable);
       
  3712 																ktSettings = ams.executeFunctionByName(data.amsDatatableKeytableInitCallback, table, ktSettings) || ktSettings;
       
  3713 																table.data('ams-keytable', data.amsDatatableKeytableConstructor === undefined ?
       
  3714 																							new KeyTable(ktSettings)
       
  3715 																							: ams.executeFunctionByName(data.amsDatatableKeytableConstructor, table, plugin, ktSettings));
       
  3716 																break;
       
  3717 															case 'rowgrouping':
       
  3718 																var rgSettings = $.extend({}, data.amsDatatableRowgroupingOptions, settings.rowgrouping);
       
  3719 																rgSettings = ams.executeFunctionByName(data.amsDatatableRowgroupingInitCallback, table, rgSettings) || rgSettings;
       
  3720 																table.data('ams-rowgrouping', data.amsDatatableRowgroupingConstructor === undefined ?
       
  3721 																							table.rowGrouping(rgSettings)
       
  3722 																							: ams.executeFunctionByName(data.amsDatatableRowgroupingConstructor, table, plugin, rgSettings));
       
  3723 																break;
       
  3724 															case 'rowreordering':
       
  3725 																var rrSettings = $.extend({}, data.amsDatatableRowreorderingOptions, settings.rowreordering);
       
  3726 																rrSettings = ams.executeFunctionByName(data.amsDatatableRowreorderingInitCallback, table, rrSettings) || rrSettings;
       
  3727 																table.data('ams-rowreordering', data.amsDatatableRowreorderingConstructor === undefined ?
       
  3728 																							table.rowReordering(rrSettings)
       
  3729 																							: ams.executeFunctionByName(data.amsDatatableRowreorderingConstructor, table, plugin, rrSettings));
       
  3730 																break;
       
  3731 															default:
       
  3732 																break;
       
  3733 														}
       
  3734 													}
       
  3735 												}
       
  3736 												var finalizers = (data.amsDatatableFinalizeCallback || '').split(/\s+/);
       
  3737 												if (finalizers.length > 0) {
       
  3738 													for (index=0; index < finalizers.length; index++) {
       
  3739 														ams.executeFunctionByName(finalizers[index], table, plugin, settings);
       
  3740 													}
       
  3741 												}
       
  3742 											}
       
  3743 											catch (e) {}
       
  3744 										});
  3836 										});
  3745 								   });
  3837 								   });
  3746 				}
  3838 				}
  3747 			},
  3839 			},
  3748 
  3840 
  5015 		// Notify reset to update Select2 widgets
  5107 		// Notify reset to update Select2 widgets
  5016 		$(document).on('reset', 'form', function(e) {
  5108 		$(document).on('reset', 'form', function(e) {
  5017 			var form = $(this);
  5109 			var form = $(this);
  5018 			setTimeout(function() {
  5110 			setTimeout(function() {
  5019 				form.find('.select2').trigger('change');
  5111 				form.find('.select2').trigger('change');
       
  5112 				$('[data-ams-reset-callback]', form).each(function() {
       
  5113 					var element = $(this);
       
  5114 					var data = element.data();
       
  5115 					var callback = ams.getFunctionByName(data.amsResetCallback);
       
  5116 					if (callback !== undefined) {
       
  5117 						callback.call(form, element, data.amsResetCallbackOptions);
       
  5118 					}
       
  5119 				});
  5020 			}, 10);
  5120 			}, 10);
  5021 			ams.form.setFocus(form);
  5121 			ams.form.setFocus(form);
  5022 		});
  5122 		});
  5023 
  5123 
  5024 		// Initialize custom reset handlers
  5124 		// Initialize custom reset handlers