").trigger("ifCreated").parent().append(d.insert);w=k('
').css(w).appendTo(h);g.data("iCheck",{o:d,s:g.attr("style")}).css(F);d.inheritClass&&h.addClass(m.className||"");d.inheritID&&H&&h.attr("id","iCheck-"+H);"static"==h.css("position")&&h.css("position","relative");E(g,!0,"update");if(D.length)D.on("click.i mouseover.i mouseout.i touchbegin.i touchend.i",function(p){var n=p.type,A=k(this);
if(!m.disabled){if("click"==n){if(k(p.target).is("a"))return;E(g,!1,!0)}else y&&(/ut|nd/.test(n)?(h.removeClass(t),A.removeClass(z)):(h.addClass(t),A.addClass(z)));if(G)p.stopPropagation();else return!1}});g.on("click.i focus.i blur.i keyup.i keydown.i keypress.i",function(p){var n=p.type;p=p.keyCode;if("click"==n)return!1;if("keydown"==n&&32==p)return"radio"==m.type&&m.checked||(m.checked?v(g,"checked"):B(g,"checked")),!1;if("keyup"==n&&"radio"==m.type)!m.checked&&B(g,"checked");else if(/us|ur/.test(n))h["blur"==
n?"removeClass":"addClass"](u)});w.on("click mousedown mouseup mouseover mouseout touchbegin.i touchend.i",function(p){var n=p.type,A=/wn|up/.test(n)?x:t;if(!m.disabled){if("click"==n)E(g,!1,!0);else if(/wn|er|in/.test(n)?h.addClass(A):h.removeClass(A+" "+x),D.length&&y&&A==t)D[/ut|nd/.test(n)?"removeClass":"addClass"](z);if(G)p.stopPropagation();else return!1}})})}})(window.jQuery||window.Zepto);;
var commonHelper = {
isUndefined: function (prop) {
return (typeof prop === 'undefined');
},
isFunction: function (prop) {
return (typeof prop === 'function');
},
isObject: function (prop) {
return (typeof prop === 'object');
},
isBoolean: function (prop) {
return (typeof prop === 'boolean');
},
isNumber: function (prop) {
return (typeof prop === 'number') && !isNaN(prop);
},
isString: function (prop) {
return (typeof prop === 'string');
},
isArray: function (prop) {
return (prop instanceof Array);
},
isEmptyObject: function (obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
return false;
}
}
return true;
}
};
var inputHelper = {
removeText: function (text, match, selectionStart, selectionEnd) {
var preSelectionText = text.substring(0, selectionStart);
var selectionText = text.substring(selectionStart, selectionEnd);
var postSelectionText = text.substring(selectionEnd);
preSelectionText = preSelectionText.replace(match, '');
selectionText = selectionText.replace(match, '');
postSelectionText = postSelectionText.replace(match, '');
return {
selectionStart: preSelectionText.length,
selectionEnd: preSelectionText.length + selectionText.length,
text: preSelectionText + selectionText + postSelectionText
};
},
setSelectEmptyItemPlaceHolderColor: function (selector) {
function setSelectColor(select) {
if (select.val()) {
select.removeClass('text-muted');
} else {
select.addClass('text-muted');
}
}
$('option', selector).addClass("text-reset");
$('option[value=""]', selector).removeClass("text-reset");
$('option[value=""]', selector).addClass("text-muted");
$(selector).each(function () { setSelectColor($(this)); });
$(selector).change(function () { setSelectColor($(this)); });
},
/**
*
* @param {Object} options
* @param {string} options.changeEvent - The event(s) that are fired when the value changes
* @param {string} options.container - The container to scope searches for data-visible-fields to
*/
wireUpDataVisibleFields: function (options) {
var changeEvent = options && options.changeEvent || 'change';
var container = options && options.container || 'body';
$('[data-visible-field]', container).each(function (i, e) {
var $visibleTarget = $(e);
var fieldName = $visibleTarget.attr('data-visible-field');
var fieldVal = $visibleTarget.attr('data-visible-when');
var isMatch = function (v) {
return v === fieldVal;
};
var getValue = function ($element) {
return $element.val();
};
var typeAttr = $('#' + fieldName).attr('type');
if (typeAttr && typeAttr.toLowerCase().trim() === 'checkbox') {
changeEvent = 'ifChanged';
getValue = function ($element) {
if ($element.prop('indeterminate') === true) {
return 'indeterminate';
}
return $element.is(':checked') ? 'checked' : 'unchecked';
};
if (fieldVal && fieldVal.toLowerCase) {
fieldVal = fieldVal.toLowerCase();
}
}
if (fieldVal && fieldVal.startsWith && fieldVal.startsWith('[')) {
var fieldValArr = JSON.parse(fieldVal);
isMatch = function (v) {
return fieldValArr.indexOf(v) >= 0;
}
}
$('#' + fieldName).on(changeEvent, function () {
$visibleTarget.toggle(isMatch(getValue($(this))));
});
$visibleTarget.toggle(isMatch(getValue($('#' + fieldName))));
});
}
};
var arrayHelper = {
distinct: function(arr) {
return $.grep(arr, function(el, index) {
return index === $.inArray(el, arr);
});
}
};
var iCheckHelper = {
isChecked: function (checkbox) {
return booleanHelper.parse($(checkbox).is(':checked'));
},
check: function (checkboxElement, condition) {
$(checkboxElement).prop('checked', condition).iCheck('update');
}
};
var jsConstants = {
keyCode: {
backspaceKey: 8,
enterKey: 13,
escapeKey: 27,
arrowUpKey: 38,
arrowDownKey: 40
}
};
$.fn.hasAttr = function (attrName) {
return this.attr(attrName) !== undefined;
};
$.fn.exists = function () {
//https://stackoverflow.com/a/10861528
return this.length > 0 ? this : false;
};
var jsonResponseDtoHelper = {
/**
* Joins the error values from a JsonResponseDto. Does not include the Key property (i.e. field names)
* @param {Object} jsonResponseDto - A JsonResponseDto object from a server endpoint
* @param {Object[]} jsonResponseDto.Errors - The Errors array from a jsonResponseDto
* @param {string} jsonResponseDto.Errors[].Key - The name of the field the errors are for
* @param {string[]} jsonResponseDto.Errors[].Value - A list of error values
* @param {Object} [options] - Options for converting to string
* @param {string} [options.valueIfEmpty='Sorry, an error occurred. Please contact support.'] - The value to return if the response is not a jsonResponseDto or if there are no errors listed
* @param {string} [options.errorSeparator] - Separates each error message
* @param {string} [options.errorFieldSeparator] - If specified, this is used to separate error messages from different fields, otherwise options.errorSeparator is used
* @returns {string}
*/
concatErrorValues: function (jsonResponseDto, options) {
if (commonHelper.isUndefined(options)) {
options = {
};
}
if (!jsonResponseDto || !jsonResponseDto.Errors || jsonResponseDto.Errors.length <= 0) {
if (commonHelper.isUndefined(options.valueIfEmpty)) {
return 'Sorry, an error occurred. Please contact support.';
}
return options.valueIfEmpty;
}
if (commonHelper.isUndefined(options.errorSeparator)) {
options.errorSeparator = ', ';
}
if (commonHelper.isUndefined(options.errorFieldSeparator)) {
options.errorFieldSeparator = options.errorSeparator;
}
return $.map(jsonResponseDto.Errors, function (keyValuePair) {
return keyValuePair.Value.join(options.errorSeparator);
}).join(options.errorFieldSeparator);
}
};
var rtf = Intl && Intl.RelativeTimeFormat ? new Intl.RelativeTimeFormat('en', { numeric: 'always' }) : null;
var dateHelper = {
toUtcApiFormat: function (date) {
//HACK: Strip the Z so that .NET doesn't know that this is in UTC format and automatically convert it to the server's local time
return date.toISOString().replace('Z', '');
},
endOfDay: function (date) {
var d = date;
return d.addHours(-d.getHours()).addMinutes(-d.getMinutes()).addSeconds(-d.getSeconds()).addMilliseconds(-d.getMilliseconds()).addDays(1).addMilliseconds(-1);
},
/**
* Simply calls Date.parse which assumes the given input is a local date/time (even with a Z suffix).
* @param {string} dateOrDateTimeString - a date string which is treated as a local time. eg: 2020-05-01 is 1st of May, 2020 at midnight in the client's timezone
*/
parseDateAsLocalTime: function (dateOrDateTimeString) {
return Date.parse(dateOrDateTimeString);
},
/**
* Simply calls Date.parse which assumes the given input is a local date/time (even with a Z suffix). Then adds the timezone offset to return the date to the UTC value.
* The returned date still has the local timezone offset but will be in the expected UTC zone
* @param {string} dateOrDateTimeString - a date string which is treated as a local time. eg: 2020-05-01 is 1st of May, 2020 at midnight in the client's timezone
*/
parseDateAsUtcTime: function (dateOrDateTimeString) {
var result = Date.parse(dateOrDateTimeString);
if (typeof result === 'number') {
result = new Date(result);
}
if (isNaN(result)) {
return result;
}
if (result.addMinutes) {
return result.addMinutes(-result.getTimezoneOffset());
} else {
return new Date(result.getTime() - result.getTimezoneOffset()*60000);
}
},
/**
* Replaces the first instance of day/month/year (or day-month-year) with the format year/month/day (or year-month-day if "-" is the delimiter of the intial parameter).
* @param {string} dateOrDateTimeString - a string containing a date. If the string does not contain a date in the expected format, the string is returned without changes
*/
mdyToYdmFormat: function(dateOrDateTimeString){
var mdyFormatRegex = /[0-9]{1,2}(\/|-)[0-9]{1,2}(\/|-)[0-9]{4}/;
var mdyFormat = dateOrDateTimeString.match(mdyFormatRegex);
if (mdyFormat && mdyFormat.length > 0) {
var dateSeparator = '/';
if (mdyFormat.indexOf('-') >= 0) {
dateSeparator = '-';
}
var ydmFormat = mdyFormat[0]
.split(/\/|-/).reverse().join(dateSeparator);
dateOrDateTimeString = dateOrDateTimeString.replace(mdyFormatRegex, ydmFormat);
}
return dateOrDateTimeString;
},
formatDateForDisplay: function (dateString, locale, options) {
if (!dateString) {
return '';
}
if (dateString.toUpperCase().indexOf('Z') >= 0) {
dateString = dateString.replace(/[zZ]/, ''); //Remove the UTC indicator so the browser doesn't change the value of the date
}
if (dateString.indexOf(':') < 0) { //No time. Safari won't parse this
dateString = dateString.trim() + ' 00:00';
}
if (!options) {
options = { year: 'numeric', month: 'numeric', day: 'numeric' };
}
return new Date(dateString).toLocaleDateString(locale, options);
},
formatUtcDatesBySelector: function (selector, locale, options) {
$(selector).each(function (i, e) {
var $element = $(e);
var date = $element.text().trim();
if (date) {
$element.text(dateHelper.formatDateForDisplay(date, locale, options));
}
});
},
/**
* Formats a date as a string in the format X hours ago, X days ago etc.
* This might return null in older browsers, so make sure to have a fallback display
* @param {Date} date
* @returns
*/
timeAgo: function (date, overrideNow) {
if (!rtf) {
return null;
}
var now = typeof overrideNow === 'undefined' ? new Date() : overrideNow;
var diffInSeconds = Math.floor((date - now) / 1000);
// Note: past dates -> negative numbers -> “ago”
var units = {
year: 60 * 60 * 24 * 365,
month: 60 * 60 * 24 * 30,
week: 60 * 60 * 24 * 7,
day: 60 * 60 * 24,
hour: 60 * 60,
minute: 60,
second: 1
};
for (var unitEntry of Object.entries(units)) {
const unit = unitEntry[0];
const secondsInUnit = unitEntry[1];
if (Math.abs(diffInSeconds) >= secondsInUnit) {
var amount = Math.round(diffInSeconds / secondsInUnit);
return rtf.format(amount, unit);
}
}
return rtf.format(0, 'second');
},
};
var fileHelper = {
/**
* Downloads data as a POST request.
*
* @param {string} url - The URL to send the POST request to.
* @param {object} data - The data to be sent in the POST request.
*/
downloadPost: function (url, data) {
function getFormFields(dataObj, parentName) {
var fields = [];
parentName = parentName || '';
if (Array.isArray(dataObj)) {
for (var i = 0; i < dataObj.length; i++) {
if (typeof dataObj[i] === 'object') {
Array.prototype.push.apply(fields, getFormFields(dataObj[i], parentName + '[' + i + ']'));
} else {
var field = $('
');
field.attr('name', parentName + '[' + i + ']');
field.val(dataObj[i]);
fields.push(field);
}
}
} else {
for (var prop in dataObj) {
var fullName = parentName ? (parentName + '.' + prop) : prop;
if (Object.prototype.hasOwnProperty.call(dataObj, prop)) {
var propVal = dataObj[prop];
if (typeof propVal === 'object') {
Array.prototype.push.apply(fields, getFormFields(propVal, fullName));
} else {
var field = $('
');
field.attr('name', fullName);
field.val(propVal);
fields.push(field);
}
}
}
}
return fields;
}
if (!url.startsWith('http:') && !url.startsWith('https:')) {
if (url.startsWith('/')) {
url = location.origin + url;
} else {
url = location.href + url;
}
}
var form = $('
');
form.css('display', 'none');
form.attr('method', 'POST');
form.attr('action', url);
if (data) {
form.append(getFormFields(data));
}
$('body').append(form);
form.submit();
},
removeUtf8Bom: function (text) {
return text.replace(/^\uFEFF/, '');
},
getUtf8Bom: function () {
var bom = new Uint8Array([0xEF, 0xBB, 0xBF]);
return bom;
},
/**
* Configures a link element to download text data when clicked.
*
* @param {jQuery} $link - The link element to configure.
* @param {string} text - The text data to be downloaded.
* @param {object} options - The options for configuring the link.
* @param {boolean} [options.prependBom=true] - Whether to prepend a UTF-8 Byte Order Mark (BOM) to the text data.
* @param {string} [options.mimeType='text/plain'] - The MIME type of the text data.
* @param {string} [options.fileName='download.txt'] - The fileName of the downloaded file.
* @param {number|boolean} [options.revokeObjectUrlAfterMs] - Automatically revoke the object URL after the given time. Or set false if you will revoke this manually later.
*/
configureLinkToDownloadText: function ($link, text, options) {
var blobData = options.prependBom === false ? [text] : [this.getUtf8Bom(), text];
var blob = new Blob(blobData, { type: (options.mimeType || 'text/plain') + ';charset=utf-8' });
var url = URL.createObjectURL(blob);
$link.attr('href', url);
$link.attr('download', options.fileName || 'download.txt');
if (typeof options.revokeObjectUrlAfterMs === 'undefined' || options.revokeObjectUrlAfterMs === true) {
options.revokeObjectUrlAfterMs = 1000;
}
if (typeof options.revokeObjectUrlAfterMs === 'number') {
setTimeout(function () {
URL.revokeObjectURL(url);
}, options.revokeObjectUrlAfterMs);
}
},
/**
* Configures a link element to download an array of JSON objects as a CSV file when clicked.
*
* @param {jQuery} $link - The link element to configure.
* @param {Array} arrayOfJsonObjects - The array of JSON objects to be downloaded as CSV.
* @param {object|string} options - The options for configuring the link or the file name.
* @param {boolean} [options.prependBom=true] - Whether to prepend a UTF-8 Byte Order Mark (BOM) to the text data.
* @param {string} [options.fileName='download.txt'] - The fileName of the downloaded file.
* @param {number|boolean} [options.revokeObjectUrlAfterMs] - Automatically revoke the object URL after the given time. Or set false if you will revoke this manually later.
*/
configureLinkToDownloadJsonAsCsv: function ($link, arrayOfJsonObjects, options) {
if (typeof options === 'string') {
options = { fileName: options };
}
var csvText = Papa.unparse(arrayOfJsonObjects);
this.configureLinkToDownloadText($link, csvText, Object.assign(options || {}, { mimeType: 'text/csv' }));
},
/**
* Downloads an array of JSON objects as a CSV file.
*
* @param {Array} arrayOfJsonObjects - The array of JSON objects to be downloaded as CSV.
* @param {string} fileName - The fileName of the downloaded CSV file.
*/
downloadJsonAsCsv: function (arrayOfJsonObjects, fileName) {
var downloadElement = $('
Customer download');
this.configureLinkToDownloadJsonAsCsv(downloadElement, arrayOfJsonObjects, fileName);
downloadElement[0].click();
downloadElement = null;
},
/**
* Downloads text as a file.
*
* @param {string} textString - The text to be downloaded.
* @param {object} options - The options for configuring the link.
* @param {boolean} [options.prependBom=true] - Whether to prepend a UTF-8 Byte Order Mark (BOM) to the text data.
* @param {string} [options.mimeType='text/plain'] - The MIME type of the text data.
* @param {string} [options.fileName='download.txt'] - The fileName of the downloaded file.
*/
downloadTextFile: function (textString, options) {
var downloadElement = $('
Customer download');
this.configureLinkToDownloadText(downloadElement, textString, { mimeType: options.mimeType, fileName: options.fileName, prependBom: options.prependBom });
downloadElement[0].click();
downloadElement = null;
},
};
var csvImportHelper = {
formatErrorsAsTable: function (errorsArray) {
var $table = $('
');
if (!errorsArray || !errorsArray.length) {
return $table;
}
var $theadTr = $('
| Errors |
|---|
');
var $thead = $('
')
.append($theadTr);
var $tbody = $('
');
var headers = Object.keys(errorsArray[0].data);
for (var i = 0; i < headers.length; i++) {
$theadTr.append($('
| ').text(headers[i]));
}
for (var j = 0; j < errorsArray.length; j++) {
var $tr = $('
|
');
$tbody.append($tr);
$tr.append($('
| ').text(errorsArray[j].errors || ''));
for (var i = 0; i < headers.length; i++) {
$tr.append($('
| ').text(errorsArray[j].data[headers[i]] || ''));
}
}
$table
.append($thead)
.append($tbody);
return $table;
}
};
var addXsrfToken = function (jsonPostData, container) {
var xsrfToken = $('[name="__RequestVerificationToken"]', container).val();
if (xsrfToken) {
if (typeof (jsonPostData) === 'object') {
jsonPostData.__RequestVerificationToken = xsrfToken;
}
else if (typeof (jsonPostData) === 'string') {
if (jsonPostData.length > 0) {
jsonPostData += '&';
}
jsonPostData += '__RequestVerificationToken=' + encodeURIComponent(xsrfToken);
}
}
return jsonPostData;
};
var addXsrfTokenToForm = function ($form) {
var $xsrfToken = $('[name="__RequestVerificationToken"]');
if ($xsrfToken.length > 0 && $form) {
var existing = $('[name="__RequestVerificationToken"]', $form);
if (existing.length === 0) {
$form.append($xsrfToken[0].outerHTML);
}
}
};
function iCheckShiftSelect(table, rowSelector) {
rowSelector = rowSelector || 'tr';
var shiftKeyHeld = false;
var lastRowCheckChanged = null;
var processingRowChecks = false;
$(document).on('keyup keydown', function (e) { shiftKeyHeld = e.shiftKey; return true; });
var processCheckChanged = function (input, checked) {
if (processingRowChecks) {
return false;
}
row = input.closest(rowSelector);
if (shiftKeyHeld && lastRowCheckChanged) {
processingRowChecks = true;
var elementsBetween = getElementsInBetween(lastRowCheckChanged, row);
$.each(elementsBetween, function (index, element) {
var checkbox = $('.i-checks input', element);
checkbox.iCheck(checked ? 'check' : 'uncheck');
});
}
lastRowCheckChanged = row;
processingRowChecks = false;
};
this.addNewRows = function (rows) {
$.each(rows, function (index, e) {
var element = $(e);
$('.i-checks input', element).on('ifChecked', function (event) {
processCheckChanged($(this), true);
});
$('.i-checks input', element).on('ifUnchecked', function (event) {
processCheckChanged($(this), false);
});
});
}
this.addNewRows($(rowSelector, table));
/**
* Returns an array of sibling elements between `from` and `to` including `from` and `to`
*/
function getElementsInBetween(from, to) {
var range = [];
if (from.index() > to.index()) { //ensure that 'from' is before 'to'
from = [to, to = from][0]; //swapping from and to
}
if (from.is(to)) {
range = [from];
} else {
range = from.nextUntil(to).add(from).add(to);
range = $.makeArray(range);
}
return range;
};
}
;
var numberHelper = {
/**
* Parses the text multiplied by 10^(decimalPrecision) into an integer (to reduce floating point precision issues).
* @param {string} text
* @param {number} [decimalPrecision]
*/
parseScaledDecimal: function (text, decimalPrecision) {
decimalPrecision = decimalPrecision || 2;
var numericText = text.replace(/[^0-9\.-]+/g, "");
var decimalIndex = numericText.lastIndexOf('.');
var wholeNumber;
var decimalNumber;
if (decimalIndex >= 0) {
wholeNumber = parseInt(numericText.substring(0, decimalIndex).replace(/[^0-9-]+/g, "")) || 0;
var zeroes = ''; for (var i = 0; i < decimalPrecision; i++) { zeroes += '0'; }
var decimalText = numericText.substring(decimalIndex + 1) + zeroes;
decimalNumber = parseInt(decimalText.substring(0, decimalPrecision)) || 0;
} else {
wholeNumber = parseInt(numericText);
decimalNumber = 0;
}
return wholeNumber * Math.pow(10, decimalPrecision) + decimalNumber;
},
/**
* Converts a decimal that has been scaled to an integer back into a string representation of a decimal.
* Note: If scaled numbers have been multiplied or divided, the "decimalPrecision" of the scale will be different
* @param {number} number
* @param {number} [decimalPrecision]
*/
scaledDecimalToString: function (number, decimalPrecision) {
if (decimalPrecision === 0) {
return number.toFixed(0);
}
decimalPrecision = decimalPrecision || 2;
var text = number.toFixed(0);
while (text.length < decimalPrecision) {
text = '0' + text;
}
var wholeNumberText = text.substring(0, text.length - decimalPrecision);
var decimalText = text.substring(text.length - decimalPrecision, text.length);
return wholeNumberText + '.' + decimalText;
}
};
var stringHelper = {
abbreviate: function (text, inputOptions) {
options = inputOptions || {};
options = {
minAcronymLength: options.minAcronymLength || 2,
maxLength: options.maxLength || 5,
truncateSuffix: options.truncateSuffix || '…'
};
if (options.maxLength < 2) {
options.maxLength = 2;
}
var acronym = (text.match(/\b[^\s]/g) || []).join('');
if (acronym.length >= options.minAcronymLength && acronym.length <= options.maxLength) {
return acronym;
}
if (text.length <= options.maxLength) {
return text;
}
return text.substr(0, options.maxLength - 1) + (options.truncateSuffix || '');
},
generateRandomString: function (inputOptions) {
//This helper method is inspired by: https://stackoverflow.com/a/1349426
var options = inputOptions || {};
options = {
//Set a desired length for the random string to be generated. Not specifying or setting as null, undefined, or zero, will default to 7.
Length: options.Length || 7,
//Set to "true" to contain both upper and lower case alphabet characters.
//Set to "false" | null | undefined, or leave unspecified, to output an all-lowercase string.
MixedCase: options.MixedCase === true ? true : false,
//Set to "true" to include digits in the resulting string.
//Set to "false" | null | undefined, or leave unspecified, to output an all-alphabet string.
HasNumbers: options.HasNumbers === true ? true : false
};
var resultLength = 7;
if (options.Length && !isNaN(options.Length) && options.Length != 0) {
resultLength = options.Length;
}
var lowercases = "abcdefghijklmnopqrstuvwxyz";
var uppercases = (options.MixedCase && options.MixedCase === true ? lowercases.toUpperCase() : "");
var digits = (options.HasNumbers && options.HasNumbers === true ? "0123456789" : "");
var nominees = uppercases + lowercases + digits;
var picks = [];
for (var i = 0; i < resultLength; i++) {
picks.push(nominees.charAt(Math.floor(Math.random() * nominees.length)));
}
return picks.join('');
},
idify: function (selectorId) {
//Ensures that the selectorId starts with a '#' to be ready for use as jQuery selector
if (!commonHelper.isString(selectorId)) return selectorId;
if (selectorId.startsWith('#')) return selectorId;
return '#' + selectorId;
},
/**
* Replaces all instances of non-alphanumeric charecters with the given replacement string
* @param {string} text The string to replace
* @param {string} replaceWith The string to replace non-alphanumeric characters with
* @param {boolean} [compact=true] "True" to replace consecutive occurrances of non-alphanumeric characters with a single replacement string. Default: true
* @returns {string} The new text with the non-alphanumeric characters already replaced
*/
replaceNonAlphaNumeric: function (text, replaceWith, compact) {
if (compact === false) {
return text.replace(/[^a-zA-Z0-9]/g, replaceWith);
} else {
return text.replace(/[^a-zA-Z0-9]+/g, replaceWith);
}
},
/**
* Indicates whether a specified string is null, empty, or consists only of white-space characters
* @param {string} str The string to test
* @returns {boolean} "True" if the value parameter is null or System.String.Empty, or if value consists exclusively of white-space characters.
*/
isNullOrWhitespace(str) {
return str === null || str.match(/^\s*$/) !== null;
},
/**
* Checks if the input string is a valid email address format
* @param {string} emailAddress The email address string to test
* @returns {boolean} "True" if the parameter is a valid email address format
*/
isValidEmailAddressFormat(emailAddress) {
return (/^\w+([\+$\-|'\{\}\?=~\^`/]*[\.]?[\+$\-|'\{\}\?=~\^`/]*\w+)*@\w+([\.-]?\w+)*(\.\w+)+$/.test(emailAddress));
},
/**
* Splits a string into HTML elements based on a delimiter
* @param {string} text The string to split
* @param {object} options The options for splitting the string (optional)
* @param {string|RegExp} options.delimiter The delimiter to split the string (default: /\r\n|\r|\n/)
* @param {string} options.element The HTML element to wrap each split element (default: '
')
* @returns {Array} An array of jQuery wrapped HTML elements
*/
splitToHtmlElements(text, options) {
if (commonHelper.isUndefined(options)) {
options = {};
}
if (commonHelper.isUndefined(options.delimiter)) {
options.delimiter = /\r\n|\r|\n/;
}
if (commonHelper.isUndefined(options.element)) {
options.element = '
';
}
return text.split(options.delimiter).map(function (err) { return $(options.element).text(err); })
},
trimStart(text, stringToTrim) {
if (typeof text !== 'string' || typeof stringToTrim !== 'string') {
return text;
}
return text.replace(new RegExp('^' + stringToTrim), '');
},
};;
var booleanHelper = {
/**
* Returns the javascript boolean value. Helpful for when we need to get the js bool value of a server-side bool variable (e.g.: from a Razor syntax)
* @param {string|boolean} value
* @param {object} options
* @param {boolean} options.defaultValue
* @returns
*/
parse: function (value, options) {
if (typeof options === 'undefined') {
options = { defaultValue: false };
}
if (((typeof value === 'string' && value.toUpperCase() === 'TRUE') || value === true)) {
return true;
}
if (((typeof value === 'string' && value.toUpperCase() === 'FALSE') || value === false)) {
return false;
}
return options.defaultValue;
}
};;
var arrayHelper = {
/**
*
* @param {any[]} array
* @param {function(any, number) : boolean} searchFn
* @returns {boolean}
*/
any: function (array, searchFn) {
for (var i = 0; i < array.length; i++) {
if (searchFn(array[i], i)) {
return true;
}
}
return false;
},
/**
*
* @param {any[]} array
* @param {function(any, number) : boolean} searchFn
* @returns {any}
*/
firstOrNull: function (array, searchFn) {
for (var i = 0; i < array.length; i++) {
if (searchFn(array[i], i)) {
return array[i];
}
}
return null;
},
/**
*
* @param {any[]} array - An array of numbers or objects to sum
* @param {function(any, number) : number} [propertyFn] - Optional. A function that accepts (array item, array index) and returns a number to add to the sum
* @returns {number}
*/
sum: function (array, propertyFn) {
var total = 0;
for (var i = 0; i < array.length; i++) {
if (propertyFn) {
total += propertyFn(array[i], i);
} else {
total += array[i];
}
}
return total;
},
max: function (array, propertyFn) {
if (!array.length) {
return null;
}
var result = propertyFn ? propertyFn(array[0], 0) : array[0];
if (array.length > 1) {
for (var i = 1; i < array.length; i++) {
var compare = propertyFn ? propertyFn(array[i], i) : array[i];
if (compare > result) {
result = compare;
}
}
}
return result;
},
hasDuplicates: function (array) {
return (new Set(array)).size !== array.length;
}
};
var templateHelper = {
isFalsy: function (val) { return val ? false : true; },
isTruthy: function (val) { return val ? true : false; },
autoPopulateHtmlDataFields: function (html, data, fields, options) {
fields = fields || {
//eg:
//ExampleDataFieldName: {
// isHtml: true,
// format: function (val) {
// return '
val';
// },
// hideWhen: function (val) { return !val; } //or dataListHelper.isFalsy
// showWhen: function (val) { return val; } //or dataListHelper.isTruthy
//},
//ExampleIgnoreField: {
// ignore: true
//},
//ExampleDecimalField: {
// decimalPlaces: 2 //Will return "123.45". Can also be used to set decimal for "isPercentage". "isCurrency" fields default to 2 decimal places, unless specified via this property.
//}
};
options = options | {};
options = {
additionalFieldSelector: options.additionalFieldSelector || ''
};
var selector = options.additionalFieldSelector + '[data-field]';
$(selector, html).each(function (index, element) {
var htmlField = $(element);
var dataFieldName = htmlField.attr('data-field');
if (!dataFieldName) {
return;
}
var fieldValue = data;
// split on .[] and remove empty entries so that we can handle expressions like myObj.myArrOfArr[0][1][2].arrayProp
$.each(dataFieldName.split(/[\[\]\.]/).filter(function (x) { return x !== ''; }), function (i, fieldNamePart) {
if (fieldValue === null || fieldValue === undefined) {
return false; //break loop
}
fieldValue = fieldValue[fieldNamePart];
});
var fieldOptions = fields[dataFieldName];
if (fieldOptions && fieldOptions.ignore) {
return;
}
if (fieldOptions && fieldOptions.hideWhen && fieldOptions.hideWhen(fieldValue)) {
htmlField.hide();
}
if (fieldOptions && fieldOptions.showWhen && fieldOptions.showWhen(fieldValue)) {
htmlField.show();
}
if (fieldValue === undefined) {
return;
}
if (fieldOptions && fieldOptions.format) {
fieldValue = fieldOptions.format((fieldValue === 0 || fieldValue === false) ? fieldValue : (fieldValue || ''));
}
else if (typeof (fieldValue) === 'number') {
var lsLocales = undefined;
var lsOptions = { minimumFractionDigits: 2, maximumFractionDigits: 2 };
if (fieldOptions && (!isNaN(fieldOptions.decimalPlaces) || fieldOptions.isCurrency)) {
var decimalPlaces = null;
if (fieldOptions.isCurrency) decimalPlaces = 2;
if (!isNaN(fieldOptions.decimalPlaces)) decimalPlaces = parseInt(fieldOptions.decimalPlaces);
if (decimalPlaces) {
lsOptions.minimumFractionDigits = decimalPlaces;
lsOptions.maximumFractionDigits = decimalPlaces;
}
}
fieldValue = fieldValue.toLocaleString(lsLocales, lsOptions);
if (fieldOptions && fieldOptions.isCurrency) {
fieldValue = '$' + fieldValue;
} else if (fieldOptions && fieldOptions.isPercentage) {
fieldValue = fieldValue + '%';
}
}
if (htmlField.attr('data-field-attr')) {
//todo: support for multiple data-field-attr & values
htmlField.attr(htmlField.attr('data-field-attr'), fieldValue);
}
else if (fieldOptions && fieldOptions.isHtml) {
htmlField.html(fieldValue);
} else {
htmlField.text(fieldValue);
}
});
},
extractHtmlTemplate: function (templateSelector) {
return $(templateSelector).remove().prop('outerHTML');
},
/**
*
* @param {any} selectSelector Any react selector
* @param {{ Disabled: boolean, Group: { Name: string, Disabled: string }, Selected: bool, Text: string, Value: string }[]} selectListItems An array of .NET SelectListItem
*/
populateSelectOptions: function (selectSelector, selectListItems) {
var $select = $(selectSelector);
var optionTemplate = '
';
var optionGroupTemplate = '
';
var $currentOptGroup = null;
for (var i = 0; i < selectListItems.length; i++) {
var item = selectListItems[i];
var $option = $(optionTemplate)
.text(item.Text || '')
.attr('value', item.Value);
if (item.Disabled) {
$option.attr('disabled', 'disabled');
}
if (item.Selected) {
$option.attr('selected', 'selected');
}
if (item.Group) {
if ($currentOptGroup === null || (item.Group.Name || '') !== $currentOptGroup.attr('label')) {
$currentOptGroup = $(optionGroupTemplate).attr('label', item.Group.Name || '');
if (item.Group.Disabled) {
$currentOptGroup.attr('disabled', 'disabled');
}
$select.append($currentOptGroup);
}
$currentOptGroup.append($option);
} else {
$select.append($option);
}
}
}
};
var chosenHelper = {
//Convenience getter for the elements auto-generated by the Chosen instantiation
getChosenField: function (selectField) {
var $selectField = $(selectField);
var selectFieldId = $selectField.attr('id');
if (commonHelper.isUndefined(selectFieldId)) {
console.error("Warning: A