");
+
+ // Create a div to contain the matching values and add it to the DOM
+ var containerId = utils.genContainerId("SPAutocomplete", opt.columnName, opt.listName);
+ columnObj.after("
");
+
+ // Set the width to match the width of the input control
+ var containerObj = $("#" + containerId);
+ containerObj.css("width", columnObjWidth);
+
+ // Handle keypresses
+ $(columnObj).keyup(function () {
+
+ // Get the column's value
+ var columnValue = $(this).val();
+
+ // Hide the container while we're working on it
+ containerObj.hide();
+
+ // Have enough characters been typed yet?
+ if (columnValue.length < opt.numChars) {
+ return false;
+ }
+
+ // Show the the processingIndicator as a background image in the input element
+ columnObj.css({
+ "background-image": "url(" + opt.processingIndicator + ")",
+ "background-position": "right",
+ "background-repeat": "no-repeat"
+ });
+
+ // Array to hold the matched values
+ var matchArray = [];
+
+ // Build the appropriate CAMLQuery
+ var camlQuery = "
";
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += "";
+ }
+ camlQuery += "<" + opt.filterType + ">" + columnValue + " ";
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += opt.CAMLQuery + " ";
+ }
+ camlQuery += " ";
+
+ // Call GetListItems to find all of the potential values
+ $().SPServices({
+ operation: "GetListItems",
+ async: false,
+ webURL: opt.WebURL,
+ listName: opt.sourceList,
+ CAMLQuery: camlQuery,
+ CAMLQueryOptions: opt.CAMLQueryOptions,
+ CAMLViewFields: "
",
+ CAMLRowLimit: opt.CAMLRowLimit,
+ completefunc: function (xData) {
+ // Handle upper/lower case if ignoreCase = true
+ var testValue = opt.ignoreCase ? columnValue.toUpperCase() : columnValue;
+ // See which values match and add the ones that do to matchArray
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+ var thisValue = $(this).attr("ows_" + opt.sourceColumn);
+ var thisValueTest = opt.ignoreCase ? $(this).attr("ows_" + opt.sourceColumn).toUpperCase() : $(this).attr("ows_" + opt.sourceColumn);
+ // Make sure we have a match...
+ if (opt.filterType === "Contains") {
+ var firstMatch = thisValueTest.indexOf(testValue);
+ if ((firstMatch >= 0) &&
+ // ...and that the match is not already in the array if we want uniqueness
+ (!opt.uniqueVals || ($.inArray(thisValue, matchArray) === -1))) {
+ matchArray.push($(this).attr("ows_" + opt.sourceColumn));
+ }
+ } else {
+ // Handles normal case, which is BeginsWith and and other unknown values
+ if (testValue === thisValueTest.substr(0, testValue.length) &&
+ // ...and that the match is not already in the array if we want uniqueness
+ (!opt.uniqueVals || ($.inArray(thisValue, matchArray) === -1))) {
+ matchArray.push($(this).attr("ows_" + opt.sourceColumn));
+ }
+ }
+ });
+ }
+ });
+
+ // Build out the set of list elements to contain the available values
+ var out = "";
+ for (var i = 0; i < matchArray.length; i++) {
+ // If a highlightClass has been supplied, wrap a span around each match
+ if (opt.highlightClass.length > 0) {
+ // Set up Regex based on whether we want to ignore case
+ var thisRegex = new RegExp(columnValue, opt.ignoreCase ? "gi" : "g");
+ // Look for all occurrences
+ var matches = matchArray[i].match(thisRegex);
+ var startLoc = 0;
+ // Loop for each occurrence, wrapping each in a span with the highlightClass CSS class
+ for (matchNum = 0; matchNum < matches.length; matchNum++) {
+ var thisPos = matchArray[i].indexOf(matches[matchNum], startLoc);
+ var endPos = thisPos + matches[matchNum].length;
+ var thisSpan = "
" + matches[matchNum] + " ";
+ matchArray[i] = matchArray[i].substr(0, thisPos) + thisSpan + matchArray[i].substr(endPos);
+ startLoc = thisPos + thisSpan.length;
+ }
+ }
+ // Add the value to the markup for the container
+ out += "
" + matchArray[i] + " ";
+ }
+
+ // Add all the list elements to the containerId container
+ containerObj.html(out);
+ // Set up hehavior for the available values in the list element
+ $("#" + containerId + " li").click(function () {
+ $("#" + containerId).fadeOut(opt.slideUpSpeed);
+ columnObj.val($(this).text());
+ }).mouseover(function () {
+ var mouseoverCss = {
+ "cursor": "hand",
+ "color": "#ffffff",
+ "background": "#3399ff"
+ };
+ $(this).css(mouseoverCss);
+ }).mouseout(function () {
+ var mouseoutCss = {
+ "cursor": "inherit",
+ "color": columnObjColor,
+ "background": "transparent"
+ };
+ $(this).css(mouseoutCss);
+ });
+
+ // If we've got some values to show, then show 'em!
+ if (matchArray.length > 0) {
+ $("#" + containerId).slideDown(opt.slideDownSpeed);
+ }
+ // Remove the processing indicator
+ columnObj.css("background-image", "");
+ });
+
+ }; // End $.fn.SPServices.SPAutocomplete
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ '../utils/constants',
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // Function to set up cascading dropdowns on a SharePoint form
+ // (Newform.aspx, EditForm.aspx, or any other customized form.)
+ $.fn.SPServices.SPCascadeDropdowns = function (options) {
+
+ var opt = $.extend({}, {
+ relationshipWebURL: "", // [Optional] The name of the Web (site) which contains the relationships list
+ relationshipList: "", // The name of the list which contains the parent/child relationships
+ relationshipListParentColumn: "", // The internal name of the parent column in the relationship list
+ relationshipListChildColumn: "", // The internal name of the child column in the relationship list
+ relationshipListSortColumn: "", // [Optional] If specified, sort the options in the dropdown by this column,
+ // otherwise the options are sorted by relationshipListChildColumn
+ parentColumn: "", // The display name of the parent column in the form
+ childColumn: "", // The display name of the child column in the form
+ listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.
+ CAMLQuery: "", // [Optional] For power users, this CAML fragment will be Anded with the default query on the relationshipList
+ CAMLQueryOptions: "
FALSE ", // [Optional] For power users, ability to specify Query Options
+ promptText: "", // [DEPRECATED] Text to use as prompt. If included, {0} will be replaced with the value of childColumn. Original value "Choose {0}..."
+ noneText: "(None)", // [Optional] Text to use for the (None) selection. Provided for non-English language support.
+ simpleChild: false, // [Optional] If set to true and childColumn is a complex dropdown, convert it to a simple dropdown
+ selectSingleOption: false, // [Optional] If set to true and there is only a single child option, select it
+ matchOnId: false, // By default, we match on the lookup's text value. If matchOnId is true, we'll match on the lookup id instead.
+ completefunc: null, // Function to call on completion of rendering the change.
+ debug: false // If true, show error messages;if false, run silent
+ }, options);
+
+
+ var thisParentSetUp = false;
+ var thisFunction = "SPServices.SPCascadeDropdowns";
+
+ // Find the parent column's select (dropdown)
+ var parentSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.parentColumn
+ });
+ if (parentSelect.Obj.html() === null && opt.debug) {
+ utils.errBox(thisFunction, "parentColumn: " + opt.parentColumn, constants.TXTColumnNotFound);
+ return;
+ }
+
+ // Find the child column's select (dropdown)
+ var childSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.childColumn
+ });
+ if (childSelect.Obj.html() === null && opt.debug) {
+ utils.errBox(thisFunction, "childColumn: " + opt.childColumn, constants.TXTColumnNotFound);
+ return;
+ }
+
+ // If requested and the childColumn is a complex dropdown, convert to a simple dropdown
+ if (opt.simpleChild === true && childSelect.Type === constants.dropdownType.complex) {
+ $().SPServices.SPComplexToSimpleDropdown({
+ listName: opt.listName,
+ columnName: opt.childColumn
+ });
+ // Set the childSelect to reference the new simple dropdown
+ childSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.childColumn
+ });
+ }
+
+ var childColumnRequired, childColumnStatic;
+
+ // Get information about the childColumn from the current list
+ $().SPServices({
+ operation: "GetList",
+ async: false,
+ cacheXML: true,
+ listName: opt.listName,
+ completefunc: function (xData) {
+ $(xData.responseXML).find("Fields").each(function () {
+ $(this).find("Field[DisplayName='" + opt.childColumn + "']").each(function () {
+ // Determine whether childColumn is Required
+ childColumnRequired = ($(this).attr("Required") === "TRUE");
+ childColumnStatic = $(this).attr("StaticName");
+ // Stop looking; we're done
+ return false;
+ });
+ });
+ }
+ });
+
+ // Save data about each child column on the parent
+ var childColumn = {
+ opt: opt,
+ childSelect: childSelect,
+ childColumnStatic: childColumnStatic,
+ childColumnRequired: childColumnRequired
+ };
+ var childColumns = parentSelect.Obj.data("SPCascadeDropdownsChildColumns");
+
+ // If this is the first child for this parent, then create the data object to hold the settings
+ if (typeof childColumns === "undefined") {
+ parentSelect.Obj.data("SPCascadeDropdownsChildColumns", [childColumn]);
+ // If we already have a data object for this parent, then add the setting for this child to it
+ } else {
+ childColumns.push(childColumn);
+ parentSelect.Obj.data("SPCascadeDropdownsChildColumns", childColumns);
+ thisParentSetUp = true;
+ }
+
+ // We only need to bind to the event(s) if we haven't already done so
+ if (!thisParentSetUp) {
+ switch (parentSelect.Type) {
+ // Plain old select
+ case constants.dropdownType.simple:
+ parentSelect.Obj.bind("change", function () {
+ cascadeDropdown(parentSelect);
+ });
+ break;
+ // Input / Select hybrid
+ case constants.dropdownType.complex:
+ // Bind to any change on the hidden input element
+ parentSelect.optHid.bind("propertychange", function () {
+ cascadeDropdown(parentSelect);
+ });
+ break;
+ // Multi-select hybrid
+ case constants.dropdownType.multiSelect:
+ // Handle the dblclick on the candidate select
+ $(parentSelect.master.candidateControl).bind("dblclick", function () {
+ cascadeDropdown(parentSelect);
+ });
+ // Handle the dblclick on the selected values
+ $(parentSelect.master.resultControl).bind("dblclick", function () {
+ cascadeDropdown(parentSelect);
+ });
+ // Handle button clicks
+ $(parentSelect.master.addControl).bind("click", function () {
+ cascadeDropdown(parentSelect);
+ });
+ $(parentSelect.master.removeControl).bind("click", function () {
+ cascadeDropdown(parentSelect);
+ });
+ break;
+ default:
+ break;
+ }
+ }
+ // Fire the change to set the initially allowable values
+ cascadeDropdown(parentSelect);
+
+ }; // End $.fn.SPServices.SPCascadeDropdowns
+
+ function cascadeDropdown(parentSelect) {
+ var choices = "";
+ var parentSelectSelected;
+ var childSelectSelected = null;
+ var newMultiLookupPickerdata;
+ var numChildOptions;
+ var firstChildOptionId;
+ var firstChildOptionValue;
+
+ // Filter each child column
+ var childColumns = parentSelect.Obj.data("SPCascadeDropdownsChildColumns");
+ $(childColumns).each(function () {
+
+ // Break out the data objects for this child column
+ var i;
+ var opt = this.opt;
+ var childSelect = this.childSelect;
+ var childColumnStatic = this.childColumnStatic;
+ var childColumnRequired = this.childColumnRequired;
+
+ // Get the parent column selection(s)
+ parentSelectSelected = utils.getDropdownSelected(parentSelect, opt.matchOnId);
+
+ // If the selection hasn't changed, then there's nothing to do right now. This is useful to reduce
+ // the number of Web Service calls when the parentSelect.Type = constants.dropdownType.complex or constants.dropdownType.multiSelect, as there are multiple propertychanges
+ // which don't require any action. The attribute will be unique per child column in case there are
+ // multiple children for a given parent.
+ var allParentSelections = parentSelectSelected.join(constants.spDelim);
+ if (parentSelect.Obj.data("SPCascadeDropdown_Selected_" + childColumnStatic) === allParentSelections) {
+ return;
+ }
+ parentSelect.Obj.data("SPCascadeDropdown_Selected_" + childColumnStatic, allParentSelections);
+
+ // Get the current child column selection(s)
+ childSelectSelected = utils.getDropdownSelected(childSelect, true);
+
+ // When the parent column's selected option changes, get the matching items from the relationship list
+ // Get the list items which match the current selection
+ var sortColumn = (opt.relationshipListSortColumn.length > 0) ? opt.relationshipListSortColumn : opt.relationshipListChildColumn;
+ var camlQuery = "
";
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += "";
+ }
+
+ // Build up the criteria for inclusion
+ if (parentSelectSelected.length === 0) {
+ // Handle the case where no values are selected in multi-selects
+ camlQuery += "" : "'/>") +
+ utils.escapeColumnValue(parentSelectSelected[0]) + " ";
+ }
+ for (i = 0; i < parentSelectSelected.length; i++) {
+ camlQuery += "" : "'/>") +
+ utils.escapeColumnValue(parentSelectSelected[i]) + " ";
+ }
+ }
+ camlQuery += "";
+ }
+
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += opt.CAMLQuery + " ";
+ }
+
+ // Make sure we don't get any items which don't have the child value
+ camlQuery += " ";
+
+ $().SPServices({
+ operation: "GetListItems",
+ // Force sync so that we have the right values for the child column onchange trigger
+ async: false,
+ webURL: opt.relationshipWebURL,
+ listName: opt.relationshipList,
+ // Filter based on the currently selected parent column's value
+ CAMLQuery: camlQuery,
+ // Only get the parent and child columns
+ CAMLViewFields: "
",
+ // Override the default view rowlimit and get all appropriate rows
+ CAMLRowLimit: 0,
+ // Even though setting IncludeMandatoryColumns to FALSE doesn't work as the docs describe, it fixes a bug in GetListItems with mandatory multi-selects
+ CAMLQueryOptions: opt.CAMLQueryOptions,
+ completefunc: function (xData) {
+
+ // Handle errors
+ $(xData.responseXML).find("errorstring").each(function () {
+ var thisFunction = "SPServices.SPCascadeDropdowns";
+ var errorText = $(this).text();
+ if (opt.debug && errorText === "One or more field types are not installed properly. Go to the list settings page to delete these fields.") {
+ utils.errBox(thisFunction,
+ "relationshipListParentColumn: " + opt.relationshipListParentColumn + " or " +
+ "relationshipListChildColumn: " + opt.relationshipListChildColumn,
+ "Not found in relationshipList " + opt.relationshipList);
+ } else if (opt.debug && errorText === "Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).") {
+ utils.errBox(thisFunction,
+ "relationshipList: " + opt.relationshipList,
+ "List not found");
+ }
+
+ });
+
+ // Add an explanatory prompt
+ switch (childSelect.Type) {
+ case constants.dropdownType.simple:
+ // Remove all of the existing options
+ childSelect.Obj[0].innerHTML = "";
+// $(childSelect.Obj).find("option").remove();
+ // If the column is required or the promptText option is empty, don't add the prompt text
+ if (!childColumnRequired && (opt.promptText.length > 0)) {
+ childSelect.Obj.append("
" + opt.promptText.replace(/\{0\}/g, opt.childColumn) + " ");
+ } else if (!childColumnRequired) {
+ childSelect.Obj.append("
" + opt.noneText + " ");
+ }
+ break;
+ case constants.dropdownType.complex:
+ // If the column is required, don't add the "(None)" option
+ choices = childColumnRequired ? "" : opt.noneText + "|0";
+ childSelect.Obj.val("");
+ break;
+ case constants.dropdownType.multiSelect:
+ // Remove all of the existing options
+ $(childSelect.master.candidateControl).find("option").remove();
+ newMultiLookupPickerdata = "";
+ break;
+ default:
+ break;
+ }
+ // Get the count of items returned and save it so that we can select if it's a single option
+ // The item count is stored thus:
+ numChildOptions = parseFloat($(xData.responseXML).SPFilterNode("rs:data").attr("ItemCount"));
+
+ // Add an option for each child item
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+
+ var thisOption = {};
+
+ // If relationshipListChildColumn is a Lookup column, then the ID should be for the Lookup value,
+ // else the ID of the relationshipList item
+ var thisValue = $(this).attr("ows_" + opt.relationshipListChildColumn);
+
+ if (typeof thisValue !== "undefined" && thisValue.indexOf(constants.spDelim) > 0) {
+ thisOption = new utils.SplitIndex(thisValue);
+ } else {
+ thisOption.id = $(this).attr("ows_ID");
+ thisOption.value = thisValue;
+ }
+
+ // If the relationshipListChildColumn is a calculated column, then the value isn't preceded by the ID,
+ // but by the datatype. In this case, thisOption.id should be the ID of the relationshipList item.
+ // e.g., float;#12345.67
+ if (isNaN(thisOption.id)) {
+ thisOption.id = $(this).attr("ows_ID");
+ }
+
+ // Save the id and value for the first child option in case we need to select it (selectSingleOption option is true)
+ firstChildOptionId = thisOption.id;
+ firstChildOptionValue = thisOption.value;
+
+ switch (childSelect.Type) {
+ case constants.dropdownType.simple:
+ var selected = ($(this).attr("ows_ID") === childSelectSelected[0]) ? " selected='selected'" : "";
+ childSelect.Obj.append("" + thisOption.value + "");
+ break;
+ case constants.dropdownType.complex:
+ if (thisOption.id === childSelectSelected[0]) {
+ childSelect.Obj.val(thisOption.value);
+ }
+ choices = choices + ((choices.length > 0) ? "|" : "") + thisOption.value + "|" + thisOption.id;
+ break;
+ case constants.dropdownType.multiSelect:
+ $(childSelect.master.candidateControl).append("" + thisOption.value + " ");
+ newMultiLookupPickerdata += thisOption.id + "|t" + thisOption.value + "|t |t |t";
+ break;
+ default:
+ break;
+ }
+ });
+
+ switch (childSelect.Type) {
+ case constants.dropdownType.simple:
+ childSelect.Obj.trigger("change");
+ // If there is only one option and the selectSingleOption option is true, then select it
+ if (numChildOptions === 1 && opt.selectSingleOption === true) {
+ $(childSelect.Obj).find("option[value!='0']:first").attr("selected", "selected");
+ }
+ break;
+ case constants.dropdownType.complex:
+ // Set the allowable choices
+ childSelect.Obj.attr("choices", choices);
+ // If there is only one option and the selectSingleOption option is true, then select it
+ if (numChildOptions === 1 && opt.selectSingleOption === true) {
+ // Set the input element value
+ $(childSelect.Obj).val(firstChildOptionValue);
+ // Set the value of the optHid input element
+ childSelect.optHid.val(firstChildOptionId);
+ }
+ // If there's no selection, then remove the value in the associated hidden input element (optHid)
+ if (childSelect.Obj.val() === "") {
+ childSelect.optHid.val("");
+ }
+ break;
+ case constants.dropdownType.multiSelect:
+ // Clear the master
+ childSelect.master.data = "";
+ childSelect.MultiLookupPickerdata.val(newMultiLookupPickerdata);
+
+ // Clear any prior selections that are no longer valid or aren't selected
+ $(childSelect.master.resultControl).find("option").each(function () {
+ var thisSelected = $(this);
+ thisSelected.prop("selected", true);
+ $(childSelect.master.candidateControl).find("option[value='" + thisSelected.val() + "']").each(function () {
+ thisSelected.prop("selected", false);
+ });
+ });
+ GipRemoveSelectedItems(childSelect.master);
+
+ // Hide any options in the candidate list which are already selected
+ $(childSelect.master.candidateControl).find("option").each(function () {
+ var thisSelected = $(this);
+ $(childSelect.master.resultControl).find("option[value='" + thisSelected.val() + "']").each(function () {
+ thisSelected.remove();
+ });
+ });
+ GipAddSelectedItems(childSelect.master);
+
+ // Set master.data to the newly allowable values
+ childSelect.master.data = GipGetGroupData(newMultiLookupPickerdata);
+
+ // Trigger a dblclick so that the child will be cascaded if it is a multiselect.
+ $(childSelect.master.candidateControl).trigger("dblclick");
+
+ break;
+ default:
+ break;
+ }
+ }
+ });
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc();
+ }
+ }); // $(childColumns).each(function()
+
+ } // End cascadeDropdown
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ "../utils/constants",
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // function to convert complex dropdowns to simple dropdowns
+ $.fn.SPServices.SPComplexToSimpleDropdown = function (options) {
+
+ var opt = $.extend({}, {
+ listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.
+ columnName: "", // The display name of the column in the form
+ completefunc: null, // Function to call on completion of rendering the change.
+ debug: false // If true, show error messages;if false, run silent
+ }, options);
+
+ // Find the column's select (dropdown)
+ var columnSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.columnName
+ });
+ if (columnSelect.Obj.html() === null && opt.debug) {
+ utils.errBox("SPServices.SPComplexToSimpleDropdown", "columnName: " + opt.columnName, constants.TXTColumnNotFound);
+ return;
+ }
+
+ // If we don't have a complex dropdown, then there is nothing to do
+ if (columnSelect.Type !== constants.dropdownType.complex) {
+ return;
+ }
+
+ // The available options are stored in the choices attribute of the complex dropdown's input element...
+ var choices = $(columnSelect.Obj).attr("choices").split("|");
+
+ // We need to know which option is selected already, if any
+ var complexSelectSelectedId = columnSelect.optHid.val();
+
+ // Build up the simple dropdown, giving it an easy to select id
+ var simpleSelectId = utils.genContainerId("SPComplexToSimpleDropdown", columnSelect.Obj.attr("title"), opt.listName);
+
+ var simpleSelect = "";
+ for (var i = 0; i < choices.length; i = i + 2) {
+ var simpleSelectSelected = (choices[i + 1] === complexSelectSelectedId) ? " selected='selected' " : " ";
+ simpleSelect += "" + choices[i] + "";
+ }
+ simpleSelect += " ";
+
+ // Append the new simple select to the form
+ columnSelect.Obj.closest("td").prepend(simpleSelect);
+ var simpleSelectObj = $("#" + simpleSelectId);
+
+ // Remove the complex dropdown functionality since we don't need it anymore...
+ columnSelect.Obj.closest("span").find("img").remove();
+ // ...and hide the input element
+ columnSelect.Obj.closest("span").find("input").hide();
+
+ // When the simple select changes...
+ simpleSelectObj.change(function () {
+ var thisVal = $(this).val();
+ // ...set the optHid input element's value to the valus of the selected option...
+ columnSelect.optHid.val(thisVal);
+ // ...and save the selected value as the hidden input's value only if the value is not equal to "0" (None)
+ $(columnSelect.Obj).val($(this).find("option[value='" + (thisVal !== "0" ? thisVal : "") + "']").html());
+ });
+ // Trigger a change to ensure that the selected value registers in the complex dropdown
+ simpleSelectObj.trigger("change");
+
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc();
+ }
+
+ }; // End $.fn.SPServices.SPConvertToSimpleDropdown
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ "../utils/constants",
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // Function to display related information when an option is selected on a form.
+ $.fn.SPServices.SPDisplayRelatedInfo = function (options) {
+
+ var opt = $.extend({}, {
+ listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.
+ columnName: "", // The display name of the column in the form
+ relatedWebURL: "", // [Optional] The name of the Web (site) which contains the related list
+ relatedList: "", // The name of the list which contains the additional information
+ relatedListColumn: "", // The internal name of the related column in the related list
+ relatedColumns: [], // An array of related columns to display
+ displayFormat: "table", // The format to use in displaying the related information. Possible values are: [table, list, none]
+ headerCSSClass: "ms-vh2", // CSS class for the table headers
+ rowCSSClass: "ms-vb", // CSS class for the table rows
+ CAMLQuery: "", // [Optional] For power users, this CAML fragment will be ed with the default query on the relatedList
+ numChars: 0, // If used on an input column (not a dropdown), no matching will occur until at least this number of characters has been entered
+ matchType: "Eq", // If used on an input column (not a dropdown), type of match. Can be any valid CAML comparison operator, most often "Eq" or "BeginsWith"
+ matchOnId: false, // By default, we match on the lookup's text value. If matchOnId is true, we'll match on the lookup id instead.
+ completefunc: null, // Function to call on completion of rendering the change.
+ debug: false // If true, show error messages;if false, run silent
+ }, options);
+
+ var i;
+ var relatedColumnsXML = [];
+ var relatedListXML;
+ var thisFunction = "SPServices.SPDisplayRelatedInfo";
+
+ // Find the column's select (dropdown)
+ var columnSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.columnName
+ });
+ if (columnSelect.Obj.html() === null && opt.debug) {
+ utils.errBox(thisFunction, "columnName: " + opt.columnName, constants.TXTColumnNotFound);
+ return;
+ }
+
+ // Get information about the related list and its columns
+ $().SPServices({
+ operation: "GetList",
+ async: false,
+ cacheXML: true,
+ webURL: opt.relatedWebURL,
+ listName: opt.relatedList,
+ completefunc: function (xData) {
+ // If debug is on, notify about an error
+ $(xData.responseXML).find("faultcode").each(function () {
+ if (opt.debug) {
+ utils.errBox(thisFunction, "relatedList: " + opt.relatedList, "List not found");
+
+ }
+ });
+ // Get info about the related list
+ relatedListXML = $(xData.responseXML).find("List");
+ // Save the information about each column requested
+ for (i = 0; i < opt.relatedColumns.length; i++) {
+ relatedColumnsXML[opt.relatedColumns[i]] = $(xData.responseXML).find("Fields > Field[Name='" + opt.relatedColumns[i] + "']");
+ }
+ relatedColumnsXML[opt.relatedListColumn] = $(xData.responseXML).find("Fields > Field[Name='" + opt.relatedListColumn + "']");
+ }
+ });
+
+ switch (columnSelect.Type) {
+ // Plain old select
+ case constants.dropdownType.simple:
+ columnSelect.Obj.bind("change", function () {
+ showRelated(opt, relatedListXML, relatedColumnsXML);
+ });
+ break;
+ // Input / Select hybrid
+ case constants.dropdownType.complex:
+ // Bind to any change on the hidden input element
+ columnSelect.optHid.bind("propertychange", function () {
+ showRelated(opt, relatedListXML, relatedColumnsXML);
+ });
+ break;
+ // Multi-select hybrid
+ case constants.dropdownType.multiSelect:
+ if (opt.debug) {
+ utils.errBox(thisFunction, "columnName: " + opt.columnName, "Multi-select columns not supported by this function");
+ }
+ break;
+ default:
+ break;
+ }
+ // Fire the change to set the initially allowable values
+ showRelated(opt, relatedListXML, relatedColumnsXML);
+
+ }; // End $.fn.SPServices.SPDisplayRelatedInfo
+
+ function showRelated(opt, relatedListXML, relatedColumnsXML) {
+
+ var i;
+ var columnSelectSelected;
+ var thisFunction = "SPServices.SPDisplayRelatedInfo";
+
+ // Find the column's select (dropdown)
+ var columnSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.columnName
+ });
+
+ // Get the current column selection(s)
+ columnSelectSelected = utils.getDropdownSelected(columnSelect, opt.matchOnId);
+ if (columnSelect.Type === constants.dropdownType.complex && opt.numChars > 0 && columnSelectSelected[0].length < opt.numChars) {
+ return;
+ }
+
+ // If the selection hasn't changed, then there's nothing to do right now. This is useful to reduce
+ // the number of Web Service calls when the parentSelect.Type = constants.dropdownType.complex, as there are multiple propertychanges
+ // which don't require any action.
+ if (columnSelect.Obj.attr("showRelatedSelected") === columnSelectSelected[0]) {
+ return;
+ }
+ columnSelect.Obj.attr("showRelatedSelected", columnSelectSelected[0]);
+
+ if(opt.displayFormat !== "none") {
+ // Generate a unique id for the container
+ var divId = utils.genContainerId("SPDisplayRelatedInfo", opt.columnName, opt.listName);
+ // Remove the old container...
+ $("#" + divId).remove();
+ // ...and append a new, empty one
+ columnSelect.Obj.parent().append("
");
+ }
+
+ // Get the list items which match the current selection
+ var camlQuery = "";
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += "";
+ }
+
+ // Need to handle Lookup columns differently than static columns
+ var relatedListColumnType = relatedColumnsXML[opt.relatedListColumn].attr("Type");
+ if (relatedListColumnType === "Lookup") {
+ camlQuery += "" : "'/>") +
+ utils.escapeColumnValue(columnSelectSelected[0]) + " " : opt.relatedListColumn + "'/>") +
+ utils.escapeColumnValue(columnSelectSelected[0]) + " ";
+ }
+ camlQuery += " " + viewFields + " ",
+ // Override the default view rowlimit and get all appropriate rows
+ CAMLRowLimit: 0,
+ completefunc: function (xData) {
+
+ // Handle errors
+ $(xData.responseXML).find("errorstring").each(function () {
+ var errorText = $(this).text();
+ if (opt.debug && errorText === "One or more field types are not installed properly. Go to the list settings page to delete these fields.") {
+ utils.errBox(thisFunction,
+ "relatedListColumn: " + opt.relatedListColumn,
+ "Column not found in relatedList " + opt.relatedList);
+ } else if (opt.debug && errorText === "Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).") {
+ utils.errBox(thisFunction,
+ "relatedList: " + opt.relatedList,
+ "List not found");
+ }
+
+ });
+
+ var outString;
+ // Output each row
+ switch (opt.displayFormat) {
+ // Only implementing the table format in the first iteration (v0.2.9)
+ case "table":
+ outString = "";
+ outString += "";
+ for (i = 0; i < opt.relatedColumns.length; i++) {
+ if (typeof relatedColumnsXML[opt.relatedColumns[i]] === "undefined" && opt.debug) {
+ utils.errBox(thisFunction, "columnName: " + opt.relatedColumns[i], "Column not found in relatedList");
+ return;
+ }
+ outString += "";
+ }
+ outString += " ";
+ // Add an option for each child item
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+ outString += "";
+ for (i = 0; i < opt.relatedColumns.length; i++) {
+ outString += "" + showColumn(relatedListXML, relatedColumnsXML[opt.relatedColumns[i]], $(this).attr("ows_" + opt.relatedColumns[i]), opt) + " ";
+ }
+ outString += " ";
+ });
+ outString += "
";
+ break;
+ // list format implemented in v0.5.0. Still table-based, but vertical orientation.
+ case "list":
+ outString = "";
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+ for (i = 0; i < opt.relatedColumns.length; i++) {
+ if (typeof relatedColumnsXML[opt.relatedColumns[i]] === "undefined" && opt.debug) {
+ utils.errBox(thisFunction, "columnName: " + opt.relatedColumns[i], "Column not found in relatedList");
+ return;
+ }
+ outString += "";
+ outString += "";
+ outString += "" + showColumn(relatedListXML, relatedColumnsXML[opt.relatedColumns[i]], $(this).attr("ows_" + opt.relatedColumns[i]), opt) + " ";
+ outString += " ";
+ }
+ });
+ outString += "
";
+ break;
+ case "none":
+ break;
+ default:
+ break;
+ }
+ // Write out the results
+ if(opt.displayFormat !== "none") {
+ $("#" + divId).html(outString);
+ }
+
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc(xData);
+ }
+
+ }
+ });
+ } // End showRelated
+
+ // Display a column (field) formatted correctly based on its definition in the list.
+ // NOTE: Currently not dealing with locale differences.
+ // columnXML The XML node for the column from a GetList operation
+ // columnValue The text representation of the column's value
+ // opt The current set of options
+ function showColumn(listXML, columnXML, columnValue, opt) {
+
+ if (typeof columnValue === "undefined") {
+ return "";
+ }
+
+ var i;
+ var outString = "";
+ var fileName = "";
+ var dispUrl;
+ var numDecimals;
+ var outArray = [];
+ var webUrl = opt.relatedWebURL.length > 0 ? opt.relatedWebURL : $().SPServices.SPGetCurrentSite();
+
+
+
+
+
+
+
+ switch (columnXML.attr("Type")) {
+ case "Text":
+ outString = columnValue;
+ break;
+ case "URL":
+ switch (columnXML.attr("Format")) {
+ // URL as hyperlink
+ case "Hyperlink":
+ outString = "" +
+ columnValue.substring(columnValue.search(",") + 1) + " ";
+ break;
+ // URL as image
+ case "Image":
+ outString = "" +
+ userMultiValues[i + 1] + " ");
+ }
+ outString = outArray.join(", ");
+ break;
+ case "Calculated":
+ var calcColumn = columnValue.split(constants.spDelim);
+ outString = calcColumn[1];
+ break;
+ case "Number":
+ numDecimals = columnXML.attr("Decimals");
+ outString = typeof numDecimals === "undefined" ?
+ parseFloat(columnValue).toString() :
+ parseFloat(columnValue).toFixed(numDecimals).toString();
+ break;
+ case "Currency":
+ numDecimals = columnXML.attr("Decimals");
+ outString = typeof numDecimals === "undefined" ?
+ parseFloat(columnValue).toFixed(2).toString() :
+ parseFloat(columnValue).toFixed(numDecimals).toString();
+ break;
+ case "Lookup":
+ switch (columnXML.attr("Name")) {
+ case "FileRef":
+ // Get the display form URL for the lookup source list
+ dispUrl = listXML.attr("BaseType") === "1" ? listXML.attr("RootFolder") + constants.SLASH + "Forms/DispForm.aspx" :
+ listXML.attr("RootFolder") + constants.SLASH + "DispForm.aspx";
+ outString = "" +
+ columnValue.substring(columnValue.search(constants.spDelim) + 2) + " ";
+ break;
+ case "FileDirRef":
+ // Get the display form URL for the lookup source list
+ dispUrl = constants.SLASH + columnValue.substring(columnValue.search(constants.spDelim) + 2);
+ outString = "" +
+ columnValue.substring(columnValue.search(constants.spDelim) + 2) + " ";
+ break;
+ // Any other lookup column
+ default:
+ // Get the display form URL for the lookup source list
+ dispUrl = utils.getListFormUrl(columnXML.attr("List"), "DisplayForm");
+ outString = "" +
+ columnValue.substring(columnValue.search(constants.spDelim) + 2) + " ";
+ break;
+ }
+ break;
+ case "LookupMulti":
+ // Get the display form URL for the lookup source list
+ dispUrl = utils.getListFormUrl(columnXML.attr("List"), "DisplayForm");
+ // Show all the values as links to the items, separated by commas
+ outString = "";
+ if (columnValue.length > 0) {
+ var lookupMultiValues = columnValue.split(constants.spDelim);
+ for (i = 0; i < lookupMultiValues.length / 2; i++) {
+ outArray.push("" +
+ lookupMultiValues[(i * 2) + 1] + " ");
+ }
+ }
+ outString = outArray.join(", ");
+ break;
+ case "File":
+ fileName = columnValue.substring(columnValue.search(constants.spDelim) + 2);
+ outString = "" + fileName + " ";
+ break;
+ case "Counter":
+ outString = columnValue;
+ break;
+ case "DateTime":
+ outString = columnValue;
+ break;
+ default:
+ outString = columnValue;
+ break;
+ }
+ return outString;
+ } // End of function showColumn
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ "../utils/constants",
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ /* jshint undef: true */
+ /* global GipAddSelectedItems, GipRemoveSelectedItems, GipGetGroupData */
+
+ // Function to filter a lookup based dropdown
+ $.fn.SPServices.SPFilterDropdown = function (options) {
+
+ var opt = $.extend({}, {
+ relationshipWebURL: "", // [Optional] The name of the Web (site) which contains the relationshipList
+ relationshipList: "", // The name of the list which contains the lookup values
+ relationshipListColumn: "", // The internal name of the column in the relationship list
+ relationshipListSortColumn: "", // [Optional] If specified, sort the options in the dropdown by this column,
+ // otherwise the options are sorted by relationshipListColumn
+ relationshipListSortAscending: true, // [Optional] By default, the sort is ascending. If false, descending
+ columnName: "", // The display name of the column in the form
+ listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.
+ promptText: "", // [DEPRECATED] Text to use as prompt. If included, {0} will be replaced with the value of columnName. IOrignal value "Choose {0}..."
+ noneText: "(None)", // [Optional] Text to use for the (None) selection. Provided for non-English language support.
+ CAMLQuery: "", // This CAML fragment will be applied to the relationshipList
+ CAMLQueryOptions: "FALSE ";
+ if (opt.CAMLQuery.length > 0) {
+ camlQuery += opt.CAMLQuery;
+ }
+ camlQuery += " " + opt.promptText.replace(/\{0\}/g, opt.columnName) + " ");
+ } else if (!columnColumnRequired) {
+ columnSelect.Obj.append("" + opt.noneText + " ");
+ }
+ break;
+ case constants.dropdownType.complex:
+ // If the column is required, don't add the "(None)" option
+ choices = columnColumnRequired ? "" : opt.noneText + "|0";
+ columnSelect.Obj.val("");
+ break;
+ case constants.dropdownType.multiSelect:
+ // Remove all of the existing options
+ $(columnSelect.master.candidateControl).find("option").remove();
+ newMultiLookupPickerdata = "";
+ break;
+ default:
+ break;
+ }
+
+ // Add an option for each item
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+
+ var thisOption = {};
+
+ // If relationshipListColumn is a Lookup column, then the ID should be for the Lookup value,
+ // else the ID of the relationshipList item
+ var thisValue = $(this).attr("ows_" + opt.relationshipListColumn);
+
+ if (typeof thisValue !== "undefined" && thisValue.indexOf(constants.spDelim) > 0) {
+ thisOption = new utils.SplitIndex(thisValue);
+ } else {
+ thisOption.id = $(this).attr("ows_ID");
+ thisOption.value = thisValue;
+ }
+
+ // If the relationshipListColumn is a calculated column, then the value isn't preceded by the ID,
+ // but by the datatype. In this case, thisOption.id should be the ID of the relationshipList item.
+ // e.g., float;#12345.67
+ if (isNaN(thisOption.id)) {
+ thisOption.id = $(this).attr("ows_ID");
+ }
+
+ switch (columnSelect.Type) {
+ case constants.dropdownType.simple:
+ var selected = ($(this).attr("ows_ID") === columnSelectSelected[0]) ? " selected='selected'" : "";
+ columnSelect.Obj.append("" + thisOption.value + "");
+ break;
+ case constants.dropdownType.complex:
+ if (thisOption.id === columnSelectSelected[0]) {
+ columnSelect.Obj.val(thisOption.value);
+ }
+ choices = choices + ((choices.length > 0) ? "|" : "") + thisOption.value + "|" + thisOption.id;
+ break;
+ case constants.dropdownType.multiSelect:
+ $(columnSelect.master.candidateControl).append("" + thisOption.value + " ");
+ newMultiLookupPickerdata += thisOption.id + "|t" + thisOption.value + "|t |t |t";
+ break;
+ default:
+ break;
+ }
+ });
+
+ switch (columnSelect.Type) {
+ case constants.dropdownType.simple:
+ columnSelect.Obj.trigger("change");
+ break;
+ case constants.dropdownType.complex:
+ columnSelect.Obj.attr("choices", choices);
+ columnSelect.Obj.trigger("propertychange");
+ break;
+ case constants.dropdownType.multiSelect:
+ // Clear the master
+ columnSelect.master.data = "";
+
+ columnSelect.MultiLookupPickerdata.val(newMultiLookupPickerdata);
+ // Clear any prior selections that are no longer valid
+ $(columnSelect.master.resultControl).find("option").each(function () {
+ var thisSelected = $(this);
+ $(this).attr("selected", "selected");
+ $(columnSelect.master.candidateControl).find("option").each(function () {
+ if ($(this).html() === thisSelected.html()) {
+ thisSelected.removeAttr("selected");
+ }
+ });
+ });
+ GipRemoveSelectedItems(columnSelect.master);
+ // Hide any options in the candidate list which are already selected
+ $(columnSelect.master.candidateControl).find("option").each(function () {
+ var thisSelected = $(this);
+ $(columnSelect.master.resultControl).find("option").each(function () {
+ if ($(this).html() === thisSelected.html()) {
+ thisSelected.remove();
+ }
+ });
+ });
+ GipAddSelectedItems(columnSelect.master);
+ // Set master.data to the newly allowable values
+ columnSelect.master.data = GipGetGroupData(newMultiLookupPickerdata);
+
+ // Trigger a dblclick so that the child will be cascaded if it is a multiselect.
+ $(columnSelect.master.candidateControl).trigger("dblclick");
+
+ break;
+ default:
+ break;
+ }
+ }
+ });
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc();
+ }
+ }; // End $.fn.SPServices.SPFilterDropdown
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core.js'
+], function (
+ $
+) {
+
+ "use strict";
+
+ // Find an MMS Picker in the page
+ // Returns references to:
+ // terms - The aaray of terms as value/guid pairs
+ $.fn.SPServices.SPFindMMSPicker = function (options) {
+
+ var opt = $.extend({}, {
+ MMSDisplayName: "" // The displayName of the MMS Picker on the form
+ }, options);
+
+ var thisTerms = [];
+
+ // Find the div for the column which contains the entered data values
+ var thisDiv = $("div[title='" + opt.MMSDisplayName + "']");
+ var thisHiddenInput = thisDiv.closest("td").find("input[type='hidden']");
+ var thisTermArray = thisHiddenInput.val().split(";");
+
+ for (var i = 0; i < thisTermArray.length; i++) {
+ var thisOne = thisTermArray[i].split("|");
+ thisTerms.push({
+ value: thisOne[0],
+ guid: thisOne[1]
+ });
+
+ }
+
+ return {
+ terms: thisTerms
+ };
+
+ }; // End $.fn.SPServices.SPFindMMSPicker
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core.js'
+], function (
+ $
+) {
+
+ "use strict";
+
+ // Find a People Picker in the page
+ // Returns references to:
+ // row - The TR which contains the People Picker (useful if you'd like to hide it at some point)
+ // contents - The element which contains the current value
+ // currentValue - The current value if it is set
+ // checkNames - The Check Names image (in case you'd like to click it at some point)
+ // checkNamesPhrase - you can pass your local phrase here to check names, like in russian it would be - ????????? ?????
+ $.fn.SPServices.SPFindPeoplePicker = function (options) {
+
+ var opt = $.extend({}, {
+ peoplePickerDisplayName: "", // The displayName of the People Picker on the form
+ valueToSet: "", // The value to set the People Picker to. Should be a string containing each username or groupname separated by semi-colons.
+ checkNames: true, // If set to true, the Check Names image will be clicked to resolve the names
+ checkNamesPhrase: 'Check Names' // English default
+ }, options);
+
+ var thisRow = $("nobr").filter(function () {
+ // Ensures we get a match whether or not the People Picker is required (if required, the nobr contains a span also)
+ return $(this).contents().eq(0).text() === opt.peoplePickerDisplayName;
+ }).closest("tr");
+
+ var thisContents = thisRow.find("div[name='upLevelDiv']");
+ var thisCheckNames = thisRow.find("img[Title='" + opt.checkNamesPhrase + "']:first");
+
+ // If a value was provided, set the value
+ if (opt.valueToSet.length > 0) {
+ thisContents.html(opt.valueToSet);
+ }
+
+ // If checkName is true, click the check names icon
+ if (opt.checkNames) {
+ thisCheckNames.click();
+ }
+ var thisCurrentValue = $.trim(thisContents.text());
+
+ // Parse the entity data
+ var dictionaryEntries = [];
+
+ // IE
+ thisContents.children("span").each(function () {
+
+ // Grab the entity data
+ var thisData = $(this).find("div[data]").attr("data");
+
+ var dictionaryEntry = {};
+
+ // Entity data is only available in IE
+ if (typeof thisData !== "undefined") {
+ var arrayOfDictionaryEntry = $.parseXML(thisData);
+ var $xml = $(arrayOfDictionaryEntry);
+
+ $xml.find("DictionaryEntry").each(function () {
+ var key = $(this).find("Key").text();
+ dictionaryEntry[key] = $(this).find("Value").text();
+ });
+ dictionaryEntries.push(dictionaryEntry);
+ // For other browsers, we'll call GetUserInfo to get the data
+ } else {
+ $().SPServices({
+ operation: "GetUserInfo",
+ async: false,
+ cacheXML: true,
+ userLoginName: $(this).attr("title"),
+ completefunc: function (xData) {
+
+ $(xData.responseXML).find("User").each(function () {
+
+ $.each(this.attributes, function (i, attrib) {
+ dictionaryEntry[attrib.name] = attrib.value;
+ });
+ dictionaryEntries.push(dictionaryEntry);
+ });
+ }
+ });
+ }
+ });
+
+ return {
+ row: thisRow,
+ contents: thisContents,
+ currentValue: thisCurrentValue,
+ checkNames: thisCheckNames,
+ dictionaryEntries: dictionaryEntries
+ };
+ }; // End $.fn.SPServices.SPFindPeoplePicker
+
+ // Mistakenly released previously outside the SPServices namespace. This takes care of offering both.
+ $.fn.SPFindPeoplePicker = function (options) {
+ return $().SPServices.SPFindPeoplePicker(options);
+ }; // End $.fn.SPFindPeoplePicker
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ "../utils/constants",
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // Function which provides a link on a Lookup column for the user to follow
+ // which allows them to add a new value to the Lookup list.
+ // Based on http://blog.mastykarz.nl/extending-lookup-fields-add-new-item-option/
+ // by Waldek Mastykarz
+ $.fn.SPServices.SPLookupAddNew = function (options) {
+
+ var opt = $.extend({}, {
+ lookupColumn: "", // The display name of the Lookup column
+ promptText: "Add new {0}", // Text to use as prompt + column name
+ newWindow: false, // If true, the link will open in a new window *without* passing the Source.
+ ContentTypeID: "", // [Optional] Pass the ContentTypeID if you'd like to specify it
+ completefunc: null, // Function to call on completion of rendering the change.
+ debug: false // If true, show error messages;if false, run silent
+ }, options);
+
+ var thisFunction = "SPServices.SPLookupAddNew";
+
+ // Find the lookup column's select (dropdown)
+ var lookupSelect = $().SPServices.SPDropdownCtl({
+ displayName: opt.lookupColumn
+ });
+ if (lookupSelect.Obj.html() === null && opt.debug) {
+ utils.errBox(thisFunction, "lookupColumn: " + opt.lookupColumn, constants.TXTColumnNotFound);
+ return;
+ }
+
+ var newUrl = "";
+ var lookupListUrl = "";
+ var lookupColumnStaticName = "";
+ // Use GetList for the current list to determine the details for the Lookup column
+ $().SPServices({
+ operation: "GetList",
+ async: false,
+ cacheXML: true,
+ listName: $().SPServices.SPListNameFromUrl(),
+ completefunc: function (xData) {
+ $(xData.responseXML).find("Field[DisplayName='" + opt.lookupColumn + "']").each(function () {
+ lookupColumnStaticName = $(this).attr("StaticName");
+ // Use GetList for the Lookup column's list to determine the list's URL
+ $().SPServices({
+ operation: "GetList",
+ async: false,
+ cacheXML: true,
+ listName: $(this).attr("List"),
+ completefunc: function (xData) {
+ $(xData.responseXML).find("List").each(function () {
+ lookupListUrl = $(this).attr("WebFullUrl");
+ // Need to handle when list is in the root site
+ lookupListUrl = lookupListUrl !== constants.SLASH ? lookupListUrl + constants.SLASH : lookupListUrl;
+ });
+ }
+ });
+ // Get the NewItem form for the Lookup column's list
+ newUrl = utils.getListFormUrl($(this).attr("List"), "NewForm");
+ // Stop looking;we're done
+ return false;
+ });
+ }
+ });
+
+ if (lookupListUrl.length === 0 && opt.debug) {
+ utils.errBox(thisFunction, "lookupColumn: " + opt.lookupColumn, "This column does not appear to be a lookup column");
+ return;
+ }
+ if (newUrl.length > 0) {
+ // Build the link to the Lookup column's list enclosed in a div with the id="SPLookupAddNew_" + lookupColumnStaticName
+ var newHref = lookupListUrl + newUrl;
+ // If requested, open the link in a new window and if requested, pass the ContentTypeID
+ newHref += opt.newWindow ?
+ ((opt.ContentTypeID.length > 0) ? "?ContentTypeID=" + opt.ContentTypeID : "") + "' target='_blank'" :
+ "?" + ((opt.ContentTypeID.length > 0) ? "ContentTypeID=" + opt.ContentTypeID + "&" : "") + "Source=" + utils.escapeUrl(location.href) + "'";
+ var newLink = "" + "
0) ? location.href.substring(0, location.href.indexOf("?")) : location.href;
+ // ... plus the Source if it exists
+ var thisSource = (typeof queryStringVals.Source === "string") ?
+ "Source=" + queryStringVals.Source.replace(/\//g, "%2f").replace(/:/g, "%3a") : "";
+
+ var newQS = [];
+ if (typeof QSList !== "undefined") {
+ newQS.push("List=" + QSList);
+ }
+ if (typeof QSRootFolder !== "undefined") {
+ newQS.push("RootFolder=" + QSRootFolder);
+ }
+ if (typeof QSContentTypeId !== "undefined") {
+ newQS.push("ContentTypeId=" + QSContentTypeId);
+ }
+
+ var newAction = thisUrl +
+ ((newQS.length > 0) ? ("?" + newQS.join("&") + "&") : "?") +
+ // Set the Source to point back to this page with the lastID this user has added
+ "Source=" + thisUrl +
+ "?ID=" + lastID +
+ // Pass the original source as RealSource, if present
+ ((thisSource.length > 0) ? ("%26RealSource=" + queryStringVals.Source) : "") +
+ // Pass the override RedirectURL, if present
+ ((typeof queryStringVals.RedirectURL === "string") ? ("%26RedirectURL=" + queryStringVals.RedirectURL) : "");
+
+ // Set the new form action
+ setTimeout(function() {
+ document.forms.aspnetForm.action = newAction;
+ }, 0);
+ });
+ // If this is the load after the item is saved, wait until the new item has been saved (commits are asynchronous),
+ // then do the redirect to redirectUrl with the new lastID, passing along the original Source.
+ } else {
+ while (queryStringVals.ID === lastID) {
+ lastID = $().SPServices.SPGetLastItemId({
+ listName: thisList
+ });
+ }
+ // If there is a RedirectURL parameter on the Query String, then redirect there instead of the value
+ // specified in the options (opt.redirectUrl)
+ var thisRedirectUrl = (typeof queryStringVals.RedirectURL === "string") ? queryStringVals.RedirectURL : opt.redirectUrl;
+ location.href = thisRedirectUrl + "?" + opt.qsParamName + "=" + lastID +
+ ((typeof queryStringVals.RealSource === "string") ? ("&Source=" + queryStringVals.RealSource) : "");
+ }
+ }; // End $.fn.SPServices.SPRedirectWithID
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ utils
+) {
+
+ "use strict";
+
+ // Function which checks to see if the value for a column on the form is unique in the list.
+ $.fn.SPServices.SPRequireUnique = function (options) {
+
+ var opt = $.extend({}, {
+ columnStaticName: "Title", // Name of the column
+ duplicateAction: 0, // 0 = warn, 1 = prevent
+ ignoreCase: false, // If set to true, the function ignores case, if false it looks for an exact match
+ initMsg: "This value must be unique.", // Initial message to display after setup
+ initMsgCSSClass: "ms-vb", // CSS class for initial message
+ errMsg: "This value is not unique.", // Error message to display if not unique
+ errMsgCSSClass: "ms-formvalidation", // CSS class for error message
+ showDupes: false, // If true, show links to the duplicate item(s) after the error message
+ completefunc: null // Function to call on completion of rendering the change.
+ }, options);
+
+ // Get the current item's ID from the Query String
+ var queryStringVals = $().SPServices.SPGetQueryString();
+ var thisID = queryStringVals.ID;
+ var thisList = $().SPServices.SPListNameFromUrl();
+
+ // Set the messages based on the options provided
+ var msg = "{1} " + columnValueIDs[i][1] + " ";
+ }
+ $("span#SPRequireUnique" + opt.columnStaticName).append(out);
+ }
+ }
+
+ });
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc();
+ }
+ }; // End $.fn.SPServices.SPRequireUnique
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ "../utils/constants",
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // Does an audit of a site's list forms to show where script is in use.
+ $.fn.SPServices.SPScriptAudit = function (options) {
+
+ var opt = $.extend({}, {
+ webURL: "", // [Optional] The name of the Web (site) to audit
+ listName: "", // [Optional] The name of a specific list to audit. If not present, all lists in the site are audited.
+ outputId: "", // The id of the DOM object for output
+ auditForms: true, // Audit the form pages
+ auditViews: true, // Audit the view pages
+ auditPages: true, // Audit the Pages Document Library
+ auditPagesListName: "Pages", // The Pages Document Library(ies), if desired. Either a single string or an array of strings.
+ showHiddenLists: false, // Show output for hidden lists
+ showNoScript: false, // Show output for lists with no scripts (effectively "verbose")
+ showSrc: true // Show the source location for included scripts
+ }, options);
+
+ var formTypes = [
+ ["New", "NewForm.aspx", false],
+ ["Display", "DispForm.aspx", false],
+ ["Edit", "EditForm.aspx", false]
+ ];
+ var listXml;
+
+ // Build the table to contain the results
+ $("#" + opt.outputId)
+ .append("
" +
+ "" +
+ "List " +
+ "Page Class " +
+ "Page Type " +
+ "Page " +
+ (opt.showSrc ? "Script References " : "") +
+ " " +
+ "
");
+ // Apply the CSS class to the headers
+ var scriptAuditContainer = $("#SPScriptAudit");
+ scriptAuditContainer.find("th").attr("class", "ms-vh2-nofilter");
+
+ // Don't bother with the lists if the options don't require them
+ if (opt.auditForms || opt.auditViews) {
+ // First, get all of the lists within the site
+ $().SPServices({
+ operation: "GetListCollection",
+ webURL: opt.webURL,
+ async: false, // Need this to be synchronous so we're assured of a valid value
+ completefunc: function (xData) {
+ $(xData.responseXML).find("List").each(function () {
+ listXml = $(this);
+
+ // If listName has been specified, then only return results for that list
+ if ((opt.listName.length === 0) || (listXml.attr("Title") === opt.listName)) {
+ // Don't work with hidden lists unless we're asked to
+ if ((opt.showHiddenLists && listXml.attr("Hidden") === "False") || !opt.showHiddenLists) {
+
+ // Audit the list's forms
+ if (opt.auditForms) {
+ // Get the list's Content Types, therefore the form pages
+ $().SPServices({
+ operation: "GetListContentTypes",
+ webURL: opt.webURL,
+ listName: listXml.attr("ID"),
+ async: false, // Need this to be synchronous so we're assured of a valid value
+ completefunc: function (xData) {
+ $(xData.responseXML).find("ContentType").each(function () {
+ // Don't deal with folders
+ if ($(this).attr("ID").substring(0, 6) !== "0x0120") {
+ var formUrls = $(this).find("FormUrls");
+ for (var i = 0; i < formTypes.length; i++) {
+ // Look for a customized form...
+ $(formUrls).find(formTypes[i][0]).each(function () {
+ SPScriptAuditPage(opt, listXml, "Form", this.nodeName, ((opt.webURL.length > 0) ? opt.webURL : $().SPServices.SPGetCurrentSite()) + constants.SLASH + $(this).text());
+ formTypes[i][2] = true;
+ });
+ // ...else the uncustomized form
+ if (!formTypes[i][2]) {
+ var defaultViewUrl = listXml.attr("DefaultViewUrl");
+ SPScriptAuditPage(opt, listXml, "Form", formTypes[i][0],
+ defaultViewUrl.substring(0, defaultViewUrl.lastIndexOf(constants.SLASH) + 1) + formTypes[i][1]);
+ }
+ }
+ // Reset the form types
+ for (i = 0; i < formTypes.length; i++) {
+ formTypes[i][2] = false;
+ }
+ }
+ });
+ }
+ });
+ }
+
+ // Audit the list's views
+ if (opt.auditViews) {
+ // Get the list's Views
+ $().SPServices({
+ operation: "GetViewCollection",
+ webURL: opt.webURL,
+ listName: listXml.attr("ID"),
+ async: false, // Need this to be synchronous so we're assured of a valid value
+ completefunc: function (xData) {
+ $(xData.responseXML).find("View").each(function () {
+ SPScriptAuditPage(opt, listXml, "View", $(this).attr("DisplayName"), $(this).attr("Url"));
+ });
+ }
+ });
+ }
+
+ }
+ }
+ });
+ }
+ });
+ }
+
+ // Don't bother with auditing pages if the options don't require it
+ var numLists = 0;
+ var listsArray = [];
+ if (typeof opt.auditPagesListName === "string") {
+ numLists = 1;
+ listsArray.push(opt.auditPagesListName);
+ } else {
+ numLists = opt.auditPagesListName.length;
+ listsArray = opt.auditPagesListName;
+ }
+
+ if (opt.auditPages) {
+ for (var i = 0; i < numLists; i++) {
+ $().SPServices({
+ operation: "GetList",
+ async: false,
+ cacheXML: true,
+ webURL: opt.webURL,
+ listName: listsArray[i],
+ completefunc: function (xData) {
+ $(xData.responseXML).find("List").each(function () {
+ listXml = $(this);
+ });
+ }
+ });
+ // Get all of the items from the Document Library
+ $().SPServices({
+ operation: "GetListItems",
+ async: false,
+ webURL: opt.webURL,
+ listName: listsArray[i],
+ CAMLQuery: "
Folder ",
+ CAMLViewFields: "
",
+ CAMLRowLimit: 0,
+ completefunc: function (xData) {
+ $(xData.responseXML).SPFilterNode("z:row").each(function () {
+ var thisPageUrl = $(this).attr("ows_FileRef").split(constants.spDelim)[1];
+ var thisTitle = $(this).attr("ows_Title");
+ var thisPageType = (typeof thisTitle !== "undefined") ? thisTitle : "";
+ if (thisPageUrl.indexOf(".aspx") > 0) {
+ SPScriptAuditPage(opt, listXml, "Page", thisPageType, constants.SLASH + thisPageUrl);
+ }
+ });
+ }
+ });
+ }
+ }
+ // Remove progress indicator and make the output pretty by cleaning up the ms-alternating CSS class
+ scriptAuditContainer.find("tr[class='ms-alternating']:even").removeAttr("class");
+ }; // End $.fn.SPServices.SPScriptAudit
+
+ // Displays the usage of scripts in a site
+ function SPScriptAuditPage(opt, listXml, pageClass, pageType, pageUrl) {
+
+ var jQueryPage = 0;
+ var pageScriptSrc = {};
+ pageScriptSrc.type = [];
+ pageScriptSrc.src = [];
+ pageScriptSrc.script = [];
+ var scriptRegex = RegExp("
", "gi");
+
+ // Fetch the page
+ $.ajax({
+ type: "GET",
+ url: pageUrl,
+ dataType: "text",
+ async: false,
+ success: function (xData) {
+
+ var scriptMatch;
+
+ while (scriptMatch = scriptRegex.exec(xData)) {
+ var scriptLanguage = getScriptAttribute(scriptMatch, "language");
+ var scriptType = getScriptAttribute(scriptMatch, "type");
+ var scriptSrc = getScriptAttribute(scriptMatch, "src");
+ if (scriptSrc !== null && scriptSrc.length > 0 && !coreScript(scriptSrc)) {
+ pageScriptSrc.type.push((scriptLanguage !== null && scriptLanguage.length > 0) ? scriptLanguage : scriptType);
+ pageScriptSrc.src.push(scriptSrc);
+ jQueryPage++;
+ }
+ }
+
+ // Only show pages without script if we've been asked to do so.
+ if ((!opt.showNoScript && (pageScriptSrc.type.length > 0)) || opt.showNoScript) {
+ var pagePath = pageUrl.substring(0, pageUrl.lastIndexOf(constants.SLASH) + 1);
+ var out = "" +
+ "" + listXml.attr("Title") + ((listXml.attr("Hidden") === "True") ? '(Hidden)' : '') + " " + pageClass + " " +
+ "" + pageType + " " +
+ "" + utils.fileName(pageUrl) + " ";
+ for (var i = 0; i < pageScriptSrc.type.length; i++) {
+ thisSrcPath = (pageScriptSrc.src[i].substr(0, 1) !== constants.SLASH) ? pagePath + pageScriptSrc.src[i] : pageScriptSrc.src[i];
+ out += "" + pageScriptSrc.type[i] + " ";
+ out += "" + utils.fileName(pageScriptSrc.src[i]) + "
" + $(this).html() + " ");
+ });
+ // ...then the right (selected values) select (in case some values have already been selected)
+ $(thisMultiSelect.master.resultControl).find("option").each(function () {
+ cloneObj.append("" + $(this).html() + " ");
+ });
+
+ // We'll add 5px for a little padding on the right.
+ var divWidth = cloneObj.width() + 5;
+ var newDivWidth = divWidth;
+ if (opt.minWidth > 0 || opt.maxWidth > 0) {
+ if (divWidth < opt.minWidth) {
+ divWidth = opt.minWidth;
+ }
+ if (newDivWidth < opt.minWidth) {
+ newDivWidth = opt.minWidth;
+ }
+ if (newDivWidth > opt.maxWidth) {
+ newDivWidth = opt.maxWidth;
+ }
+ }
+ var selectWidth = divWidth;
+
+ // Set the new widths
+ $(thisMultiSelect.master.candidateControl).css("width", selectWidth + "px").parent().css("width", newDivWidth + "px");
+ $(thisMultiSelect.master.resultControl).css("width", selectWidth + "px").parent().css("width", newDivWidth + "px");
+
+ // Remove the select's clone, since we're done with it
+ cloneObj.remove();
+
+ }; // End $.fn.SPServices.SPSetMultiSelectSizes
+
+ return $;
+
+});
+/*
+* spservices - Work with SharePoint's Web Services using jQuery
+* Version 2.0.0-pre-alpha
+* @requires jQuery v1.8 or greater - jQuery 1.10.x+ recommended
+*
+* Copyright (c) 2009-2016 Sympraxis Consulting LLC
+* Examples and docs at:
+* http://spservices.codeplex.com/
+* Licensed under the MIT license:
+* http://www.opensource.org/licenses/mit-license.php
+*/
+/*
+* @description SPServices is a jQuery library which abstracts SharePoint's Web Services and makes them easier to use. It also includes functions which use the various Web Service operations to provide more useful (and cool) capabilities. It works entirely client side and requires no server install.
+* @type jQuery
+* @name spservices
+* @category Plugins/spservices
+* @author Sympraxis Consulting LLC/marc.anderson@sympraxisconsulting.com
+*/
+define([
+ 'jquery',
+ '../utils/constants',
+ '../core/SPServices.utils',
+ //---------------------------
+ // We don't need local variables for these dependencies
+ // because they are added to the jQuery namespace.
+ '../core/SPServices.core'
+], function (
+ $,
+ constants,
+ utils
+) {
+
+ "use strict";
+
+ // SPUpdateMultipleListItems allows you to update multiple items in a list based upon some common characteristic or metadata criteria.
+ $.fn.SPServices.SPUpdateMultipleListItems = function (options) {
+
+ var opt = $.extend({}, {
+ webURL: "", // [Optional] URL of the target Web. If not specified, the current Web is used.
+ listName: "", // The list to operate on.
+ CAMLQuery: "", // A CAML fragment specifying which items in the list will be selected and updated
+ batchCmd: "Update", // The operation to perform. By default, Update.
+ valuepairs: [], // Valuepairs for the update in the form [[fieldname1, fieldvalue1], [fieldname2, fieldvalue2]...]
+ completefunc: null, // Function to call on completion of rendering the change.
+ debug: false // If true, show error messages;if false, run silent
+ }, options);
+
+ var i;
+ var itemsToUpdate = [];
+ var documentsToUpdate = [];
+
+ // Call GetListItems to find all of the items matching the CAMLQuery
+ $().SPServices({
+ operation: "GetListItems",
+ async: false,
+ webURL: opt.webURL,
+ listName: opt.listName,
+ CAMLQuery: opt.CAMLQuery,
+ CAMLQueryOptions: "";
+ for (i = 0; i < itemsToUpdate.length; i++) {
+ batch += "";
+ for (fieldNum = 0; fieldNum < opt.valuepairs.length; fieldNum++) {
+ batch += "" + utils.escapeColumnValue(opt.valuepairs[fieldNum][1]) + " ";
+ }
+ batch += "" + itemsToUpdate[i] + " ";
+ if (documentsToUpdate[i].length > 0) {
+ batch += "" + documentsToUpdate[i] + " ";
+ }
+ batch += " ";
+ }
+ batch += " ";
+
+ // Call UpdateListItems to update all of the items matching the CAMLQuery
+ $().SPServices({
+ operation: "UpdateListItems",
+ async: false,
+ webURL: opt.webURL,
+ listName: opt.listName,
+ updates: batch,
+ completefunc: function (xData) {
+ // If present, call completefunc when all else is done
+ if (opt.completefunc !== null) {
+ opt.completefunc(xData);
+ }
+ }
+ });
+
+ }; // End $.fn.SPServices.SPUpdateMultipleListItems
+
+ return $;
+
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["SPServices.core.js","core/SPServices.core.js","SPServices.utils.js","core/SPServices.utils.js","Version.js","core/Version.js","constants.js","utils/constants.js","SPConvertDateToISO.js","utils/SPConvertDateToISO.js","SPDebugXMLHttpResult.js","utils/SPDebugXMLHttpResult.js","SPDropdownCtl.js","utils/SPDropdownCtl.js","SPFilterNode.js","utils/SPFilterNode.js","SPGetCurrentSite.js","utils/SPGetCurrentSite.js","SPGetCurrentUser.js","utils/SPGetCurrentUser.js","SPGetDisplayFromStatic.js","utils/SPGetDisplayFromStatic.js","SPGetLastItemId.js","utils/SPGetLastItemId.js","SPGetListItemsJson.js","utils/SPGetListItemsJson.js","SPGetQueryString.js","utils/SPGetQueryString.js","SPGetStaticFromDisplay.js","utils/SPGetStaticFromDisplay.js","SPListNameFromUrl.js","utils/SPListNameFromUrl.js","SPXmlToJson.js","utils/SPXmlToJson.js","SPArrangeChoices.js","value-added/SPArrangeChoices.js","SPAutocomplete.js","value-added/SPAutocomplete.js","SPCascadeDropdowns.js","value-added/SPCascadeDropdowns.js","SPComplexToSimpleDropdown.js","value-added/SPComplexToSimpleDropdown.js","SPDisplayRelatedInfo.js","value-added/SPDisplayRelatedInfo.js","SPFilterDropdown.js","value-added/SPFilterDropdown.js","SPFindMMSPicker.js","value-added/SPFindMMSPicker.js","SPFindPeoplePicker.js","value-added/SPFindPeoplePicker.js","SPLookupAddNew.js","value-added/SPLookupAddNew.js","SPRedirectWithID.js","value-added/SPRedirectWithID.js","SPRequireUnique.js","value-added/SPRequireUnique.js","SPScriptAudit.js","value-added/SPScriptAudit.js","SPSetMultiSelectSizes.js","value-added/SPSetMultiSelectSizes.js","SPUpdateMultipleListItems.js","value-added/SPUpdateMultipleListItems.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/rDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACpGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/TA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/ZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"jQuery.SPServices-2.0.0-pre-alpha.js","sourcesContent":[null,"/**\r\n * Original SPServices core modules...\r\n */\r\ndefine([\r\n    \"jquery\",\r\n    \"../utils/constants\",\r\n    \"../core/SPServices.utils\"\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    /* jshint undef: true */\r\n\r\n    \"use strict\";\r\n\r\n    var SOAPAction = \"\";\r\n    var SOAPEnvelope = {\r\n        header: \"<soap:Envelope xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:soap='http://schemas.xmlsoap.org/soap/envelope/'><soap:Body>\",\r\n        footer: \"</soap:Body></soap:Envelope>\",\r\n        payload: \"\"\r\n    };\r\n\r\n    // Caching\r\n    var promisesCache = {};\r\n\r\n    //   Web Service names\r\n    var webServices = {\r\n        ALERTS: \"Alerts\",\r\n        AUTHENTICATION: \"Authentication\",\r\n        COPY: \"Copy\",\r\n        FORMS: \"Forms\",\r\n        LISTS: \"Lists\",\r\n        MEETINGS: \"Meetings\",\r\n        OFFICIALFILE: \"OfficialFile\",\r\n        PEOPLE: \"People\",\r\n        PERMISSIONS: \"Permissions\",\r\n        PUBLISHEDLINKSSERVICE: \"PublishedLinksService\",\r\n        SEARCH: \"Search\",\r\n        SHAREPOINTDIAGNOSTICS: \"SharePointDiagnostics\",\r\n        SITEDATA: \"SiteData\",\r\n        SITES: \"Sites\",\r\n        SOCIALDATASERVICE: \"SocialDataService\",\r\n        SPELLCHECK: \"SpellCheck\",\r\n        TAXONOMYSERVICE: \"TaxonomyClientService\",\r\n        USERGROUP: \"usergroup\",\r\n        USERPROFILESERVICE: \"UserProfileService\",\r\n        VERSIONS: \"Versions\",\r\n        VIEWS: \"Views\",\r\n        WEBPARTPAGES: \"WebPartPages\",\r\n        WEBS: \"Webs\",\r\n        WORKFLOW: \"Workflow\",\r\n        /* Nintex Web Service*/\r\n        NINTEXWORKFLOW: \"NintexWorkflow/Workflow\"        \r\n    };\r\n\r\n    var encodeOptionList = [\"listName\", \"description\"]; // Used to encode options which may contain special characters\r\n\r\n\r\n    // Array to store Web Service information\r\n    //  WSops.OpName = [WebService, needs_SOAPAction];\r\n    //      OpName              The name of the Web Service operation -> These names are unique\r\n    //      WebService          The name of the WebService this operation belongs to\r\n    //      needs_SOAPAction    Boolean indicating whether the operation needs to have the SOAPAction passed in the setRequestHeaderfunction.\r\n    //                          true if the operation does a write, else false\r\n\r\n    var WSops = {};\r\n\r\n    WSops.GetAlerts = [webServices.ALERTS, false];\r\n    WSops.DeleteAlerts = [webServices.ALERTS, true];\r\n\r\n    WSops.Mode = [webServices.AUTHENTICATION, false];\r\n    WSops.Login = [webServices.AUTHENTICATION, false];\r\n\r\n    WSops.CopyIntoItems = [webServices.COPY, true];\r\n    WSops.CopyIntoItemsLocal = [webServices.COPY, true];\r\n    WSops.GetItem = [webServices.COPY, false];\r\n\r\n    WSops.GetForm = [webServices.FORMS, false];\r\n    WSops.GetFormCollection = [webServices.FORMS, false];\r\n\r\n    WSops.AddAttachment = [webServices.LISTS, true];\r\n    WSops.AddDiscussionBoardItem = [webServices.LISTS, true];\r\n    WSops.AddList = [webServices.LISTS, true];\r\n    WSops.AddListFromFeature = [webServices.LISTS, true];\r\n    WSops.ApplyContentTypeToList = [webServices.LISTS, true];\r\n    WSops.CheckInFile = [webServices.LISTS, true];\r\n    WSops.CheckOutFile = [webServices.LISTS, true];\r\n    WSops.CreateContentType = [webServices.LISTS, true];\r\n    WSops.DeleteAttachment = [webServices.LISTS, true];\r\n    WSops.DeleteContentType = [webServices.LISTS, true];\r\n    WSops.DeleteContentTypeXmlDocument = [webServices.LISTS, true];\r\n    WSops.DeleteList = [webServices.LISTS, true];\r\n    WSops.GetAttachmentCollection = [webServices.LISTS, false];\r\n    WSops.GetList = [webServices.LISTS, false];\r\n    WSops.GetListAndView = [webServices.LISTS, false];\r\n    WSops.GetListCollection = [webServices.LISTS, false];\r\n    WSops.GetListContentType = [webServices.LISTS, false];\r\n    WSops.GetListContentTypes = [webServices.LISTS, false];\r\n    WSops.GetListItemChanges = [webServices.LISTS, false];\r\n    WSops.GetListItemChangesSinceToken = [webServices.LISTS, false];\r\n    WSops.GetListItems = [webServices.LISTS, false];\r\n    WSops.GetVersionCollection = [webServices.LISTS, false];\r\n    WSops.UndoCheckOut = [webServices.LISTS, true];\r\n    WSops.UpdateContentType = [webServices.LISTS, true];\r\n    WSops.UpdateContentTypesXmlDocument = [webServices.LISTS, true];\r\n    WSops.UpdateContentTypeXmlDocument = [webServices.LISTS, true];\r\n    WSops.UpdateList = [webServices.LISTS, true];\r\n    WSops.UpdateListItems = [webServices.LISTS, true];\r\n\r\n    WSops.AddMeeting = [webServices.MEETINGS, true];\r\n    WSops.CreateWorkspace = [webServices.MEETINGS, true];\r\n    WSops.RemoveMeeting = [webServices.MEETINGS, true];\r\n    WSops.SetWorkSpaceTitle = [webServices.MEETINGS, true];\r\n\r\n    WSops.GetRecordRouting = [webServices.OFFICIALFILE, false];\r\n    WSops.GetRecordRoutingCollection = [webServices.OFFICIALFILE, false];\r\n    WSops.GetServerInfo = [webServices.OFFICIALFILE, false];\r\n    WSops.SubmitFile = [webServices.OFFICIALFILE, true];\r\n\r\n    WSops.ResolvePrincipals = [webServices.PEOPLE, true];\r\n    WSops.SearchPrincipals = [webServices.PEOPLE, false];\r\n\r\n    WSops.AddPermission = [webServices.PERMISSIONS, true];\r\n    WSops.AddPermissionCollection = [webServices.PERMISSIONS, true];\r\n    WSops.GetPermissionCollection = [webServices.PERMISSIONS, true];\r\n    WSops.RemovePermission = [webServices.PERMISSIONS, true];\r\n    WSops.RemovePermissionCollection = [webServices.PERMISSIONS, true];\r\n    WSops.UpdatePermission = [webServices.PERMISSIONS, true];\r\n\r\n    WSops.GetLinks = [webServices.PUBLISHEDLINKSSERVICE, true];\r\n\r\n    WSops.GetPortalSearchInfo = [webServices.SEARCH, false];\r\n    WSops.GetQuerySuggestions = [webServices.SEARCH, false];\r\n    WSops.GetSearchMetadata = [webServices.SEARCH, false];\r\n    WSops.Query = [webServices.SEARCH, false];\r\n    WSops.QueryEx = [webServices.SEARCH, false];\r\n    WSops.Registration = [webServices.SEARCH, false];\r\n    WSops.Status = [webServices.SEARCH, false];\r\n\r\n    WSops.SendClientScriptErrorReport = [webServices.SHAREPOINTDIAGNOSTICS, true];\r\n\r\n    WSops.GetAttachments = [webServices.SITEDATA, false];\r\n    WSops.EnumerateFolder = [webServices.SITEDATA, false];\r\n    WSops.SiteDataGetList = [webServices.SITEDATA, false];\r\n    WSops.SiteDataGetListCollection = [webServices.SITEDATA, false];\r\n    WSops.SiteDataGetSite = [webServices.SITEDATA, false];\r\n    WSops.SiteDataGetSiteUrl = [webServices.SITEDATA, false];\r\n    WSops.SiteDataGetWeb = [webServices.SITEDATA, false];\r\n\r\n    WSops.CreateWeb = [webServices.SITES, true];\r\n    WSops.DeleteWeb = [webServices.SITES, true];\r\n    WSops.GetSite = [webServices.SITES, false];\r\n    WSops.GetSiteTemplates = [webServices.SITES, false];\r\n\r\n    WSops.AddComment = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.AddTag = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.AddTagByKeyword = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.CountCommentsOfUser = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.CountCommentsOfUserOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.CountCommentsOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.CountRatingsOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.CountTagsOfUser = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.DeleteComment = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.DeleteRating = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.DeleteTag = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.DeleteTagByKeyword = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.DeleteTags = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetAllTagTerms = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetAllTagTermsForUrlFolder = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetAllTagUrls = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetAllTagUrlsByKeyword = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetCommentsOfUser = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetCommentsOfUserOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetCommentsOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetRatingAverageOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetRatingOfUserOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetRatingOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetRatingsOfUser = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetRatingsOnUrl = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetSocialDataForFullReplication = [webServices.SOCIALDATASERVICE, false];\r\n    WSops.GetTags = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagsOfUser = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagTerms = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagTermsOfUser = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagTermsOnUrl = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagUrlsOfUser = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagUrlsOfUserByKeyword = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagUrls = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.GetTagUrlsByKeyword = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.SetRating = [webServices.SOCIALDATASERVICE, true];\r\n    WSops.UpdateComment = [webServices.SOCIALDATASERVICE, true];\r\n\r\n    WSops.SpellCheck = [webServices.SPELLCHECK, false];\r\n\r\n    // Taxonomy Service Calls\r\n    // Updated 2011.01.27 by Thomas McMillan\r\n    WSops.AddTerms = [webServices.TAXONOMYSERVICE, true];\r\n    WSops.GetChildTermsInTerm = [webServices.TAXONOMYSERVICE, false];\r\n    WSops.GetChildTermsInTermSet = [webServices.TAXONOMYSERVICE, false];\r\n    WSops.GetKeywordTermsByGuids = [webServices.TAXONOMYSERVICE, false];\r\n    WSops.GetTermsByLabel = [webServices.TAXONOMYSERVICE, false];\r\n    WSops.GetTermSets = [webServices.TAXONOMYSERVICE, false];\r\n\r\n    WSops.AddGroup = [webServices.USERGROUP, true];\r\n    WSops.AddGroupToRole = [webServices.USERGROUP, true];\r\n    WSops.AddRole = [webServices.USERGROUP, true];\r\n    WSops.AddRoleDef = [webServices.USERGROUP, true];\r\n    WSops.AddUserCollectionToGroup = [webServices.USERGROUP, true];\r\n    WSops.AddUserCollectionToRole = [webServices.USERGROUP, true];\r\n    WSops.AddUserToGroup = [webServices.USERGROUP, true];\r\n    WSops.AddUserToRole = [webServices.USERGROUP, true];\r\n    WSops.GetAllUserCollectionFromWeb = [webServices.USERGROUP, false];\r\n    WSops.GetGroupCollection = [webServices.USERGROUP, false];\r\n    WSops.GetGroupCollectionFromRole = [webServices.USERGROUP, false];\r\n    WSops.GetGroupCollectionFromSite = [webServices.USERGROUP, false];\r\n    WSops.GetGroupCollectionFromUser = [webServices.USERGROUP, false];\r\n    WSops.GetGroupCollectionFromWeb = [webServices.USERGROUP, false];\r\n    WSops.GetGroupInfo = [webServices.USERGROUP, false];\r\n    WSops.GetRoleCollection = [webServices.USERGROUP, false];\r\n    WSops.GetRoleCollectionFromGroup = [webServices.USERGROUP, false];\r\n    WSops.GetRoleCollectionFromUser = [webServices.USERGROUP, false];\r\n    WSops.GetRoleCollectionFromWeb = [webServices.USERGROUP, false];\r\n    WSops.GetRoleInfo = [webServices.USERGROUP, false];\r\n    WSops.GetRolesAndPermissionsForCurrentUser = [webServices.USERGROUP, false];\r\n    WSops.GetRolesAndPermissionsForSite = [webServices.USERGROUP, false];\r\n    WSops.GetUserCollection = [webServices.USERGROUP, false];\r\n    WSops.GetUserCollectionFromGroup = [webServices.USERGROUP, false];\r\n    WSops.GetUserCollectionFromRole = [webServices.USERGROUP, false];\r\n    WSops.GetUserCollectionFromSite = [webServices.USERGROUP, false];\r\n    WSops.GetUserCollectionFromWeb = [webServices.USERGROUP, false];\r\n    WSops.GetUserInfo = [webServices.USERGROUP, false];\r\n    WSops.GetUserLoginFromEmail = [webServices.USERGROUP, false];\r\n    WSops.RemoveGroup = [webServices.USERGROUP, true];\r\n    WSops.RemoveGroupFromRole = [webServices.USERGROUP, true];\r\n    WSops.RemoveRole = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserCollectionFromGroup = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserCollectionFromRole = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserCollectionFromSite = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserFromGroup = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserFromRole = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserFromSite = [webServices.USERGROUP, true];\r\n    WSops.RemoveUserFromWeb = [webServices.USERGROUP, true];\r\n    WSops.UpdateGroupInfo = [webServices.USERGROUP, true];\r\n    WSops.UpdateRoleDefInfo = [webServices.USERGROUP, true];\r\n    WSops.UpdateRoleInfo = [webServices.USERGROUP, true];\r\n    WSops.UpdateUserInfo = [webServices.USERGROUP, true];\r\n\r\n    WSops.AddColleague = [webServices.USERPROFILESERVICE, true];\r\n    WSops.AddLink = [webServices.USERPROFILESERVICE, true];\r\n    WSops.AddMembership = [webServices.USERPROFILESERVICE, true];\r\n    WSops.AddPinnedLink = [webServices.USERPROFILESERVICE, true];\r\n    WSops.CreateMemberGroup = [webServices.USERPROFILESERVICE, true];\r\n    WSops.CreateUserProfileByAccountName = [webServices.USERPROFILESERVICE, true];\r\n    WSops.GetCommonColleagues = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetCommonManager = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetCommonMemberships = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetInCommon = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetPropertyChoiceList = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserColleagues = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserLinks = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserMemberships = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserPinnedLinks = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserProfileByGuid = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserProfileByIndex = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserProfileByName = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserProfileCount = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserProfileSchema = [webServices.USERPROFILESERVICE, false];\r\n    WSops.GetUserPropertyByAccountName = [webServices.USERPROFILESERVICE, false];\r\n    WSops.ModifyUserPropertyByAccountName = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveAllColleagues = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveAllLinks = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveAllMemberships = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveAllPinnedLinks = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveColleague = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveLink = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemoveMembership = [webServices.USERPROFILESERVICE, true];\r\n    WSops.RemovePinnedLink = [webServices.USERPROFILESERVICE, true];\r\n    WSops.UpdateColleaguePrivacy = [webServices.USERPROFILESERVICE, true];\r\n    WSops.UpdateLink = [webServices.USERPROFILESERVICE, true];\r\n    WSops.UpdateMembershipPrivacy = [webServices.USERPROFILESERVICE, true];\r\n    WSops.UpdatePinnedLink = [webServices.USERPROFILESERVICE, true];\r\n\r\n    WSops.DeleteAllVersions = [webServices.VERSIONS, true];\r\n    WSops.DeleteVersion = [webServices.VERSIONS, true];\r\n    WSops.GetVersions = [webServices.VERSIONS, false];\r\n    WSops.RestoreVersion = [webServices.VERSIONS, true];\r\n\r\n    WSops.AddView = [webServices.VIEWS, true];\r\n    WSops.DeleteView = [webServices.VIEWS, true];\r\n    WSops.GetView = [webServices.VIEWS, false];\r\n    WSops.GetViewHtml = [webServices.VIEWS, false];\r\n    WSops.GetViewCollection = [webServices.VIEWS, false];\r\n    WSops.UpdateView = [webServices.VIEWS, true];\r\n    WSops.UpdateViewHtml = [webServices.VIEWS, true];\r\n\r\n    WSops.AddWebPart = [webServices.WEBPARTPAGES, true];\r\n    WSops.AddWebPartToZone = [webServices.WEBPARTPAGES, true];\r\n    WSops.DeleteWebPart = [webServices.WEBPARTPAGES, true];\r\n    WSops.GetWebPart2 = [webServices.WEBPARTPAGES, false];\r\n    WSops.GetWebPartPage = [webServices.WEBPARTPAGES, false];\r\n    WSops.GetWebPartProperties = [webServices.WEBPARTPAGES, false];\r\n    WSops.GetWebPartProperties2 = [webServices.WEBPARTPAGES, false];\r\n    WSops.SaveWebPart2 = [webServices.WEBPARTPAGES, true];\r\n\r\n    WSops.WebsCreateContentType = [webServices.WEBS, true];\r\n    WSops.GetColumns = [webServices.WEBS, false];\r\n    WSops.GetContentType = [webServices.WEBS, false];\r\n    WSops.GetContentTypes = [webServices.WEBS, false];\r\n    WSops.GetCustomizedPageStatus = [webServices.WEBS, false];\r\n    WSops.GetListTemplates = [webServices.WEBS, false];\r\n    WSops.GetObjectIdFromUrl = [webServices.WEBS, false]; // 2010\r\n    WSops.GetWeb = [webServices.WEBS, false];\r\n    WSops.GetWebCollection = [webServices.WEBS, false];\r\n    WSops.GetAllSubWebCollection = [webServices.WEBS, false];\r\n    WSops.UpdateColumns = [webServices.WEBS, true];\r\n    WSops.WebsUpdateContentType = [webServices.WEBS, true];\r\n    WSops.WebUrlFromPageUrl = [webServices.WEBS, false];\r\n\r\n    WSops.AlterToDo = [webServices.WORKFLOW, true];\r\n    WSops.ClaimReleaseTask = [webServices.WORKFLOW, true];\r\n    WSops.GetTemplatesForItem = [webServices.WORKFLOW, false];\r\n    WSops.GetToDosForItem = [webServices.WORKFLOW, false];\r\n    WSops.GetWorkflowDataForItem = [webServices.WORKFLOW, false];\r\n    WSops.GetWorkflowTaskData = [webServices.WORKFLOW, false];\r\n    WSops.StartWorkflow = [webServices.WORKFLOW, true];\r\n\r\n\t//Nintex \r\n    WSops.AddLongTermDelegationRule = [webServices.NINTEXWORKFLOW, true];\r\n    WSops.AddWorkflowSchedule = [webServices.NINTEXWORKFLOW, true];\r\n    WSops.AddWorkflowScheduleOnListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.CheckGlobalReuseStatus = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.CheckInForms = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.DelegateAllTasks = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.DelegateTask = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.DeleteLongTermDelegationRule = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.DeleteSnippet = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.DeleteWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ExportWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n    WSops.FixWorkflowsInSiteFromTemplate = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetFolders = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetItemsPendingMyApproval = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetListContentTypes = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetOutcomesForFlexiTask = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetRunningWorkflowTasks = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetRunningWorkflowTasksCollection = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetRunningWorkflowTasksForCurrentUser = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetRunningWorkflowTasksForCurrentUserForListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetRunningWorkflowTasksForListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetTaskDetailsUsingStub = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetTaskStubsForCurrentUser = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetWorkflowHistory = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.GetWorkflowHistoryForListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.HideTaskForApprover = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.HideWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessFlexiTaskResponse = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessFlexiTaskResponse2 = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessTaskResponse = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessTaskResponse2 = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessTaskResponse3 = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.ProcessTaskResponseUsingToken = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWF = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFSkipValidation = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFSkipValidationNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFXml = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFXmlNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFXmlSkipValidation = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishFromNWFXmlSkipValidationNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.PublishWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.QueryForMessages = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.RemoveWorkflowSchedule = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.RemoveWorkflowScheduleOnListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveFromNWF = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveFromNWFNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveFromNWFXml = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveFromNWFXmlNoOverwrite = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveSnippet = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveTemplate = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveTemplate2 = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SaveWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.SnippetExists = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.StartSiteWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.NintexStartWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.StartWorkflowOnListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.TemplateExists = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.TerminateWorkflow = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.TerminateWorkflowByName = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.TerminateWorkflowByNameForListItem = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.WorkflowExists = [webServices.NINTEXWORKFLOW, true];\r\n\tWSops.WorkflowFormProductSelected = [webServices.NINTEXWORKFLOW, true];\r\n\r\n\r\n    // Main function, which calls SharePoint's Web Services directly.\r\n    $.fn.SPServices = function (options) {\r\n\r\n        // If there are no options passed in, use the defaults.  Extend replaces each default with the passed option.\r\n        var opt = $.extend({}, $.fn.SPServices.defaults, options);\r\n\r\n        // Encode options which may contain special character, esp. ampersand\r\n        for (var i = 0; i < encodeOptionList.length; i++) {\r\n            if (typeof opt[encodeOptionList[i]] === \"string\") {\r\n                opt[encodeOptionList[i]] = utils.encodeXml(opt[encodeOptionList[i]]);\r\n            }\r\n        }\r\n\r\n        // Put together operation header and SOAPAction for the SOAP call based on which Web Service we're calling\r\n        SOAPEnvelope.opheader = \"<\" + opt.operation + \" \";\r\n\r\n\r\n\r\n        switch (WSops[opt.operation][0]) {\r\n            case webServices.ALERTS:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/2002/1/alerts/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/2002/1/alerts/\";\r\n                break;\r\n            case webServices.MEETINGS:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/meetings/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/meetings/\";\r\n                break;\r\n            case webServices.OFFICIALFILE:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/recordsrepository/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/recordsrepository/\";\r\n                break;\r\n            case webServices.PERMISSIONS:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/directory/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/directory/\";\r\n                break;\r\n            case webServices.PUBLISHEDLINKSSERVICE:\r\n                SOAPEnvelope.opheader += \"xmlns='http://microsoft.com/webservices/SharePointPortalServer/PublishedLinksService/' >\";\r\n                SOAPAction = \"http://microsoft.com/webservices/SharePointPortalServer/PublishedLinksService/\";\r\n                break;\r\n            case webServices.SEARCH:\r\n                SOAPEnvelope.opheader += \"xmlns='urn:Microsoft.Search' >\";\r\n                SOAPAction = \"urn:Microsoft.Search/\";\r\n                break;\r\n            case webServices.SHAREPOINTDIAGNOSTICS:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/diagnostics/' >\";\r\n                SOAPAction = \"http://schemas.microsoft.com/sharepoint/diagnostics/\";\r\n                break;\r\n            case webServices.SOCIALDATASERVICE:\r\n                SOAPEnvelope.opheader += \"xmlns='http://microsoft.com/webservices/SharePointPortalServer/SocialDataService' >\";\r\n                SOAPAction = \"http://microsoft.com/webservices/SharePointPortalServer/SocialDataService/\";\r\n                break;\r\n            case webServices.SPELLCHECK:\r\n                SOAPEnvelope.opheader += \"xmlns='http://schemas.microsoft.com/sharepoint/publishing/spelling/' >\";\r\n                SOAPAction = \"http://schemas.microsoft.com/sharepoint/publishing/spelling/SpellCheck\";\r\n                break;\r\n            case webServices.TAXONOMYSERVICE:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/taxonomy/soap/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/taxonomy/soap/\";\r\n                break;\r\n            case webServices.USERGROUP:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/directory/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/directory/\";\r\n                break;\r\n            case webServices.USERPROFILESERVICE:\r\n                SOAPEnvelope.opheader += \"xmlns='http://microsoft.com/webservices/SharePointPortalServer/UserProfileService' >\";\r\n                SOAPAction = \"http://microsoft.com/webservices/SharePointPortalServer/UserProfileService/\";\r\n                break;\r\n            case webServices.WEBPARTPAGES:\r\n                SOAPEnvelope.opheader += \"xmlns='http://microsoft.com/sharepoint/webpartpages' >\";\r\n                SOAPAction = \"http://microsoft.com/sharepoint/webpartpages/\";\r\n                break;\r\n            case webServices.WORKFLOW:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/workflow/' >\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/workflow/\";\r\n                break;\r\n            default:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMASharePoint + \"/soap/'>\";\r\n                SOAPAction = constants.SCHEMASharePoint + \"/soap/\";\r\n                break;\r\n        }\r\n\r\n        // Add the operation to the SOAPAction and opfooter\r\n        SOAPAction += opt.operation;\r\n        SOAPEnvelope.opfooter = \"</\" + opt.operation + \">\";\r\n\r\n        // Build the URL for the Ajax call based on which operation we're calling\r\n        // If the webURL has been provided, then use it, else use the current site\r\n        var ajaxURL = \"_vti_bin/\" + WSops[opt.operation][0] + \".asmx\";\r\n        var webURL = opt.webURL !== undefined ? opt.webURL : opt.webUrl;\r\n        if (webURL.charAt(webURL.length - 1) === constants.SLASH) {\r\n            ajaxURL = webURL + ajaxURL;\r\n        } else if (webURL.length > 0) {\r\n            ajaxURL = webURL + constants.SLASH + ajaxURL;\r\n        } else {\r\n            var thisSite = $().SPServices.SPGetCurrentSite();\r\n            ajaxURL = thisSite + ((thisSite.charAt(thisSite.length - 1) === constants.SLASH) ? ajaxURL : (constants.SLASH + ajaxURL));\r\n        }\r\n\r\n        SOAPEnvelope.payload = \"\";\r\n        // Each operation requires a different set of values.  This switch statement sets them up in the SOAPEnvelope.payload.\r\n        switch (opt.operation) {\r\n            // ALERT OPERATIONS\r\n            case \"GetAlerts\":\r\n                break;\r\n            case \"DeleteAlerts\":\r\n                SOAPEnvelope.payload += \"<IDs>\";\r\n                for (i = 0; i < opt.IDs.length; i++) {\r\n                    SOAPEnvelope.payload += constants.wrapNode(\"string\", opt.IDs[i]);\r\n                }\r\n                SOAPEnvelope.payload += \"</IDs>\";\r\n                break;\r\n\r\n            // AUTHENTICATION OPERATIONS\r\n            case \"Mode\":\r\n                break;\r\n            case \"Login\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"username\", \"password\"]);\r\n                break;\r\n\r\n            // COPY OPERATIONS\r\n            case \"CopyIntoItems\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"SourceUrl\"]);\r\n                SOAPEnvelope.payload += \"<DestinationUrls>\";\r\n                for (i = 0; i < opt.DestinationUrls.length; i++) {\r\n                    SOAPEnvelope.payload += utils.wrapNode(\"string\", opt.DestinationUrls[i]);\r\n                }\r\n                SOAPEnvelope.payload += \"</DestinationUrls>\";\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"Fields\", \"Stream\", \"Results\"]);\r\n                break;\r\n            case \"CopyIntoItemsLocal\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"SourceUrl\"]);\r\n                SOAPEnvelope.payload += \"<DestinationUrls>\";\r\n                for (i = 0; i < opt.DestinationUrls.length; i++) {\r\n                    SOAPEnvelope.payload += utils.wrapNode(\"string\", opt.DestinationUrls[i]);\r\n                }\r\n                SOAPEnvelope.payload += \"</DestinationUrls>\";\r\n                break;\r\n            case \"GetItem\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"Url\", \"Fields\", \"Stream\"]);\r\n                break;\r\n\r\n            // FORM OPERATIONS\r\n            case \"GetForm\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"formUrl\"]);\r\n                break;\r\n            case \"GetFormCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                break;\r\n\r\n            // LIST OPERATIONS\r\n            case \"AddAttachment\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"listItemID\", \"fileName\", \"attachment\"]);\r\n                break;\r\n            case \"AddDiscussionBoardItem\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"message\"]);\r\n                break;\r\n            case \"AddList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"description\", \"templateID\"]);\r\n                break;\r\n            case \"AddListFromFeature\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"description\", \"featureID\", \"templateID\"]);\r\n                break;\r\n            case \"ApplyContentTypeToList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"webUrl\", \"contentTypeId\", \"listName\"]);\r\n                break;\r\n            case \"CheckInFile\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"comment\", \"CheckinType\"]);\r\n                break;\r\n            case \"CheckOutFile\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"checkoutToLocal\", \"lastmodified\"]);\r\n                break;\r\n            case \"CreateContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"displayName\", \"parentType\", \"fields\", \"contentTypeProperties\", \"addToView\"]);\r\n                break;\r\n            case \"DeleteAttachment\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"listItemID\", \"url\"]);\r\n                break;\r\n            case \"DeleteContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"contentTypeId\"]);\r\n                break;\r\n            case \"DeleteContentTypeXmlDocument\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"contentTypeId\", \"documentUri\"]);\r\n                break;\r\n            case \"DeleteList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                break;\r\n            case \"GetAttachmentCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", [\"listItemID\", \"ID\"]]);\r\n                break;\r\n            case \"GetList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                break;\r\n            case \"GetListAndView\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\"]);\r\n                break;\r\n            case \"GetListCollection\":\r\n                break;\r\n            case \"GetListContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"contentTypeId\"]);\r\n                break;\r\n            case \"GetListContentTypes\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                break;\r\n            case \"GetListItems\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\", [\"query\", \"CAMLQuery\"],\r\n                    [\"viewFields\", \"CAMLViewFields\"],\r\n                    [\"rowLimit\", \"CAMLRowLimit\"],\r\n                    [\"queryOptions\", \"CAMLQueryOptions\"]\r\n                ]);\r\n                break;\r\n            case \"GetListItemChanges\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewFields\", \"since\", \"contains\"]);\r\n                break;\r\n            case \"GetListItemChangesSinceToken\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\", [\"query\", \"CAMLQuery\"],\r\n                    [\"viewFields\", \"CAMLViewFields\"],\r\n                    [\"rowLimit\", \"CAMLRowLimit\"],\r\n                    [\"queryOptions\", \"CAMLQueryOptions\"], {\r\n                        name: \"changeToken\",\r\n                        sendNull: false\r\n                    }, {\r\n                        name: \"contains\",\r\n                        sendNull: false\r\n                    }\r\n                ]);\r\n                break;\r\n            case \"GetVersionCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"strlistID\", \"strlistItemID\", \"strFieldName\"]);\r\n                break;\r\n            case \"UndoCheckOut\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\"]);\r\n                break;\r\n            case \"UpdateContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"contentTypeId\", \"contentTypeProperties\", \"newFields\", \"updateFields\", \"deleteFields\", \"addToView\"]);\r\n                break;\r\n            case \"UpdateContentTypesXmlDocument\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"newDocument\"]);\r\n                break;\r\n            case \"UpdateContentTypeXmlDocument\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"contentTypeId\", \"newDocument\"]);\r\n                break;\r\n            case \"UpdateList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"listProperties\", \"newFields\", \"updateFields\", \"deleteFields\", \"listVersion\"]);\r\n                break;\r\n            case \"UpdateListItems\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                if (typeof opt.updates !== \"undefined\" && opt.updates.length > 0) {\r\n                    utils.addToPayload(opt, SOAPEnvelope, [\"updates\"]);\r\n                } else {\r\n                    SOAPEnvelope.payload += \"<updates><Batch OnError='Continue'><Method ID='1' Cmd='\" + opt.batchCmd + \"'>\";\r\n                    for (i = 0; i < opt.valuepairs.length; i++) {\r\n                        SOAPEnvelope.payload += \"<Field Name='\" + opt.valuepairs[i][0] + \"'>\" + utils.escapeColumnValue(opt.valuepairs[i][1]) + \"</Field>\";\r\n                    }\r\n                    if (opt.batchCmd !== \"New\") {\r\n                        SOAPEnvelope.payload += \"<Field Name='ID'>\" + opt.ID + \"</Field>\";\r\n                    }\r\n                    SOAPEnvelope.payload += \"</Method></Batch></updates>\";\r\n                }\r\n                break;\r\n\r\n            // MEETINGS OPERATIONS\r\n            case \"AddMeeting\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"organizerEmail\", \"uid\", \"sequence\", \"utcDateStamp\", \"title\", \"location\", \"utcDateStart\", \"utcDateEnd\", \"nonGregorian\"]);\r\n                break;\r\n            case \"CreateWorkspace\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"title\", \"templateName\", \"lcid\", \"timeZoneInformation\"]);\r\n                break;\r\n            case \"RemoveMeeting\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"recurrenceId\", \"uid\", \"sequence\", \"utcDateStamp\", \"cancelMeeting\"]);\r\n                break;\r\n            case \"SetWorkspaceTitle\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"title\"]);\r\n                break;\r\n\r\n            // OFFICIALFILE OPERATIONS\r\n            case \"GetRecordRouting\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"recordRouting\"]);\r\n                break;\r\n            case \"GetRecordRoutingCollection\":\r\n                break;\r\n            case \"GetServerInfo\":\r\n                break;\r\n            case \"SubmitFile\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileToSubmit\"], [\"properties\"], [\"recordRouting\"], [\"sourceUrl\"], [\"userName\"]);\r\n                break;\r\n\r\n\r\n            // PEOPLE OPERATIONS\r\n            case \"ResolvePrincipals\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"principalKeys\", \"principalType\", \"addToUserInfoList\"]);\r\n                break;\r\n            case \"SearchPrincipals\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"searchText\", \"maxResults\", \"principalType\"]);\r\n                break;\r\n\r\n            // PERMISSION OPERATIONS\r\n            case \"AddPermission\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\", \"permissionIdentifier\", \"permissionType\", \"permissionMask\"]);\r\n                break;\r\n            case \"AddPermissionCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\", \"permissionsInfoXml\"]);\r\n                break;\r\n            case \"GetPermissionCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\"]);\r\n                break;\r\n            case \"RemovePermission\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\", \"permissionIdentifier\", \"permissionType\"]);\r\n                break;\r\n            case \"RemovePermissionCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\", \"memberIdsXml\"]);\r\n                break;\r\n            case \"UpdatePermission\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectName\", \"objectType\", \"permissionIdentifier\", \"permissionType\", \"permissionMask\"]);\r\n                break;\r\n\r\n            // PUBLISHEDLINKSSERVICE OPERATIONS\r\n            case \"GetLinks\":\r\n                break;\r\n\r\n            // SEARCH OPERATIONS\r\n            case \"GetPortalSearchInfo\":\r\n                SOAPEnvelope.opheader = \"<\" + opt.operation + \" xmlns='http://microsoft.com/webservices/OfficeServer/QueryService'>\";\r\n                SOAPAction = \"http://microsoft.com/webservices/OfficeServer/QueryService/\" + opt.operation;\r\n                break;\r\n            case \"GetQuerySuggestions\":\r\n                SOAPEnvelope.opheader = \"<\" + opt.operation + \" xmlns='http://microsoft.com/webservices/OfficeServer/QueryService'>\";\r\n                SOAPAction = \"http://microsoft.com/webservices/OfficeServer/QueryService/\" + opt.operation;\r\n                SOAPEnvelope.payload += utils.wrapNode(\"queryXml\", constants.encodeXml(opt.queryXml));\r\n                break;\r\n            case \"GetSearchMetadata\":\r\n                SOAPEnvelope.opheader = \"<\" + opt.operation + \" xmlns='http://microsoft.com/webservices/OfficeServer/QueryService'>\";\r\n                SOAPAction = \"http://microsoft.com/webservices/OfficeServer/QueryService/\" + opt.operation;\r\n                break;\r\n            case \"Query\":\r\n                SOAPEnvelope.payload += utils.wrapNode(\"queryXml\", constants.encodeXml(opt.queryXml));\r\n                break;\r\n            case \"QueryEx\":\r\n                SOAPEnvelope.opheader = \"<\" + opt.operation + \" xmlns='http://microsoft.com/webservices/OfficeServer/QueryService'>\";\r\n                SOAPAction = \"http://microsoft.com/webservices/OfficeServer/QueryService/\" + opt.operation;\r\n                SOAPEnvelope.payload += utils.wrapNode(\"queryXml\", constants.encodeXml(opt.queryXml));\r\n                break;\r\n            case \"Registration\":\r\n                SOAPEnvelope.payload += utils.wrapNode(\"registrationXml\", constants.encodeXml(opt.registrationXml));\r\n                break;\r\n            case \"Status\":\r\n                break;\r\n\r\n            // SHAREPOINTDIAGNOSTICS OPERATIONS\r\n            case \"SendClientScriptErrorReport\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"message\", \"file\", \"line\", \"client\", \"stack\", \"team\", \"originalFile\"]);\r\n                break;\r\n\r\n            // SITEDATA OPERATIONS\r\n            case \"EnumerateFolder\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"strFolderUrl\"]);\r\n                break;\r\n            case \"GetAttachments\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"strListName\", \"strItemId\"]);\r\n                break;\r\n            case \"SiteDataGetList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"strListName\"]);\r\n                // Because this operation has a name which duplicates the Lists WS, need to handle\r\n                SOAPEnvelope = constants.siteDataFixSOAPEnvelope(SOAPEnvelope, opt.operation);\r\n                break;\r\n            case \"SiteDataGetListCollection\":\r\n                // Because this operation has a name which duplicates the Lists WS, need to handle\r\n                SOAPEnvelope = constants.siteDataFixSOAPEnvelope(SOAPEnvelope, opt.operation);\r\n                break;\r\n            case \"SiteDataGetSite\":\r\n                // Because this operation has a name which duplicates the Lists WS, need to handle\r\n                SOAPEnvelope = constants.siteDataFixSOAPEnvelope(SOAPEnvelope, opt.operation);\r\n                break;\r\n            case \"SiteDataGetSiteUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"Url\"]);\r\n                // Because this operation has a name which duplicates the Lists WS, need to handle\r\n                SOAPEnvelope = constants.siteDataFixSOAPEnvelope(SOAPEnvelope, opt.operation);\r\n                break;\r\n            case \"SiteDataGetWeb\":\r\n                // Because this operation has a name which duplicates the Lists WS, need to handle\r\n                SOAPEnvelope = constants.siteDataFixSOAPEnvelope(SOAPEnvelope, opt.operation);\r\n                break;\r\n\r\n            // SITES OPERATIONS\r\n            case \"CreateWeb\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"title\", \"description\", \"templateName\", \"language\", \"languageSpecified\",\r\n                    \"locale\", \"localeSpecified\", \"collationLocale\", \"collationLocaleSpecified\", \"uniquePermissions\",\r\n                    \"uniquePermissionsSpecified\", \"anonymous\", \"anonymousSpecified\", \"presence\", \"presenceSpecified\"\r\n                ]);\r\n                break;\r\n            case \"DeleteWeb\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetSite\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"SiteUrl\"]);\r\n                break;\r\n            case \"GetSiteTemplates\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"LCID\", \"TemplateList\"]);\r\n                break;\r\n\r\n            // SOCIALDATASERVICE OPERATIONS\r\n            case \"AddComment\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"comment\", \"isHighPriority\", \"title\"]);\r\n                break;\r\n            case \"AddTag\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"termID\", \"title\", \"isPrivate\"]);\r\n                break;\r\n            case \"AddTagByKeyword\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"keyword\", \"title\", \"isPrivate\"]);\r\n                break;\r\n            case \"CountCommentsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\"]);\r\n                break;\r\n            case \"CountCommentsOfUserOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"url\"]);\r\n                break;\r\n            case \"CountCommentsOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"CountRatingsOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"CountTagsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\"]);\r\n                break;\r\n            case \"DeleteComment\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"lastModifiedTime\"]);\r\n                break;\r\n            case \"DeleteRating\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"DeleteTag\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"termID\"]);\r\n                break;\r\n            case \"DeleteTagByKeyword\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"keyword\"]);\r\n                break;\r\n            case \"DeleteTags\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetAllTagTerms\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"maximumItemsToReturn\"]);\r\n                break;\r\n            case \"GetAllTagTermsForUrlFolder\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"urlFolder\", \"maximumItemsToReturn\"]);\r\n                break;\r\n            case \"GetAllTagUrls\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"termID\"]);\r\n                break;\r\n            case \"GetAllTagUrlsByKeyword\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"keyword\"]);\r\n                break;\r\n            case \"GetCommentsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"maximumItemsToReturn\", \"startIndex\"]);\r\n                break;\r\n            case \"GetCommentsOfUserOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"url\"]);\r\n                break;\r\n            case \"GetCommentsOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"maximumItemsToReturn\", \"startIndex\"]);\r\n                if (typeof opt.excludeItemsTime !== \"undefined\" && opt.excludeItemsTime.length > 0) {\r\n                    SOAPEnvelope.payload += utils.wrapNode(\"excludeItemsTime\", opt.excludeItemsTime);\r\n                }\r\n                break;\r\n            case \"GetRatingAverageOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetRatingOfUserOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"url\"]);\r\n                break;\r\n            case \"GetRatingOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetRatingsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\"]);\r\n                break;\r\n            case \"GetRatingsOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetSocialDataForFullReplication\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\"]);\r\n                break;\r\n            case \"GetTags\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\"]);\r\n                break;\r\n            case \"GetTagsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"maximumItemsToReturn\", \"startIndex\"]);\r\n                break;\r\n            case \"GetTagTerms\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"maximumItemsToReturn\"]);\r\n                break;\r\n            case \"GetTagTermsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userAccountName\", \"maximumItemsToReturn\"]);\r\n                break;\r\n            case \"GetTagTermsOnUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"maximumItemsToReturn\"]);\r\n                break;\r\n            case \"GetTagUrls\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"termID\"]);\r\n                break;\r\n            case \"GetTagUrlsByKeyword\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"keyword\"]);\r\n                break;\r\n            case \"GetTagUrlsOfUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"termID\", \"userAccountName\"]);\r\n                break;\r\n            case \"GetTagUrlsOfUserByKeyword\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"keyword\", \"userAccountName\"]);\r\n                break;\r\n            case \"SetRating\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"rating\", \"title\", \"analysisDataEntry\"]);\r\n                break;\r\n            case \"UpdateComment\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"url\", \"lastModifiedTime\", \"comment\", \"isHighPriority\"]);\r\n                break;\r\n\r\n            // SPELLCHECK OPERATIONS\r\n            case \"SpellCheck\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"chunksToSpell\", \"declaredLanguage\", \"useLad\"]);\r\n                break;\r\n\r\n            // TAXONOMY OPERATIONS\r\n            case \"AddTerms\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"sharedServiceId\", \"termSetId\", \"lcid\", \"newTerms\"]);\r\n                break;\r\n            case \"GetChildTermsInTerm\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"sspId\", \"lcid\", \"termId\", \"termSetId\"]);\r\n                break;\r\n            case \"GetChildTermsInTermSet\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"sspId\", \"lcid\", \"termSetId\"]);\r\n                break;\r\n            case \"GetKeywordTermsByGuids\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"termIds\", \"lcid\"]);\r\n                break;\r\n            case \"GetTermsByLabel\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"label\", \"lcid\", \"matchOption\", \"resultCollectionSize\", \"termIds\", \"addIfNotFound\"]);\r\n                break;\r\n            case \"GetTermSets\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"sharedServiceIds\", \"termSetIds\", \"lcid\", \"clientTimeStamps\", \"clientVersions\"]);\r\n                break;\r\n\r\n            // USERS AND GROUPS OPERATIONS\r\n            case \"AddGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"ownerIdentifier\", \"ownerType\", \"defaultUserLoginName\", \"description\"]);\r\n                break;\r\n            case \"AddGroupToRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"roleName\"]);\r\n                break;\r\n            case \"AddRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"description\", \"permissionMask\"]);\r\n                break;\r\n            case \"AddRoleDef\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"description\", \"permissionMask\"]);\r\n                break;\r\n            case \"AddUserCollectionToGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"usersInfoXml\"]);\r\n                break;\r\n            case \"AddUserCollectionToRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"usersInfoXml\"]);\r\n                break;\r\n            case \"AddUserToGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"userName\", \"userLoginName\", \"userEmail\", \"userNotes\"]);\r\n                break;\r\n            case \"AddUserToRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"userName\", \"userLoginName\", \"userEmail\", \"userNotes\"]);\r\n                break;\r\n            case \"GetAllUserCollectionFromWeb\":\r\n                break;\r\n            case \"GetGroupCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupNamesXml\"]);\r\n                break;\r\n            case \"GetGroupCollectionFromRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\"]);\r\n                break;\r\n            case \"GetGroupCollectionFromSite\":\r\n                break;\r\n            case \"GetGroupCollectionFromUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\"]);\r\n                break;\r\n            case \"GetGroupCollectionFromWeb\":\r\n                break;\r\n            case \"GetGroupInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\"]);\r\n                break;\r\n            case \"GetRoleCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleNamesXml\"]);\r\n                break;\r\n            case \"GetRoleCollectionFromGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\"]);\r\n                break;\r\n            case \"GetRoleCollectionFromUser\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\"]);\r\n                break;\r\n            case \"GetRoleCollectionFromWeb\":\r\n                break;\r\n            case \"GetRoleInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\"]);\r\n                break;\r\n            case \"GetRolesAndPermissionsForCurrentUser\":\r\n                break;\r\n            case \"GetRolesAndPermissionsForSite\":\r\n                break;\r\n            case \"GetUserCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginNamesXml\"]);\r\n                break;\r\n            case \"GetUserCollectionFromGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\"]);\r\n                break;\r\n            case \"GetUserCollectionFromRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\"]);\r\n                break;\r\n            case \"GetUserCollectionFromSite\":\r\n                break;\r\n            case \"GetUserCollectionFromWeb\":\r\n                break;\r\n            case \"GetUserInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\"]);\r\n                break;\r\n            case \"GetUserLoginFromEmail\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"emailXml\"]);\r\n                break;\r\n            case \"RemoveGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\"]);\r\n                break;\r\n            case \"RemoveGroupFromRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"groupName\"]);\r\n                break;\r\n            case \"RemoveRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\"]);\r\n                break;\r\n            case \"RemoveUserCollectionFromGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"userLoginNamesXml\"]);\r\n                break;\r\n            case \"RemoveUserCollectionFromRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"userLoginNamesXml\"]);\r\n                break;\r\n            case \"RemoveUserCollectionFromSite\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginNamesXml\"]);\r\n                break;\r\n            case \"RemoveUserFromGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"groupName\", \"userLoginName\"]);\r\n                break;\r\n            case \"RemoveUserFromRole\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"roleName\", \"userLoginName\"]);\r\n                break;\r\n            case \"RemoveUserFromSite\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\"]);\r\n                break;\r\n            case \"RemoveUserFromWeb\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\"]);\r\n                break;\r\n            case \"UpdateGroupInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"oldGroupName\", \"groupName\", \"ownerIdentifier\", \"ownerType\", \"description\"]);\r\n                break;\r\n            case \"UpdateRoleDefInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"oldRoleName\", \"roleName\", \"description\", \"permissionMask\"]);\r\n                break;\r\n            case \"UpdateRoleInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"oldRoleName\", \"roleName\", \"description\", \"permissionMask\"]);\r\n                break;\r\n            case \"UpdateUserInfo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"userLoginName\", \"userName\", \"userEmail\", \"userNotes\"]);\r\n                break;\r\n\r\n            // USERPROFILESERVICE OPERATIONS\r\n            case \"AddColleague\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"colleagueAccountName\", \"group\", \"privacy\", \"isInWorkGroup\"]);\r\n                break;\r\n            case \"AddLink\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"name\", \"url\", \"group\", \"privacy\"]);\r\n                break;\r\n            case \"AddMembership\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"membershipInfo\", \"group\", \"privacy\"]);\r\n                break;\r\n            case \"AddPinnedLink\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"name\", \"url\"]);\r\n                break;\r\n            case \"CreateMemberGroup\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"membershipInfo\"]);\r\n                break;\r\n            case \"CreateUserProfileByAccountName\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetCommonColleagues\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetCommonManager\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetCommonMemberships\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetInCommon\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetPropertyChoiceList\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"propertyName\"]);\r\n                break;\r\n            case \"GetUserColleagues\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetUserLinks\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetUserMemberships\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetUserPinnedLinks\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"GetUserProfileByGuid\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"guid\"]);\r\n                break;\r\n            case \"GetUserProfileByIndex\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"index\"]);\r\n                break;\r\n            case \"GetUserProfileByName\":\r\n                // Note that this operation is inconsistent with the others, using AccountName rather than accountName\r\n                if (typeof opt.accountName !== \"undefined\" && opt.accountName.length > 0) {\r\n                    utils.addToPayload(opt, SOAPEnvelope, [\r\n                        [\"AccountName\", \"accountName\"]\r\n                    ]);\r\n                } else {\r\n                    utils.addToPayload(opt, SOAPEnvelope, [\"AccountName\"]);\r\n                }\r\n                break;\r\n            case \"GetUserProfileCount\":\r\n                break;\r\n            case \"GetUserProfileSchema\":\r\n                break;\r\n            case \"GetUserPropertyByAccountName\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"propertyName\"]);\r\n                break;\r\n            case \"ModifyUserPropertyByAccountName\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"newData\"]);\r\n                break;\r\n            case \"RemoveAllColleagues\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"RemoveAllLinks\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"RemoveAllMemberships\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"RemoveAllPinnedLinks\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\"]);\r\n                break;\r\n            case \"RemoveColleague\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"colleagueAccountName\"]);\r\n                break;\r\n            case \"RemoveLink\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"id\"]);\r\n                break;\r\n            case \"RemoveMembership\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"sourceInternal\", \"sourceReference\"]);\r\n                break;\r\n            case \"RemovePinnedLink\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"id\"]);\r\n                break;\r\n            case \"UpdateColleaguePrivacy\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"colleagueAccountName\", \"newPrivacy\"]);\r\n                break;\r\n            case \"UpdateLink\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"data\"]);\r\n                break;\r\n            case \"UpdateMembershipPrivacy\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"sourceInternal\", \"sourceReference\", \"newPrivacy\"]);\r\n                break;\r\n            case \"UpdatePinnedLink \":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"accountName\", \"data\"]);\r\n                break;\r\n\r\n            // VERSIONS OPERATIONS\r\n            case \"DeleteAllVersions\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileName\"]);\r\n                break;\r\n            case \"DeleteVersion\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileName\", \"fileVersion\"]);\r\n                break;\r\n            case \"GetVersions\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileName\"]);\r\n                break;\r\n            case \"RestoreVersion\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileName\", \"fileVersion\"]);\r\n                break;\r\n\r\n            // VIEW OPERATIONS\r\n            case \"AddView\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\", \"viewFields\", \"query\", \"rowLimit\", \"type\", \"makeViewDefault\"]);\r\n                break;\r\n            case \"DeleteView\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\"]);\r\n                break;\r\n            case \"GetView\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\"]);\r\n                break;\r\n            case \"GetViewCollection\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\"]);\r\n                break;\r\n            case \"GetViewHtml\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\"]);\r\n                break;\r\n            case \"UpdateView\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\", \"viewProperties\", \"query\", \"viewFields\", \"aggregations\", \"formats\", \"rowLimit\"]);\r\n                break;\r\n            case \"UpdateViewHtml\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"listName\", \"viewName\", \"viewProperties\", \"toolbar\", \"viewHeader\", \"viewBody\", \"viewFooter\", \"viewEmpty\", \"rowLimitExceeded\",\r\n                    \"query\", \"viewFields\", \"aggregations\", \"formats\", \"rowLimit\"\r\n                ]);\r\n                break;\r\n\r\n            // WEBPARTPAGES OPERATIONS\r\n            case \"AddWebPart\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"webPartXml\", \"storage\"]);\r\n                break;\r\n            case \"AddWebPartToZone\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"webPartXml\", \"storage\", \"zoneId\", \"zoneIndex\"]);\r\n                break;\r\n            case \"DeleteWebPart\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"storageKey\", \"storage\"]);\r\n                break;\r\n            case \"GetWebPart2\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"storageKey\", \"storage\", \"behavior\"]);\r\n                break;\r\n            case \"GetWebPartPage\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"documentName\", \"behavior\"]);\r\n                break;\r\n            case \"GetWebPartProperties\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"storage\"]);\r\n                break;\r\n            case \"GetWebPartProperties2\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"storage\", \"behavior\"]);\r\n                break;\r\n            case \"SaveWebPart2\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"pageUrl\", \"storageKey\", \"webPartXml\", \"storage\", \"allowTypeChange\"]);\r\n                break;\r\n\r\n            // WEBS OPERATIONS\r\n            case \"WebsCreateContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"displayName\", \"parentType\", \"newFields\", \"contentTypeProperties\"]);\r\n                break;\r\n            case \"GetColumns\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"webUrl\"]);\r\n                break;\r\n            case \"GetContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"contentTypeId\"]);\r\n                break;\r\n            case \"GetContentTypes\":\r\n                break;\r\n            case \"GetCustomizedPageStatus\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"fileUrl\"]);\r\n                break;\r\n            case \"GetListTemplates\":\r\n                break;\r\n            case \"GetObjectIdFromUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"objectUrl\"]);\r\n                break;\r\n            case \"GetWeb\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\r\n                    [\"webUrl\", \"webURL\"]\r\n                ]);\r\n                break;\r\n            case \"GetWebCollection\":\r\n                break;\r\n            case \"GetAllSubWebCollection\":\r\n                break;\r\n            case \"UpdateColumns\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"newFields\", \"updateFields\", \"deleteFields\"]);\r\n                break;\r\n            case \"WebsUpdateContentType\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"contentTypeId\", \"contentTypeProperties\", \"newFields\", \"updateFields\", \"deleteFields\"]);\r\n                break;\r\n            case \"WebUrlFromPageUrl\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\r\n                    [\"pageUrl\", \"pageURL\"]\r\n                ]);\r\n                break;\r\n\r\n            // WORKFLOW OPERATIONS\r\n            case \"AlterToDo\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\", \"todoId\", \"todoListId\", \"taskData\"]);\r\n                break;\r\n            case \"ClaimReleaseTask\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\", \"taskId\", \"listId\", \"fClaim\"]);\r\n                break;\r\n            case \"GetTemplatesForItem\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\"]);\r\n                break;\r\n            case \"GetToDosForItem\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\"]);\r\n                break;\r\n            case \"GetWorkflowDataForItem\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\"]);\r\n                break;\r\n            case \"GetWorkflowTaskData\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\", \"listId\", \"taskId\"]);\r\n                break;\r\n            case \"StartWorkflow\":\r\n                utils.addToPayload(opt, SOAPEnvelope, [\"item\", \"templateId\", \"workflowParameters\"]);\r\n                break;\r\n\r\n            default:\r\n                break;\r\n        }\r\n\r\n        // Glue together the pieces of the SOAP message\r\n        var msg = SOAPEnvelope.header + SOAPEnvelope.opheader + SOAPEnvelope.payload + SOAPEnvelope.opfooter + SOAPEnvelope.footer;\r\n\r\n        // Check to see if we've already cached the results\r\n        var cachedPromise;\r\n        if (opt.cacheXML) {\r\n            cachedPromise = promisesCache[msg];\r\n        }\r\n\r\n        // Do we have any customHeaders?\r\n        var headers = opt.customHeaders ? opt.customHeaders : {};\r\n\r\n        if (typeof cachedPromise === \"undefined\") {\r\n\r\n            // Finally, make the Ajax call\r\n            var p = $.ajax({\r\n                // The relative URL for the AJAX call\r\n                url: ajaxURL,\r\n                // By default, the AJAX calls are asynchronous.  You can specify false to require a synchronous call.\r\n                async: opt.async,\r\n                // Optionally, pass in headers\r\n                headers: headers,\r\n                // Before sending the msg, need to send the request header\r\n                beforeSend: function (xhr) {\r\n                    // If we need to pass the SOAPAction, do so\r\n                    if (WSops[opt.operation][1]) {\r\n                        xhr.setRequestHeader(\"SOAPAction\", SOAPAction);\r\n                    }\r\n                },\r\n                // Always a POST\r\n                type: \"POST\",\r\n                // Here is the SOAP request we've built above\r\n                data: msg,\r\n                // We're getting XML; tell jQuery so that it doesn't need to do a best guess\r\n                dataType: \"xml\",\r\n                // and this is its content type\r\n                contentType: \"text/xml;charset='utf-8'\",\r\n                complete: function (xData, Status) {\r\n                    // When the call is complete, call the completefunc if there is one\r\n                    if ($.isFunction(opt.completefunc)) {\r\n                        opt.completefunc(xData, Status);\r\n\r\n                    }\r\n                }\r\n            });\r\n            if(opt.cacheXML) {\r\n                promisesCache[msg] = p;\r\n            }\r\n\r\n            // Return the promise\r\n            return p;\r\n\r\n        } else {\r\n\r\n            // Call the completefunc if there is one\r\n            if ($.isFunction(opt.completefunc)) {\r\n                cachedPromise.done(function(data, status, jqXHR){\r\n                    opt.completefunc(jqXHR, status);\r\n                });\r\n            }\r\n            // Return the cached promise\r\n            return cachedPromise;\r\n        }\r\n\r\n    }; // End $.fn.SPServices\r\n    \r\n    //Main function which calls Nintex's Web Services directly\r\n    $.fn.NintexServices = function (options)\r\n    {\r\n        // If there are no options passed in, use the defaults.  Extend replaces each default with the passed option.\r\n        var opt = $.extend({}, $.fn.SPServices.defaults, options);\r\n\r\n        // Encode options which may contain special character, esp. ampersand\r\n        for (var i = 0; i < encodeOptionList.length; i++) {\r\n            if (typeof opt[encodeOptionList[i]] === \"string\") {\r\n                opt[encodeOptionList[i]] = utils.encodeXml(opt[encodeOptionList[i]]);\r\n            }\r\n        }//end for\r\n        \r\n        // Put together operation header and SOAPAction for the SOAP call based on which Web Service we're calling\r\n        SOAPEnvelope.opheader = \"<\" + opt.operation + \" \";\r\n        switch (WSops[opt.operation][0]) {\r\n            case webServices.NINTEXWORKFLOW:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMANintex + \"'>\";\r\n                SOAPAction = constants.SCHEMANintex + \"/\";\r\n                break;            \t\r\n            default:\r\n                SOAPEnvelope.opheader += \"xmlns='\" + constants.SCHEMANintex + \"/soap/'>\";\r\n                SOAPAction = constants.SCHEMANintex + \"/soap/\";\r\n                break;\r\n        }//end switch\r\n        \r\n        // Add the operation to the SOAPAction and opfooter\r\n        SOAPAction += opt.operation;\r\n        SOAPEnvelope.opfooter = \"</\" + opt.operation + \">\";\r\n\r\n        // Build the URL for the Ajax call based on which operation we're calling\r\n        // If the webURL has been provided, then use it, else use the current site\r\n        var ajaxURL = \"_vti_bin/\" + WSops[opt.operation][0] + \".asmx\";\r\n        var thisSite = $().SPServices.SPGetCurrentSite();\r\n        var webURL = opt.webURL !== undefined ? opt.webURL : opt.webUrl;\r\n        if (webURL.charAt(webURL.length - 1) === constants.SLASH) {\r\n            ajaxURL = webURL + ajaxURL;\r\n        } else if (webURL.length > 0) {\r\n            ajaxURL = webURL + constants.SLASH + ajaxURL;\r\n        } else {\r\n            ajaxURL = thisSite + ((thisSite.charAt(thisSite.length - 1) === constants.SLASH) ? ajaxURL : (constants.SLASH + ajaxURL));\r\n        }\r\n\r\n        SOAPEnvelope.payload = \"\";\r\n        // Each operation requires a different set of values.  This switch statement sets them up in the SOAPEnvelope.payload.\r\n        switch (opt.operation) {\r\n            //NINTEX WORKFLOW OPERATIONS\r\n            case \"AddLongTermDelegationRule\":\r\n            \tutils.addToPayload(opt,[\"fromTheBeginningOf\",\"untilTheEndOf\",\"delegateFrom\",\"delegateTo\",\"currentSiteOnly\"]);\r\n            \tbreak;\r\n\t\t\tcase \"AddWorkflowSchedule\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\",\"workflowName\",\"startDataXml\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"<schedule>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"MaximumRepeats\",\"WorkdaysOnly\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"<RepeatInterval>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"Type\",\"CountBetweenIntervals\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"</RepeatInterval>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"EndOn\",\"StartTime\",\"EndTime\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"</schedule>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"updateIfExists\"]);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"AddWorkflowScheduleOnListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\",\"workflowName\",\"startDataXML\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"<schedule>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"MaximumRepeats\",\"WorkdaysOnly\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"<RepeatInterval>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"Type\",\"CountBetweenIntervals\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"</RepeatInterval>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"EndOn\",\"StartTime\",\"EndTime\"]);\r\n\t\t\t\tSOAPEnvelope.payload += \"</schedule>\";\r\n\t\t\t\tutils.addToPayload(opt,[\"updateIfExists\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"CheckGlobalReuseStatus\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowName\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"CheckInForms\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowConfiguration\",\"activityConfiguration\",\"formType\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\r\n\t\t\tcase \"DelegateAllTasks\":\r\n\t\t\t\tutils.addToPayload(opt,[\"currentUser\",\"newUser\",\"sendNotification\",\"comments\",\"global\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"DelegateTask\":\r\n\t\t\t\tutils.addToPayload(opt,[\"spTaskId\",\"taskListName\",\"targetUserName\",\"comments\",\"sendNotification\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\r\n\t\t\tcase \"DeleteLongTermDelegationRule\":\r\n\t\t\t\tutils.addToPayload(opt,[\"id\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"DeleteSnippet\":\r\n\t\t\t\tutils.addToPayload(opt,[\"snippetId\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"DeleteWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"listId\",\"workflowId\",\"workflowType\"]);\r\n\t\t\t\tbreak;\t\r\n            case \"ExportWorkflow\":\r\n            \tutils.addToPayload(opt,[\"listName\",\"workflowType\",\"workflowName\"]);\r\n            \tbreak;\t\t\t\t\r\n\t\t\tcase \"FixWorkflowsInSiteFromTemplate\":\r\n\t\t\t\tutils.addToPayload(opt,[\"FixWorkflowsInSiteFromTemplate\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetFolders\":\r\n\t\t\t\tutils.addToPayload(opt,[\"listGuid\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetItemsPendingMyApproval\":\r\n\t\t\t\tutils.addToPayload(opt,[\"uniquenessInfo\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetListContentTypes\":\r\n\t\t\t\tutils.addToPayload(opt,[\"listGuid\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetOutcomesForFlexiTask\":\r\n\t\t\t\tutils.addToPayload(opt,[\"spTaskId\",\"taskListName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetRunningWorkflowTasks\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetRunningWorkflowTasksCollection\":\r\n\t\t\t\tutils.addToPayload(opt,[\"userlogin\",\"teamsiteUrl\",\"listName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetRunningWorkflowTasksForCurrentUser\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetRunningWorkflowTasksForCurrentUserForListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetRunningWorkflowTasksForListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetTaskDetailsUsingStub\":\r\n\t\t\t\tutils.addToPayload(opt,[\"taskToken\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetTaskStubsForCurrentUser\":\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetWorkflowHistory\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\",\"stateFilter\",\"workflowNameFilter\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"GetWorkflowHistoryForListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\",\"stateFilter\",\"workflowNameFilter\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"HideTaskForApprover\":\r\n\t\t\t\tutils.addToPayload(opt,[\"approverId\",\"contentDbId\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"HideWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"siteId\",\"instanceId\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"ProcessFlexiTaskResponse\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"spTaskId\",\"taskListName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"ProcessFlexiTaskResponse2\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"spTaskId\",\"taskListName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"ProcessTaskResponse\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"spTaskId\"]);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"ProcessTaskResponse2\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"spTaskId\",\"taskListName\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"ProcessTaskResponse3\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"spTaskId\",\"taskListName\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"ProcessTaskResponseUsingToken\":\r\n\t\t\t\tutils.addToPayload(opt,[\"comments\",\"outcome\",\"taskToken\",\"customOutcome\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWF\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWFNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWFSkipValidation\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWFSkipValidationNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWFXml\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishFromNWFXmlNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"PublishFromNWFXmlSkipValidation\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"PublishFromNWFXmlSkipValidationNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\",\"saveIfCannotPublish\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"PublishWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"wfName\",\"activityConfigs\",\"listId\",\"contentTypeId\",\"changeNotes\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"QueryForMessages\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowInstanceId\",\"messageId\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"RemoveWorkflowSchedule\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"RemoveWorkflowScheduleOnListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"SaveFromNWF\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"SaveFromNWFNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"SaveFromNWFXml\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"SaveFromNWFXmlNoOverwrite\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowFile\",\"listName\",\"workflowName\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"SaveSnippet\":\r\n\t\t\t\tutils.addToPayload(opt,[\"snippetName\",\"activityConfigs\"]);\r\n\t\t\t\tbreak;\t\t\r\n\t\t\tcase \"SaveTemplate\":\r\n\t\t\t\tutils.addToPayload(opt,[\"templateName\",\"templateDescription\",\"category\",\"activityConfigs\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"SaveTemplate2\":\r\n\t\t\t\tutils.addToPayload(opt,[\"templateName\",\"templateDescription\",\"category\",\"activityConfigs\",\"lcid\"]);\r\n\t\t\t\tbreak;\t\t\t\t\r\n\t\t\tcase \"SaveWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"wfName\",\"activityConfigs\",\"listId\",\"contentTypeId\",\"changeNotes\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"SnippetExists\":\r\n\t\t\t\tutils.addToPayload(opt,[\"snippetName\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"StartSiteWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowName\",\"associationData\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"StartWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\",\"workflowName\",\"associationData\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"StartWorkflowOnListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"itemId\",\"listName\",\"workflowName\",\"associationData\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"TemplateExists\":\r\n\t\t\t\tutils.addToPayload(opt,[\"templateName\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"TerminateWorkflow\":\r\n\t\t\t\tutils.addToPayload(opt,[\"listId\",\"itemId\",\"instanceId\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"TerminateWorkflowByName\":\r\n\t\t\t\tutils.addToPayload(opt,[\"fileUrl\",\"workflowName\",\"terminatePreviousInstances\"]);\r\n\t\t\t\tbreak;\t\r\n\t\t\tcase \"TerminateWorkflowByNameForListItem\":\r\n\t\t\t\tutils.addToPayload(opt,[\"listName\",\"itemId\",\"workflowName\",\"terminatePreviousInstances\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"WorkflowExists\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowName\",\"listId\",\"workflowType\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n\t\t\tcase \"WorkflowFormProductSelected\":\r\n\t\t\t\tutils.addToPayload(opt,[\"workflowConfiguration\",\"activityConfiguration\",\"product\",\"formType\"]);\r\n\t\t\t\tbreak;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\r\n            default:\r\n                break;\r\n        }//end switch\r\n\r\n        // Glue together the pieces of the SOAP message\r\n        var msg = SOAPEnvelope.header + SOAPEnvelope.opheader + SOAPEnvelope.payload + SOAPEnvelope.opfooter + SOAPEnvelope.footer;\r\n\r\n        // Check to see if we've already cached the results\r\n        var cachedPromise;\r\n        if (opt.cacheXML) {\r\n            cachedPromise = promisesCache[msg];\r\n        }\r\n\r\n        if (typeof cachedPromise === \"undefined\") {\r\n\r\n            // Finally, make the Ajax call\r\n            var p = $.ajax({\r\n                // The relative URL for the AJAX call\r\n                url: ajaxURL,\r\n                // By default, the AJAX calls are asynchronous.  You can specify false to require a synchronous call.\r\n                async: opt.async,\r\n                // Before sending the msg, need to send the request header\r\n                beforeSend: function (xhr) {\r\n                    // If we need to pass the SOAPAction, do so\r\n                    if (WSops[opt.operation][1]) {\r\n                        xhr.setRequestHeader(\"SOAPAction\", SOAPAction);\r\n                    }\r\n                },\r\n                // Always a POST\r\n                type: \"POST\",\r\n                // Here is the SOAP request we've built above\r\n                data: msg,\r\n                // We're getting XML; tell jQuery so that it doesn't need to do a best guess\r\n                dataType: \"xml\",\r\n                // and this is its content type\r\n                contentType: \"text/xml;charset='utf-8'\",\r\n                complete: function (xData, Status) {\r\n                    // When the call is complete, call the completefunc if there is one\r\n                    if ($.isFunction(opt.completefunc)) {\r\n                        opt.completefunc(xData, Status);\r\n\r\n                    }\r\n                }\r\n            });\r\n            if(opt.cacheXML) {\r\n                promisesCache[msg] = p;\r\n            }\r\n\r\n            // Return the promise\r\n            return p;\r\n\r\n        } else {\r\n\r\n            // Call the completefunc if there is one\r\n            if ($.isFunction(opt.completefunc)) {\r\n                cachedPromise.done(function(data, status, jqXHR){\r\n                    opt.completefunc(jqXHR, status);\r\n                });\r\n\r\n            }\r\n            // Return the cached promise\r\n            return cachedPromise;\r\n        }        \r\n    };//end NintexServices\r\n    \r\n\r\n    // Defaults added as a function in our library means that the caller can override the defaults\r\n    // for their session by calling this function.  Each operation requires a different set of options;\r\n    // we allow for all in a standardized way.\r\n    $.fn.SPServices.defaults = {\r\n\r\n        cacheXML: false, // If true, we'll cache the XML results with jQuery's .data() function\r\n        operation: \"\", // The Web Service operation\r\n        webURL: \"\", // URL of the target Web\r\n        customHeaders: {},\r\n        makeViewDefault: false, // true to make the view the default view for the list\r\n\r\n        // For operations requiring CAML, these options will override any abstractions\r\n        viewName: \"\", // View name in CAML format.\r\n        CAMLQuery: \"\", // Query in CAML format\r\n        CAMLViewFields: \"\", // View fields in CAML format\r\n        CAMLRowLimit: 0, // Row limit as a string representation of an integer\r\n        CAMLQueryOptions: \"<QueryOptions></QueryOptions>\", // Query options in CAML format\r\n\r\n        // Abstractions for CAML syntax\r\n        batchCmd: \"Update\", // Method Cmd for UpdateListItems\r\n        valuepairs: [], // Fieldname / Fieldvalue pairs for UpdateListItems\r\n\r\n        // As of v0.7.1, removed all options which were assigned an empty string (\"\")\r\n        DestinationUrls: [], // Array of destination URLs for copy operations\r\n        behavior: \"Version3\", // An SPWebServiceBehavior indicating whether the client supports Windows SharePoint Services 2.0 or Windows SharePoint Services 3.0: {Version2 | Version3 }\r\n        storage: \"Shared\", // A Storage value indicating how the Web Part is stored: {None | Personal | Shared}\r\n        objectType: \"List\", // objectType for operations which require it\r\n        cancelMeeting: true, // true to delete a meeting;false to remove its association with a Meeting Workspace site\r\n        nonGregorian: false, // true if the calendar is set to a format other than Gregorian;otherwise, false.\r\n        fClaim: false, // Specifies if the action is a claim or a release. Specifies true for a claim and false for a release.\r\n        recurrenceId: 0, // The recurrence ID for the meeting that needs its association removed. This parameter can be set to 0 for single-instance meetings.\r\n        sequence: 0, // An integer that is used to determine the ordering of updates in case they arrive out of sequence. Updates with a lower-than-current sequence are discarded. If the sequence is equal to the current sequence, the latest update are applied.\r\n        maximumItemsToReturn: 0, // SocialDataService maximumItemsToReturn\r\n        startIndex: 0, // SocialDataService startIndex\r\n        isHighPriority: false, // SocialDataService isHighPriority\r\n        isPrivate: false, // SocialDataService isPrivate\r\n        rating: 1, // SocialDataService rating\r\n        maxResults: 10, // Unless otherwise specified, the maximum number of principals that can be returned from a provider is 10.\r\n        principalType: \"User\", // Specifies user scope and other information: [None | User | DistributionList | SecurityGroup | SharePointGroup | All]\r\n\r\n        async: true, // Allow the user to force async\r\n        completefunc: null // Function to call on completion\r\n\r\n    }; // End $.fn.SPServices.defaults\r\n\r\n});",null,"/**\r\n * General purpose utilities\r\n *\r\n * @namespace spservices.utils\r\n */\r\ndefine([\r\n    \"jquery\",\r\n    '../utils/constants'\r\n], function(\r\n    $,\r\n    constants\r\n){\r\n    \"use strict\";\r\n\r\n    var utils = /** @lends spservices.utils */{\r\n\r\n        // Get the current context (as much as we can) on startup\r\n        // See: http://johnliu.net/blog/2012/2/3/sharepoint-javascript-current-page-context-info.html\r\n        SPServicesContext: function(options) {\r\n\r\n            var opt = $.extend({}, {\r\n                listName: \"\", // The list the form is working with. This is useful if the form is not in the list context.\r\n                thisUserId: \"\" // The current user's id in the site Collection.\r\n            }, options);\r\n\r\n            // The SharePoint variables only give us a relative path. to match the result from WebUrlFromPageUrl, we need to add the protocol, host, and (if present) port.\r\n            var siteRoot = location.protocol + \"//\" + location.host; // + (location.port !== \"\" ? location.port : \"\");\r\n\r\n            var thisContext = {};\r\n            // SharePoint 2010+ gives us a context variable\r\n            if (typeof _spPageContextInfo !== \"undefined\") {\r\n                thisContext.thisSite = siteRoot + _spPageContextInfo.webServerRelativeUrl;\r\n                thisContext.thisList = opt.listName ? opt.listName : _spPageContextInfo.pageListId;\r\n                thisContext.thisUserId = opt.thisUserId ? opt.thisUserId : _spPageContextInfo.userId;\r\n                // In SharePoint 2007, we know the UserID only\r\n            } else {\r\n                thisContext.thisSite = (typeof L_Menu_BaseUrl !== \"undefined\") ? siteRoot + L_Menu_BaseUrl : \"\";\r\n                thisContext.thisList = opt.listName ? opt.listName : \"\";\r\n                thisContext.thisUserId = opt.thisUserId ? opt.thisUserId : ((typeof _spUserId !== \"undefined\") ? _spUserId : undefined);\r\n            }\r\n\r\n            return thisContext;\r\n\r\n        }, // End of function SPServicesContext\r\n\r\n        // Global variables\r\n//        currentContext: new this.SPServicesContext(), // Variable to hold the current context as we figure it out\r\n\r\n        /**\r\n         * Wrap an XML node (n) around a value (v)\r\n         *\r\n         */\r\n        wrapNode: function(n, v) {\r\n            var thisValue = typeof v !== \"undefined\" ? v : \"\";\r\n            return \"<\" + n + \">\" + thisValue + \"</\" + n + \">\";\r\n        },\r\n\r\n        /**\r\n         * Generate a random number for sorting arrays randomly\r\n         */\r\n        randOrd: function() {\r\n            return (Math.round(Math.random()) - 0.5);\r\n        },\r\n\r\n        /**\r\n         * If a string is a URL, format it as a link, else return the string as-is\r\n         */\r\n        checkLink: function(s) {\r\n            return ((s.indexOf(\"http\") === 0) || (s.indexOf(\"/\") === 0)) ? \"<a href='\" + s + \"'>\" + s + \"</a>\" : s;\r\n        },\r\n\r\n        /**\r\n         * Get the filename from the full URL\r\n         */\r\n        fileName: function (s) {\r\n            return s.substring(s.lastIndexOf(\"/\") + 1, s.length);\r\n        },\r\n\r\n        /**\r\n         * A map of special characters to XML escaped characters.\r\n         * Taken from {@link http://dracoblue.net/dev/encodedecode-special-xml-characters-in-javascript/155/}\r\n         *\r\n         * @type {Object}\r\n         */\r\n        xml_special_to_escaped_one_map: {\r\n            '&': '&amp;',\r\n            '\"': '&quot;',\r\n            '<': '&lt;',\r\n            '>': '&gt;'\r\n        },\r\n\r\n        // Paul T., 2015.05.01: Commented out since its not currently used.\r\n        // var escaped_one_to_xml_special_map = {\r\n        // '&amp;': '&',\r\n        // '&quot;': '\"',\r\n        // '&lt;': '<',\r\n        // '&gt;': '>'\r\n        // };\r\n\r\n        /**\r\n         * Encode XML characters in a string\r\n         *\r\n         * @param {String} string\r\n         */\r\n        encodeXml: function(string) {\r\n            return string.replace(/([\\&\"<>])/g, function (str, item) {\r\n                return this.xml_special_to_escaped_one_map[item];\r\n            });\r\n        },\r\n\r\n        // Paul T., 2015-05-02: Commented out since its not currently used.\r\n        // function decodeXml(string) {\r\n        // return string.replace(/(&quot;|&lt;|&gt;|&amp;)/g,\r\n        // function (str, item) {\r\n        // return escaped_one_to_xml_special_map[item];\r\n        // });\r\n        // }\r\n\r\n        /* Taken from http://dracoblue.net/dev/encodedecode-special-xml-characters-in-javascript/155/ */\r\n\r\n        /**\r\n         * Escape column values\r\n         */\r\n        escapeColumnValue: function(s) {\r\n            if (typeof s === \"string\") {\r\n                return s.replace(/&(?![a-zA-Z]{1,8};)/g, \"&amp;\");\r\n            } else {\r\n                return s;\r\n            }\r\n        },\r\n\r\n        /**\r\n         * Escape Url\r\n         */\r\n        escapeUrl: function (u) {\r\n            return u.replace(/&/g, '%26');\r\n        },\r\n\r\n        /**\r\n         * Split values like 1;#value into id and value\r\n         * @type Class\r\n         */\r\n        SplitIndex: function(s) {\r\n            var spl = s.split(constants.spDelim);\r\n            this.id = spl[0];\r\n            this.value = spl[1];\r\n        },\r\n\r\n        /**\r\n         * Pad single digits with a zero\r\n         *\r\n         * @param {Number} n\r\n         */\r\n        pad: function (n) {\r\n            return n < 10 ? \"0\" + n : n;\r\n        },\r\n// TODO\r\n        // James Padolsey's Regex Selector for jQuery http://james.padolsey.com/javascript/regex-selector-for-jquery/\r\n        /*    $.expr[':'].regex = function (elem, index, match) {\r\n         var matchParams = match[3].split(','),\r\n         validLabels = /^(data|css):/,\r\n         attr = {\r\n         method: matchParams[0].match(validLabels) ?\r\n         matchParams[0].split(':')[0] : 'attr',\r\n         property: matchParams.shift().replace(validLabels, '')\r\n         },\r\n         regexFlags = 'ig',\r\n         regex = new RegExp(matchParams.join('').replace(/^\\s+|\\s+$/g, ''), regexFlags);\r\n         return regex.test($(elem)[attr.method](attr.property));\r\n         };\r\n         */\r\n\r\n        /**\r\n         * Build an error message based on passed parameters\r\n         */\r\n        errBox: function(func, param, msg) {\r\n            var errMsg = \"<b>Error in function</b><br/>\" + func + \"<br/>\" +\r\n                \"<b>Parameter</b><br/>\" + param + \"<br/>\" +\r\n                \"<b>Message</b><br/>\" + msg + \"<br/><br/>\" +\r\n                \"<span onmouseover='this.style.cursor=\\\"hand\\\";' onmouseout='this.style.cursor=\\\"inherit\\\";' style='width=100%;text-align:right;'>Click to continue</span></div>\";\r\n            modalBox(errMsg);\r\n        }, // End of function errBox\r\n\r\n\r\n        // Finds the td which contains a form field in default forms using the comment which contains:\r\n        //  <!--  FieldName=\"Title\"\r\n        //      FieldInternalName=\"Title\"\r\n        //      FieldType=\"SPFieldText\"\r\n        //  -->\r\n        // as the \"anchor\" to find it. Necessary because SharePoint doesn't give all field types ids or specific classes.\r\n        findFormField: function(v) {\r\n            var $formBody = $(\"td.ms-formbody, td.ms-formbodysurvey\"),\r\n                // Borrowed from MDN.\r\n                // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\r\n                escapeRegExp = function (v){\r\n                    return v.replace(/([.*+?^=!:${}()|\\[\\]\\/\\\\])/g, \"\\\\$1\");\r\n                },\r\n                columnName = escapeRegExp(v),\r\n                rcommentValidation = new RegExp(\"(?:Field|FieldInternal)Name=\\\"\" + columnName + \"\\\"\", \"i\"),\r\n                $columnNode = $formBody.contents().filter(function () {\r\n                    return this.nodeType === 8 && rcommentValidation.test(this.nodeValue);\r\n                })\r\n\r\n            ;\r\n\r\n            return $columnNode.parent(\"td\");\r\n        }, // End of function findFormField\r\n\r\n        // Show a single attribute of a node, enclosed in a table\r\n        //   node               The XML node\r\n        //   opt                The current set of options\r\n        showAttrs: function(node) {\r\n            var i;\r\n            var out = \"<table class='ms-vb' width='100%'>\";\r\n            for (i = 0; i < node.attributes.length; i++) {\r\n                out += \"<tr><td width='10px' style='font-weight:bold;'>\" + i + \"</td><td width='100px'>\" +\r\n                    node.attributes.item(i).nodeName + \"</td><td>\" + utils.checkLink(node.attributes.item(i).nodeValue) + \"</td></tr>\";\r\n            }\r\n            out += \"</table>\";\r\n            return out;\r\n        }, // End of function showAttrs\r\n\r\n        // Add the option values to the SPServices.SOAPEnvelope.payload for the operation\r\n        //  opt = options for the call\r\n        //  SOAPEnvelope = envelope to add to\r\n        //  paramArray = an array of option names to add to the payload\r\n        //      \"paramName\" if the parameter name and the option name match\r\n        //      [\"paramName\", \"optionName\"] if the parameter name and the option name are different (this handles early \"wrappings\" with inconsistent naming)\r\n        //      {name: \"paramName\", sendNull: false} indicates the element is marked as \"add to payload only if non-null\"\r\n        addToPayload: function(opt, SOAPEnvelope, paramArray) {\r\n\r\n            var i;\r\n\r\n            for (i = 0; i < paramArray.length; i++) {\r\n                // the parameter name and the option name match\r\n                if (typeof paramArray[i] === \"string\") {\r\n                    SOAPEnvelope.payload += utils.wrapNode(paramArray[i], opt[paramArray[i]]);\r\n                    // the parameter name and the option name are different\r\n                } else if ($.isArray(paramArray[i]) && paramArray[i].length === 2) {\r\n                    SOAPEnvelope.payload += utils.wrapNode(paramArray[i][0], opt[paramArray[i][1]]);\r\n                    // the element not a string or an array and is marked as \"add to payload only if non-null\"\r\n                } else if ((typeof paramArray[i] === \"object\") && (paramArray[i].sendNull !== undefined)) {\r\n                    SOAPEnvelope.payload += ((opt[paramArray[i].name] === undefined) || (opt[paramArray[i].name].length === 0)) ? \"\" : utils.wrapNode(paramArray[i].name, opt[paramArray[i].name]);\r\n                    // something isn't right, so report it\r\n                } else {\r\n                    utils.errBox(opt.operation, \"paramArray[\" + i + \"]: \" + paramArray[i], \"Invalid paramArray element passed to addToPayload()\");\r\n                }\r\n            }\r\n        }, // End of function addToPayload\r\n\r\n\r\n        // The SiteData operations have the same names as other Web Service operations. To make them easy to call and unique, I'm using\r\n        // the SiteData prefix on their names. This function replaces that name with the right name in the SPServices.SOAPEnvelope.\r\n        siteDataFixSOAPEnvelope: function(SOAPEnvelope, siteDataOperation) {\r\n            var siteDataOp = siteDataOperation.substring(8);\r\n            SOAPEnvelope.opheader = SOAPEnvelope.opheader.replace(siteDataOperation, siteDataOp);\r\n            SOAPEnvelope.opfooter = SOAPEnvelope.opfooter.replace(siteDataOperation, siteDataOp);\r\n            return SOAPEnvelope;\r\n        }, // End of function siteDataFixSOAPEnvelope\r\n\r\n\r\n        /**\r\n         * Get the URL for a specified form for a list\r\n         *\r\n         * @param {Object} l\r\n         * @param {Object} f\r\n         */\r\n        getListFormUrl: function(l, f) {\r\n\r\n            var u;\r\n            $().SPServices({\r\n                operation: \"GetFormCollection\",\r\n                async: false,\r\n                listName: l,\r\n                completefunc: function (xData) {\r\n                    u = $(xData.responseXML).find(\"Form[Type='\" + f + \"']\").attr(\"Url\");\r\n                }\r\n            });\r\n            return u;\r\n\r\n        }, // End of function getListFormUrl\r\n\r\n        /**\r\n         * Returns the selected value(s) for a dropdown in an array. Expects a dropdown\r\n         * object as returned by the DropdownCtl function.\r\n         * If matchOnId is true, returns the ids rather than the text values for the\r\n         * selection options(s).\r\n         *\r\n         * @param {Object} columnSelect\r\n         * @param {Object} matchOnId\r\n         */\r\n        getDropdownSelected: function (columnSelect, matchOnId) {\r\n\r\n            var columnSelectSelected = [];\r\n\r\n            switch (columnSelect.Type) {\r\n                case constants.dropdownType.simple:\r\n                    if (matchOnId) {\r\n                        columnSelectSelected.push(columnSelect.Obj.find(\"option:selected\").val() || []);\r\n                    } else {\r\n                        columnSelectSelected.push(columnSelect.Obj.find(\"option:selected\").text() || []);\r\n                    }\r\n                    break;\r\n                case constants.dropdownType.complex:\r\n                    if (matchOnId) {\r\n                        columnSelectSelected.push(columnSelect.optHid.val() || []);\r\n                    } else {\r\n                        columnSelectSelected.push(columnSelect.Obj.val() || []);\r\n                    }\r\n                    break;\r\n                case constants.dropdownType.multiSelect:\r\n                    $(columnSelect.master.resultControl).find(\"option\").each(function () {\r\n                        if (matchOnId) {\r\n                            columnSelectSelected.push($(this).val());\r\n                        } else {\r\n                            columnSelectSelected.push($(this).html());\r\n                        }\r\n                    });\r\n                    break;\r\n                default:\r\n                    break;\r\n            }\r\n            return columnSelectSelected;\r\n\r\n        }, // End of function getDropdownSelected\r\n\r\n\r\n        /**\r\n         * Generate a unique id for a containing div using the function name and the column display name.\r\n         *\r\n         * @param {Object} funcname\r\n         * @param {Object} columnName\r\n         * @param {Object} listName\r\n         */\r\n        genContainerId: function(funcname, columnName, listName) {\r\n            var l = listName !== undefined ? listName : $().SPServices.SPListNameFromUrl();\r\n            return funcname + \"_\" + $().SPServices.SPGetStaticFromDisplay({\r\n                    listName: l,\r\n                    columnDisplayName: columnName\r\n                });\r\n        } // End of function genContainerId\r\n\r\n    }, //end: utils\r\n\r\n    //-----------[ PRIVATE METHODS BELOW ]---------------------\r\n    // These should all be defined against a local variable so\r\n    // that we get smaller minified files\r\n\r\n    /**\r\n     * Call this function to pop up a branded modal msgBox\r\n     * @private\r\n     */\r\n    modalBox = function(msg) {\r\n        var boxCSS = \"position:absolute;width:300px;height:150px;padding:10px;background-color:#000000;color:#ffffff;z-index:30;font-family:'Arial';font-size:12px;display:none;\";\r\n        $(\"#aspnetForm\").parent().append(\"<div id='SPServices_msgBox' style=\" + boxCSS + \">\" + msg);\r\n        var msgBoxObj = $(\"#SPServices_msgBox\");\r\n        var height = msgBoxObj.height();\r\n        var width = msgBoxObj.width();\r\n        var leftVal = ($(window).width() / 2) - (width / 2) + \"px\";\r\n        var topVal = ($(window).height() / 2) - (height / 2) - 100 + \"px\";\r\n        msgBoxObj.css({\r\n            border: '5px #C02000 solid',\r\n            left: leftVal,\r\n            top: topVal\r\n        }).show().fadeTo(\"slow\", 0.75).click(function () {\r\n            $(this).fadeOut(\"3000\", function () {\r\n                $(this).remove();\r\n            });\r\n        });\r\n    }; // End of function modalBox;\r\n\r\n\r\n    return utils;\r\n\r\n});\r\n\r\n",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Return the current version of SPServices as a string\r\n    $.fn.SPServices.Version = function () {\r\n\r\n        return constants.VERSION;\r\n\r\n    }; // End $.fn.SPServices.Version\r\n\r\n    return $;\r\n\r\n});",null,"define([], function () {\r\n\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Maintains a set of constants for SPServices.\r\n     *\r\n     * @namespace constants\r\n     */\r\n\r\n    var constants = {\r\n\r\n        // Version info\r\n        VERSION: \"@VERSION\", // update it in package.json... build takes care of the rest\r\n\r\n        // Simple strings\r\n        spDelim: \";#\",\r\n        SLASH: \"/\",\r\n        TXTColumnNotFound: \"Column not found on page\",\r\n\r\n        // String constants\r\n        //   General\r\n        SCHEMASharePoint: \"http://schemas.microsoft.com/sharepoint\",\r\n        SCHEMANintex: \"http://nintex.com\",\r\n        multiLookupPrefix: \"MultiLookupPicker\",\r\n        multiLookupPrefix2013: \"MultiLookup\",\r\n\r\n        // Dropdown Types\r\n        dropdownType: {\r\n            simple: \"S\",\r\n            complex: \"C\",\r\n            multiSelect: \"M\"\r\n        },\r\n\r\n        // Known list field types - See: http://msdn.microsoft.com/en-us/library/office/microsoft.sharepoint.spfieldtype(v=office.15).aspx\r\n        spListFieldTypes: [\r\n            \"Integer\",\r\n            \"Text\",\r\n            \"Note\",\r\n            \"DateTime\",\r\n            \"Counter\",\r\n            \"Choice\",\r\n            \"Lookup\",\r\n            \"Boolean\",\r\n            \"Number\",\r\n            \"Currency\",\r\n            \"URL\",\r\n//        \"Computed\", // NEW\r\n//        \"Threading\", // NEW\r\n//        \"Guid\", // NEW\r\n            \"MultiChoice\",\r\n//        \"GridChoice\", // NEW\r\n            \"Calculated\",\r\n            \"File\",\r\n            \"Attachments\",\r\n            \"User\",\r\n            \"Recurrence\", // Recurring event indicator (boolean) [0 | 1]\r\n//        \"CrossProjectLink\", // NEW\r\n            \"ModStat\",\r\n            \"ContentTypeId\",\r\n//        \"PageSeparator\", // NEW\r\n//        \"ThreadIndex\", // NEW\r\n            \"WorkflowStatus\", // NEW\r\n            \"AllDayEvent\", // All day event indicator (boolean) [0 | 1]\r\n//      \"WorkflowEventType\", // NEW\r\n//        \"Geolocation\", // NEW\r\n//        \"OutcomeChoice\", // NEW\r\n            \"RelatedItems\", // Related Items in a Workflow Tasks list\r\n\r\n            // Also seen\r\n            \"UserMulti\", // Multiselect users\r\n            \"LookupMulti\", // Multi-select lookup\r\n            \"datetime\", // Calculated date/time result\r\n            \"float\", // Calculated float\r\n            \"Calc\" // General calculated\r\n        ]\r\n\r\n    };\r\n\r\n    return constants;\r\n\r\n});\r\n",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Convert a JavaScript date to the ISO 8601 format required by SharePoint to update list items\r\n    $.fn.SPServices.SPConvertDateToISO = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            dateToConvert: new Date(), // The JavaScript date we'd like to convert. If no date is passed, the function returns the current date/time\r\n            dateOffset: \"-05:00\" // The time zone offset requested. Default is EST\r\n        }, options);\r\n\r\n        //Generate ISO 8601 date/time formatted string\r\n        var s = \"\";\r\n        var d = opt.dateToConvert;\r\n        s += d.getFullYear() + \"-\";\r\n        s += utils.pad(d.getMonth() + 1) + \"-\";\r\n        s += utils.pad(d.getDate());\r\n        s += \"T\" + utils.pad(d.getHours()) + \":\";\r\n        s += utils.pad(d.getMinutes()) + \":\";\r\n        s += utils.pad(d.getSeconds()) + \"Z\" + opt.dateOffset;\r\n        //Return the ISO8601 date string\r\n        return s;\r\n\r\n    }; // End $.fn.SPServices.SPConvertDateToISO\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n   //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core.js'\r\n], function (\r\n    $,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Utility function to show the results of a Web Service call formatted well in the browser.\r\n    $.fn.SPServices.SPDebugXMLHttpResult = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            node: null, // An XMLHttpResult object from an ajax call\r\n            indent: 0 // Number of indents\r\n        }, options);\r\n\r\n        var i;\r\n        var NODE_TEXT = 3;\r\n        var NODE_CDATA_SECTION = 4;\r\n\r\n        var outString = \"\";\r\n        // For each new subnode, begin rendering a new TABLE\r\n        outString += \"<table class='ms-vb' style='margin-left:\" + opt.indent * 3 + \"px;' width='100%'>\";\r\n        // DisplayPatterns are a bit unique, so let's handle them differently\r\n        if (opt.node.nodeName === \"DisplayPattern\") {\r\n            outString += \"<tr><td width='100px' style='font-weight:bold;'>\" + opt.node.nodeName +\r\n                \"</td><td><textarea readonly='readonly' rows='5' cols='50'>\" + opt.node.xml + \"</textarea></td></tr>\";\r\n            // A node which has no children\r\n        } else if (!opt.node.hasChildNodes()) {\r\n            outString += \"<tr><td width='100px' style='font-weight:bold;'>\" + opt.node.nodeName +\r\n                \"</td><td>\" + ((opt.node.nodeValue !== null) ? utils.checkLink(opt.node.nodeValue) : \"&nbsp;\") + \"</td></tr>\";\r\n            if (opt.node.attributes) {\r\n                outString += \"<tr><td colspan='99'>\" + utils.showAttrs(opt.node) + \"</td></tr>\";\r\n            }\r\n            // A CDATA_SECTION node\r\n        } else if (opt.node.hasChildNodes() && opt.node.firstChild.nodeType === NODE_CDATA_SECTION) {\r\n            outString += \"<tr><td width='100px' style='font-weight:bold;'>\" + opt.node.nodeName +\r\n                \"</td><td><textarea readonly='readonly' rows='5' cols='50'>\" + opt.node.parentNode.text + \"</textarea></td></tr>\";\r\n            // A TEXT node\r\n        } else if (opt.node.hasChildNodes() && opt.node.firstChild.nodeType === NODE_TEXT) {\r\n            outString += \"<tr><td width='100px' style='font-weight:bold;'>\" + opt.node.nodeName +\r\n                \"</td><td>\" + utils.checkLink(opt.node.firstChild.nodeValue) + \"</td></tr>\";\r\n            // Handle child nodes\r\n        } else {\r\n            outString += \"<tr><td width='100px' style='font-weight:bold;' colspan='99'>\" + opt.node.nodeName + \"</td></tr>\";\r\n            if (opt.node.attributes) {\r\n                outString += \"<tr><td colspan='99'>\" + utils.showAttrs(opt.node) + \"</td></tr>\";\r\n            }\r\n            // Since the node has child nodes, recurse\r\n            outString += \"<tr><td>\";\r\n            for (i = 0; i < opt.node.childNodes.length; i++) {\r\n                outString += $().SPServices.SPDebugXMLHttpResult({\r\n                    node: opt.node.childNodes.item(i),\r\n                    indent: opt.indent + 1\r\n                });\r\n            }\r\n            outString += \"</td></tr>\";\r\n        }\r\n        outString += \"</table>\";\r\n        // Return the HTML which we have built up\r\n        return outString;\r\n    }; // End $.fn.SPServices.SPDebugXMLHttpResult\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n    \"../utils/constants\",\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    utils,\r\n    constants\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Find a dropdown (or multi-select) in the DOM. Returns the dropdown object and its type:\r\n    // S = Simple (select)\r\n    // C = Compound (input + select hybrid)\r\n    // M = Multi-select (select hybrid)\r\n    $.fn.SPServices.SPDropdownCtl = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            displayName: \"\" // The displayName of the column on the form\r\n        }, options);\r\n\r\n        var columnObj = {};\r\n\r\n// Paul T., 2015.05.02: Commented out since is not currently used\r\n        // var colStaticName = $().SPServices.SPGetStaticFromDisplay({\r\n        // listName: $().SPServices.SPListNameFromUrl(),\r\n        // columnDisplayName: opt.displayName\r\n        // });\r\n\r\n        // Simple, where the select's title attribute is colName (DisplayName)\r\n        //  Examples:\r\n        //      SP2013 <select title=\"Country\" id=\"Country_d578ed64-2fa7-4c1e-8b41-9cc1d524fc28_$LookupField\">\r\n        //      SP2010: <SELECT name=ctl00$m$g_d10479d7_6965_4da0_b162_510bbbc58a7f$ctl00$ctl05$ctl01$ctl00$ctl00$ctl04$ctl00$Lookup title=Country id=ctl00_m_g_d10479d7_6965_4da0_b162_510bbbc58a7f_ctl00_ctl05_ctl01_ctl00_ctl00_ctl04_ctl00_Lookup>\r\n        //      SP2007: <select name=\"ctl00$m$g_e845e690_00da_428f_afbd_fbe804787763$ctl00$ctl04$ctl04$ctl00$ctl00$ctl04$ctl00$Lookup\" Title=\"Country\" id=\"ctl00_m_g_e845e690_00da_428f_afbd_fbe804787763_ctl00_ctl04_ctl04_ctl00_ctl00_ctl04_ctl00_Lookup\">\r\n        if ((columnObj.Obj = $(\"select[Title='\" + opt.displayName + \"']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.simple;\r\n            // Compound\r\n        } else if ((columnObj.Obj = $(\"input[Title='\" + opt.displayName + \"']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.complex;\r\n            // Simple, where the select's id begins with colStaticName (StaticName) - needed for required columns where title=\"DisplayName Required Field\"\r\n            //   Example: SP2013 <select title=\"Region Required Field\" id=\"Region_59566f6f-1c3b-4efb-9b7b-6dbc35fe3b0a_$LookupField\" showrelatedselected=\"3\">\r\n//        } else if ((columnObj.Obj = $(\"select:regex(id, (\" + colStaticName + \")(_)[0-9a-fA-F]{8}(-))\")).length === 1) {\r\n//            columnObj.Type = constants.dropdownType.simple;\r\n            // Multi-select: This will find the multi-select column control in English and most other language sites where the Title looks like 'Column Name possible values'\r\n        } else if ((columnObj.Obj = $(\"select[ID$='SelectCandidate'][Title^='\" + opt.displayName + \" ']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.multiSelect;\r\n            // Multi-select: This will find the multi-select column control on a Russian site (and perhaps others) where the Title looks like '????????? ????????: Column Name'\r\n        } else if ((columnObj.Obj = $(\"select[ID$='SelectCandidate'][Title$=': \" + opt.displayName + \"']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.multiSelect;\r\n            // Multi-select: This will find the multi-select column control on a German site (and perhaps others)\r\n        } else if ((columnObj.Obj = $(\"select[ID$='SelectCandidate'][Title$='\\\"\" + opt.displayName + \"\\\".']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.multiSelect;\r\n            // Multi-select: This will find the multi-select column control on a Italian site (and perhaps others) where the Title looks like \"Valori possibili Column name\"\r\n        } else if ((columnObj.Obj = $(\"select[ID$='SelectCandidate'][Title$=' \" + opt.displayName + \"']\")).length === 1) {\r\n            columnObj.Type = constants.dropdownType.multiSelect;\r\n        } else {\r\n            columnObj.Type = null;\r\n        }\r\n\r\n        // Last ditch effort\r\n        // Simple, finding based on the comment text at the top of the td.ms-formbody where the select's title begins with DisplayName - needed for required columns where title=\"DisplayName Required Field\"\r\n        //   Examples: SP2010 <select name=\"ctl00$m$g_308135f8_3f59_4d67_b5f8_c26776c498b7$ff51$ctl00$Lookup\" id=\"ctl00_m_g_308135f8_3f59_4d67_b5f8_c26776c498b7_ff51_ctl00_Lookup\" title=\"Region Required Field\">\r\n        //            SP2013 <select id=\"Soort_x0020_medicijn_ded19932-0b4f-4d71-bc3b-2d510e5f297a_$LookupField\" title=\"Soort medicijn Vereist veld\">\r\n        if (columnObj.Type === null) {\r\n            var fieldContainer = utils.findFormField(opt.displayName);\r\n            if (fieldContainer !== undefined) {\r\n                var fieldSelect1 = fieldContainer.find(\"select[title^='\" + opt.displayName + \" '][id$='_Lookup']\");\r\n                var fieldSelect2 = fieldContainer.find(\"select[title^='\" + opt.displayName + \" '][id$='LookupField']\");\r\n                var fieldSelect = fieldSelect1.length > 0 ? fieldSelect1 : fieldSelect2;\r\n\r\n                if (fieldSelect && fieldSelect.length === 1) {\r\n                    columnObj.Type = constants.dropdownType.simple;\r\n                    columnObj.Obj = fieldSelect;\r\n                }\r\n            }\r\n        }\r\n\r\n        if (columnObj.Type === constants.dropdownType.complex) {\r\n            columnObj.optHid = $(\"input[id='\" + columnObj.Obj.attr(\"optHid\") + \"']\");\r\n        } else if (columnObj.Type === constants.dropdownType.multiSelect) {\r\n            // Find the important bits of the multiselect control\r\n            columnObj.container = columnObj.Obj.closest(\"span\");\r\n            columnObj.MultiLookupPickerdata = columnObj.container.find(\"input[id$='\" + utils.multiLookupPrefix + \"_data'], input[id$='\" + utils.multiLookupPrefix2013 + \"_data']\");\r\n            var addButtonId = columnObj.container.find(\"[id$='AddButton']\").attr(\"id\");\r\n            columnObj.master =\r\n                window[addButtonId.replace(/AddButton/, constants.multiLookupPrefix + \"_m\")] || // SharePoint 2007\r\n                window[addButtonId.replace(/AddButton/, constants.multiLookupPrefix2013 + \"_m\")]; // SharePoint 2013\r\n        }\r\n\r\n        return columnObj;\r\n\r\n    }; // End of function $.fn.SPServices.SPDropdownCtl\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery'\r\n], function (\r\n    $\r\n) {\r\n    \"use strict\";\r\n\r\n    // This method for finding specific nodes in the returned XML was developed by Steve Workman. See his blog post\r\n    // http://www.steveworkman.com/html5-2/javascript/2011/improving-javascript-xml-node-finding-performance-by-2000/\r\n    // for performance details.\r\n    $.fn.SPFilterNode = function (name) {\r\n        return this.find('*').filter(function () {\r\n            return this.nodeName === name;\r\n        });\r\n    }; // End $.fn.SPFilterNode\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    var SPServices = window.SPServices || {};\r\n\r\n    // Function to determine the current Web's URL.  We need this for successful Ajax calls.\r\n    // The function is also available as a public function.\r\n    $.fn.SPServices.SPGetCurrentSite = function () {\r\n\r\n        var currentContext = utils.SPServicesContext();\r\n\r\n        // We've already determined the current site...\r\n        if (currentContext.thisSite.length > 0) {\r\n            return currentContext.thisSite;\r\n        }\r\n\r\n        // If we still don't know the current site, we call WebUrlFromPageUrlResult.\r\n        var msg = SPServices.SOAPEnvelope.header +\r\n            \"<WebUrlFromPageUrl xmlns='\" + constants.SCHEMASharePoint + \"/soap/' ><pageUrl>\" +\r\n            ((location.href.indexOf(\"?\") > 0) ? location.href.substr(0, location.href.indexOf(\"?\")) : location.href) +\r\n            \"</pageUrl></WebUrlFromPageUrl>\" +\r\n            SPServices.SOAPEnvelope.footer;\r\n        $.ajax({\r\n            async: false, // Need this to be synchronous so we're assured of a valid value\r\n            url: \"/_vti_bin/Webs.asmx\",\r\n            type: \"POST\",\r\n            data: msg,\r\n            dataType: \"xml\",\r\n            contentType: \"text/xml;charset=\\\"utf-8\\\"\",\r\n            complete: function (xData) {\r\n                currentContext.thisSite = $(xData.responseXML).find(\"WebUrlFromPageUrlResult\").text();\r\n            }\r\n        });\r\n\r\n        return currentContext.thisSite; // Return the URL\r\n\r\n    }; // End $.fn.SPServices.SPGetCurrentSite\r\n\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function which returns the account name for the current user in DOMAIN\\username format\r\n    $.fn.SPServices.SPGetCurrentUser = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // URL of the target Site Collection.  If not specified, the current Web is used.\r\n            fieldName: \"Name\", // Specifies which field to return from the userdisp.aspx page\r\n            fieldNames: {}, // Specifies which fields to return from the userdisp.aspx page - added in v0.7.2 to allow multiple columns\r\n            debug: false // If true, show error messages; if false, run silent\r\n        }, options);\r\n\r\n        var currentContext = utils.SPServicesContext();\r\n\r\n        // The current user's ID is reliably available in an existing JavaScript variable\r\n        if (opt.fieldName === \"ID\" && typeof currentContext.thisUserId !== \"undefined\") {\r\n            return currentContext.thisUserId;\r\n        }\r\n\r\n        var thisField = \"\";\r\n        var theseFields = {};\r\n        var fieldCount = opt.fieldNames.length > 0 ? opt.fieldNames.length : 1;\r\n        var thisUserDisp;\r\n        var thisWeb = opt.webURL.length > 0 ? opt.webURL : $().SPServices.SPGetCurrentSite();\r\n\r\n        // Get the UserDisp.aspx page using AJAX\r\n        $.ajax({\r\n            // Need this to be synchronous so we're assured of a valid value\r\n            async: false,\r\n            // Force parameter forces redirection to a page that displays the information as stored in the UserInfo table rather than My Site.\r\n            // Adding the extra Query String parameter with the current date/time forces the server to view this as a new request.\r\n            url: ((thisWeb === \"/\") ? \"\" : thisWeb) + \"/_layouts/userdisp.aspx?Force=True&\" + new Date().getTime(),\r\n            complete: function (xData) {\r\n                thisUserDisp = xData;\r\n            }\r\n        });\r\n\r\n        for (var i = 0; i < fieldCount; i++) {\r\n\r\n            // The current user's ID is reliably available in an existing JavaScript variable\r\n            if (opt.fieldNames[i] === \"ID\") {\r\n                thisField = currentContext.thisUserId;\r\n            } else {\r\n                var thisTextValue;\r\n                if (fieldCount > 1) {\r\n                    thisTextValue = RegExp(\"FieldInternalName=\\\"\" + opt.fieldNames[i] + \"\\\"\", \"gi\");\r\n                } else {\r\n                    thisTextValue = RegExp(\"FieldInternalName=\\\"\" + opt.fieldName + \"\\\"\", \"gi\");\r\n                }\r\n                $(thisUserDisp.responseText).find(\"table.ms-formtable td[id^='SPField']\").each(function () {\r\n                    if (thisTextValue.test($(this).html())) {\r\n                        // Each fieldtype contains a different data type, as indicated by the id\r\n                        switch ($(this).attr(\"id\")) {\r\n                            case \"SPFieldText\":\r\n                                thisField = $(this).text();\r\n                                break;\r\n                            case \"SPFieldNote\":\r\n                                thisField = $(this).find(\"div\").html();\r\n                                break;\r\n                            case \"SPFieldURL\":\r\n                                thisField = $(this).find(\"img\").attr(\"src\");\r\n                                break;\r\n                            // Just in case\r\n                            default:\r\n                                thisField = $(this).text();\r\n                                break;\r\n                        }\r\n                        // Stop looking; we're done\r\n                        return false;\r\n                    }\r\n                });\r\n            }\r\n            if (opt.fieldNames[i] !== \"ID\") {\r\n                thisField = (typeof thisField !== \"undefined\") ? thisField.replace(/(^[\\s\\xA0]+|[\\s\\xA0]+$)/g, '') : null;\r\n            }\r\n            if (fieldCount > 1) {\r\n                theseFields[opt.fieldNames[i]] = thisField;\r\n            }\r\n        }\r\n\r\n        return (fieldCount > 1) ? theseFields : thisField;\r\n\r\n    }; // End $.fn.SPServices.SPGetCurrentUser\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n   //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // This function returns the DisplayName for a column based on the StaticName.\r\n    $.fn.SPServices.SPGetDisplayFromStatic = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // URL of the target Web.  If not specified, the current Web is used.\r\n            listName: \"\", // The name or GUID of the list\r\n            columnStaticName: \"\", // StaticName of the column\r\n            columnStaticNames: {} // StaticName of the columns - added in v0.7.2 to allow multiple columns\r\n        }, options);\r\n\r\n        var displayName = \"\";\r\n        var displayNames = {};\r\n        var nameCount = opt.columnStaticNames.length > 0 ? opt.columnStaticNames.length : 1;\r\n\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            completefunc: function (xData) {\r\n                if (nameCount > 1) {\r\n                    for (var i = 0; i < nameCount; i++) {\r\n                        displayNames[opt.columnStaticNames[i]] = $(xData.responseXML).find(\"Field[StaticName='\" + opt.columnStaticNames[i] + \"']\").attr(\"DisplayName\");\r\n                    }\r\n                } else {\r\n                    displayName = $(xData.responseXML).find(\"Field[StaticName='\" + opt.columnStaticName + \"']\").attr(\"DisplayName\");\r\n                }\r\n            }\r\n        });\r\n\r\n        return (nameCount > 1) ? displayNames : displayName;\r\n\r\n    }; // End $.fn.SPServices.SPGetDisplayFromStatic\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function to return the ID of the last item created on a list by a specific user. Useful for maintaining parent/child relationships\r\n    // between list forms\r\n    $.fn.SPServices.SPGetLastItemId = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // URL of the target Web.  If not specified, the current Web is used.\r\n            listName: \"\", // The name or GUID of the list\r\n            userAccount: \"\", // The account for the user in DOMAIN\\username format. If not specified, the current user is used.\r\n            CAMLQuery: \"\" // [Optional] For power users, this CAML fragment will be Anded with the default query on the relatedList\r\n        }, options);\r\n\r\n        var userId;\r\n        var lastId = 0;\r\n        $().SPServices({\r\n            operation: \"GetUserInfo\",\r\n            webURL: opt.webURL,\r\n            async: false,\r\n            userLoginName: (opt.userAccount !== \"\") ? opt.userAccount : $().SPServices.SPGetCurrentUser(),\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).find(\"User\").each(function () {\r\n                    userId = $(this).attr(\"ID\");\r\n                });\r\n            }\r\n        });\r\n\r\n        // Get the list items for the user, sorted by Created, descending. If the CAMLQuery option has been specified, And it with\r\n        // the existing Where clause\r\n        var camlQuery = \"<Query><Where>\";\r\n        if (opt.CAMLQuery.length > 0) {\r\n            camlQuery += \"<And>\";\r\n        }\r\n        camlQuery += \"<Eq><FieldRef Name='Author' LookupId='TRUE'/><Value Type='Integer'>\" + userId + \"</Value></Eq>\";\r\n        if (opt.CAMLQuery.length > 0) {\r\n            camlQuery += opt.CAMLQuery + \"</And>\";\r\n        }\r\n        camlQuery += \"</Where><OrderBy><FieldRef Name='Created_x0020_Date' Ascending='FALSE'/></OrderBy></Query>\";\r\n\r\n        $().SPServices({\r\n            operation: \"GetListItems\",\r\n            async: false,\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            CAMLQuery: camlQuery,\r\n            CAMLViewFields: \"<ViewFields><FieldRef Name='ID'/></ViewFields>\",\r\n            CAMLRowLimit: 1,\r\n            CAMLQueryOptions: \"<QueryOptions><ViewAttributes Scope='Recursive' /></QueryOptions>\",\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                    lastId = $(this).attr(\"ows_ID\");\r\n                });\r\n            }\r\n        });\r\n        return lastId;\r\n    }; // End $.fn.SPServices.SPGetLastItemId\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // SPGetListItemsJson retrieves items from a list in JSON format\r\n    $.fn.SPServices.SPGetListItemsJson = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // [Optional] URL of the target Web.  If not specified, the current Web is used.\r\n            listName: \"\",\r\n            viewName: \"\",\r\n            CAMLQuery: \"\",\r\n            CAMLViewFields: \"\",\r\n            CAMLRowLimit: \"\",\r\n            CAMLQueryOptions: \"\",\r\n            changeToken: \"\", // [Optional] If provided, will be passed with the request\r\n            contains: \"\", // CAML snippet for an additional filter\r\n            mapping: null, // If provided, use this mapping rather than creating one automagically from the list schema\r\n            mappingOverrides: null, // Pass in specific column overrides here\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, $().SPServices.defaults, options);\r\n\r\n        var newChangeToken;\r\n        var thisListJsonMapping = {};\r\n        var deletedIds = [];\r\n        var result = $.Deferred();\r\n\r\n        // Call GetListItems to find all of the items matching the CAMLQuery\r\n        var thisData = $().SPServices({\r\n            operation: \"GetListItemChangesSinceToken\",\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            viewName: opt.viewName,\r\n            CAMLQuery: opt.CAMLQuery,\r\n            CAMLViewFields: opt.CAMLViewFields,\r\n            CAMLRowLimit: opt.CAMLRowLimit,\r\n            CAMLQueryOptions: opt.CAMLQueryOptions,\r\n            changeToken: opt.changeToken,\r\n            contains: opt.contains\r\n        });\r\n\r\n        thisData.then(function () {\r\n\r\n            var mappingKey = \"SPGetListItemsJson\" + opt.webURL + opt.listName;\r\n\r\n            // We're going to use this multiple times\r\n            var responseXml = $(thisData.responseXML);\r\n\r\n            // Get the changeToken\r\n            newChangeToken = responseXml.find(\"Changes\").attr(\"LastChangeToken\");\r\n\r\n            // Some of the existing items may have been deleted\r\n            responseXml.find(\"listitems Changes Id[ChangeType='Delete']\").each(function () {\r\n                deletedIds.push($(this).text());\r\n            });\r\n\r\n            if (opt.mapping === null) {\r\n                // Automagically create the mapping\r\n                responseXml.find(\"List > Fields > Field\").each(function () {\r\n                    var thisField = $(this);\r\n                    var thisType = thisField.attr(\"Type\");\r\n                    // Only work with known column types\r\n                    if ($.inArray(thisType, constants.spListFieldTypes) >= 0) {\r\n                        thisListJsonMapping[\"ows_\" + thisField.attr(\"Name\")] = {\r\n                            mappedName: thisField.attr(\"Name\"),\r\n                            objectType: thisField.attr(\"Type\")\r\n                        };\r\n                    }\r\n\r\n                });\r\n\r\n            } else {\r\n                thisListJsonMapping = opt.mapping;\r\n            }\r\n\r\n            // Implement any mappingOverrides\r\n            // Example: { ows_JSONTextColumn: { mappedName: \"JTC\", objectType: \"JSON\" } }\r\n            if (opt.mappingOverrides !== null) {\r\n                // For each mappingOverride, override the list schema\r\n                for (var mapping in opt.mappingOverrides) {\r\n                    thisListJsonMapping[mapping] = opt.mappingOverrides[mapping];\r\n                }\r\n            }\r\n\r\n            // If we haven't retrieved the list schema in this call, try to grab it from the saved data from a prior call\r\n            if ($.isEmptyObject(thisListJsonMapping)) {\r\n                thisListJsonMapping = $(document).data(mappingKey);\r\n            } else {\r\n                $(document).data(mappingKey, thisListJsonMapping);\r\n            }\r\n\r\n            var jsonData = responseXml.SPFilterNode(\"z:row\").SPXmlToJson({\r\n                mapping: thisListJsonMapping,\r\n                sparse: true\r\n            });\r\n\r\n            var thisResult = {\r\n                changeToken: newChangeToken,\r\n                mapping: thisListJsonMapping,\r\n                data: jsonData,\r\n                deletedIds: deletedIds\r\n            };\r\n\r\n            result.resolveWith(thisResult);\r\n\r\n        },\r\n        function (err) { \r\n            result.rejectWith(err);\r\n        });\r\n\r\n        return result.promise();\r\n\r\n    }; // End $.fn.SPServices.SPGetListItemsJson\r\n\r\n    return $;\r\n\r\n});\r\n",null,"define([\r\n    'jquery'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Get the Query String parameters and their values and return in an array\r\n    // Includes code from http://www.developerdrive.com/2013/08/turning-the-querystring-into-a-json-object-using-javascript/\r\n    // Simplified in 2014.01 using this code\r\n    $.fn.SPServices.SPGetQueryString = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            lowercase: false // If true, parameter names will be converted to lowercase\r\n        }, options);\r\n\r\n        var queryStringVals = {};\r\n\r\n        var qs = location.search.slice(1).split('&');\r\n\r\n        for (var i = 0; i < qs.length; i++) {\r\n            var param = qs[i].split('=');\r\n            var paramName = opt.lowercase ? param[0].toLowerCase() : param[0];\r\n            queryStringVals[paramName] = decodeURIComponent(param[1] || \"\");\r\n        }\r\n\r\n        return queryStringVals;\r\n\r\n    }; // End $.fn.SPServices.SPGetQueryString\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n   //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // This function returns the StaticName for a column based on the DisplayName.\r\n    $.fn.SPServices.SPGetStaticFromDisplay = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // URL of the target Web.  If not specified, the current Web is used.\r\n            listName: \"\", // The name or GUID of the list\r\n            columnDisplayName: \"\", // DisplayName of the column\r\n            columnDisplayNames: {} // DisplayNames of the columns - added in v0.7.2 to allow multiple columns\r\n        }, options);\r\n\r\n        var staticName = \"\";\r\n        var staticNames = {};\r\n        var nameCount = opt.columnDisplayNames.length > 0 ? opt.columnDisplayNames.length : 1;\r\n\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            completefunc: function (xData) {\r\n                if (nameCount > 1) {\r\n                    for (var i = 0; i < nameCount; i++) {\r\n                        staticNames[opt.columnDisplayNames[i]] = $(xData.responseXML).find(\"Field[DisplayName='\" + opt.columnDisplayNames[i] + \"']\").attr(\"StaticName\");\r\n                    }\r\n                } else {\r\n                    staticName = $(xData.responseXML).find(\"Field[DisplayName='\" + opt.columnDisplayName + \"']\").attr(\"StaticName\");\r\n                }\r\n            }\r\n        });\r\n\r\n        return (nameCount > 1) ? staticNames : staticName;\r\n\r\n    }; // End $.fn.SPServices.SPGetStaticFromDisplay\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    $.fn.SPServices.SPListNameFromUrl = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            listName: \"\" // [Optional] Pass in the name or GUID of a list if you are not in its context. e.g., on a Web Part pages in the Pages library\r\n        }, options);\r\n\r\n        var currentContext = utils.SPServicesContext();\r\n\r\n        // Has the list name or GUID been passed in?\r\n        if (opt.listName.length > 0) {\r\n// TODO            currentContext({ listName: opt.listName });\r\n            return opt.listName;\r\n            // Do we already know the current list?\r\n        } else if (currentContext.thisList !== undefined && currentContext.thisList.length > 0) {\r\n            return currentContext.thisList;\r\n        }\r\n\r\n        // Parse out the list's root URL from the current location or the passed url\r\n        var thisPage = location.href;\r\n        var thisPageBaseName = thisPage.substring(0, thisPage.indexOf(\".aspx\"));\r\n        var listPath = decodeURIComponent(thisPageBaseName.substring(0, thisPageBaseName.lastIndexOf(constants.SLASH) + 1)).toUpperCase();\r\n\r\n        // Call GetListCollection and loop through the results to find a match with the list's URL to get the list's GUID\r\n        $().SPServices({\r\n            operation: \"GetListCollection\",\r\n            async: false,\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).find(\"List\").each(function () {\r\n                    var defaultViewUrl = $(this).attr(\"DefaultViewUrl\");\r\n                    var listCollList = defaultViewUrl.substring(0, defaultViewUrl.lastIndexOf(constants.SLASH) + 1).toUpperCase();\r\n                    if (listPath.indexOf(listCollList) > 0) {\r\n                        currentContext.thisList = $(this).attr(\"ID\");\r\n                        return false;\r\n                    }\r\n                });\r\n            }\r\n        });\r\n\r\n        // Return the list GUID (ID)\r\n        return currentContext.thisList;\r\n\r\n    }; // End $.fn.SPServices.SPListNameFromUrl\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // This function converts an XML node set to JSON\r\n    // Initial implementation focuses only on GetListItems\r\n    $.fn.SPXmlToJson = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            mapping: {}, // columnName: mappedName: \"mappedName\", objectType: \"objectType\"\r\n            includeAllAttrs: false, // If true, return all attributes, regardless whether they are in the mapping\r\n            removeOws: true, // Specifically for GetListItems, if true, the leading ows_ will be stripped off the field name\r\n            sparse: false // If true, empty (\"\") values will not be returned\r\n        }, options);\r\n\r\n        var attrNum;\r\n        var jsonObject = [];\r\n\r\n        this.each(function () {\r\n            var row = {};\r\n            var rowAttrs = this.attributes;\r\n\r\n            if (!opt.sparse) {\r\n                // Bring back all mapped columns, even those with no value\r\n                $.each(opt.mapping, function () {\r\n                    row[this.mappedName] = \"\";\r\n                });\r\n            }\r\n\r\n            // Parse through the element's attributes\r\n            for (attrNum = 0; attrNum < rowAttrs.length; attrNum++) {\r\n                var thisAttrName = rowAttrs[attrNum].name;\r\n                var thisMapping = opt.mapping[thisAttrName];\r\n                var thisObjectName = thisMapping && thisMapping.mappedName ? thisMapping.mappedName : opt.removeOws ? thisAttrName.split(\"ows_\")[1] : thisAttrName;\r\n                var thisObjectType = thisMapping !== undefined ? thisMapping.objectType : undefined;\r\n                if (opt.includeAllAttrs || thisMapping !== undefined) {\r\n                    row[thisObjectName] = attrToJson(rowAttrs[attrNum].value, thisObjectType);\r\n                }\r\n            }\r\n            // Push this item into the JSON Object\r\n            jsonObject.push(row);\r\n\r\n        });\r\n\r\n        // Return the JSON object\r\n        return jsonObject;\r\n\r\n    }; // End $.fn.SPServices.SPXmlToJson\r\n\r\n\r\n    function attrToJson(v, objectType) {\r\n        function identity(x) { return x; }\r\n\r\n        var result = {\r\n\r\n            /* Generic [Reusable] Functions */\r\n            \"Integer\": intToJsonObject,\r\n            \"Number\": floatToJsonObject,\r\n            \"Boolean\": booleanToJsonObject,\r\n            \"DateTime\": dateToJsonObject,\r\n            \"User\": userToJsonObject,\r\n            \"UserMulti\": userMultiToJsonObject,\r\n            \"Lookup\": lookupToJsonObject,\r\n            \"lookupMulti\": lookupMultiToJsonObject,\r\n            \"MultiChoice\": choiceMultiToJsonObject,\r\n            \"Calculated\": calcToJsonObject,\r\n            \"Attachments\": attachmentsToJsonObject,\r\n            \"URL\": urlToJsonObject,\r\n            \"JSON\": jsonToJsonObject, // Special case for text JSON stored in text columns\r\n\r\n            /* These objectTypes reuse above functions */\r\n            \"Text\": result.Default,\r\n            \"Counter\": result.Integer,\r\n            \"datetime\": result.DateTime,    // For calculated columns, stored as datetime;#value\r\n            \"AllDayEvent\": result.Boolean,\r\n            \"Recurrence\": result.Boolean,\r\n            \"Currency\": result.Number,\r\n            \"float\": result.Number, // For calculated columns, stored as float;#value\r\n            \"RelatedItems\": result.JSON,\r\n\r\n            \"Default\": identity\r\n        };\r\n\r\n        return (result[objectType] || identity)(v);\r\n\r\n/*\r\n        switch (objectType) {\r\n\r\n            case \"Text\":\r\n                colValue = v;\r\n                break;\r\n            case \"DateTime\":\r\n            case \"datetime\": // For calculated columns, stored as datetime;#value\r\n                // Dates have dashes instead of slashes: ows_Created=\"2009-08-25 14:24:48\"\r\n                colValue = dateToJsonObject(v);\r\n                break;\r\n            case \"User\":\r\n                colValue = userToJsonObject(v);\r\n                break;\r\n            case \"UserMulti\":\r\n                colValue = userMultiToJsonObject(v);\r\n                break;\r\n            case \"Lookup\":\r\n                colValue = lookupToJsonObject(v);\r\n                break;\r\n\r\n            case \"LookupMulti\":\r\n                colValue = lookupMultiToJsonObject(v);\r\n                break;\r\n            case \"Boolean\":\r\n            case \"AllDayEvent\":\r\n            case \"Recurrence\":\r\n                colValue = booleanToJsonObject(v);\r\n                break;\r\n\r\n            case \"Integer\":\r\n                colValue = intToJsonObject(v);\r\n                break;\r\n\r\n            case \"Counter\":\r\n                colValue = intToJsonObject(v);\r\n                break;\r\n\r\n            case \"MultiChoice\":\r\n                colValue = choiceMultiToJsonObject(v);\r\n                break;\r\n            case \"Number\":\r\n            case \"Currency\":\r\n            case \"float\": // For calculated columns, stored as float;#value\r\n                colValue = floatToJsonObject(v);\r\n                break;\r\n            case \"Calculated\":\r\n                colValue = calcToJsonObject(v);\r\n                break;\r\n            case \"Attachments\":\r\n                colValue = attachmentsToJsonObject(v);\r\n                break;\r\n            case \"URL\":\r\n                colValue = urlToJsonObject(v);\r\n                break;\r\n            case \"JSON\":\r\n            case \"RelatedItems\":\r\n                colValue = jsonToJsonObject(v); // Special case for text JSON stored in text columns\r\n                break;\r\n\r\n            default:\r\n                // All other objectTypes will be simple strings\r\n                colValue = v;\r\n                break;\r\n        }\r\n        return colValue;\r\n */\r\n    }\r\n\r\n    function intToJsonObject(s) {\r\n        return parseInt(s, 10);\r\n    }\r\n\r\n    function floatToJsonObject(s) {\r\n        return parseFloat(s);\r\n    }\r\n\r\n    function booleanToJsonObject(s) {\r\n        return s !== \"0\";\r\n    }\r\n\r\n    function dateToJsonObject(s) {\r\n\r\n        var dt = s.split(\"T\")[0] !== s ? s.split(\"T\") : s.split(\" \");\r\n        var d = dt[0].split(\"-\");\r\n        var t = dt[1].split(\":\");\r\n        var t3 = t[2].split(\"Z\");\r\n        return new Date(d[0], (d[1] - 1), d[2], t[0], t[1], t3[0]);\r\n    }\r\n\r\n    function userToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisUser = new utils.SplitIndex(s);\r\n            var thisUserExpanded = thisUser.value.split(\",#\");\r\n            if (thisUserExpanded.length === 1) {\r\n                return {\r\n                    userId: thisUser.id,\r\n                    userName: thisUser.value\r\n                };\r\n            } else {\r\n                return {\r\n                    userId: thisUser.id,\r\n                    userName: thisUserExpanded[0].replace(/(,,)/g, \",\"),\r\n                    loginName: thisUserExpanded[1].replace(/(,,)/g, \",\"),\r\n                    email: thisUserExpanded[2].replace(/(,,)/g, \",\"),\r\n                    sipAddress: thisUserExpanded[3].replace(/(,,)/g, \",\"),\r\n                    title: thisUserExpanded[4].replace(/(,,)/g, \",\")\r\n                };\r\n            }\r\n        }\r\n    }\r\n\r\n    function userMultiToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisUserMultiObject = [];\r\n            var thisUserMulti = s.split(constants.spDelim);\r\n            for (var i = 0; i < thisUserMulti.length; i = i + 2) {\r\n                var thisUser = userToJsonObject(thisUserMulti[i] + constants.spDelim + thisUserMulti[i + 1]);\r\n                thisUserMultiObject.push(thisUser);\r\n            }\r\n            return thisUserMultiObject;\r\n        }\r\n    }\r\n\r\n    function lookupToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisLookup = s.split(constants.spDelim);\r\n            return {\r\n                lookupId: thisLookup[0],\r\n                lookupValue: thisLookup[1]\r\n            };\r\n        }\r\n    }\r\n\r\n    function lookupMultiToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisLookupMultiObject = [];\r\n            var thisLookupMulti = s.split(constants.spDelim);\r\n            for (var i = 0; i < thisLookupMulti.length; i = i + 2) {\r\n                var thisLookup = lookupToJsonObject(thisLookupMulti[i] + constants.spDelim + thisLookupMulti[i + 1]);\r\n                thisLookupMultiObject.push(thisLookup);\r\n            }\r\n            return thisLookupMultiObject;\r\n        }\r\n    }\r\n\r\n    function choiceMultiToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisChoiceMultiObject = [];\r\n            var thisChoiceMulti = s.split(constants.spDelim);\r\n            for (var i = 0; i < thisChoiceMulti.length; i++) {\r\n                if (thisChoiceMulti[i].length !== 0) {\r\n                    thisChoiceMultiObject.push(thisChoiceMulti[i]);\r\n                }\r\n            }\r\n            return thisChoiceMultiObject;\r\n        }\r\n    }\r\n\r\n    function attachmentsToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else if (s === \"0\" || s === \"1\") {\r\n            return s;\r\n        } else {\r\n            var thisObject = [];\r\n            var thisString = s.split(constants.spDelim);\r\n            for (var i = 0; i < thisString.length; i++) {\r\n                if (thisString[i].length !== 0) {\r\n                    var fileName = thisString[i];\r\n                    if (thisString[i].lastIndexOf(\"/\") !== -1) {\r\n                        var tokens = thisString[i].split(\"/\");\r\n                        fileName = tokens[tokens.length - 1];\r\n                    }\r\n                    thisObject.push({\r\n                        attachment: thisString[i],\r\n                        fileName: fileName\r\n                    });\r\n                }\r\n            }\r\n            return thisObject;\r\n        }\r\n    }\r\n\r\n    function urlToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisUrl = s.split(\", \");\r\n            return {\r\n                Url: thisUrl[0],\r\n                Description: thisUrl[1]\r\n            };\r\n        }\r\n    }\r\n\r\n    function calcToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            var thisCalc = s.split(constants.spDelim);\r\n            // The first value will be the calculated column value type, the second will be the value\r\n            return attrToJson(thisCalc[1], thisCalc[0]);\r\n        }\r\n    }\r\n\r\n    function jsonToJsonObject(s) {\r\n        if (s.length === 0) {\r\n            return null;\r\n        } else {\r\n            return $.parseJSON(s);\r\n        }\r\n    }\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Rearrange radio buttons or checkboxes in a form from vertical to horizontal display to save page real estate\r\n    $.fn.SPServices.SPArrangeChoices = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list name for the current form\r\n            columnName: \"\", // The display name of the column in the form\r\n            perRow: 99, // Maximum number of choices desired per row.\r\n            randomize: false // If true, randomize the order of the options\r\n        }, options);\r\n\r\n        var columnFillInChoice = false;\r\n        var columnOptions = [];\r\n\r\n        // Get information about columnName from the list to determine if we're allowing fill-in choices\r\n        var thisGetList = $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            listName: opt.listName\r\n        });\r\n\r\n        // when the promise is available...\r\n        thisGetList.done(function () {\r\n            $(thisGetList.responseXML).find(\"Field[DisplayName='\" + opt.columnName + \"']\").each(function () {\r\n                // Determine whether columnName allows a fill-in choice\r\n                columnFillInChoice = ($(this).attr(\"FillInChoice\") === \"TRUE\");\r\n                // Stop looking;we're done\r\n                return false;\r\n            });\r\n\r\n            var thisFormField = utils.findFormField(opt.columnName);\r\n            var totalChoices = $(thisFormField).find(\"tr\").length;\r\n            var fillinPrompt;\r\n            var fillinInput;\r\n\r\n            // Collect all of the choices\r\n            $(thisFormField).find(\"tr\").each(function (choiceNumber) {\r\n                // If this is the fill-in prompt, save it...\r\n                if (columnFillInChoice && choiceNumber === (totalChoices - 2)) {\r\n                    fillinPrompt = $(this).find(\"td\");\r\n                    // ...or if it is the fill-in input box, save it...\r\n                } else if (columnFillInChoice && choiceNumber === (totalChoices - 1)) {\r\n                    fillinInput = $(this).find(\"td\");\r\n                    // ...else push into the columnOptions array.\r\n                } else {\r\n                    columnOptions.push($(this).find(\"td\"));\r\n                }\r\n            });\r\n\r\n            // If randomize is true, randomly sort the options\r\n            if (opt.randomize) {\r\n                columnOptions.sort(utils.randOrd);\r\n            }\r\n\r\n            //Create a new choices table to hold the arranged choices.\r\n            var newChoiceTable = $(\"<table cellpadding='0' cellspacing='1'></table>\");\r\n\r\n            //Iterate over all available choices placing them in the correct position in the new choices table.\r\n            for (var i = 0; i < columnOptions.length; i++) {\r\n                // If we've already got perRow columnOptions in the row, close off the row\r\n                if ((i + 1) % opt.perRow === 0) {\r\n                    newChoiceTable.append(\"<tr></tr>\");\r\n                }\r\n                newChoiceTable.append(columnOptions[i]);\r\n            }\r\n\r\n            //Insert fillInChoices section under available choices.\r\n            if (columnFillInChoice) {\r\n                var fillInRow = $(\"<tr><td colspan='99'><table cellpadding='0' cellspacing='1'><tr></tr></table></td></tr>\");\r\n                fillInRow.find(\"tr\").append(fillinPrompt);\r\n                fillInRow.find(\"tr\").append(fillinInput);\r\n                newChoiceTable.append(fillInRow);\r\n            }\r\n\r\n            //Insert new table before the old choice table so that choices will still line up with header.\r\n            var choiceTable = $(thisFormField).find(\"table:first\");\r\n            choiceTable.before(newChoiceTable);\r\n\r\n            //Choices table is not removed because validation depends on the table id.\r\n            choiceTable.hide();\r\n\r\n        });\r\n\r\n    }; // End $.fn.SPServices.SPArrangeChoices\r\n\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Provide suggested values from a list for in input column based on characters typed\r\n    $.fn.SPServices.SPAutocomplete = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // [Optional] The name of the Web (site) which contains the sourceList\r\n            sourceList: \"\", // The name of the list which contains the values\r\n            sourceColumn: \"\", // The static name of the column which contains the values\r\n            columnName: \"\", // The display name of the column in the form\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            CAMLQuery: \"\", // [Optional] For power users, this CAML fragment will be Anded with the default query on the relatedList\r\n            CAMLQueryOptions: \"<QueryOptions></QueryOptions>\", // [Optional] For power users, allows specifying the CAMLQueryOptions for the GetListItems call\r\n            CAMLRowLimit: 0, // [Optional] Override the default view rowlimit and get all appropriate rows\r\n            filterType: \"BeginsWith\", // Type of filtering: [BeginsWith, Contains]\r\n            numChars: 0, // Wait until this number of characters has been typed before attempting any actions\r\n            ignoreCase: false, // If set to true, the function ignores case, if false it looks for an exact match\r\n            highlightClass: \"\", // If a class is supplied, highlight the matched characters in the values by applying that class to a wrapping span\r\n            uniqueVals: false, // If set to true, the function only adds unique values to the list (no duplicates)\r\n            maxHeight: 99999, // Sets the maximum number of values to display before scrolling occurs\r\n            slideDownSpeed: \"fast\", // Speed at which the div should slide down when values match (milliseconds or [\"fast\" | \"slow\"])\r\n            processingIndicator: \"_layouts/images/REFRESH.GIF\", // If present, show this while processing\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n        var matchNum;\r\n\r\n        // Find the input control for the column and save some of its attributes\r\n        var columnObj = utils.findFormField(opt.columnName).find(\"input[Title^='\" + opt.columnName + \"']\");\r\n        columnObj.css(\"position\", \"\");\r\n        var columnObjColor = columnObj.css(\"color\");\r\n        var columnObjWidth = columnObj.css(\"width\");\r\n\r\n        if (columnObj.html() === null && opt.debug) {\r\n            utils.errBox(\"SPServices.SPAutocomplete\",\r\n                \"columnName: \" + opt.columnName,\r\n                \"Column is not an input control or is not found on page\");\r\n            return;\r\n        }\r\n\r\n        // Remove the <br/> which isn't needed and messes up the formatting\r\n        columnObj.closest(\"span\").find(\"br\").remove();\r\n        columnObj.wrap(\"<div>\");\r\n\r\n        // Create a div to contain the matching values and add it to the DOM\r\n        var containerId = utils.genContainerId(\"SPAutocomplete\", opt.columnName, opt.listName);\r\n        columnObj.after(\"<div><ul id='\" + containerId + \"' style='width:\" + columnObjWidth + \";display:none;padding:2px;border:1px solid #2A1FAA;background-color:#FFF;position:absolute;z-index:40;margin:0'></div>\");\r\n\r\n        // Set the width to match the width of the input control\r\n        var containerObj = $(\"#\" + containerId);\r\n        containerObj.css(\"width\", columnObjWidth);\r\n\r\n        // Handle keypresses\r\n        $(columnObj).keyup(function () {\r\n\r\n            // Get the column's value\r\n            var columnValue = $(this).val();\r\n\r\n            // Hide the container while we're working on it\r\n            containerObj.hide();\r\n\r\n            // Have enough characters been typed yet?\r\n            if (columnValue.length < opt.numChars) {\r\n                return false;\r\n            }\r\n\r\n            // Show the the processingIndicator as a background image in the input element\r\n            columnObj.css({\r\n                \"background-image\": \"url(\" + opt.processingIndicator + \")\",\r\n                \"background-position\": \"right\",\r\n                \"background-repeat\": \"no-repeat\"\r\n            });\r\n\r\n            // Array to hold the matched values\r\n            var matchArray = [];\r\n\r\n            // Build the appropriate CAMLQuery\r\n            var camlQuery = \"<Query><OrderBy><FieldRef Name='\" + opt.sourceColumn + \"'/></OrderBy><Where>\";\r\n            if (opt.CAMLQuery.length > 0) {\r\n                camlQuery += \"<And>\";\r\n            }\r\n            camlQuery += \"<\" + opt.filterType + \"><FieldRef Name='\" + opt.sourceColumn + \"'/><Value Type='Text'>\" + columnValue + \"</Value></\" + opt.filterType + \">\";\r\n            if (opt.CAMLQuery.length > 0) {\r\n                camlQuery += opt.CAMLQuery + \"</And>\";\r\n            }\r\n            camlQuery += \"</Where></Query>\";\r\n\r\n            // Call GetListItems to find all of the potential values\r\n            $().SPServices({\r\n                operation: \"GetListItems\",\r\n                async: false,\r\n                webURL: opt.WebURL,\r\n                listName: opt.sourceList,\r\n                CAMLQuery: camlQuery,\r\n                CAMLQueryOptions: opt.CAMLQueryOptions,\r\n                CAMLViewFields: \"<ViewFields><FieldRef Name='\" + opt.sourceColumn + \"' /></ViewFields>\",\r\n                CAMLRowLimit: opt.CAMLRowLimit,\r\n                completefunc: function (xData) {\r\n                    // Handle upper/lower case if ignoreCase = true\r\n                    var testValue = opt.ignoreCase ? columnValue.toUpperCase() : columnValue;\r\n                    // See which values match and add the ones that do to matchArray\r\n                    $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                        var thisValue = $(this).attr(\"ows_\" + opt.sourceColumn);\r\n                        var thisValueTest = opt.ignoreCase ? $(this).attr(\"ows_\" + opt.sourceColumn).toUpperCase() : $(this).attr(\"ows_\" + opt.sourceColumn);\r\n                        // Make sure we have a match...\r\n                        if (opt.filterType === \"Contains\") {\r\n                            var firstMatch = thisValueTest.indexOf(testValue);\r\n                            if ((firstMatch >= 0) &&\r\n                                    // ...and that the match is not already in the array if we want uniqueness\r\n                                (!opt.uniqueVals || ($.inArray(thisValue, matchArray) === -1))) {\r\n                                matchArray.push($(this).attr(\"ows_\" + opt.sourceColumn));\r\n                            }\r\n                        } else {\r\n                            // Handles normal case, which is BeginsWith and and other unknown values\r\n                            if (testValue === thisValueTest.substr(0, testValue.length) &&\r\n                                    // ...and that the match is not already in the array if we want uniqueness\r\n                                (!opt.uniqueVals || ($.inArray(thisValue, matchArray) === -1))) {\r\n                                matchArray.push($(this).attr(\"ows_\" + opt.sourceColumn));\r\n                            }\r\n                        }\r\n                    });\r\n                }\r\n            });\r\n\r\n            // Build out the set of list elements to contain the available values\r\n            var out = \"\";\r\n            for (var i = 0; i < matchArray.length; i++) {\r\n                // If a highlightClass has been supplied, wrap a span around each match\r\n                if (opt.highlightClass.length > 0) {\r\n                    // Set up Regex based on whether we want to ignore case\r\n                    var thisRegex = new RegExp(columnValue, opt.ignoreCase ? \"gi\" : \"g\");\r\n                    // Look for all occurrences\r\n                    var matches = matchArray[i].match(thisRegex);\r\n                    var startLoc = 0;\r\n                    // Loop for each occurrence, wrapping each in a span with the highlightClass CSS class\r\n                    for (matchNum = 0; matchNum < matches.length; matchNum++) {\r\n                        var thisPos = matchArray[i].indexOf(matches[matchNum], startLoc);\r\n                        var endPos = thisPos + matches[matchNum].length;\r\n                        var thisSpan = \"<span class='\" + opt.highlightClass + \"'>\" + matches[matchNum] + \"</span>\";\r\n                        matchArray[i] = matchArray[i].substr(0, thisPos) + thisSpan + matchArray[i].substr(endPos);\r\n                        startLoc = thisPos + thisSpan.length;\r\n                    }\r\n                }\r\n                // Add the value to the markup for the container\r\n                out += \"<li style='display: block;position: relative;cursor: pointer;'>\" + matchArray[i] + \"</li>\";\r\n            }\r\n\r\n            // Add all the list elements to the containerId container\r\n            containerObj.html(out);\r\n            // Set up hehavior for the available values in the list element\r\n            $(\"#\" + containerId + \" li\").click(function () {\r\n                $(\"#\" + containerId).fadeOut(opt.slideUpSpeed);\r\n                columnObj.val($(this).text());\r\n            }).mouseover(function () {\r\n                var mouseoverCss = {\r\n                    \"cursor\": \"hand\",\r\n                    \"color\": \"#ffffff\",\r\n                    \"background\": \"#3399ff\"\r\n                };\r\n                $(this).css(mouseoverCss);\r\n            }).mouseout(function () {\r\n                var mouseoutCss = {\r\n                    \"cursor\": \"inherit\",\r\n                    \"color\": columnObjColor,\r\n                    \"background\": \"transparent\"\r\n                };\r\n                $(this).css(mouseoutCss);\r\n            });\r\n\r\n            // If we've got some values to show, then show 'em!\r\n            if (matchArray.length > 0) {\r\n                $(\"#\" + containerId).slideDown(opt.slideDownSpeed);\r\n            }\r\n            // Remove the processing indicator\r\n            columnObj.css(\"background-image\", \"\");\r\n        });\r\n\r\n    }; // End $.fn.SPServices.SPAutocomplete\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function to set up cascading dropdowns on a SharePoint form\r\n    // (Newform.aspx, EditForm.aspx, or any other customized form.)\r\n    $.fn.SPServices.SPCascadeDropdowns = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            relationshipWebURL: \"\", // [Optional] The name of the Web (site) which contains the relationships list\r\n            relationshipList: \"\", // The name of the list which contains the parent/child relationships\r\n            relationshipListParentColumn: \"\", // The internal name of the parent column in the relationship list\r\n            relationshipListChildColumn: \"\", // The internal name of the child column in the relationship list\r\n            relationshipListSortColumn: \"\", // [Optional] If specified, sort the options in the dropdown by this column,\r\n            // otherwise the options are sorted by relationshipListChildColumn\r\n            parentColumn: \"\", // The display name of the parent column in the form\r\n            childColumn: \"\", // The display name of the child column in the form\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            CAMLQuery: \"\", // [Optional] For power users, this CAML fragment will be Anded with the default query on the relationshipList\r\n            CAMLQueryOptions: \"<QueryOptions><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns></QueryOptions>\", // [Optional] For power users, ability to specify Query Options\r\n            promptText: \"\", // [DEPRECATED] Text to use as prompt. If included, {0} will be replaced with the value of childColumn. Original value \"Choose {0}...\"\r\n            noneText: \"(None)\", // [Optional] Text to use for the (None) selection. Provided for non-English language support.\r\n            simpleChild: false, // [Optional] If set to true and childColumn is a complex dropdown, convert it to a simple dropdown\r\n            selectSingleOption: false, // [Optional] If set to true and there is only a single child option, select it\r\n            matchOnId: false, // By default, we match on the lookup's text value. If matchOnId is true, we'll match on the lookup id instead.\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n\r\n        var thisParentSetUp = false;\r\n        var thisFunction = \"SPServices.SPCascadeDropdowns\";\r\n\r\n        // Find the parent column's select (dropdown)\r\n        var parentSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.parentColumn\r\n        });\r\n        if (parentSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"parentColumn: \" + opt.parentColumn, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        // Find the child column's select (dropdown)\r\n        var childSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.childColumn\r\n        });\r\n        if (childSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"childColumn: \" + opt.childColumn, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        // If requested and the childColumn is a complex dropdown, convert to a simple dropdown\r\n        if (opt.simpleChild === true && childSelect.Type === constants.dropdownType.complex) {\r\n            $().SPServices.SPComplexToSimpleDropdown({\r\n                listName: opt.listName,\r\n                columnName: opt.childColumn\r\n            });\r\n            // Set the childSelect to reference the new simple dropdown\r\n            childSelect = $().SPServices.SPDropdownCtl({\r\n                displayName: opt.childColumn\r\n            });\r\n        }\r\n\r\n        var childColumnRequired, childColumnStatic;\r\n\r\n        // Get information about the childColumn from the current list\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            listName: opt.listName,\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).find(\"Fields\").each(function () {\r\n                    $(this).find(\"Field[DisplayName='\" + opt.childColumn + \"']\").each(function () {\r\n                        // Determine whether childColumn is Required\r\n                        childColumnRequired = ($(this).attr(\"Required\") === \"TRUE\");\r\n                        childColumnStatic = $(this).attr(\"StaticName\");\r\n                        // Stop looking; we're done\r\n                        return false;\r\n                    });\r\n                });\r\n            }\r\n        });\r\n\r\n        // Save data about each child column on the parent\r\n        var childColumn = {\r\n            opt: opt,\r\n            childSelect: childSelect,\r\n            childColumnStatic: childColumnStatic,\r\n            childColumnRequired: childColumnRequired\r\n        };\r\n        var childColumns = parentSelect.Obj.data(\"SPCascadeDropdownsChildColumns\");\r\n\r\n        // If this is the first child for this parent, then create the data object to hold the settings\r\n        if (typeof childColumns === \"undefined\") {\r\n            parentSelect.Obj.data(\"SPCascadeDropdownsChildColumns\", [childColumn]);\r\n            // If we already have a data object for this parent, then add the setting for this child to it\r\n        } else {\r\n            childColumns.push(childColumn);\r\n            parentSelect.Obj.data(\"SPCascadeDropdownsChildColumns\", childColumns);\r\n            thisParentSetUp = true;\r\n        }\r\n\r\n        // We only need to bind to the event(s) if we haven't already done so\r\n        if (!thisParentSetUp) {\r\n            switch (parentSelect.Type) {\r\n                // Plain old select\r\n                case constants.dropdownType.simple:\r\n                    parentSelect.Obj.bind(\"change\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    break;\r\n                // Input / Select hybrid\r\n                case constants.dropdownType.complex:\r\n                    // Bind to any change on the hidden input element\r\n                    parentSelect.optHid.bind(\"propertychange\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    break;\r\n                // Multi-select hybrid\r\n                case constants.dropdownType.multiSelect:\r\n                    // Handle the dblclick on the candidate select\r\n                    $(parentSelect.master.candidateControl).bind(\"dblclick\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    // Handle the dblclick on the selected values\r\n                    $(parentSelect.master.resultControl).bind(\"dblclick\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    // Handle button clicks\r\n                    $(parentSelect.master.addControl).bind(\"click\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    $(parentSelect.master.removeControl).bind(\"click\", function () {\r\n                        cascadeDropdown(parentSelect);\r\n                    });\r\n                    break;\r\n                default:\r\n                    break;\r\n            }\r\n        }\r\n        // Fire the change to set the initially allowable values\r\n        cascadeDropdown(parentSelect);\r\n\r\n    }; // End $.fn.SPServices.SPCascadeDropdowns\r\n\r\n    function cascadeDropdown(parentSelect) {\r\n        var choices = \"\";\r\n        var parentSelectSelected;\r\n        var childSelectSelected = null;\r\n        var newMultiLookupPickerdata;\r\n        var numChildOptions;\r\n        var firstChildOptionId;\r\n        var firstChildOptionValue;\r\n\r\n        // Filter each child column\r\n        var childColumns = parentSelect.Obj.data(\"SPCascadeDropdownsChildColumns\");\r\n        $(childColumns).each(function () {\r\n\r\n            // Break out the data objects for this child column\r\n            var i;\r\n            var opt = this.opt;\r\n            var childSelect = this.childSelect;\r\n            var childColumnStatic = this.childColumnStatic;\r\n            var childColumnRequired = this.childColumnRequired;\r\n\r\n            // Get the parent column selection(s)\r\n            parentSelectSelected = utils.getDropdownSelected(parentSelect, opt.matchOnId);\r\n\r\n            // If the selection hasn't changed, then there's nothing to do right now.  This is useful to reduce\r\n            // the number of Web Service calls when the parentSelect.Type = constants.dropdownType.complex or constants.dropdownType.multiSelect, as there are multiple propertychanges\r\n            // which don't require any action.  The attribute will be unique per child column in case there are\r\n            // multiple children for a given parent.\r\n            var allParentSelections = parentSelectSelected.join(constants.spDelim);\r\n            if (parentSelect.Obj.data(\"SPCascadeDropdown_Selected_\" + childColumnStatic) === allParentSelections) {\r\n                return;\r\n            }\r\n            parentSelect.Obj.data(\"SPCascadeDropdown_Selected_\" + childColumnStatic, allParentSelections);\r\n\r\n            // Get the current child column selection(s)\r\n            childSelectSelected = utils.getDropdownSelected(childSelect, true);\r\n\r\n            // When the parent column's selected option changes, get the matching items from the relationship list\r\n            // Get the list items which match the current selection\r\n            var sortColumn = (opt.relationshipListSortColumn.length > 0) ? opt.relationshipListSortColumn : opt.relationshipListChildColumn;\r\n            var camlQuery = \"<Query><OrderBy><FieldRef Name='\" + sortColumn + \"'/></OrderBy><Where><And>\";\r\n            if (opt.CAMLQuery.length > 0) {\r\n                camlQuery += \"<And>\";\r\n            }\r\n\r\n            // Build up the criteria for inclusion\r\n            if (parentSelectSelected.length === 0) {\r\n                // Handle the case where no values are selected in multi-selects\r\n                camlQuery += \"<Eq><FieldRef Name='\" + opt.relationshipListParentColumn + \"'/><Value Type='Text'></Value></Eq>\";\r\n            } else if (parentSelectSelected.length === 1) {\r\n                // Only one value is selected\r\n                camlQuery += \"<Eq><FieldRef Name='\" + opt.relationshipListParentColumn +\r\n                    (opt.matchOnId ? \"' LookupId='True'/><Value Type='Integer'>\" : \"'/><Value Type='Text'>\") +\r\n                    utils.escapeColumnValue(parentSelectSelected[0]) + \"</Value></Eq>\";\r\n            } else {\r\n                var compound = (parentSelectSelected.length > 2);\r\n                for (i = 0; i < (parentSelectSelected.length - 1); i++) {\r\n                    camlQuery += \"<Or>\";\r\n                }\r\n                for (i = 0; i < parentSelectSelected.length; i++) {\r\n                    camlQuery += \"<Eq><FieldRef Name='\" + opt.relationshipListParentColumn +\r\n                        (opt.matchOnId ? \"' LookupId='True'/><Value Type='Integer'>\" : \"'/><Value Type='Text'>\") +\r\n                        utils.escapeColumnValue(parentSelectSelected[i]) + \"</Value></Eq>\";\r\n                    if (i > 0 && (i < (parentSelectSelected.length - 1)) && compound) {\r\n                        camlQuery += \"</Or>\";\r\n                    }\r\n                }\r\n                camlQuery += \"</Or>\";\r\n            }\r\n\r\n            if (opt.CAMLQuery.length > 0) {\r\n                camlQuery += opt.CAMLQuery + \"</And>\";\r\n            }\r\n\r\n            // Make sure we don't get any items which don't have the child value\r\n            camlQuery += \"<IsNotNull><FieldRef Name='\" + opt.relationshipListChildColumn + \"' /></IsNotNull>\";\r\n\r\n            camlQuery += \"</And></Where></Query>\";\r\n\r\n            $().SPServices({\r\n                operation: \"GetListItems\",\r\n                // Force sync so that we have the right values for the child column onchange trigger\r\n                async: false,\r\n                webURL: opt.relationshipWebURL,\r\n                listName: opt.relationshipList,\r\n                // Filter based on the currently selected parent column's value\r\n                CAMLQuery: camlQuery,\r\n                // Only get the parent and child columns\r\n                CAMLViewFields: \"<ViewFields><FieldRef Name='\" + opt.relationshipListParentColumn + \"' /><FieldRef Name='\" + opt.relationshipListChildColumn + \"' /></ViewFields>\",\r\n                // Override the default view rowlimit and get all appropriate rows\r\n                CAMLRowLimit: 0,\r\n                // Even though setting IncludeMandatoryColumns to FALSE doesn't work as the docs describe, it fixes a bug in GetListItems with mandatory multi-selects\r\n                CAMLQueryOptions: opt.CAMLQueryOptions,\r\n                completefunc: function (xData) {\r\n\r\n                    // Handle errors\r\n                    $(xData.responseXML).find(\"errorstring\").each(function () {\r\n                        var thisFunction = \"SPServices.SPCascadeDropdowns\";\r\n                        var errorText = $(this).text();\r\n                        if (opt.debug && errorText === \"One or more field types are not installed properly. Go to the list settings page to delete these fields.\") {\r\n                            utils.errBox(thisFunction,\r\n                                \"relationshipListParentColumn: \" + opt.relationshipListParentColumn + \" or \" +\r\n                                \"relationshipListChildColumn: \" + opt.relationshipListChildColumn,\r\n                                \"Not found in relationshipList \" + opt.relationshipList);\r\n                        } else if (opt.debug && errorText === \"Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).\") {\r\n                            utils.errBox(thisFunction,\r\n                                \"relationshipList: \" + opt.relationshipList,\r\n                                \"List not found\");\r\n                        }\r\n\r\n                    });\r\n\r\n                    // Add an explanatory prompt\r\n                    switch (childSelect.Type) {\r\n                        case constants.dropdownType.simple:\r\n                            // Remove all of the existing options\r\n                            childSelect.Obj[0].innerHTML = \"\";\r\n//                            $(childSelect.Obj).find(\"option\").remove();\r\n                            // If the column is required or the promptText option is empty, don't add the prompt text\r\n                            if (!childColumnRequired && (opt.promptText.length > 0)) {\r\n                                childSelect.Obj.append(\"<option value='0'>\" + opt.promptText.replace(/\\{0\\}/g, opt.childColumn) + \"</option>\");\r\n                            } else if (!childColumnRequired) {\r\n                                childSelect.Obj.append(\"<option value='0'>\" + opt.noneText + \"</option>\");\r\n                            }\r\n                            break;\r\n                        case constants.dropdownType.complex:\r\n                            // If the column is required, don't add the \"(None)\" option\r\n                            choices = childColumnRequired ? \"\" : opt.noneText + \"|0\";\r\n                            childSelect.Obj.val(\"\");\r\n                            break;\r\n                        case constants.dropdownType.multiSelect:\r\n                            // Remove all of the existing options\r\n                            $(childSelect.master.candidateControl).find(\"option\").remove();\r\n                            newMultiLookupPickerdata = \"\";\r\n                            break;\r\n                        default:\r\n                            break;\r\n                    }\r\n                    // Get the count of items returned and save it so that we can select if it's a single option\r\n                    // The item count is stored thus: <rs:data ItemCount=\"1\">\r\n                    numChildOptions = parseFloat($(xData.responseXML).SPFilterNode(\"rs:data\").attr(\"ItemCount\"));\r\n\r\n                    // Add an option for each child item\r\n                    $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n\r\n                        var thisOption = {};\r\n\r\n                        // If relationshipListChildColumn is a Lookup column, then the ID should be for the Lookup value,\r\n                        // else the ID of the relationshipList item\r\n                        var thisValue = $(this).attr(\"ows_\" + opt.relationshipListChildColumn);\r\n\r\n                        if (typeof thisValue !== \"undefined\" && thisValue.indexOf(constants.spDelim) > 0) {\r\n                            thisOption = new utils.SplitIndex(thisValue);\r\n                        } else {\r\n                            thisOption.id = $(this).attr(\"ows_ID\");\r\n                            thisOption.value = thisValue;\r\n                        }\r\n\r\n                        // If the relationshipListChildColumn is a calculated column, then the value isn't preceded by the ID,\r\n                        // but by the datatype.  In this case, thisOption.id should be the ID of the relationshipList item.\r\n                        // e.g., float;#12345.67\r\n                        if (isNaN(thisOption.id)) {\r\n                            thisOption.id = $(this).attr(\"ows_ID\");\r\n                        }\r\n\r\n                        // Save the id and value for the first child option in case we need to select it (selectSingleOption option is true)\r\n                        firstChildOptionId = thisOption.id;\r\n                        firstChildOptionValue = thisOption.value;\r\n\r\n                        switch (childSelect.Type) {\r\n                            case constants.dropdownType.simple:\r\n                                var selected = ($(this).attr(\"ows_ID\") === childSelectSelected[0]) ? \" selected='selected'\" : \"\";\r\n                                childSelect.Obj.append(\"<option\" + selected + \" value='\" + thisOption.id + \"'>\" + thisOption.value + \"</option>\");\r\n                                break;\r\n                            case constants.dropdownType.complex:\r\n                                if (thisOption.id === childSelectSelected[0]) {\r\n                                    childSelect.Obj.val(thisOption.value);\r\n                                }\r\n                                choices = choices + ((choices.length > 0) ? \"|\" : \"\") + thisOption.value + \"|\" + thisOption.id;\r\n                                break;\r\n                            case constants.dropdownType.multiSelect:\r\n                                $(childSelect.master.candidateControl).append(\"<option value='\" + thisOption.id + \"'>\" + thisOption.value + \"</option>\");\r\n                                newMultiLookupPickerdata += thisOption.id + \"|t\" + thisOption.value + \"|t |t |t\";\r\n                                break;\r\n                            default:\r\n                                break;\r\n                        }\r\n                    });\r\n\r\n                    switch (childSelect.Type) {\r\n                        case constants.dropdownType.simple:\r\n                            childSelect.Obj.trigger(\"change\");\r\n                            // If there is only one option and the selectSingleOption option is true, then select it\r\n                            if (numChildOptions === 1 && opt.selectSingleOption === true) {\r\n                                $(childSelect.Obj).find(\"option[value!='0']:first\").attr(\"selected\", \"selected\");\r\n                            }\r\n                            break;\r\n                        case constants.dropdownType.complex:\r\n                            // Set the allowable choices\r\n                            childSelect.Obj.attr(\"choices\", choices);\r\n                            // If there is only one option and the selectSingleOption option is true, then select it\r\n                            if (numChildOptions === 1 && opt.selectSingleOption === true) {\r\n                                // Set the input element value\r\n                                $(childSelect.Obj).val(firstChildOptionValue);\r\n                                // Set the value of the optHid input element\r\n                                childSelect.optHid.val(firstChildOptionId);\r\n                            }\r\n                            // If there's no selection, then remove the value in the associated hidden input element (optHid)\r\n                            if (childSelect.Obj.val() === \"\") {\r\n                                childSelect.optHid.val(\"\");\r\n                            }\r\n                            break;\r\n                        case constants.dropdownType.multiSelect:\r\n                            // Clear the master\r\n                            childSelect.master.data = \"\";\r\n                            childSelect.MultiLookupPickerdata.val(newMultiLookupPickerdata);\r\n\r\n                            // Clear any prior selections that are no longer valid or aren't selected\r\n                            $(childSelect.master.resultControl).find(\"option\").each(function () {\r\n                                var thisSelected = $(this);\r\n                                thisSelected.prop(\"selected\", true);\r\n                                $(childSelect.master.candidateControl).find(\"option[value='\" + thisSelected.val() + \"']\").each(function () {\r\n                                    thisSelected.prop(\"selected\", false);\r\n                                });\r\n                            });\r\n                            GipRemoveSelectedItems(childSelect.master);\r\n\r\n                            // Hide any options in the candidate list which are already selected\r\n                            $(childSelect.master.candidateControl).find(\"option\").each(function () {\r\n                                var thisSelected = $(this);\r\n                                $(childSelect.master.resultControl).find(\"option[value='\" + thisSelected.val() + \"']\").each(function () {\r\n                                    thisSelected.remove();\r\n                                });\r\n                            });\r\n                            GipAddSelectedItems(childSelect.master);\r\n\r\n                            // Set master.data to the newly allowable values\r\n                            childSelect.master.data = GipGetGroupData(newMultiLookupPickerdata);\r\n\r\n                            // Trigger a dblclick so that the child will be cascaded if it is a multiselect.\r\n                            $(childSelect.master.candidateControl).trigger(\"dblclick\");\r\n\r\n                            break;\r\n                        default:\r\n                            break;\r\n                    }\r\n                }\r\n            });\r\n            // If present, call completefunc when all else is done\r\n            if (opt.completefunc !== null) {\r\n                opt.completefunc();\r\n            }\r\n        }); // $(childColumns).each(function()\r\n\r\n    } // End cascadeDropdown\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // function to convert complex dropdowns to simple dropdowns\r\n    $.fn.SPServices.SPComplexToSimpleDropdown = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            columnName: \"\", // The display name of the column in the form\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n        // Find the column's select (dropdown)\r\n        var columnSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.columnName\r\n        });\r\n        if (columnSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(\"SPServices.SPComplexToSimpleDropdown\", \"columnName: \" + opt.columnName, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        // If we don't have a complex dropdown, then there is nothing to do\r\n        if (columnSelect.Type !== constants.dropdownType.complex) {\r\n            return;\r\n        }\r\n\r\n        // The available options are stored in the choices attribute of the complex dropdown's input element...\r\n        var choices = $(columnSelect.Obj).attr(\"choices\").split(\"|\");\r\n\r\n        // We need to know which option is selected already, if any\r\n        var complexSelectSelectedId = columnSelect.optHid.val();\r\n\r\n        // Build up the simple dropdown, giving it an easy to select id\r\n        var simpleSelectId = utils.genContainerId(\"SPComplexToSimpleDropdown\", columnSelect.Obj.attr(\"title\"), opt.listName);\r\n\r\n        var simpleSelect = \"<select id='\" + simpleSelectId + \"' title='\" + opt.columnName + \"'>\";\r\n        for (var i = 0; i < choices.length; i = i + 2) {\r\n            var simpleSelectSelected = (choices[i + 1] === complexSelectSelectedId) ? \" selected='selected' \" : \" \";\r\n            simpleSelect += \"<option\" + simpleSelectSelected + \"value='\" + choices[i + 1] + \"'>\" + choices[i] + \"</option>\";\r\n        }\r\n        simpleSelect += \"</select>\";\r\n\r\n        // Append the new simple select to the form\r\n        columnSelect.Obj.closest(\"td\").prepend(simpleSelect);\r\n        var simpleSelectObj = $(\"#\" + simpleSelectId);\r\n\r\n        // Remove the complex dropdown functionality since we don't need it anymore...\r\n        columnSelect.Obj.closest(\"span\").find(\"img\").remove();\r\n        // ...and hide the input element\r\n        columnSelect.Obj.closest(\"span\").find(\"input\").hide();\r\n\r\n        // When the simple select changes...\r\n        simpleSelectObj.change(function () {\r\n            var thisVal = $(this).val();\r\n            // ...set the optHid input element's value to the valus of the selected option...\r\n            columnSelect.optHid.val(thisVal);\r\n            // ...and save the selected value as the hidden input's value only if the value is not equal to \"0\" (None)\r\n            $(columnSelect.Obj).val($(this).find(\"option[value='\" + (thisVal !== \"0\" ? thisVal : \"\") + \"']\").html());\r\n        });\r\n        // Trigger a change to ensure that the selected value registers in the complex dropdown\r\n        simpleSelectObj.trigger(\"change\");\r\n\r\n        // If present, call completefunc when all else is done\r\n        if (opt.completefunc !== null) {\r\n            opt.completefunc();\r\n        }\r\n\r\n    }; // End $.fn.SPServices.SPConvertToSimpleDropdown\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function to display related information when an option is selected on a form.\r\n    $.fn.SPServices.SPDisplayRelatedInfo = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            columnName: \"\", // The display name of the column in the form\r\n            relatedWebURL: \"\", // [Optional] The name of the Web (site) which contains the related list\r\n            relatedList: \"\", // The name of the list which contains the additional information\r\n            relatedListColumn: \"\", // The internal name of the related column in the related list\r\n            relatedColumns: [], // An array of related columns to display\r\n            displayFormat: \"table\", // The format to use in displaying the related information.  Possible values are: [table, list, none]\r\n            headerCSSClass: \"ms-vh2\", // CSS class for the table headers\r\n            rowCSSClass: \"ms-vb\", // CSS class for the table rows\r\n            CAMLQuery: \"\", // [Optional] For power users, this CAML fragment will be <And>ed with the default query on the relatedList\r\n            numChars: 0, // If used on an input column (not a dropdown), no matching will occur until at least this number of characters has been entered\r\n            matchType: \"Eq\", // If used on an input column (not a dropdown), type of match. Can be any valid CAML comparison operator, most often \"Eq\" or \"BeginsWith\"\r\n            matchOnId: false, // By default, we match on the lookup's text value. If matchOnId is true, we'll match on the lookup id instead.\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n        var i;\r\n        var relatedColumnsXML = [];\r\n        var relatedListXML;\r\n        var thisFunction = \"SPServices.SPDisplayRelatedInfo\";\r\n\r\n        // Find the column's select (dropdown)\r\n        var columnSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.columnName\r\n        });\r\n        if (columnSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"columnName: \" + opt.columnName, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        // Get information about the related list and its columns\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            webURL: opt.relatedWebURL,\r\n            listName: opt.relatedList,\r\n            completefunc: function (xData) {\r\n                // If debug is on, notify about an error\r\n                $(xData.responseXML).find(\"faultcode\").each(function () {\r\n                    if (opt.debug) {\r\n                        utils.errBox(thisFunction, \"relatedList: \" + opt.relatedList, \"List not found\");\r\n\r\n                    }\r\n                });\r\n                // Get info about the related list\r\n                relatedListXML = $(xData.responseXML).find(\"List\");\r\n                // Save the information about each column requested\r\n                for (i = 0; i < opt.relatedColumns.length; i++) {\r\n                    relatedColumnsXML[opt.relatedColumns[i]] = $(xData.responseXML).find(\"Fields > Field[Name='\" + opt.relatedColumns[i] + \"']\");\r\n                }\r\n                relatedColumnsXML[opt.relatedListColumn] = $(xData.responseXML).find(\"Fields > Field[Name='\" + opt.relatedListColumn + \"']\");\r\n            }\r\n        });\r\n\r\n        switch (columnSelect.Type) {\r\n            // Plain old select\r\n            case constants.dropdownType.simple:\r\n                columnSelect.Obj.bind(\"change\", function () {\r\n                    showRelated(opt, relatedListXML, relatedColumnsXML);\r\n                });\r\n                break;\r\n            // Input / Select hybrid\r\n            case constants.dropdownType.complex:\r\n                // Bind to any change on the hidden input element\r\n                columnSelect.optHid.bind(\"propertychange\", function () {\r\n                    showRelated(opt, relatedListXML, relatedColumnsXML);\r\n                });\r\n                break;\r\n            // Multi-select hybrid\r\n            case constants.dropdownType.multiSelect:\r\n                if (opt.debug) {\r\n                    utils.errBox(thisFunction, \"columnName: \" + opt.columnName, \"Multi-select columns not supported by this function\");\r\n                }\r\n                break;\r\n            default:\r\n                break;\r\n        }\r\n        // Fire the change to set the initially allowable values\r\n        showRelated(opt, relatedListXML, relatedColumnsXML);\r\n\r\n    }; // End $.fn.SPServices.SPDisplayRelatedInfo\r\n\r\n    function showRelated(opt, relatedListXML, relatedColumnsXML) {\r\n\r\n        var i;\r\n        var columnSelectSelected;\r\n        var thisFunction = \"SPServices.SPDisplayRelatedInfo\";\r\n\r\n        // Find the column's select (dropdown)\r\n        var columnSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.columnName\r\n        });\r\n\r\n        // Get the current column selection(s)\r\n        columnSelectSelected = utils.getDropdownSelected(columnSelect, opt.matchOnId);\r\n        if (columnSelect.Type === constants.dropdownType.complex && opt.numChars > 0 && columnSelectSelected[0].length < opt.numChars) {\r\n            return;\r\n        }\r\n\r\n        // If the selection hasn't changed, then there's nothing to do right now.  This is useful to reduce\r\n        // the number of Web Service calls when the parentSelect.Type = constants.dropdownType.complex, as there are multiple propertychanges\r\n        // which don't require any action.\r\n        if (columnSelect.Obj.attr(\"showRelatedSelected\") === columnSelectSelected[0]) {\r\n            return;\r\n        }\r\n        columnSelect.Obj.attr(\"showRelatedSelected\", columnSelectSelected[0]);\r\n\r\n        if(opt.displayFormat !== \"none\") {\r\n            // Generate a unique id for the container\r\n            var divId = utils.genContainerId(\"SPDisplayRelatedInfo\", opt.columnName, opt.listName);\r\n            // Remove the old container...\r\n            $(\"#\" + divId).remove();\r\n            // ...and append a new, empty one\r\n            columnSelect.Obj.parent().append(\"<div id=\" + divId + \"></div>\");\r\n        }\r\n\r\n        // Get the list items which match the current selection\r\n        var camlQuery = \"<Query><Where>\";\r\n        if (opt.CAMLQuery.length > 0) {\r\n            camlQuery += \"<And>\";\r\n        }\r\n\r\n        // Need to handle Lookup columns differently than static columns\r\n        var relatedListColumnType = relatedColumnsXML[opt.relatedListColumn].attr(\"Type\");\r\n        if (relatedListColumnType === \"Lookup\") {\r\n            camlQuery += \"<Eq><FieldRef Name='\" + opt.relatedListColumn +\r\n                (opt.matchOnId ? \"' LookupId='True'/><Value Type='Integer'>\" : \"'/><Value Type='Text'>\") +\r\n                utils.escapeColumnValue(columnSelectSelected[0]) + \"</Value></Eq>\";\r\n        } else {\r\n            camlQuery += \"<Eq><FieldRef Name='\" +\r\n                (opt.matchOnId ? \"ID' /><Value Type='Counter'>\" : opt.relatedListColumn + \"'/><Value Type='Text'>\") +\r\n                utils.escapeColumnValue(columnSelectSelected[0]) + \"</Value></Eq>\";\r\n        }\r\n\r\n        if (opt.CAMLQuery.length > 0) {\r\n            camlQuery += opt.CAMLQuery + \"</And>\";\r\n        }\r\n        camlQuery += \"</Where></Query>\";\r\n\r\n        var viewFields = \" \";\r\n        for (i = 0; i < opt.relatedColumns.length; i++) {\r\n            viewFields += \"<FieldRef Name='\" + opt.relatedColumns[i] + \"' />\";\r\n        }\r\n\r\n        $().SPServices({\r\n            operation: \"GetListItems\",\r\n            async: false,\r\n            webURL: opt.relatedWebURL,\r\n            listName: opt.relatedList,\r\n            // Filter based on the column's currently selected value\r\n            CAMLQuery: camlQuery,\r\n            CAMLViewFields: \"<ViewFields>\" + viewFields + \"</ViewFields>\",\r\n            // Override the default view rowlimit and get all appropriate rows\r\n            CAMLRowLimit: 0,\r\n            completefunc: function (xData) {\r\n\r\n                // Handle errors\r\n                $(xData.responseXML).find(\"errorstring\").each(function () {\r\n                    var errorText = $(this).text();\r\n                    if (opt.debug && errorText === \"One or more field types are not installed properly. Go to the list settings page to delete these fields.\") {\r\n                        utils.errBox(thisFunction,\r\n                            \"relatedListColumn: \" + opt.relatedListColumn,\r\n                            \"Column not found in relatedList \" + opt.relatedList);\r\n                    } else if (opt.debug && errorText === \"Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).\") {\r\n                        utils.errBox(thisFunction,\r\n                            \"relatedList: \" + opt.relatedList,\r\n                            \"List not found\");\r\n                    }\r\n\r\n                });\r\n\r\n                var outString;\r\n                // Output each row\r\n                switch (opt.displayFormat) {\r\n                    // Only implementing the table format in the first iteration (v0.2.9)\r\n                    case \"table\":\r\n                        outString = \"<table>\";\r\n                        outString += \"<tr>\";\r\n                        for (i = 0; i < opt.relatedColumns.length; i++) {\r\n                            if (typeof relatedColumnsXML[opt.relatedColumns[i]] === \"undefined\" && opt.debug) {\r\n                                utils.errBox(thisFunction, \"columnName: \" + opt.relatedColumns[i], \"Column not found in relatedList\");\r\n                                return;\r\n                            }\r\n                            outString += \"<th class='\" + opt.headerCSSClass + \"'>\" + relatedColumnsXML[opt.relatedColumns[i]].attr(\"DisplayName\") + \"</th>\";\r\n                        }\r\n                        outString += \"</tr>\";\r\n                        // Add an option for each child item\r\n                        $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                            outString += \"<tr>\";\r\n                            for (i = 0; i < opt.relatedColumns.length; i++) {\r\n                                outString += \"<td class='\" + opt.rowCSSClass + \"'>\" + showColumn(relatedListXML, relatedColumnsXML[opt.relatedColumns[i]], $(this).attr(\"ows_\" + opt.relatedColumns[i]), opt) + \"</td>\";\r\n                            }\r\n                            outString += \"</tr>\";\r\n                        });\r\n                        outString += \"</table>\";\r\n                        break;\r\n                    // list format implemented in v0.5.0. Still table-based, but vertical orientation.\r\n                    case \"list\":\r\n                        outString = \"<table>\";\r\n                        $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                            for (i = 0; i < opt.relatedColumns.length; i++) {\r\n                                if (typeof relatedColumnsXML[opt.relatedColumns[i]] === \"undefined\" && opt.debug) {\r\n                                    utils.errBox(thisFunction, \"columnName: \" + opt.relatedColumns[i], \"Column not found in relatedList\");\r\n                                    return;\r\n                                }\r\n                                outString += \"<tr>\";\r\n                                outString += \"<th class='\" + opt.headerCSSClass + \"'>\" + relatedColumnsXML[opt.relatedColumns[i]].attr(\"DisplayName\") + \"</th>\";\r\n                                outString += \"<td class='\" + opt.rowCSSClass + \"'>\" + showColumn(relatedListXML, relatedColumnsXML[opt.relatedColumns[i]], $(this).attr(\"ows_\" + opt.relatedColumns[i]), opt) + \"</td>\";\r\n                                outString += \"</tr>\";\r\n                            }\r\n                        });\r\n                        outString += \"</table>\";\r\n                        break;\r\n                    case \"none\":\r\n                        break;\r\n                    default:\r\n                        break;\r\n                }\r\n                // Write out the results\r\n                if(opt.displayFormat !== \"none\") {\r\n                    $(\"#\" + divId).html(outString);\r\n                }\r\n\r\n                // If present, call completefunc when all else is done\r\n                if (opt.completefunc !== null) {\r\n                    opt.completefunc(xData);\r\n                }\r\n\r\n            }\r\n        });\r\n    } // End showRelated\r\n\r\n    // Display a column (field) formatted correctly based on its definition in the list.\r\n    // NOTE: Currently not dealing with locale differences.\r\n    //   columnXML          The XML node for the column from a GetList operation\r\n    //   columnValue        The text representation of the column's value\r\n    //   opt                The current set of options\r\n    function showColumn(listXML, columnXML, columnValue, opt) {\r\n\r\n        if (typeof columnValue === \"undefined\") {\r\n            return \"\";\r\n        }\r\n\r\n        var i;\r\n        var outString = \"\";\r\n        var fileName = \"\";\r\n        var dispUrl;\r\n        var numDecimals;\r\n        var outArray = [];\r\n        var webUrl = opt.relatedWebURL.length > 0 ? opt.relatedWebURL : $().SPServices.SPGetCurrentSite();\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n        switch (columnXML.attr(\"Type\")) {\r\n            case \"Text\":\r\n                outString = columnValue;\r\n                break;\r\n            case \"URL\":\r\n                switch (columnXML.attr(\"Format\")) {\r\n                    // URL as hyperlink\r\n                    case \"Hyperlink\":\r\n                        outString = \"<a href='\" + columnValue.substring(0, columnValue.search(\",\")) + \"'>\" +\r\n                            columnValue.substring(columnValue.search(\",\") + 1) + \"</a>\";\r\n                        break;\r\n                    // URL as image\r\n                    case \"Image\":\r\n                        outString = \"<img alt='\" + columnValue.substring(columnValue.search(\",\") + 1) +\r\n                            \"' src='\" + columnValue.substring(0, columnValue.search(\",\")) + \"'/>\";\r\n                        break;\r\n                    // Just in case\r\n                    default:\r\n                        outString = columnValue;\r\n                        break;\r\n                }\r\n                break;\r\n            case \"User\":\r\n            case \"UserMulti\":\r\n                var userMultiValues = columnValue.split(constants.spDelim);\r\n                for (i = 0; i < userMultiValues.length; i = i + 2) {\r\n                    outArray.push(\"<a href='/_layouts/userdisp.aspx?ID=\" + userMultiValues[i] +\r\n                        \"&Source=\" + utils.escapeUrl(location.href) + \"'>\" +\r\n                        userMultiValues[i + 1] + \"</a>\");\r\n                }\r\n                outString = outArray.join(\", \");\r\n                break;\r\n            case \"Calculated\":\r\n                var calcColumn = columnValue.split(constants.spDelim);\r\n                outString = calcColumn[1];\r\n                break;\r\n            case \"Number\":\r\n                numDecimals = columnXML.attr(\"Decimals\");\r\n                outString = typeof numDecimals === \"undefined\" ?\r\n                    parseFloat(columnValue).toString() :\r\n                    parseFloat(columnValue).toFixed(numDecimals).toString();\r\n                break;\r\n            case \"Currency\":\r\n                numDecimals = columnXML.attr(\"Decimals\");\r\n                outString = typeof numDecimals === \"undefined\" ?\r\n                    parseFloat(columnValue).toFixed(2).toString() :\r\n                    parseFloat(columnValue).toFixed(numDecimals).toString();\r\n                break;\r\n            case \"Lookup\":\r\n                switch (columnXML.attr(\"Name\")) {\r\n                    case \"FileRef\":\r\n                        // Get the display form URL for the lookup source list\r\n                        dispUrl = listXML.attr(\"BaseType\") === \"1\" ? listXML.attr(\"RootFolder\") + constants.SLASH + \"Forms/DispForm.aspx\" :\r\n                        listXML.attr(\"RootFolder\") + constants.SLASH + \"DispForm.aspx\";\r\n                        outString = \"<a href='\" + dispUrl +\r\n                            \"?ID=\" + columnValue.substring(0, columnValue.search(constants.spDelim)) + \"&RootFolder=*&Source=\" + utils.escapeUrl(location.href) + \"'>\" +\r\n                            columnValue.substring(columnValue.search(constants.spDelim) + 2) + \"</a>\";\r\n                        break;\r\n                    case \"FileDirRef\":\r\n                        // Get the display form URL for the lookup source list\r\n                        dispUrl = constants.SLASH + columnValue.substring(columnValue.search(constants.spDelim) + 2);\r\n                        outString = \"<a href='\" + dispUrl + \"'>\" +\r\n                            columnValue.substring(columnValue.search(constants.spDelim) + 2) + \"</a>\";\r\n                        break;\r\n                    // Any other lookup column\r\n                    default:\r\n                        // Get the display form URL for the lookup source list\r\n                        dispUrl = utils.getListFormUrl(columnXML.attr(\"List\"), \"DisplayForm\");\r\n                        outString = \"<a href='\" + opt.relatedWebURL + constants.SLASH + dispUrl +\r\n                            \"?ID=\" + columnValue.substring(0, columnValue.search(constants.spDelim)) + \"&RootFolder=*&Source=\" + utils.escapeUrl(location.href) + \"'>\" +\r\n                            columnValue.substring(columnValue.search(constants.spDelim) + 2) + \"</a>\";\r\n                        break;\r\n                }\r\n                break;\r\n            case \"LookupMulti\":\r\n                // Get the display form URL for the lookup source list\r\n                dispUrl = utils.getListFormUrl(columnXML.attr(\"List\"), \"DisplayForm\");\r\n                // Show all the values as links to the items, separated by commas\r\n                outString = \"\";\r\n                if (columnValue.length > 0) {\r\n                    var lookupMultiValues = columnValue.split(constants.spDelim);\r\n                    for (i = 0; i < lookupMultiValues.length / 2; i++) {\r\n                        outArray.push(\"<a href='\" + webUrl + constants.SLASH + dispUrl +\r\n                            \"?ID=\" + lookupMultiValues[i * 2] + \"&RootFolder=*&Source=\" + utils.escapeUrl(location.href) + \"'>\" +\r\n                            lookupMultiValues[(i * 2) + 1] + \"</a>\");\r\n                    }\r\n                }\r\n                outString = outArray.join(\", \");\r\n                break;\r\n            case \"File\":\r\n                fileName = columnValue.substring(columnValue.search(constants.spDelim) + 2);\r\n                outString = \"<a href='\" + listXML.attr(\"RootFolder\") + constants.SLASH + fileName + \"'>\" + fileName + \"</a>\";\r\n                break;\r\n            case \"Counter\":\r\n                outString = columnValue;\r\n                break;\r\n            case \"DateTime\":\r\n                outString = columnValue;\r\n                break;\r\n            default:\r\n                outString = columnValue;\r\n                break;\r\n        }\r\n        return outString;\r\n    } // End of function showColumn\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    /* jshint undef: true */\r\n    /* global GipAddSelectedItems, GipRemoveSelectedItems, GipGetGroupData */\r\n\r\n    // Function to filter a lookup based dropdown\r\n    $.fn.SPServices.SPFilterDropdown = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            relationshipWebURL: \"\", // [Optional] The name of the Web (site) which contains the relationshipList\r\n            relationshipList: \"\", // The name of the list which contains the lookup values\r\n            relationshipListColumn: \"\", // The internal name of the column in the relationship list\r\n            relationshipListSortColumn: \"\", // [Optional] If specified, sort the options in the dropdown by this column,\r\n            // otherwise the options are sorted by relationshipListColumn\r\n            relationshipListSortAscending: true, // [Optional] By default, the sort is ascending. If false, descending\r\n            columnName: \"\", // The display name of the column in the form\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            promptText: \"\", // [DEPRECATED] Text to use as prompt. If included, {0} will be replaced with the value of columnName. IOrignal value \"Choose {0}...\"\r\n            noneText: \"(None)\", // [Optional] Text to use for the (None) selection. Provided for non-English language support.\r\n            CAMLQuery: \"\", // This CAML fragment will be applied to the relationshipList\r\n            CAMLQueryOptions: \"<QueryOptions><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns><ViewAttributes Scope='RecursiveAll'/></QueryOptions>\", // Need this to mirror SharePoint's behavior, but it can be overridden\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages; if false, run silent\r\n        }, options);\r\n\r\n        var choices = \"\";\r\n        var columnSelectSelected = null;\r\n        var newMultiLookupPickerdata;\r\n        var columnColumnRequired;\r\n        var thisFunction = \"SPServices.SPFilterDropdown\";\r\n\r\n        // Find the column's select (dropdown)\r\n        var columnSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.columnName\r\n        });\r\n        if (columnSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"columnName: \" + opt.columnName, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        // Get the current column selection(s)\r\n        columnSelectSelected = utils.getDropdownSelected(columnSelect, true);\r\n\r\n        // Get the relationshipList items which match the current selection\r\n        var sortColumn = (opt.relationshipListSortColumn.length > 0) ? opt.relationshipListSortColumn : opt.relationshipListColumn;\r\n        var sortOrder = (opt.relationshipListSortAscending === true) ? \"\" : \"Ascending='FALSE'\";\r\n        var camlQuery = \"<Query><OrderBy><FieldRef Name='\" + sortColumn + \"' \" + sortOrder + \"/></OrderBy><Where>\";\r\n        if (opt.CAMLQuery.length > 0) {\r\n            camlQuery += opt.CAMLQuery;\r\n        }\r\n        camlQuery += \"</Where></Query>\";\r\n\r\n        // Get information about columnName from the current list\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            listName: opt.listName,\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).find(\"Fields\").each(function () {\r\n                    $(this).find(\"Field[DisplayName='\" + opt.columnName + \"']\").each(function () {\r\n                        // Determine whether columnName is Required\r\n                        columnColumnRequired = ($(this).attr(\"Required\") === \"TRUE\");\r\n                        // Stop looking; we're done\r\n                        return false;\r\n                    });\r\n                });\r\n            }\r\n        });\r\n\r\n        $().SPServices({\r\n            operation: \"GetListItems\",\r\n            // Force sync so that we have the right values for the column onchange trigger\r\n            async: false,\r\n            webURL: opt.relationshipWebURL,\r\n            listName: opt.relationshipList,\r\n            // Filter based on the specified CAML\r\n            CAMLQuery: camlQuery,\r\n            // Only get the columnName's data (plus columns we can't prevent)\r\n            CAMLViewFields: \"<ViewFields><FieldRef Name='\" + opt.relationshipListColumn + \"' /></ViewFields>\",\r\n            // Override the default view rowlimit and get all appropriate rows\r\n            CAMLRowLimit: 0,\r\n            // Even though setting IncludeMandatoryColumns to FALSE doesn't work as the docs describe, it fixes a bug in GetListItems with mandatory multi-selects\r\n            CAMLQueryOptions: opt.CAMLQueryOptions,\r\n            completefunc: function (xData) {\r\n\r\n                // Handle errors\r\n                $(xData.responseXML).find(\"errorstring\").each(function () {\r\n                    var errorText = $(this).text();\r\n                    if (opt.debug && errorText === \"One or more field types are not installed properly. Go to the list settings page to delete these fields.\") {\r\n                        utils.errBox(thisFunction,\r\n                            \"relationshipListColumn: \" + opt.relationshipListColumn,\r\n                            \"Not found in relationshipList \" + opt.relationshipList);\r\n                    } else if (opt.debug && errorText === \"Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).\") {\r\n                        utils.errBox(thisFunction,\r\n                            \"relationshipList: \" + opt.relationshipList,\r\n                            \"List not found\");\r\n                    }\r\n\r\n                });\r\n\r\n                // Add an explanatory prompt\r\n                switch (columnSelect.Type) {\r\n                    case constants.dropdownType.simple:\r\n                        // Remove all of the existing options\r\n                        $(columnSelect.Obj).find(\"option\").remove();\r\n                        // If the column is required or the promptText option is empty, don't add the prompt text\r\n                        if (!columnColumnRequired && (opt.promptText.length > 0)) {\r\n                            columnSelect.Obj.append(\"<option value='0'>\" + opt.promptText.replace(/\\{0\\}/g, opt.columnName) + \"</option>\");\r\n                        } else if (!columnColumnRequired) {\r\n                            columnSelect.Obj.append(\"<option value='0'>\" + opt.noneText + \"</option>\");\r\n                        }\r\n                        break;\r\n                    case constants.dropdownType.complex:\r\n                        // If the column is required, don't add the \"(None)\" option\r\n                        choices = columnColumnRequired ? \"\" : opt.noneText + \"|0\";\r\n                        columnSelect.Obj.val(\"\");\r\n                        break;\r\n                    case constants.dropdownType.multiSelect:\r\n                        // Remove all of the existing options\r\n                        $(columnSelect.master.candidateControl).find(\"option\").remove();\r\n                        newMultiLookupPickerdata = \"\";\r\n                        break;\r\n                    default:\r\n                        break;\r\n                }\r\n\r\n                // Add an option for each item\r\n                $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n\r\n                    var thisOption = {};\r\n\r\n                    // If relationshipListColumn is a Lookup column, then the ID should be for the Lookup value,\r\n                    // else the ID of the relationshipList item\r\n                    var thisValue = $(this).attr(\"ows_\" + opt.relationshipListColumn);\r\n\r\n                    if (typeof thisValue !== \"undefined\" && thisValue.indexOf(constants.spDelim) > 0) {\r\n                        thisOption = new utils.SplitIndex(thisValue);\r\n                    } else {\r\n                        thisOption.id = $(this).attr(\"ows_ID\");\r\n                        thisOption.value = thisValue;\r\n                    }\r\n\r\n                    // If the relationshipListColumn is a calculated column, then the value isn't preceded by the ID,\r\n                    // but by the datatype.  In this case, thisOption.id should be the ID of the relationshipList item.\r\n                    // e.g., float;#12345.67\r\n                    if (isNaN(thisOption.id)) {\r\n                        thisOption.id = $(this).attr(\"ows_ID\");\r\n                    }\r\n\r\n                    switch (columnSelect.Type) {\r\n                        case constants.dropdownType.simple:\r\n                            var selected = ($(this).attr(\"ows_ID\") === columnSelectSelected[0]) ? \" selected='selected'\" : \"\";\r\n                            columnSelect.Obj.append(\"<option\" + selected + \" value='\" + thisOption.id + \"'>\" + thisOption.value + \"</option>\");\r\n                            break;\r\n                        case constants.dropdownType.complex:\r\n                            if (thisOption.id === columnSelectSelected[0]) {\r\n                                columnSelect.Obj.val(thisOption.value);\r\n                            }\r\n                            choices = choices + ((choices.length > 0) ? \"|\" : \"\") + thisOption.value + \"|\" + thisOption.id;\r\n                            break;\r\n                        case constants.dropdownType.multiSelect:\r\n                            $(columnSelect.master.candidateControl).append(\"<option value='\" + thisOption.id + \"'>\" + thisOption.value + \"</option>\");\r\n                            newMultiLookupPickerdata += thisOption.id + \"|t\" + thisOption.value + \"|t |t |t\";\r\n                            break;\r\n                        default:\r\n                            break;\r\n                    }\r\n                });\r\n\r\n                switch (columnSelect.Type) {\r\n                    case constants.dropdownType.simple:\r\n                        columnSelect.Obj.trigger(\"change\");\r\n                        break;\r\n                    case constants.dropdownType.complex:\r\n                        columnSelect.Obj.attr(\"choices\", choices);\r\n                        columnSelect.Obj.trigger(\"propertychange\");\r\n                        break;\r\n                    case constants.dropdownType.multiSelect:\r\n                        // Clear the master\r\n                        columnSelect.master.data = \"\";\r\n\r\n                        columnSelect.MultiLookupPickerdata.val(newMultiLookupPickerdata);\r\n                        // Clear any prior selections that are no longer valid\r\n                        $(columnSelect.master.resultControl).find(\"option\").each(function () {\r\n                            var thisSelected = $(this);\r\n                            $(this).attr(\"selected\", \"selected\");\r\n                            $(columnSelect.master.candidateControl).find(\"option\").each(function () {\r\n                                if ($(this).html() === thisSelected.html()) {\r\n                                    thisSelected.removeAttr(\"selected\");\r\n                                }\r\n                            });\r\n                        });\r\n                        GipRemoveSelectedItems(columnSelect.master);\r\n                        // Hide any options in the candidate list which are already selected\r\n                        $(columnSelect.master.candidateControl).find(\"option\").each(function () {\r\n                            var thisSelected = $(this);\r\n                            $(columnSelect.master.resultControl).find(\"option\").each(function () {\r\n                                if ($(this).html() === thisSelected.html()) {\r\n                                    thisSelected.remove();\r\n                                }\r\n                            });\r\n                        });\r\n                        GipAddSelectedItems(columnSelect.master);\r\n                        // Set master.data to the newly allowable values\r\n                        columnSelect.master.data = GipGetGroupData(newMultiLookupPickerdata);\r\n\r\n                        // Trigger a dblclick so that the child will be cascaded if it is a multiselect.\r\n                        $(columnSelect.master.candidateControl).trigger(\"dblclick\");\r\n\r\n                        break;\r\n                    default:\r\n                        break;\r\n                }\r\n            }\r\n        });\r\n        // If present, call completefunc when all else is done\r\n        if (opt.completefunc !== null) {\r\n            opt.completefunc();\r\n        }\r\n    }; // End $.fn.SPServices.SPFilterDropdown\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core.js'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Find an MMS Picker in the page\r\n    // Returns references to:\r\n    //   terms - The aaray of terms as value/guid pairs\r\n    $.fn.SPServices.SPFindMMSPicker = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            MMSDisplayName: \"\" // The displayName of the MMS Picker on the form\r\n        }, options);\r\n\r\n        var thisTerms = [];\r\n\r\n        // Find the div for the column which contains the entered data values\r\n        var thisDiv = $(\"div[title='\" + opt.MMSDisplayName + \"']\");\r\n        var thisHiddenInput = thisDiv.closest(\"td\").find(\"input[type='hidden']\");\r\n        var thisTermArray = thisHiddenInput.val().split(\";\");\r\n\r\n        for (var i = 0; i < thisTermArray.length; i++) {\r\n            var thisOne = thisTermArray[i].split(\"|\");\r\n            thisTerms.push({\r\n                value: thisOne[0],\r\n                guid: thisOne[1]\r\n            });\r\n\r\n        }\r\n\r\n        return {\r\n            terms: thisTerms\r\n        };\r\n\r\n    }; // End $.fn.SPServices.SPFindMMSPicker\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core.js'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Find a People Picker in the page\r\n    // Returns references to:\r\n    //   row - The TR which contains the People Picker (useful if you'd like to hide it at some point)\r\n    //   contents - The element which contains the current value\r\n    //   currentValue - The current value if it is set\r\n    //   checkNames - The Check Names image (in case you'd like to click it at some point)\r\n    //   checkNamesPhrase - you can pass your local phrase here to check names, like in russian it would be - ????????? ?????\r\n    $.fn.SPServices.SPFindPeoplePicker = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            peoplePickerDisplayName: \"\", // The displayName of the People Picker on the form\r\n            valueToSet: \"\", // The value to set the People Picker to. Should be a string containing each username or groupname separated by semi-colons.\r\n            checkNames: true, // If set to true, the Check Names image will be clicked to resolve the names\r\n            checkNamesPhrase: 'Check Names' // English default\r\n        }, options);\r\n\r\n        var thisRow = $(\"nobr\").filter(function () {\r\n            // Ensures we get a match whether or not the People Picker is required (if required, the nobr contains a span also)\r\n            return $(this).contents().eq(0).text() === opt.peoplePickerDisplayName;\r\n        }).closest(\"tr\");\r\n\r\n        var thisContents = thisRow.find(\"div[name='upLevelDiv']\");\r\n        var thisCheckNames = thisRow.find(\"img[Title='\" + opt.checkNamesPhrase + \"']:first\");\r\n\r\n        // If a value was provided, set the value\r\n        if (opt.valueToSet.length > 0) {\r\n            thisContents.html(opt.valueToSet);\r\n        }\r\n\r\n        // If checkName is true, click the check names icon\r\n        if (opt.checkNames) {\r\n            thisCheckNames.click();\r\n        }\r\n        var thisCurrentValue = $.trim(thisContents.text());\r\n\r\n        // Parse the entity data\r\n        var dictionaryEntries = [];\r\n\r\n        // IE\r\n        thisContents.children(\"span\").each(function () {\r\n\r\n            // Grab the entity data\r\n            var thisData = $(this).find(\"div[data]\").attr(\"data\");\r\n\r\n            var dictionaryEntry = {};\r\n\r\n            // Entity data is only available in IE\r\n            if (typeof thisData !== \"undefined\") {\r\n                var arrayOfDictionaryEntry = $.parseXML(thisData);\r\n                var $xml = $(arrayOfDictionaryEntry);\r\n\r\n                $xml.find(\"DictionaryEntry\").each(function () {\r\n                    var key = $(this).find(\"Key\").text();\r\n                    dictionaryEntry[key] = $(this).find(\"Value\").text();\r\n                });\r\n                dictionaryEntries.push(dictionaryEntry);\r\n                // For other browsers, we'll call GetUserInfo to get the data\r\n            } else {\r\n                $().SPServices({\r\n                    operation: \"GetUserInfo\",\r\n                    async: false,\r\n                    cacheXML: true,\r\n                    userLoginName: $(this).attr(\"title\"),\r\n                    completefunc: function (xData) {\r\n\r\n                        $(xData.responseXML).find(\"User\").each(function () {\r\n\r\n                            $.each(this.attributes, function (i, attrib) {\r\n                                dictionaryEntry[attrib.name] = attrib.value;\r\n                            });\r\n                            dictionaryEntries.push(dictionaryEntry);\r\n                        });\r\n                    }\r\n                });\r\n            }\r\n        });\r\n\r\n        return {\r\n            row: thisRow,\r\n            contents: thisContents,\r\n            currentValue: thisCurrentValue,\r\n            checkNames: thisCheckNames,\r\n            dictionaryEntries: dictionaryEntries\r\n        };\r\n    }; // End $.fn.SPServices.SPFindPeoplePicker\r\n\r\n    // Mistakenly released previously outside the SPServices namespace. This takes care of offering both.\r\n    $.fn.SPFindPeoplePicker = function (options) {\r\n        return $().SPServices.SPFindPeoplePicker(options);\r\n    }; // End $.fn.SPFindPeoplePicker\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function which provides a link on a Lookup column for the user to follow\r\n    // which allows them to add a new value to the Lookup list.\r\n    // Based on http://blog.mastykarz.nl/extending-lookup-fields-add-new-item-option/\r\n    // by Waldek Mastykarz\r\n    $.fn.SPServices.SPLookupAddNew = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            lookupColumn: \"\", // The display name of the Lookup column\r\n            promptText: \"Add new {0}\", // Text to use as prompt + column name\r\n            newWindow: false, // If true, the link will open in a new window *without* passing the Source.\r\n            ContentTypeID: \"\", // [Optional] Pass the ContentTypeID if you'd like to specify it\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n        var thisFunction = \"SPServices.SPLookupAddNew\";\r\n\r\n        // Find the lookup column's select (dropdown)\r\n        var lookupSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.lookupColumn\r\n        });\r\n        if (lookupSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"lookupColumn: \" + opt.lookupColumn, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n\r\n        var newUrl = \"\";\r\n        var lookupListUrl = \"\";\r\n        var lookupColumnStaticName = \"\";\r\n        // Use GetList for the current list to determine the details for the Lookup column\r\n        $().SPServices({\r\n            operation: \"GetList\",\r\n            async: false,\r\n            cacheXML: true,\r\n            listName: $().SPServices.SPListNameFromUrl(),\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).find(\"Field[DisplayName='\" + opt.lookupColumn + \"']\").each(function () {\r\n                    lookupColumnStaticName = $(this).attr(\"StaticName\");\r\n                    // Use GetList for the Lookup column's list to determine the list's URL\r\n                    $().SPServices({\r\n                        operation: \"GetList\",\r\n                        async: false,\r\n                        cacheXML: true,\r\n                        listName: $(this).attr(\"List\"),\r\n                        completefunc: function (xData) {\r\n                            $(xData.responseXML).find(\"List\").each(function () {\r\n                                lookupListUrl = $(this).attr(\"WebFullUrl\");\r\n                                // Need to handle when list is in the root site\r\n                                lookupListUrl = lookupListUrl !== constants.SLASH ? lookupListUrl + constants.SLASH : lookupListUrl;\r\n                            });\r\n                        }\r\n                    });\r\n                    // Get the NewItem form for the Lookup column's list\r\n                    newUrl = utils.getListFormUrl($(this).attr(\"List\"), \"NewForm\");\r\n                    // Stop looking;we're done\r\n                    return false;\r\n                });\r\n            }\r\n        });\r\n\r\n        if (lookupListUrl.length === 0 && opt.debug) {\r\n            utils.errBox(thisFunction, \"lookupColumn: \" + opt.lookupColumn, \"This column does not appear to be a lookup column\");\r\n            return;\r\n        }\r\n        if (newUrl.length > 0) {\r\n            // Build the link to the Lookup column's list enclosed in a div with the id=\"SPLookupAddNew_\" + lookupColumnStaticName\r\n            var newHref = lookupListUrl + newUrl;\r\n            // If requested, open the link in a new window and if requested, pass the ContentTypeID\r\n            newHref += opt.newWindow ?\r\n            ((opt.ContentTypeID.length > 0) ? \"?ContentTypeID=\" + opt.ContentTypeID : \"\") + \"' target='_blank'\" :\r\n            \"?\" + ((opt.ContentTypeID.length > 0) ? \"ContentTypeID=\" + opt.ContentTypeID + \"&\" : \"\") + \"Source=\" + utils.escapeUrl(location.href) + \"'\";\r\n            var newLink = \"<div id='SPLookupAddNew_\" + lookupColumnStaticName + \"'>\" + \"<a href='\" + newHref + \">\" + opt.promptText.replace(/\\{0\\}/g, opt.lookupColumn) + \"</a></div>\";\r\n            // Append the link to the Lookup columns's formbody table cell\r\n            $(lookupSelect.Obj).parents(\"td.ms-formbody\").append(newLink);\r\n        } else if (opt.debug) {\r\n            utils.errBox(thisFunction, \"lookupColumn: \" + opt.lookupColumn, \"NewForm cannot be found\");\r\n            return;\r\n        }\r\n        // If present, call completefunc when all else is done\r\n        if (opt.completefunc !== null) {\r\n            opt.completefunc();\r\n        }\r\n    }; // End $.fn.SPServices.SPLookupAddNew\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n   //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // This function allows you to redirect to a another page from a new item form with the new\r\n    // item's ID. This allows chaining of forms from item creation onward.\r\n    $.fn.SPServices.SPRedirectWithID = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            redirectUrl: \"\", // Page for the redirect\r\n            qsParamName: \"ID\" // In some cases, you may want to pass the newly created item's ID with a different\r\n            // parameter name than ID. Specify that name here, if needed.\r\n        }, options);\r\n\r\n        var thisList = $().SPServices.SPListNameFromUrl();\r\n        var queryStringVals = $().SPServices.SPGetQueryString();\r\n        var lastID = queryStringVals.ID;\r\n        var QSList = queryStringVals.List;\r\n        var QSRootFolder = queryStringVals.RootFolder;\r\n        var QSContentTypeId = queryStringVals.ContentTypeId;\r\n\r\n        // On first load, change the form actions to redirect back to this page with the current lastID for this user and the\r\n        // original Source.\r\n        if (typeof queryStringVals.ID === \"undefined\") {\r\n            lastID = $().SPServices.SPGetLastItemId({\r\n                listName: thisList\r\n            });\r\n            $(\"form[id='aspnetForm']\").each(function () {\r\n                // This page...\r\n                var thisUrl = (location.href.indexOf(\"?\") > 0) ? location.href.substring(0, location.href.indexOf(\"?\")) : location.href;\r\n                // ... plus the Source if it exists\r\n                var thisSource = (typeof queryStringVals.Source === \"string\") ?\r\n                \"Source=\" + queryStringVals.Source.replace(/\\//g, \"%2f\").replace(/:/g, \"%3a\") : \"\";\r\n\r\n                var newQS = [];\r\n                if (typeof QSList !== \"undefined\") {\r\n                    newQS.push(\"List=\" + QSList);\r\n                }\r\n                if (typeof QSRootFolder !== \"undefined\") {\r\n                    newQS.push(\"RootFolder=\" + QSRootFolder);\r\n                }\r\n                if (typeof QSContentTypeId !== \"undefined\") {\r\n                    newQS.push(\"ContentTypeId=\" + QSContentTypeId);\r\n                }\r\n\r\n                var newAction = thisUrl +\r\n                    ((newQS.length > 0) ? (\"?\" + newQS.join(\"&\") + \"&\") : \"?\") +\r\n                        // Set the Source to point back to this page with the lastID this user has added\r\n                    \"Source=\" + thisUrl +\r\n                    \"?ID=\" + lastID +\r\n                        // Pass the original source as RealSource, if present\r\n                    ((thisSource.length > 0) ? (\"%26RealSource=\" + queryStringVals.Source) : \"\") +\r\n                        // Pass the override RedirectURL, if present\r\n                    ((typeof queryStringVals.RedirectURL === \"string\") ? (\"%26RedirectURL=\" + queryStringVals.RedirectURL) : \"\");\r\n\r\n                // Set the new form action\r\n                setTimeout(function() {\r\n                    document.forms.aspnetForm.action = newAction;\r\n                }, 0);\r\n            });\r\n            // If this is the load after the item is saved, wait until the new item has been saved (commits are asynchronous),\r\n            // then do the redirect to redirectUrl with the new lastID, passing along the original Source.\r\n        } else {\r\n            while (queryStringVals.ID === lastID) {\r\n                lastID = $().SPServices.SPGetLastItemId({\r\n                    listName: thisList\r\n                });\r\n            }\r\n            // If there is a RedirectURL parameter on the Query String, then redirect there instead of the value\r\n            // specified in the options (opt.redirectUrl)\r\n            var thisRedirectUrl = (typeof queryStringVals.RedirectURL === \"string\") ? queryStringVals.RedirectURL : opt.redirectUrl;\r\n            location.href = thisRedirectUrl + \"?\" + opt.qsParamName + \"=\" + lastID +\r\n                ((typeof queryStringVals.RealSource === \"string\") ? (\"&Source=\" + queryStringVals.RealSource) : \"\");\r\n        }\r\n    }; // End $.fn.SPServices.SPRedirectWithID\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Function which checks to see if the value for a column on the form is unique in the list.\r\n    $.fn.SPServices.SPRequireUnique = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            columnStaticName: \"Title\", // Name of the column\r\n            duplicateAction: 0, // 0 = warn, 1 = prevent\r\n            ignoreCase: false, // If set to true, the function ignores case, if false it looks for an exact match\r\n            initMsg: \"This value must be unique.\", // Initial message to display after setup\r\n            initMsgCSSClass: \"ms-vb\", // CSS class for initial message\r\n            errMsg: \"This value is not unique.\", // Error message to display if not unique\r\n            errMsgCSSClass: \"ms-formvalidation\", // CSS class for error message\r\n            showDupes: false, // If true, show links to the duplicate item(s) after the error message\r\n            completefunc: null // Function to call on completion of rendering the change.\r\n        }, options);\r\n\r\n        // Get the current item's ID from the Query String\r\n        var queryStringVals = $().SPServices.SPGetQueryString();\r\n        var thisID = queryStringVals.ID;\r\n        var thisList = $().SPServices.SPListNameFromUrl();\r\n\r\n        // Set the messages based on the options provided\r\n        var msg = \"<span id='SPRequireUnique\" + opt.columnStaticName + \"' class='{0}'>{1}</span><br/>\";\r\n        var firstMsg = msg.replace(/\\{0\\}/g, opt.initMsgCSSClass).replace(/\\{1\\}/g, opt.initMsg);\r\n\r\n        // We need the DisplayName\r\n        var columnDisplayName = $().SPServices.SPGetDisplayFromStatic({\r\n            listName: thisList,\r\n            columnStaticName: opt.columnStaticName\r\n        });\r\n        var columnObj = utils.findFormField(columnDisplayName).find(\"input[Title^='\" + columnDisplayName + \"']\");\r\n        columnObj.parent().append(firstMsg);\r\n\r\n        columnObj.blur(function () {\r\n            var columnValueIDs = [];\r\n            // Get the columnDisplayName's value\r\n            var columnValue = $(this).val();\r\n            if (columnValue.length === 0) {\r\n                return false;\r\n            }\r\n\r\n            // Call the Lists Web Service (GetListItems) to see if the value already exists\r\n            $().SPServices({\r\n                operation: \"GetListItems\",\r\n                async: false,\r\n                listName: thisList,\r\n                // Make sure we get all the items, ignoring any filters on the default view.\r\n                CAMLQuery: \"<Query><Where><IsNotNull><FieldRef Name='\" + opt.columnStaticName + \"'/></IsNotNull></Where></Query>\",\r\n                // Filter based on columnStaticName's value\r\n                CAMLViewFields: \"<ViewFields><FieldRef Name='ID' /><FieldRef Name='\" + opt.columnStaticName + \"' /></ViewFields>\",\r\n                // Override the default view rowlimit and get all appropriate rows\r\n                CAMLRowLimit: 0,\r\n                completefunc: function (xData) {\r\n                    var testValue = opt.ignoreCase ? columnValue.toUpperCase() : columnValue;\r\n                    $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                        var thisValue = opt.ignoreCase ? $(this).attr(\"ows_\" + opt.columnStaticName).toUpperCase() : $(this).attr(\"ows_\" + opt.columnStaticName);\r\n                        // If this value already exists in columnStaticName and it's not the current item, then save the ID in the array\r\n                        if ((testValue === thisValue) && ($(this).attr(\"ows_ID\") !== thisID)) {\r\n                            columnValueIDs.push([$(this).attr(\"ows_ID\"), $(this).attr(\"ows_\" + opt.columnStaticName)]);\r\n                        }\r\n                    });\r\n                }\r\n            });\r\n            var newMsg = opt.initMsg;\r\n            var msgContainer = $(\"#SPRequireUnique\" + opt.columnStaticName);\r\n            msgContainer.html(newMsg).attr(\"class\", opt.initMsgCSSClass);\r\n\r\n            $(\"input[value='OK']:disabled, input[value='Save']:disabled\").removeAttr(\"disabled\");\r\n            if (columnValueIDs.length > 0) {\r\n                newMsg = opt.errMsg;\r\n                msgContainer.html(newMsg).attr(\"class\", opt.errMsgCSSClass);\r\n                if (opt.duplicateAction === 1) {\r\n                    columnObj.focus();\r\n                    $(\"input[value='OK'], input[value='Save']\").attr(\"disabled\", \"disabled\");\r\n                }\r\n                if (opt.showDupes) {\r\n                    var out = \" \" + columnValueIDs.length + \" duplicate item\" + (columnValueIDs.length > 1 ? \"s\" : \"\") + \": \";\r\n                    for (var i = 0; i < columnValueIDs.length; i++) {\r\n                        out += \"<a href='DispForm.aspx?ID=\" + columnValueIDs[i][0] + \"&Source=\" + location.href + \"'>\" + columnValueIDs[i][1] + \"</a> \";\r\n                    }\r\n                    $(\"span#SPRequireUnique\" + opt.columnStaticName).append(out);\r\n                }\r\n            }\r\n\r\n        });\r\n        // If present, call completefunc when all else is done\r\n        if (opt.completefunc !== null) {\r\n            opt.completefunc();\r\n        }\r\n    }; // End $.fn.SPServices.SPRequireUnique\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // Does an audit of a site's list forms to show where script is in use.\r\n    $.fn.SPServices.SPScriptAudit = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // [Optional] The name of the Web (site) to audit\r\n            listName: \"\", // [Optional] The name of a specific list to audit. If not present, all lists in the site are audited.\r\n            outputId: \"\", // The id of the DOM object for output\r\n            auditForms: true, // Audit the form pages\r\n            auditViews: true, // Audit the view pages\r\n            auditPages: true, // Audit the Pages Document Library\r\n            auditPagesListName: \"Pages\", // The Pages Document Library(ies), if desired. Either a single string or an array of strings.\r\n            showHiddenLists: false, // Show output for hidden lists\r\n            showNoScript: false, // Show output for lists with no scripts (effectively \"verbose\")\r\n            showSrc: true // Show the source location for included scripts\r\n        }, options);\r\n\r\n        var formTypes = [\r\n            [\"New\", \"NewForm.aspx\", false],\r\n            [\"Display\", \"DispForm.aspx\", false],\r\n            [\"Edit\", \"EditForm.aspx\", false]\r\n        ];\r\n        var listXml;\r\n\r\n        // Build the table to contain the results\r\n        $(\"#\" + opt.outputId)\r\n            .append(\"<table id='SPScriptAudit' width='100%' style='border-collapse: collapse;' border=0 cellSpacing=0 cellPadding=1>\" +\r\n            \"<tr>\" +\r\n            \"<th></th>\" +\r\n            \"<th>List</th>\" +\r\n            \"<th>Page Class</th>\" +\r\n            \"<th>Page Type</th>\" +\r\n            \"<th>Page</th>\" +\r\n            (opt.showSrc ? \"<th>Script References</th>\" : \"\") +\r\n            \"</tr>\" +\r\n            \"</table>\");\r\n        // Apply the CSS class to the headers\r\n        var scriptAuditContainer = $(\"#SPScriptAudit\");\r\n        scriptAuditContainer.find(\"th\").attr(\"class\", \"ms-vh2-nofilter\");\r\n\r\n        // Don't bother with the lists if the options don't require them\r\n        if (opt.auditForms || opt.auditViews) {\r\n            // First, get all of the lists within the site\r\n            $().SPServices({\r\n                operation: \"GetListCollection\",\r\n                webURL: opt.webURL,\r\n                async: false, // Need this to be synchronous so we're assured of a valid value\r\n                completefunc: function (xData) {\r\n                    $(xData.responseXML).find(\"List\").each(function () {\r\n                        listXml = $(this);\r\n\r\n                        // If listName has been specified, then only return results for that list\r\n                        if ((opt.listName.length === 0) || (listXml.attr(\"Title\") === opt.listName)) {\r\n                            // Don't work with hidden lists unless we're asked to\r\n                            if ((opt.showHiddenLists && listXml.attr(\"Hidden\") === \"False\") || !opt.showHiddenLists) {\r\n\r\n                                // Audit the list's forms\r\n                                if (opt.auditForms) {\r\n                                    // Get the list's Content Types, therefore the form pages\r\n                                    $().SPServices({\r\n                                        operation: \"GetListContentTypes\",\r\n                                        webURL: opt.webURL,\r\n                                        listName: listXml.attr(\"ID\"),\r\n                                        async: false, // Need this to be synchronous so we're assured of a valid value\r\n                                        completefunc: function (xData) {\r\n                                            $(xData.responseXML).find(\"ContentType\").each(function () {\r\n                                                // Don't deal with folders\r\n                                                if ($(this).attr(\"ID\").substring(0, 6) !== \"0x0120\") {\r\n                                                    var formUrls = $(this).find(\"FormUrls\");\r\n                                                    for (var i = 0; i < formTypes.length; i++) {\r\n                                                        // Look for a customized form...\r\n                                                        $(formUrls).find(formTypes[i][0]).each(function () {\r\n                                                            SPScriptAuditPage(opt, listXml, \"Form\", this.nodeName, ((opt.webURL.length > 0) ? opt.webURL : $().SPServices.SPGetCurrentSite()) + constants.SLASH + $(this).text());\r\n                                                            formTypes[i][2] = true;\r\n                                                        });\r\n                                                        // ...else the uncustomized form\r\n                                                        if (!formTypes[i][2]) {\r\n                                                            var defaultViewUrl = listXml.attr(\"DefaultViewUrl\");\r\n                                                            SPScriptAuditPage(opt, listXml, \"Form\", formTypes[i][0],\r\n                                                                defaultViewUrl.substring(0, defaultViewUrl.lastIndexOf(constants.SLASH) + 1) + formTypes[i][1]);\r\n                                                        }\r\n                                                    }\r\n                                                    // Reset the form types\r\n                                                    for (i = 0; i < formTypes.length; i++) {\r\n                                                        formTypes[i][2] = false;\r\n                                                    }\r\n                                                }\r\n                                            });\r\n                                        }\r\n                                    });\r\n                                }\r\n\r\n                                // Audit the list's views\r\n                                if (opt.auditViews) {\r\n                                    // Get the list's Views\r\n                                    $().SPServices({\r\n                                        operation: \"GetViewCollection\",\r\n                                        webURL: opt.webURL,\r\n                                        listName: listXml.attr(\"ID\"),\r\n                                        async: false, // Need this to be synchronous so we're assured of a valid value\r\n                                        completefunc: function (xData) {\r\n                                            $(xData.responseXML).find(\"View\").each(function () {\r\n                                                SPScriptAuditPage(opt, listXml, \"View\", $(this).attr(\"DisplayName\"), $(this).attr(\"Url\"));\r\n                                            });\r\n                                        }\r\n                                    });\r\n                                }\r\n\r\n                            }\r\n                        }\r\n                    });\r\n                }\r\n            });\r\n        }\r\n\r\n        // Don't bother with auditing pages if the options don't require it\r\n        var numLists = 0;\r\n        var listsArray = [];\r\n        if (typeof opt.auditPagesListName === \"string\") {\r\n            numLists = 1;\r\n            listsArray.push(opt.auditPagesListName);\r\n        } else {\r\n            numLists = opt.auditPagesListName.length;\r\n            listsArray = opt.auditPagesListName;\r\n        }\r\n\r\n        if (opt.auditPages) {\r\n            for (var i = 0; i < numLists; i++) {\r\n                $().SPServices({\r\n                    operation: \"GetList\",\r\n                    async: false,\r\n                    cacheXML: true,\r\n                    webURL: opt.webURL,\r\n                    listName: listsArray[i],\r\n                    completefunc: function (xData) {\r\n                        $(xData.responseXML).find(\"List\").each(function () {\r\n                            listXml = $(this);\r\n                        });\r\n                    }\r\n                });\r\n                // Get all of the items from the Document Library\r\n                $().SPServices({\r\n                    operation: \"GetListItems\",\r\n                    async: false,\r\n                    webURL: opt.webURL,\r\n                    listName: listsArray[i],\r\n                    CAMLQuery: \"<Query><Where><Neq><FieldRef Name='ContentType'/><Value Type='Text'>Folder</Value></Neq></Where></Query>\",\r\n                    CAMLViewFields: \"<ViewFields><FieldRef Name='Title'/><FieldRef Name='FileRef'/></ViewFields>\",\r\n                    CAMLRowLimit: 0,\r\n                    completefunc: function (xData) {\r\n                        $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                            var thisPageUrl = $(this).attr(\"ows_FileRef\").split(constants.spDelim)[1];\r\n                            var thisTitle = $(this).attr(\"ows_Title\");\r\n                            var thisPageType = (typeof thisTitle !== \"undefined\") ? thisTitle : \"\";\r\n                            if (thisPageUrl.indexOf(\".aspx\") > 0) {\r\n                                SPScriptAuditPage(opt, listXml, \"Page\", thisPageType, constants.SLASH + thisPageUrl);\r\n                            }\r\n                        });\r\n                    }\r\n                });\r\n            }\r\n        }\r\n        // Remove progress indicator and make the output pretty by cleaning up the ms-alternating CSS class\r\n        scriptAuditContainer.find(\"tr[class='ms-alternating']:even\").removeAttr(\"class\");\r\n    }; // End $.fn.SPServices.SPScriptAudit\r\n\r\n    // Displays the usage of scripts in a site\r\n    function SPScriptAuditPage(opt, listXml, pageClass, pageType, pageUrl) {\r\n\r\n        var jQueryPage = 0;\r\n        var pageScriptSrc = {};\r\n        pageScriptSrc.type = [];\r\n        pageScriptSrc.src = [];\r\n        pageScriptSrc.script = [];\r\n        var scriptRegex = RegExp(\"<script[\\\\s\\\\S]*?/script>\", \"gi\");\r\n\r\n        // Fetch the page\r\n        $.ajax({\r\n            type: \"GET\",\r\n            url: pageUrl,\r\n            dataType: \"text\",\r\n            async: false,\r\n            success: function (xData) {\r\n\r\n                var scriptMatch;\r\n\r\n                while (scriptMatch = scriptRegex.exec(xData)) {\r\n                    var scriptLanguage = getScriptAttribute(scriptMatch, \"language\");\r\n                    var scriptType = getScriptAttribute(scriptMatch, \"type\");\r\n                    var scriptSrc = getScriptAttribute(scriptMatch, \"src\");\r\n                    if (scriptSrc !== null && scriptSrc.length > 0 && !coreScript(scriptSrc)) {\r\n                        pageScriptSrc.type.push((scriptLanguage !== null && scriptLanguage.length > 0) ? scriptLanguage : scriptType);\r\n                        pageScriptSrc.src.push(scriptSrc);\r\n                        jQueryPage++;\r\n                    }\r\n                }\r\n\r\n                // Only show pages without script if we've been asked to do so.\r\n                if ((!opt.showNoScript && (pageScriptSrc.type.length > 0)) || opt.showNoScript) {\r\n                    var pagePath = pageUrl.substring(0, pageUrl.lastIndexOf(constants.SLASH) + 1);\r\n                    var out = \"<tr class=ms-alternating>\" +\r\n                        \"<td class=ms-vb-icon><a href='\" + listXml.attr(\"DefaultViewUrl\") + \"'><IMG border=0 src='\" + listXml.attr(\"ImageUrl\") + \"'width=16 height=16></A></TD>\" +\r\n                        \"<td class=ms-vb2><a href='\" + listXml.attr(\"DefaultViewUrl\") + \"'>\" + listXml.attr(\"Title\") + ((listXml.attr(\"Hidden\") === \"True\") ? '(Hidden)' : '') + \"</td>\" +\r\n                        \"<td class=ms-vb2>\" + pageClass + \"</td>\" +\r\n                        \"<td class=ms-vb2>\" + pageType + \"</td>\" +\r\n                        \"<td class=ms-vb2><a href='\" + pageUrl + \"'>\" + utils.fileName(pageUrl) + \"</td>\";\r\n                    if (opt.showSrc) {\r\n                        var thisSrcPath;\r\n                        out += \"<td valign='top'><table width='100%' style='border-collapse: collapse;' border=0 cellSpacing=0 cellPadding=1>\";\r\n                        for (var i = 0; i < pageScriptSrc.type.length; i++) {\r\n                            thisSrcPath = (pageScriptSrc.src[i].substr(0, 1) !== constants.SLASH) ? pagePath + pageScriptSrc.src[i] : pageScriptSrc.src[i];\r\n                            out += \"<tr><td class=ms-vb2 width='30%'>\" + pageScriptSrc.type[i] + \"</td>\";\r\n                            out += \"<td class=ms-vb2 width='70%'><a href='\" + thisSrcPath + \"'>\" + utils.fileName(pageScriptSrc.src[i]) + \"</td></tr>\";\r\n                        }\r\n                        out += \"</table></td>\";\r\n                    }\r\n                    $(\"#SPScriptAudit\").append(out);\r\n                }\r\n            }\r\n        });\r\n    } // End of function SPScriptAuditPage\r\n\r\n    function getScriptAttribute(source, attribute) {\r\n        var matches;\r\n        var regex = RegExp(attribute + \"=(\\\"([^\\\"]*)\\\")|('([^']*)')\", \"gi\");\r\n        if (matches = regex.exec(source)) {\r\n            return matches[2];\r\n        }\r\n        return null;\r\n    } // End of function getScriptAttribute\r\n\r\n    // Check to see if the script reference is part of SharePoint core so that we can ignore it\r\n    function coreScript(src) {\r\n        var coreScriptLocations = [\"WebResource.axd\", \"_layouts\"];\r\n        for (var i = 0; i < coreScriptLocations.length; i++) {\r\n            if (src.indexOf(coreScriptLocations[i]) > -1) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    } // End of function coreScript\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    \"../utils/constants\",\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // The SPSetMultiSelectSizes function sets the sizes of the multi-select boxes for a column on a form automagically\r\n    // based on the values they contain. The function takes into account the fontSize, fontFamily, fontWeight, etc., in its algorithm.\r\n    $.fn.SPServices.SPSetMultiSelectSizes = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            listName: $().SPServices.SPListNameFromUrl(), // The list the form is working with. This is useful if the form is not in the list context.\r\n            multiSelectColumn: \"\",\r\n            minWidth: 0,\r\n            maxWidth: 0,\r\n            debug: false\r\n        }, options);\r\n\r\n        var thisFunction = \"SPServices.SPSetMultiSelectSizes\";\r\n\r\n        // Find the multi-select column\r\n        var thisMultiSelect = $().SPServices.SPDropdownCtl({\r\n            displayName: opt.multiSelectColumn\r\n        });\r\n        if (thisMultiSelect.Obj.html() === null && opt.debug) {\r\n            utils.errBox(thisFunction, \"multiSelectColumn: \" + opt.multiSelectColumn, constants.TXTColumnNotFound);\r\n            return;\r\n        }\r\n        if (thisMultiSelect.Type !== constants.dropdownType.multiSelect && opt.debug) {\r\n            utils.errBox(thisFunction, \"multiSelectColumn: \" + opt.multiSelectColumn, \"Column is not multi-select.\");\r\n            return;\r\n        }\r\n\r\n        // Create a temporary clone of the select to use to determine the appropriate width settings.\r\n        // We'll append it to the end of the enclosing span.\r\n        var cloneId = utils.genContainerId(\"SPSetMultiSelectSizes\", opt.multiSelectColumn, opt.listName);\r\n        var cloneObj = $(\"<select id='\" + cloneId + \"' ></select>\").appendTo(thisMultiSelect.container);\r\n        cloneObj.css({\r\n            \"width\": \"auto\", // We want the clone to resize its width based on the contents\r\n            \"height\": 0, // Just to keep the page clean while we are using the clone\r\n            \"visibility\": \"hidden\" // And let's keep it hidden\r\n        });\r\n\r\n        // Add all the values to the cloned select.  First the left (possible values) select...\r\n        $(thisMultiSelect.master.candidateControl).find(\"option\").each(function () {\r\n            cloneObj.append(\"<option value='\" + $(this).html() + \"'>\" + $(this).html() + \"</option>\");\r\n        });\r\n        // ...then the right (selected values) select (in case some values have already been selected)\r\n        $(thisMultiSelect.master.resultControl).find(\"option\").each(function () {\r\n            cloneObj.append(\"<option value='\" + $(this).val() + \"'>\" + $(this).html() + \"</option>\");\r\n        });\r\n\r\n        // We'll add 5px for a little padding on the right.\r\n        var divWidth = cloneObj.width() + 5;\r\n        var newDivWidth = divWidth;\r\n        if (opt.minWidth > 0 || opt.maxWidth > 0) {\r\n            if (divWidth < opt.minWidth) {\r\n                divWidth = opt.minWidth;\r\n            }\r\n            if (newDivWidth < opt.minWidth) {\r\n                newDivWidth = opt.minWidth;\r\n            }\r\n            if (newDivWidth > opt.maxWidth) {\r\n                newDivWidth = opt.maxWidth;\r\n            }\r\n        }\r\n        var selectWidth = divWidth;\r\n\r\n        // Set the new widths\r\n        $(thisMultiSelect.master.candidateControl).css(\"width\", selectWidth + \"px\").parent().css(\"width\", newDivWidth + \"px\");\r\n        $(thisMultiSelect.master.resultControl).css(\"width\", selectWidth + \"px\").parent().css(\"width\", newDivWidth + \"px\");\r\n\r\n        // Remove the select's clone, since we're done with it\r\n        cloneObj.remove();\r\n\r\n    }; // End $.fn.SPServices.SPSetMultiSelectSizes\r\n\r\n    return $;\r\n\r\n});",null,"define([\r\n    'jquery',\r\n    '../utils/constants',\r\n    '../core/SPServices.utils',\r\n    //---------------------------\r\n    // We don't need local variables for these dependencies\r\n    // because they are added to the jQuery namespace.\r\n    '../core/SPServices.core'\r\n], function (\r\n    $,\r\n    constants,\r\n    utils\r\n) {\r\n\r\n    \"use strict\";\r\n\r\n    // SPUpdateMultipleListItems allows you to update multiple items in a list based upon some common characteristic or metadata criteria.\r\n    $.fn.SPServices.SPUpdateMultipleListItems = function (options) {\r\n\r\n        var opt = $.extend({}, {\r\n            webURL: \"\", // [Optional] URL of the target Web.  If not specified, the current Web is used.\r\n            listName: \"\", // The list to operate on.\r\n            CAMLQuery: \"\", // A CAML fragment specifying which items in the list will be selected and updated\r\n            batchCmd: \"Update\", // The operation to perform. By default, Update.\r\n            valuepairs: [], // Valuepairs for the update in the form [[fieldname1, fieldvalue1], [fieldname2, fieldvalue2]...]\r\n            completefunc: null, // Function to call on completion of rendering the change.\r\n            debug: false // If true, show error messages;if false, run silent\r\n        }, options);\r\n\r\n        var i;\r\n        var itemsToUpdate = [];\r\n        var documentsToUpdate = [];\r\n\r\n        // Call GetListItems to find all of the items matching the CAMLQuery\r\n        $().SPServices({\r\n            operation: \"GetListItems\",\r\n            async: false,\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            CAMLQuery: opt.CAMLQuery,\r\n            CAMLQueryOptions: \"<QueryOptions><ViewAttributes Scope='Recursive' /></QueryOptions>\",\r\n            completefunc: function (xData) {\r\n                $(xData.responseXML).SPFilterNode(\"z:row\").each(function () {\r\n                    itemsToUpdate.push($(this).attr(\"ows_ID\"));\r\n                    var fileRef = $(this).attr(\"ows_FileRef\");\r\n                    fileRef = \"/\" + fileRef.substring(fileRef.indexOf(constants.spDelim) + 2);\r\n                    documentsToUpdate.push(fileRef);\r\n                });\r\n            }\r\n        });\r\n\r\n        var fieldNum;\r\n        var batch = \"<Batch OnError='Continue'>\";\r\n        for (i = 0; i < itemsToUpdate.length; i++) {\r\n            batch += \"<Method ID='\" + i + \"' Cmd='\" + opt.batchCmd + \"'>\";\r\n            for (fieldNum = 0; fieldNum < opt.valuepairs.length; fieldNum++) {\r\n                batch += \"<Field Name='\" + opt.valuepairs[fieldNum][0] + \"'>\" + utils.escapeColumnValue(opt.valuepairs[fieldNum][1]) + \"</Field>\";\r\n            }\r\n            batch += \"<Field Name='ID'>\" + itemsToUpdate[i] + \"</Field>\";\r\n            if (documentsToUpdate[i].length > 0) {\r\n                batch += \"<Field Name='FileRef'>\" + documentsToUpdate[i] + \"</Field>\";\r\n            }\r\n            batch += \"</Method>\";\r\n        }\r\n        batch += \"</Batch>\";\r\n\r\n        // Call UpdateListItems to update all of the items matching the CAMLQuery\r\n        $().SPServices({\r\n            operation: \"UpdateListItems\",\r\n            async: false,\r\n            webURL: opt.webURL,\r\n            listName: opt.listName,\r\n            updates: batch,\r\n            completefunc: function (xData) {\r\n                // If present, call completefunc when all else is done\r\n                if (opt.completefunc !== null) {\r\n                    opt.completefunc(xData);\r\n                }\r\n            }\r\n        });\r\n\r\n    }; // End $.fn.SPServices.SPUpdateMultipleListItems\r\n\r\n    return $;\r\n\r\n});"],"sourceRoot":"/source/"}
diff --git a/build/jQuery.SPServices-2.0.0-pre-alpha.min.js b/build/jQuery.SPServices-2.0.0-pre-alpha.min.js
new file mode 100644
index 0000000..4273fd2
--- /dev/null
+++ b/build/jQuery.SPServices-2.0.0-pre-alpha.min.js
@@ -0,0 +1,4 @@
+!function(e){function t(o){if(a[o])return a[o].exports;var r=a[o]={exports:{},id:o,loaded:!1};return e[o].call(r.exports,r,r.exports,t),r.loaded=!0,r.exports}var a={};return t.m=e,t.c=a,t.p="",t(0)}([function(e,t,a){a(1),a(4),a(5),a(3),a(6),a(7),a(8),a(9),a(10),a(11),a(12),a(13),a(14),a(15),a(16),a(17),a(18),a(19),a(20),a(21),a(22),a(23),a(24),a(25),a(26),a(27),a(28),a(29),a(30),a(31),e.exports=a(32)},function(e,t,a){var o,r;o=[a(2),a(3),a(4)],r=function(e,t,a){"use strict";var o="",r={header:"",footer:" ",o=t.SCHEMASharePoint+"/soap/2002/1/alerts/";break;case s.MEETINGS:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/meetings/' >",o=t.SCHEMASharePoint+"/soap/meetings/";break;case s.OFFICIALFILE:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/recordsrepository/' >",o=t.SCHEMASharePoint+"/soap/recordsrepository/";break;case s.PERMISSIONS:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/directory/' >",o=t.SCHEMASharePoint+"/soap/directory/";break;case s.PUBLISHEDLINKSSERVICE:r.opheader+="xmlns='http://microsoft.com/webservices/SharePointPortalServer/PublishedLinksService/' >",o="http://microsoft.com/webservices/SharePointPortalServer/PublishedLinksService/";break;case s.SEARCH:r.opheader+="xmlns='urn:Microsoft.Search' >",o="urn:Microsoft.Search/";break;case s.SHAREPOINTDIAGNOSTICS:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/diagnostics/' >",o="http://schemas.microsoft.com/sharepoint/diagnostics/";break;case s.SOCIALDATASERVICE:r.opheader+="xmlns='http://microsoft.com/webservices/SharePointPortalServer/SocialDataService' >",o="http://microsoft.com/webservices/SharePointPortalServer/SocialDataService/";break;case s.SPELLCHECK:r.opheader+="xmlns='http://schemas.microsoft.com/sharepoint/publishing/spelling/' >",o="http://schemas.microsoft.com/sharepoint/publishing/spelling/SpellCheck";break;case s.TAXONOMYSERVICE:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/taxonomy/soap/' >",o=t.SCHEMASharePoint+"/taxonomy/soap/";break;case s.USERGROUP:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/directory/' >",o=t.SCHEMASharePoint+"/soap/directory/";break;case s.USERPROFILESERVICE:r.opheader+="xmlns='http://microsoft.com/webservices/SharePointPortalServer/UserProfileService' >",o="http://microsoft.com/webservices/SharePointPortalServer/UserProfileService/";break;case s.WEBPARTPAGES:r.opheader+="xmlns='http://microsoft.com/sharepoint/webpartpages' >",o="http://microsoft.com/sharepoint/webpartpages/";break;case s.WORKFLOW:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/workflow/' >",o=t.SCHEMASharePoint+"/soap/workflow/";break;default:r.opheader+="xmlns='"+t.SCHEMASharePoint+"/soap/'>",o=t.SCHEMASharePoint+"/soap/"}o+=c.operation,r.opfooter="";var u="_vti_bin/"+l[c.operation][0]+".asmx",p=void 0!==c.webURL?c.webURL:c.webUrl;if(p.charAt(p.length-1)===t.SLASH)u=p+u;else if(p.length>0)u=p+t.SLASH+u;else{var S=e().SPServices.SPGetCurrentSite();u=S+(S.charAt(S.length-1)===t.SLASH?u:t.SLASH+u)}switch(r.payload="",c.operation){case"GetAlerts":break;case"DeleteAlerts":for(r.payload+="",m=0;m";break;case"Mode":break;case"Login":a.addToPayload(c,r,["username","password"]);break;case"CopyIntoItems":for(a.addToPayload(c,r,["SourceUrl"]),r.payload+="",m=0;m",a.addToPayload(c,r,["Fields","Stream","Results"]);break;case"CopyIntoItemsLocal":for(a.addToPayload(c,r,["SourceUrl"]),r.payload+="",m=0;m";break;case"GetItem":a.addToPayload(c,r,["Url","Fields","Stream"]);break;case"GetForm":a.addToPayload(c,r,["listName","formUrl"]);break;case"GetFormCollection":a.addToPayload(c,r,["listName"]);break;case"AddAttachment":a.addToPayload(c,r,["listName","listItemID","fileName","attachment"]);break;case"AddDiscussionBoardItem":a.addToPayload(c,r,["listName","message"]);break;case"AddList":a.addToPayload(c,r,["listName","description","templateID"]);break;case"AddListFromFeature":a.addToPayload(c,r,["listName","description","featureID","templateID"]);break;case"ApplyContentTypeToList":a.addToPayload(c,r,["webUrl","contentTypeId","listName"]);break;case"CheckInFile":a.addToPayload(c,r,["pageUrl","comment","CheckinType"]);break;case"CheckOutFile":a.addToPayload(c,r,["pageUrl","checkoutToLocal","lastmodified"]);break;case"CreateContentType":a.addToPayload(c,r,["listName","displayName","parentType","fields","contentTypeProperties","addToView"]);break;case"DeleteAttachment":a.addToPayload(c,r,["listName","listItemID","url"]);break;case"DeleteContentType":a.addToPayload(c,r,["listName","contentTypeId"]);break;case"DeleteContentTypeXmlDocument":a.addToPayload(c,r,["listName","contentTypeId","documentUri"]);break;case"DeleteList":a.addToPayload(c,r,["listName"]);break;case"GetAttachmentCollection":a.addToPayload(c,r,["listName",["listItemID","ID"]]);break;case"GetList":a.addToPayload(c,r,["listName"]);break;case"GetListAndView":a.addToPayload(c,r,["listName","viewName"]);break;case"GetListCollection":break;case"GetListContentType":a.addToPayload(c,r,["listName","contentTypeId"]);break;case"GetListContentTypes":a.addToPayload(c,r,["listName"]);break;case"GetListItems":a.addToPayload(c,r,["listName","viewName",["query","CAMLQuery"],["viewFields","CAMLViewFields"],["rowLimit","CAMLRowLimit"],["queryOptions","CAMLQueryOptions"]]);break;case"GetListItemChanges":a.addToPayload(c,r,["listName","viewFields","since","contains"]);break;case"GetListItemChangesSinceToken":a.addToPayload(c,r,["listName","viewName",["query","CAMLQuery"],["viewFields","CAMLViewFields"],["rowLimit","CAMLRowLimit"],["queryOptions","CAMLQueryOptions"],{name:"changeToken",sendNull:!1},{name:"contains",sendNull:!1}]);break;case"GetVersionCollection":a.addToPayload(c,r,["strlistID","strlistItemID","strFieldName"]);break;case"UndoCheckOut":a.addToPayload(c,r,["pageUrl"]);break;case"UpdateContentType":a.addToPayload(c,r,["listName","contentTypeId","contentTypeProperties","newFields","updateFields","deleteFields","addToView"]);break;case"UpdateContentTypesXmlDocument":a.addToPayload(c,r,["listName","newDocument"]);break;case"UpdateContentTypeXmlDocument":a.addToPayload(c,r,["listName","contentTypeId","newDocument"]);break;case"UpdateList":a.addToPayload(c,r,["listName","listProperties","newFields","updateFields","deleteFields","listVersion"]);break;case"UpdateListItems":if(a.addToPayload(c,r,["listName"]),"undefined"!=typeof c.updates&&c.updates.length>0)a.addToPayload(c,r,["updates"]);else{for(r.payload+="",m=0;m"+a.escapeColumnValue(c.valuepairs[m][1])+"";"New"!==c.batchCmd&&(r.payload+=""+c.ID+" "),r.payload+=" ",o=t.SCHEMANintex+"/";break;default:r.opheader+="xmlns='"+t.SCHEMANintex+"/soap/'>",o=t.SCHEMANintex+"/soap/"}o+=c.operation,r.opfooter="";var u="_vti_bin/"+l[c.operation][0]+".asmx",p=e().SPServices.SPGetCurrentSite(),S=void 0!==c.webURL?c.webURL:c.webUrl;switch(u=S.charAt(S.length-1)===t.SLASH?S+u:S.length>0?S+t.SLASH+u:p+(p.charAt(p.length-1)===t.SLASH?u:t.SLASH+u),r.payload="",c.operation){case"AddLongTermDelegationRule":a.addToPayload(c,["fromTheBeginningOf","untilTheEndOf","delegateFrom","delegateTo","currentSiteOnly"]);break;case"AddWorkflowSchedule":a.addToPayload(c,["fileUrl","workflowName","startDataXml"]),r.payload+="",a.addToPayload(c,["MaximumRepeats","WorkdaysOnly"]),r.payload+="",a.addToPayload(c,["Type","CountBetweenIntervals"]),r.payload+=" ",a.addToPayload(c,["EndOn","StartTime","EndTime"]),r.payload+=" ",a.addToPayload(c,["updateIfExists"]);break;case"AddWorkflowScheduleOnListItem":a.addToPayload(c,["itemId","listName","workflowName","startDataXML"]),r.payload+="",a.addToPayload(c,["MaximumRepeats","WorkdaysOnly"]),r.payload+="",a.addToPayload(c,["Type","CountBetweenIntervals"]),r.payload+=" ",a.addToPayload(c,["EndOn","StartTime","EndTime"]),r.payload+=" ",a.addToPayload(c,["updateIfExists"]);break;case"CheckGlobalReuseStatus":a.addToPayload(c,["workflowName"]);break;case"CheckInForms":a.addToPayload(c,["workflowConfiguration","activityConfiguration","formType"]);break;case"DelegateAllTasks":a.addToPayload(c,["currentUser","newUser","sendNotification","comments","global"]);break;case"DelegateTask":a.addToPayload(c,["spTaskId","taskListName","targetUserName","comments","sendNotification"]);break;case"DeleteLongTermDelegationRule":a.addToPayload(c,["id"]);break;case"DeleteSnippet":a.addToPayload(c,["snippetId"]);break;case"DeleteWorkflow":a.addToPayload(c,["listId","workflowId","workflowType"]);break;case"ExportWorkflow":a.addToPayload(c,["listName","workflowType","workflowName"]);break;case"FixWorkflowsInSiteFromTemplate":a.addToPayload(c,["FixWorkflowsInSiteFromTemplate"]);break;case"GetFolders":a.addToPayload(c,["listGuid"]);break;case"GetItemsPendingMyApproval":a.addToPayload(c,["uniquenessInfo"]);break;case"GetListContentTypes":a.addToPayload(c,["listGuid"]);break;case"GetOutcomesForFlexiTask":a.addToPayload(c,["spTaskId","taskListName"]);break;case"GetRunningWorkflowTasks":a.addToPayload(c,["fileUrl"]);break;case"GetRunningWorkflowTasksCollection":a.addToPayload(c,["userlogin","teamsiteUrl","listName"]);break;case"GetRunningWorkflowTasksForCurrentUser":a.addToPayload(c,["fileUrl"]);break;case"GetRunningWorkflowTasksForCurrentUserForListItem":a.addToPayload(c,["itemId","listName"]);break;case"GetRunningWorkflowTasksForListItem":a.addToPayload(c,["itemId","listName"]);break;case"GetTaskDetailsUsingStub":a.addToPayload(c,["taskToken"]);break;case"GetTaskStubsForCurrentUser":break;case"GetWorkflowHistory":a.addToPayload(c,["fileUrl","stateFilter","workflowNameFilter"]);break;case"GetWorkflowHistoryForListItem":a.addToPayload(c,["itemId","listName","stateFilter","workflowNameFilter"]);break;case"HideTaskForApprover":a.addToPayload(c,["approverId","contentDbId"]);break;case"HideWorkflow":a.addToPayload(c,["siteId","instanceId"]);break;case"ProcessFlexiTaskResponse":a.addToPayload(c,["comments","outcome","spTaskId","taskListName"]);break;case"ProcessFlexiTaskResponse2":a.addToPayload(c,["comments","outcome","spTaskId","taskListName"]);break;case"ProcessTaskResponse":a.addToPayload(c,["comments","outcome","spTaskId"]);break;case"ProcessTaskResponse2":a.addToPayload(c,["comments","outcome","spTaskId","taskListName"]);break;case"ProcessTaskResponse3":a.addToPayload(c,["comments","outcome","spTaskId","taskListName"]);break;case"ProcessTaskResponseUsingToken":a.addToPayload(c,["comments","outcome","taskToken","customOutcome"]);break;case"PublishFromNWF":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFSkipValidation":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFSkipValidationNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFXml":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFXmlNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFXmlSkipValidation":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishFromNWFXmlSkipValidationNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName","saveIfCannotPublish"]);break;case"PublishWorkflow":a.addToPayload(c,["wfName","activityConfigs","listId","contentTypeId","changeNotes"]);break;case"QueryForMessages":a.addToPayload(c,["workflowInstanceId","messageId"]);break;case"RemoveWorkflowSchedule":a.addToPayload(c,["fileUrl","workflowName"]);break;case"RemoveWorkflowScheduleOnListItem":a.addToPayload(c,["itemId","listName","workflowName"]);break;case"SaveFromNWF":a.addToPayload(c,["workflowFile","listName","workflowName"]);break;case"SaveFromNWFNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName"]);break;case"SaveFromNWFXml":a.addToPayload(c,["workflowFile","listName","workflowName"]);break;case"SaveFromNWFXmlNoOverwrite":a.addToPayload(c,["workflowFile","listName","workflowName"]);break;case"SaveSnippet":a.addToPayload(c,["snippetName","activityConfigs"]);break;case"SaveTemplate":a.addToPayload(c,["templateName","templateDescription","category","activityConfigs"]);break;case"SaveTemplate2":a.addToPayload(c,["templateName","templateDescription","category","activityConfigs","lcid"]);break;case"SaveWorkflow":a.addToPayload(c,["wfName","activityConfigs","listId","contentTypeId","changeNotes"]);break;case"SnippetExists":a.addToPayload(c,["snippetName"]);break;case"StartSiteWorkflow":a.addToPayload(c,["workflowName","associationData"]);break;case"StartWorkflow":a.addToPayload(c,["fileUrl","workflowName","associationData"]);break;case"StartWorkflowOnListItem":a.addToPayload(c,["itemId","listName","workflowName","associationData"]);break;case"TemplateExists":a.addToPayload(c,["templateName"]);break;case"TerminateWorkflow":a.addToPayload(c,["listId","itemId","instanceId"]);break;case"TerminateWorkflowByName":a.addToPayload(c,["fileUrl","workflowName","terminatePreviousInstances"]);break;case"TerminateWorkflowByNameForListItem":a.addToPayload(c,["listName","itemId","workflowName","terminatePreviousInstances"]);break;case"WorkflowExists":a.addToPayload(c,["workflowName","listId","workflowType"]);break;case"WorkflowFormProductSelected":a.addToPayload(c,["workflowConfiguration","activityConfiguration","product","formType"])}var f,y=r.header+r.opheader+r.payload+r.opfooter+r.footer;if(c.cacheXML&&(f=i[y]),"undefined"==typeof f){var h=e.ajax({url:u,async:c.async,beforeSend:function(e){l[c.operation][1]&&e.setRequestHeader("SOAPAction",o)},type:"POST",data:y,dataType:"xml",contentType:"text/xml;charset='utf-8'",complete:function(t,a){e.isFunction(c.completefunc)&&c.completefunc(t,a)}});return c.cacheXML&&(i[y]=h),h}return e.isFunction(c.completefunc)&&f.done(function(e,t,a){c.completefunc(a,t)}),f},e.fn.SPServices.defaults={cacheXML:!1,operation:"",webURL:"",customHeaders:{},makeViewDefault:!1,viewName:"",CAMLQuery:"",CAMLViewFields:"",CAMLRowLimit:0,CAMLQueryOptions:""+e+" ":e},fileName:function(e){return e.substring(e.lastIndexOf("/")+1,e.length)},xml_special_to_escaped_one_map:{"&":"&",'"':""","<":"<",">":">"},encodeXml:function(e){return e.replace(/([\&"<>])/g,function(e,t){return this.xml_special_to_escaped_one_map[t]})},escapeColumnValue:function(e){return"string"==typeof e?e.replace(/&(?![a-zA-Z]{1,8};)/g,"&"):e},escapeUrl:function(e){return e.replace(/&/g,"%26")},SplitIndex:function(e){var a=e.split(t.spDelim);this.id=a[0],this.value=a[1]},pad:function(e){return 10>e?"0"+e:e},errBox:function(e,t,a){var r="Error in function Parameter Message Click to continue ";o(r)},findFormField:function(t){var a=e("td.ms-formbody, td.ms-formbodysurvey"),o=function(e){return e.replace(/([.*+?^=!:${}()|\[\]\/\\])/g,"\\$1")},r=o(t),i=new RegExp('(?:Field|FieldInternal)Name="'+r+'"',"i"),s=a.contents().filter(function(){return 8===this.nodeType&&i.test(this.nodeValue)});return s.parent("td")},showAttrs:function(e){var t,o="";for(t=0;t"+t+" "+e.attributes.item(t).nodeName+" "+a.checkLink(e.attributes.item(t).nodeValue)+" ";return o+="
"},addToPayload:function(t,o,r){var i;for(i=0;i"+t);var o=e("#SPServices_msgBox"),r=o.height(),i=o.width(),s=e(window).width()/2-i/2+"px",n=e(window).height()/2-r/2-100+"px";o.css({border:"5px #C02000 solid",left:s,top:n}).show().fadeTo("slow",.75).click(function(){e(this).fadeOut("3000",function(){e(this).remove()})})};return a}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(1)],r=function(e,t){"use strict";return e.fn.SPServices.Version=function(){return t.VERSION},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPConvertDateToISO=function(t){var o=e.extend({},{dateToConvert:new Date,dateOffset:"-05:00"},t),r="",i=o.dateToConvert;return r+=i.getFullYear()+"-",r+=a.pad(i.getMonth()+1)+"-",r+=a.pad(i.getDate()),r+="T"+a.pad(i.getHours())+":",r+=a.pad(i.getMinutes())+":",r+=a.pad(i.getSeconds())+"Z"+o.dateOffset},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(4),a(1)],r=function(e,t){"use strict";return e.fn.SPServices.SPDebugXMLHttpResult=function(a){var o,r=e.extend({},{node:null,indent:0},a),i=3,s=4,n="";if(n+="","DisplayPattern"===r.node.nodeName)n+=""+r.node.nodeName+" "+r.node.nodeName+" "+r.node.nodeName+" "+t.checkLink(r.node.firstChild.nodeValue)+" "+r.node.nodeName+" "+t.showAttrs(r.node)+" ",o=0;o "+r.node.nodeName+" "+(null!==r.node.nodeValue?t.checkLink(r.node.nodeValue):" ")+" "+t.showAttrs(r.node)+"
"},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(4),a(3),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPDropdownCtl=function(o){var r=e.extend({},{displayName:""},o),i={};if(1===(i.Obj=e("select[Title='"+r.displayName+"']")).length?i.Type=a.dropdownType.simple:1===(i.Obj=e("input[Title='"+r.displayName+"']")).length?i.Type=a.dropdownType.complex:1===(i.Obj=e("select[ID$='SelectCandidate'][Title^='"+r.displayName+" ']")).length?i.Type=a.dropdownType.multiSelect:1===(i.Obj=e("select[ID$='SelectCandidate'][Title$=': "+r.displayName+"']")).length?i.Type=a.dropdownType.multiSelect:1===(i.Obj=e("select[ID$='SelectCandidate'][Title$='\""+r.displayName+"\".']")).length?i.Type=a.dropdownType.multiSelect:1===(i.Obj=e("select[ID$='SelectCandidate'][Title$=' "+r.displayName+"']")).length?i.Type=a.dropdownType.multiSelect:i.Type=null,null===i.Type){var s=t.findFormField(r.displayName);if(void 0!==s){var n=s.find("select[title^='"+r.displayName+" '][id$='_Lookup']"),l=s.find("select[title^='"+r.displayName+" '][id$='LookupField']"),d=n.length>0?n:l;d&&1===d.length&&(i.Type=a.dropdownType.simple,i.Obj=d)}}if(i.Type===a.dropdownType.complex)i.optHid=e("input[id='"+i.Obj.attr("optHid")+"']");else if(i.Type===a.dropdownType.multiSelect){i.container=i.Obj.closest("span"),i.MultiLookupPickerdata=i.container.find("input[id$='"+t.multiLookupPrefix+"_data'], input[id$='"+t.multiLookupPrefix2013+"_data']");var c=i.container.find("[id$='AddButton']").attr("id");i.master=window[c.replace(/AddButton/,a.multiLookupPrefix+"_m")]||window[c.replace(/AddButton/,a.multiLookupPrefix2013+"_m")]}return i},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2)],r=function(e){"use strict";return e.fn.SPFilterNode=function(e){return this.find("*").filter(function(){return this.nodeName===e})},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";var o=window.SPServices||{};return e.fn.SPServices.SPGetCurrentSite=function(){var r=a.SPServicesContext();if(r.thisSite.length>0)return r.thisSite;var i=o.SOAPEnvelope.header+""+(location.href.indexOf("?")>0?location.href.substr(0,location.href.indexOf("?")):location.href)+" ";return o.CAMLQuery.length>0&&(i+=""),i+=""+a+" "),i+=" 0?a.columnDisplayNames.length:1;return e().SPServices({operation:"GetList",async:!1,cacheXML:!0,webURL:a.webURL,listName:a.listName,completefunc:function(t){if(i>1)for(var s=0;i>s;s++)r[a.columnDisplayNames[s]]=e(t.responseXML).find("Field[DisplayName='"+a.columnDisplayNames[s]+"']").attr("StaticName");else o=e(t.responseXML).find("Field[DisplayName='"+a.columnDisplayName+"']").attr("StaticName")}}),i>1?r:o},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPListNameFromUrl=function(o){var r=e.extend({},{listName:""},o),i=a.SPServicesContext();if(r.listName.length>0)return r.listName;if(void 0!==i.thisList&&i.thisList.length>0)return i.thisList;var s=location.href,n=s.substring(0,s.indexOf(".aspx")),l=decodeURIComponent(n.substring(0,n.lastIndexOf(t.SLASH)+1)).toUpperCase();return e().SPServices({operation:"GetListCollection",async:!1,completefunc:function(a){e(a.responseXML).find("List").each(function(){var a=e(this).attr("DefaultViewUrl"),o=a.substring(0,a.lastIndexOf(t.SLASH)+1).toUpperCase();return l.indexOf(o)>0?(i.thisList=e(this).attr("ID"),!1):void 0})}}),i.thisList},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4)],r=function(e,t,a){"use strict";function o(e,t){function a(e){return e}var o={Integer:r,Number:i,Boolean:s,DateTime:n,User:l,UserMulti:d,Lookup:c,lookupMulti:m,MultiChoice:u,Calculated:f,Attachments:p,URL:S,JSON:y,Text:o.Default,Counter:o.Integer,datetime:o.DateTime,AllDayEvent:o.Boolean,Recurrence:o.Boolean,Currency:o.Number,"float":o.Number,RelatedItems:o.JSON,Default:a};return(o[t]||a)(e)}function r(e){return parseInt(e,10)}function i(e){return parseFloat(e)}function s(e){return"0"!==e}function n(e){var t=e.split("T")[0]!==e?e.split("T"):e.split(" "),a=t[0].split("-"),o=t[1].split(":"),r=o[2].split("Z");return new Date(a[0],a[1]-1,a[2],o[0],o[1],r[0])}function l(e){if(0===e.length)return null;var t=new a.SplitIndex(e),o=t.value.split(",#");return 1===o.length?{userId:t.id,userName:t.value}:{userId:t.id,userName:o[0].replace(/(,,)/g,","),loginName:o[1].replace(/(,,)/g,","),email:o[2].replace(/(,,)/g,","),sipAddress:o[3].replace(/(,,)/g,","),title:o[4].replace(/(,,)/g,",")}}function d(e){if(0===e.length)return null;for(var a=[],o=e.split(t.spDelim),r=0;r"),m=0;m "),c.append(i[m]);if(r){var u=e("");var l=t.genContainerId("SPAutocomplete",r.columnName,r.listName);i.after("
");var d=e("#"+l);d.css("width",n),e(i).keyup(function(){var t=e(this).val();if(d.hide(),t.length
";r.CAMLQuery.length>0&&(n+=""),n+="<"+r.filterType+">"+t+" ",r.CAMLQuery.length>0&&(n+=r.CAMLQuery+" "),n+=" ",e().SPServices({operation:"GetListItems",async:!1,webURL:r.WebURL,listName:r.sourceList,CAMLQuery:n,CAMLQueryOptions:r.CAMLQueryOptions,CAMLViewFields:"0){var u=new RegExp(t,r.ignoreCase?"gi":"g"),p=a[m].match(u),S=0;for(o=0;o"+p[o]+"";a[m]=a[m].substr(0,f)+h+a[m].substr(y),S=f+h.length}}c+=""+a[m]+" "}d.html(c),e("#"+l+" li").click(function(){e("#"+l).fadeOut(r.slideUpSpeed),i.val(e(this).text())}).mouseover(function(){var t={cursor:"hand",color:"#ffffff",background:"#3399ff"};e(this).css(t)}).mouseout(function(){var t={cursor:"inherit",color:s,background:"transparent"};e(this).css(t)}),a.length>0&&e("#"+l).slideDown(r.slideDownSpeed),i.css("background-image","")})},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";function o(o){var r,i,s,n,l,d="",c=null,m=o.Obj.data("SPCascadeDropdownsChildColumns");e(m).each(function(){var m,u=this.opt,p=this.childSelect,S=this.childColumnStatic,f=this.childColumnRequired;r=a.getDropdownSelected(o,u.matchOnId);var y=r.join(t.spDelim);if(o.Obj.data("SPCascadeDropdown_Selected_"+S)!==y){o.Obj.data("SPCascadeDropdown_Selected_"+S,y),c=a.getDropdownSelected(p,!0);var h=u.relationshipListSortColumn.length>0?u.relationshipListSortColumn:u.relationshipListChildColumn,T="";if(u.CAMLQuery.length>0&&(T+=""),0===r.length)T+="":"'/>")+a.escapeColumnValue(r[0])+" ";for(m=0;m":"'/>")+a.escapeColumnValue(r[m])+" ",m>0&&m");T+=""}u.CAMLQuery.length>0&&(T+=u.CAMLQuery+" "),T+=" "+u.promptText.replace(/\{0\}/g,u.childColumn)+" "):f||p.Obj.append(""+u.noneText+" ");break;case t.dropdownType.complex:d=f?"":u.noneText+"|0",p.Obj.val("");break;case t.dropdownType.multiSelect:e(p.master.candidateControl).find("option").remove(),i=""}switch(s=parseFloat(e(o.responseXML).SPFilterNode("rs:data").attr("ItemCount")),e(o.responseXML).SPFilterNode("z:row").each(function(){var o={},r=e(this).attr("ows_"+u.relationshipListChildColumn);switch("undefined"!=typeof r&&r.indexOf(t.spDelim)>0?o=new a.SplitIndex(r):(o.id=e(this).attr("ows_ID"),o.value=r),isNaN(o.id)&&(o.id=e(this).attr("ows_ID")),n=o.id,l=o.value,p.Type){case t.dropdownType.simple:var s=e(this).attr("ows_ID")===c[0]?" selected='selected'":"";p.Obj.append(""+o.value+"");break;case t.dropdownType.complex:o.id===c[0]&&p.Obj.val(o.value),d=d+(d.length>0?"|":"")+o.value+"|"+o.id;break;case t.dropdownType.multiSelect:e(p.master.candidateControl).append(""+o.value+" "),i+=o.id+"|t"+o.value+"|t |t |t"}}),p.Type){case t.dropdownType.simple:p.Obj.trigger("change"),1===s&&u.selectSingleOption===!0&&e(p.Obj).find("option[value!='0']:first").attr("selected","selected");break;case t.dropdownType.complex:p.Obj.attr("choices",d),1===s&&u.selectSingleOption===!0&&(e(p.Obj).val(l),p.optHid.val(n)),""===p.Obj.val()&&p.optHid.val("");break;case t.dropdownType.multiSelect:p.master.data="",p.MultiLookupPickerdata.val(i),e(p.master.resultControl).find("option").each(function(){var t=e(this);t.prop("selected",!0),e(p.master.candidateControl).find("option[value='"+t.val()+"']").each(function(){t.prop("selected",!1)})}),GipRemoveSelectedItems(p.master),e(p.master.candidateControl).find("option").each(function(){var t=e(this);e(p.master.resultControl).find("option[value='"+t.val()+"']").each(function(){t.remove()})}),GipAddSelectedItems(p.master),p.master.data=GipGetGroupData(i),e(p.master.candidateControl).trigger("dblclick")}}}),null!==u.completefunc&&u.completefunc()}})}return e.fn.SPServices.SPCascadeDropdowns=function(r){var i=e.extend({},{relationshipWebURL:"",relationshipList:"",relationshipListParentColumn:"",relationshipListChildColumn:"",relationshipListSortColumn:"",parentColumn:"",childColumn:"",listName:e().SPServices.SPListNameFromUrl(),CAMLQuery:"",CAMLQueryOptions:"FALSE ",c=0;c"+s[c]+""}d+=" ",i.Obj.closest("td").prepend(d);var u=e("#"+l);i.Obj.closest("span").find("img").remove(),i.Obj.closest("span").find("input").hide(),u.change(function(){var t=e(this).val();i.optHid.val(t),e(i.Obj).val(e(this).find("option[value='"+("0"!==t?t:"")+"']").html())}),u.trigger("change"),null!==r.completefunc&&r.completefunc()}},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";function o(o,i,s){var n,l,d="SPServices.SPDisplayRelatedInfo",c=e().SPServices.SPDropdownCtl({displayName:o.columnName});if(l=a.getDropdownSelected(c,o.matchOnId),!(c.Type===t.dropdownType.complex&&o.numChars>0&&l[0].length ";o.CAMLQuery.length>0&&(u+="");var p=s[o.relatedListColumn].attr("Type");u+="Lookup"===p?"":"'/>")+a.escapeColumnValue(l[0])+" ":o.relatedListColumn+"'/>")+a.escapeColumnValue(l[0])+" "),u+=" "+S+" ",CAMLRowLimit:0,completefunc:function(t){e(t.responseXML).find("errorstring").each(function(){var t=e(this).text();o.debug&&"One or more field types are not installed properly. Go to the list settings page to delete these fields."===t?a.errBox(d,"relatedListColumn: "+o.relatedListColumn,"Column not found in relatedList "+o.relatedList):o.debug&&"Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)."===t&&a.errBox(d,"relatedList: "+o.relatedList,"List not found")});var l;switch(o.displayFormat){case"table":for(l="",l+="",n=0;n"+s[o.relatedColumns[n]].attr("DisplayName")+""}l+=" ",e(t.responseXML).SPFilterNode("z:row").each(function(){for(l+="",n=0;n"+r(i,s[o.relatedColumns[n]],e(this).attr("ows_"+o.relatedColumns[n]),o)+"";l+=" "}),l+="
";break;case"list":l="",e(t.responseXML).SPFilterNode("z:row").each(function(){for(n=0;n"+s[o.relatedColumns[n]].attr("DisplayName")+"",l+=""+r(i,s[o.relatedColumns[n]],e(this).attr("ows_"+o.relatedColumns[n]),o)+" ",l+=""}}),l+="
";break;case"none":}"none"!==o.displayFormat&&e("#"+m).html(l),null!==o.completefunc&&o.completefunc(t)}})}}function r(o,r,i,s){if("undefined"==typeof i)return"";var n,l,d,c="",m="",u=[],p=s.relatedWebURL.length>0?s.relatedWebURL:e().SPServices.SPGetCurrentSite();switch(r.attr("Type")){case"Text":c=i;break;case"URL":switch(r.attr("Format")){case"Hyperlink":c=""+i.substring(i.search(",")+1)+" ";break;case"Image":c=""+S[n+1]+"");c=u.join(", ");break;case"Calculated":var f=i.split(t.spDelim);c=f[1];break;case"Number":d=r.attr("Decimals"),c="undefined"==typeof d?parseFloat(i).toString():parseFloat(i).toFixed(d).toString();break;case"Currency":d=r.attr("Decimals"),c="undefined"==typeof d?parseFloat(i).toFixed(2).toString():parseFloat(i).toFixed(d).toString();break;case"Lookup":switch(r.attr("Name")){case"FileRef":l="1"===o.attr("BaseType")?o.attr("RootFolder")+t.SLASH+"Forms/DispForm.aspx":o.attr("RootFolder")+t.SLASH+"DispForm.aspx",c=""+i.substring(i.search(t.spDelim)+2)+" ";break;case"FileDirRef":l=t.SLASH+i.substring(i.search(t.spDelim)+2),c=""+i.substring(i.search(t.spDelim)+2)+" ";break;default:l=a.getListFormUrl(r.attr("List"),"DisplayForm"),c=""+i.substring(i.search(t.spDelim)+2)+" "}break;case"LookupMulti":if(l=a.getListFormUrl(r.attr("List"),"DisplayForm"),c="",i.length>0){var y=i.split(t.spDelim);for(n=0;n"+y[2*n+1]+"")}c=u.join(", ");break;case"File":m=i.substring(i.search(t.spDelim)+2),c=""+m+" ";break;case"Counter":c=i;break;case"DateTime":c=i;break;default:c=i}return c}return e.fn.SPServices.SPDisplayRelatedInfo=function(r){var i,s,n=e.extend({},{listName:e().SPServices.SPListNameFromUrl(),columnName:"",relatedWebURL:"",relatedList:"",relatedListColumn:"",relatedColumns:[],displayFormat:"table",headerCSSClass:"ms-vh2",rowCSSClass:"ms-vb",CAMLQuery:"",numChars:0,matchType:"Eq",matchOnId:!1,completefunc:null,debug:!1},r),l=[],d="SPServices.SPDisplayRelatedInfo",c=e().SPServices.SPDropdownCtl({displayName:n.columnName});if(null===c.Obj.html()&&n.debug)return void a.errBox(d,"columnName: "+n.columnName,t.TXTColumnNotFound);switch(e().SPServices({operation:"GetList",async:!1,cacheXML:!0,webURL:n.relatedWebURL,listName:n.relatedList,completefunc:function(t){for(e(t.responseXML).find("faultcode").each(function(){n.debug&&a.errBox(d,"relatedList: "+n.relatedList,"List not found")}),s=e(t.responseXML).find("List"),i=0;i Field[Name='"+n.relatedColumns[i]+"']");l[n.relatedListColumn]=e(t.responseXML).find("Fields > Field[Name='"+n.relatedListColumn+"']")}}),c.Type){case t.dropdownType.simple:c.Obj.bind("change",function(){o(n,s,l)});break;case t.dropdownType.complex:c.optHid.bind("propertychange",function(){o(n,s,l)});break;case t.dropdownType.multiSelect:n.debug&&a.errBox(d,"columnName: "+n.columnName,"Multi-select columns not supported by this function")}o(n,s,l)},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPFilterDropdown=function(o){var r,i,s=e.extend({},{relationshipWebURL:"",relationshipList:"",relationshipListColumn:"",relationshipListSortColumn:"",relationshipListSortAscending:!0,columnName:"",listName:e().SPServices.SPListNameFromUrl(),promptText:"",noneText:"(None)",CAMLQuery:"",CAMLQueryOptions:"FALSE ";s.CAMLQuery.length>0&&(p+=s.CAMLQuery),p+=" "+s.promptText.replace(/\{0\}/g,s.columnName)+" "):i||c.Obj.append(""+s.noneText+" ");break;case t.dropdownType.complex:n=i?"":s.noneText+"|0",c.Obj.val("");break;case t.dropdownType.multiSelect:e(c.master.candidateControl).find("option").remove(),r=""}switch(e(o.responseXML).SPFilterNode("z:row").each(function(){var o={},i=e(this).attr("ows_"+s.relationshipListColumn);switch("undefined"!=typeof i&&i.indexOf(t.spDelim)>0?o=new a.SplitIndex(i):(o.id=e(this).attr("ows_ID"),o.value=i),isNaN(o.id)&&(o.id=e(this).attr("ows_ID")),c.Type){case t.dropdownType.simple:var d=e(this).attr("ows_ID")===l[0]?" selected='selected'":"";c.Obj.append(""+o.value+"");break;case t.dropdownType.complex:o.id===l[0]&&c.Obj.val(o.value),n=n+(n.length>0?"|":"")+o.value+"|"+o.id;break;case t.dropdownType.multiSelect:e(c.master.candidateControl).append(""+o.value+" "),r+=o.id+"|t"+o.value+"|t |t |t"}}),c.Type){case t.dropdownType.simple:c.Obj.trigger("change");break;case t.dropdownType.complex:c.Obj.attr("choices",n),c.Obj.trigger("propertychange");break;case t.dropdownType.multiSelect:c.master.data="",c.MultiLookupPickerdata.val(r),e(c.master.resultControl).find("option").each(function(){var t=e(this);e(this).attr("selected","selected"),e(c.master.candidateControl).find("option").each(function(){e(this).html()===t.html()&&t.removeAttr("selected")})}),GipRemoveSelectedItems(c.master),e(c.master.candidateControl).find("option").each(function(){var t=e(this);e(c.master.resultControl).find("option").each(function(){e(this).html()===t.html()&&t.remove()})}),GipAddSelectedItems(c.master),c.master.data=GipGetGroupData(r),e(c.master.candidateControl).trigger("dblclick")}}}),null!==s.completefunc&&s.completefunc()},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(1)],r=function(e){"use strict";return e.fn.SPServices.SPFindMMSPicker=function(t){for(var a=e.extend({},{MMSDisplayName:""},t),o=[],r=e("div[title='"+a.MMSDisplayName+"']"),i=r.closest("td").find("input[type='hidden']"),s=i.val().split(";"),n=0;n0&&r.html(a.valueToSet),a.checkNames&&i.click();var s=e.trim(r.text()),n=[];return r.children("span").each(function(){var t=e(this).find("div[data]").attr("data"),a={};if("undefined"!=typeof t){var o=e.parseXML(t),r=e(o);r.find("DictionaryEntry").each(function(){var t=e(this).find("Key").text();a[t]=e(this).find("Value").text()}),n.push(a)}else e().SPServices({operation:"GetUserInfo",async:!1,cacheXML:!0,userLoginName:e(this).attr("title"),completefunc:function(t){e(t.responseXML).find("User").each(function(){e.each(this.attributes,function(e,t){a[t.name]=t.value}),n.push(a)})}})}),{row:o,contents:r,currentValue:s,checkNames:i,dictionaryEntries:n}},e.fn.SPFindPeoplePicker=function(t){return e().SPServices.SPFindPeoplePicker(t)},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPLookupAddNew=function(o){var r=e.extend({},{lookupColumn:"",promptText:"Add new {0}",newWindow:!1,ContentTypeID:"",completefunc:null,debug:!1},o),i="SPServices.SPLookupAddNew",s=e().SPServices.SPDropdownCtl({displayName:r.lookupColumn});if(null===s.Obj.html()&&r.debug)return void a.errBox(i,"lookupColumn: "+r.lookupColumn,t.TXTColumnNotFound);var n="",l="",d="";if(e().SPServices({operation:"GetList",async:!1,cacheXML:!0,listName:e().SPServices.SPListNameFromUrl(),completefunc:function(o){e(o.responseXML).find("Field[DisplayName='"+r.lookupColumn+"']").each(function(){return d=e(this).attr("StaticName"),e().SPServices({operation:"GetList",async:!1,cacheXML:!0,listName:e(this).attr("List"),completefunc:function(a){e(a.responseXML).find("List").each(function(){l=e(this).attr("WebFullUrl"),l=l!==t.SLASH?l+t.SLASH:l})}}),n=a.getListFormUrl(e(this).attr("List"),"NewForm"),!1})}}),0===l.length&&r.debug)return void a.errBox(i,"lookupColumn: "+r.lookupColumn,"This column does not appear to be a lookup column");if(n.length>0){var c=l+n;c+=r.newWindow?(r.ContentTypeID.length>0?"?ContentTypeID="+r.ContentTypeID:"")+"' target='_blank'":"?"+(r.ContentTypeID.length>0?"ContentTypeID="+r.ContentTypeID+"&":"")+"Source="+a.escapeUrl(location.href)+"'";var m="0?location.href.substring(0,location.href.indexOf("?")):location.href,t="string"==typeof r.Source?"Source="+r.Source.replace(/\//g,"%2f").replace(/:/g,"%3a"):"",a=[];"undefined"!=typeof s&&a.push("List="+s),"undefined"!=typeof n&&a.push("RootFolder="+n),"undefined"!=typeof l&&a.push("ContentTypeId="+l);var o=e+(a.length>0?"?"+a.join("&")+"&":"?")+"Source="+e+"?ID="+i+(t.length>0?"%26RealSource="+r.Source:"")+("string"==typeof r.RedirectURL?"%26RedirectURL="+r.RedirectURL:"");setTimeout(function(){document.forms.aspnetForm.action=o},0)});else{for(;r.ID===i;)i=e().SPServices.SPGetLastItemId({listName:o});var d="string"==typeof r.RedirectURL?r.RedirectURL:a.redirectUrl;location.href=d+"?"+a.qsParamName+"="+i+("string"==typeof r.RealSource?"&Source="+r.RealSource:"")}},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(4),a(1)],r=function(e,t){"use strict";return e.fn.SPServices.SPRequireUnique=function(a){var o=e.extend({},{columnStaticName:"Title",duplicateAction:0,ignoreCase:!1,initMsg:"This value must be unique.",initMsgCSSClass:"ms-vb",errMsg:"This value is not unique.",errMsgCSSClass:"ms-formvalidation",showDupes:!1,completefunc:null},a),r=e().SPServices.SPGetQueryString(),i=r.ID,s=e().SPServices.SPListNameFromUrl(),n="{1} "+t[d][1]+" ";e("span#SPRequireUnique"+o.columnStaticName).append(l)}}),null!==o.completefunc&&o.completefunc()},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";function o(o,s,n,l,d){var c=0,m={};m.type=[],m.src=[],m.script=[];var u=RegExp("
","gi");e.ajax({type:"GET",url:d,dataType:"text",async:!1,success:function(p){for(var S;S=u.exec(p);){var f=r(S,"language"),y=r(S,"type"),h=r(S,"src");null!==h&&h.length>0&&!i(h)&&(m.type.push(null!==f&&f.length>0?f:y),m.src.push(h),c++)}if(!o.showNoScript&&m.type.length>0||o.showNoScript){var T=d.substring(0,d.lastIndexOf(t.SLASH)+1),P=""+s.attr("Title")+("True"===s.attr("Hidden")?"(Hidden)":"")+" "+n+" "+l+" "+a.fileName(d)+" -1)return!0;return!1}return e.fn.SPServices.SPScriptAudit=function(a){var r,i=e.extend({},{webURL:"",listName:"",outputId:"",auditForms:!0,auditViews:!0,auditPages:!0,auditPagesListName:"Pages",showHiddenLists:!1,showNoScript:!1,showSrc:!0},a),s=[["New","NewForm.aspx",!1],["Display","DispForm.aspx",!1],["Edit","EditForm.aspx",!1]];e("#"+i.outputId).append("List Page Class Page Type Page "+(i.showSrc?"Script References ":"")+"
");var n=e("#SPScriptAudit");n.find("th").attr("class","ms-vh2-nofilter"),(i.auditForms||i.auditViews)&&e().SPServices({operation:"GetListCollection",webURL:i.webURL,async:!1,completefunc:function(a){e(a.responseXML).find("List").each(function(){
+r=e(this),0!==i.listName.length&&r.attr("Title")!==i.listName||(i.showHiddenLists&&"False"===r.attr("Hidden")||!i.showHiddenLists)&&(i.auditForms&&e().SPServices({operation:"GetListContentTypes",webURL:i.webURL,listName:r.attr("ID"),async:!1,completefunc:function(a){e(a.responseXML).find("ContentType").each(function(){if("0x0120"!==e(this).attr("ID").substring(0,6)){for(var a=e(this).find("FormUrls"),n=0;n0?i.webURL:e().SPServices.SPGetCurrentSite())+t.SLASH+e(this).text()),s[n][2]=!0}),!s[n][2]){var l=r.attr("DefaultViewUrl");o(i,r,"Form",s[n][0],l.substring(0,l.lastIndexOf(t.SLASH)+1)+s[n][1])}for(n=0;nc;c++)e().SPServices({operation:"GetList",async:!1,cacheXML:!0,webURL:i.webURL,listName:d[c],completefunc:function(t){e(t.responseXML).find("List").each(function(){r=e(this)})}}),e().SPServices({operation:"GetListItems",async:!1,webURL:i.webURL,listName:d[c],CAMLQuery:"Folder "+e(this).html()+" ")}),e(s.master.resultControl).find("option").each(function(){l.append(""+e(this).html()+" ")});var d=l.width()+5,c=d;(r.minWidth>0||r.maxWidth>0)&&(dr.maxWidth&&(c=r.maxWidth));var m=d;e(s.master.candidateControl).css("width",m+"px").parent().css("width",c+"px"),e(s.master.resultControl).css("width",m+"px").parent().css("width",c+"px"),l.remove()},e}.apply(t,o),!(void 0!==r&&(e.exports=r))},function(e,t,a){var o,r;o=[a(2),a(3),a(4),a(1)],r=function(e,t,a){"use strict";return e.fn.SPServices.SPUpdateMultipleListItems=function(o){var r,i=e.extend({},{webURL:"",listName:"",CAMLQuery:"",batchCmd:"Update",valuepairs:[],completefunc:null,debug:!1},o),s=[],n=[];e().SPServices({operation:"GetListItems",async:!1,webURL:i.webURL,listName:i.listName,CAMLQuery:i.CAMLQuery,CAMLQueryOptions:"";for(r=0;r",l=0;l"+a.escapeColumnValue(i.valuepairs[l][1])+"";d+=""+s[r]+" ",n[r].length>0&&(d+=""+n[r]+" "),d+=""}d+=" ",e().SPServices({operation:"UpdateListItems",async:!1,webURL:i.webURL,listName:i.listName,updates:d,completefunc:function(e){null!==i.completefunc&&i.completefunc(e)}})},e}.apply(t,o),!(void 0!==r&&(e.exports=r))}]);
\ No newline at end of file
diff --git a/src/core/SPServices.core.js b/src/core/SPServices.core.js
index 2b6bda0..7f0dace 100644
--- a/src/core/SPServices.core.js
+++ b/src/core/SPServices.core.js
@@ -50,7 +50,9 @@ define([
VIEWS: "Views",
WEBPARTPAGES: "WebPartPages",
WEBS: "Webs",
- WORKFLOW: "Workflow"
+ WORKFLOW: "Workflow",
+ /* Nintex Web Service*/
+ NINTEXWORKFLOW: "NintexWorkflow/Workflow"
};
var encodeOptionList = ["listName", "description"]; // Used to encode options which may contain special characters
@@ -324,6 +326,71 @@ define([
WSops.GetWorkflowTaskData = [webServices.WORKFLOW, false];
WSops.StartWorkflow = [webServices.WORKFLOW, true];
+ //Nintex
+ WSops.AddLongTermDelegationRule = [webServices.NINTEXWORKFLOW, true];
+ WSops.AddWorkflowSchedule = [webServices.NINTEXWORKFLOW, true];
+ WSops.AddWorkflowScheduleOnListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.CheckGlobalReuseStatus = [webServices.NINTEXWORKFLOW, true];
+ WSops.CheckInForms = [webServices.NINTEXWORKFLOW, true];
+ WSops.DelegateAllTasks = [webServices.NINTEXWORKFLOW, true];
+ WSops.DelegateTask = [webServices.NINTEXWORKFLOW, true];
+ WSops.DeleteLongTermDelegationRule = [webServices.NINTEXWORKFLOW, true];
+ WSops.DeleteSnippet = [webServices.NINTEXWORKFLOW, true];
+ WSops.DeleteWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.ExportWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.FixWorkflowsInSiteFromTemplate = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetFolders = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetItemsPendingMyApproval = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetListContentTypes = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetOutcomesForFlexiTask = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetRunningWorkflowTasks = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetRunningWorkflowTasksCollection = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetRunningWorkflowTasksForCurrentUser = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetRunningWorkflowTasksForCurrentUserForListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetRunningWorkflowTasksForListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetTaskDetailsUsingStub = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetTaskStubsForCurrentUser = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetWorkflowHistory = [webServices.NINTEXWORKFLOW, true];
+ WSops.GetWorkflowHistoryForListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.HideTaskForApprover = [webServices.NINTEXWORKFLOW, true];
+ WSops.HideWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessFlexiTaskResponse = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessFlexiTaskResponse2 = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessTaskResponse = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessTaskResponse2 = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessTaskResponse3 = [webServices.NINTEXWORKFLOW, true];
+ WSops.ProcessTaskResponseUsingToken = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWF = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFSkipValidation = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFSkipValidationNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFXml = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFXmlNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFXmlSkipValidation = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishFromNWFXmlSkipValidationNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.PublishWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.QueryForMessages = [webServices.NINTEXWORKFLOW, true];
+ WSops.RemoveWorkflowSchedule = [webServices.NINTEXWORKFLOW, true];
+ WSops.RemoveWorkflowScheduleOnListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveFromNWF = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveFromNWFNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveFromNWFXml = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveFromNWFXmlNoOverwrite = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveSnippet = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveTemplate = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveTemplate2 = [webServices.NINTEXWORKFLOW, true];
+ WSops.SaveWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.SnippetExists = [webServices.NINTEXWORKFLOW, true];
+ WSops.StartSiteWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.NintexStartWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.StartWorkflowOnListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.TemplateExists = [webServices.NINTEXWORKFLOW, true];
+ WSops.TerminateWorkflow = [webServices.NINTEXWORKFLOW, true];
+ WSops.TerminateWorkflowByName = [webServices.NINTEXWORKFLOW, true];
+ WSops.TerminateWorkflowByNameForListItem = [webServices.NINTEXWORKFLOW, true];
+ WSops.WorkflowExists = [webServices.NINTEXWORKFLOW, true];
+ WSops.WorkflowFormProductSelected = [webServices.NINTEXWORKFLOW, true];
+
// Main function, which calls SharePoint's Web Services directly.
$.fn.SPServices = function (options) {
@@ -1295,6 +1362,323 @@ define([
}
}; // End $.fn.SPServices
+
+ //Main function which calls Nintex's Web Services directly
+ $.fn.NintexServices = function (options)
+ {
+ // If there are no options passed in, use the defaults. Extend replaces each default with the passed option.
+ var opt = $.extend({}, $.fn.SPServices.defaults, options);
+
+ // Encode options which may contain special character, esp. ampersand
+ for (var i = 0; i < encodeOptionList.length; i++) {
+ if (typeof opt[encodeOptionList[i]] === "string") {
+ opt[encodeOptionList[i]] = utils.encodeXml(opt[encodeOptionList[i]]);
+ }
+ }//end for
+
+ // Put together operation header and SOAPAction for the SOAP call based on which Web Service we're calling
+ SOAPEnvelope.opheader = "<" + opt.operation + " ";
+ switch (WSops[opt.operation][0]) {
+ case webServices.NINTEXWORKFLOW:
+ SOAPEnvelope.opheader += "xmlns='" + constants.SCHEMANintex + "'>";
+ SOAPAction = constants.SCHEMANintex + "/";
+ break;
+ default:
+ SOAPEnvelope.opheader += "xmlns='" + constants.SCHEMANintex + "/soap/'>";
+ SOAPAction = constants.SCHEMANintex + "/soap/";
+ break;
+ }//end switch
+
+ // Add the operation to the SOAPAction and opfooter
+ SOAPAction += opt.operation;
+ SOAPEnvelope.opfooter = "";
+
+ // Build the URL for the Ajax call based on which operation we're calling
+ // If the webURL has been provided, then use it, else use the current site
+ var ajaxURL = "_vti_bin/" + WSops[opt.operation][0] + ".asmx";
+ var thisSite = $().SPServices.SPGetCurrentSite();
+ var webURL = opt.webURL !== undefined ? opt.webURL : opt.webUrl;
+ if (webURL.charAt(webURL.length - 1) === constants.SLASH) {
+ ajaxURL = webURL + ajaxURL;
+ } else if (webURL.length > 0) {
+ ajaxURL = webURL + constants.SLASH + ajaxURL;
+ } else {
+ ajaxURL = thisSite + ((thisSite.charAt(thisSite.length - 1) === constants.SLASH) ? ajaxURL : (constants.SLASH + ajaxURL));
+ }
+
+ SOAPEnvelope.payload = "";
+ // Each operation requires a different set of values. This switch statement sets them up in the SOAPEnvelope.payload.
+ switch (opt.operation) {
+ //NINTEX WORKFLOW OPERATIONS
+ case "AddLongTermDelegationRule":
+ utils.addToPayload(opt,["fromTheBeginningOf","untilTheEndOf","delegateFrom","delegateTo","currentSiteOnly"]);
+ break;
+ case "AddWorkflowSchedule":
+ utils.addToPayload(opt,["fileUrl","workflowName","startDataXml"]);
+ SOAPEnvelope.payload += "";
+ utils.addToPayload(opt,["MaximumRepeats","WorkdaysOnly"]);
+ SOAPEnvelope.payload += "";
+ utils.addToPayload(opt,["Type","CountBetweenIntervals"]);
+ SOAPEnvelope.payload += " ";
+ utils.addToPayload(opt,["EndOn","StartTime","EndTime"]);
+ SOAPEnvelope.payload += " ";
+ utils.addToPayload(opt,["updateIfExists"]);
+ break;
+ case "AddWorkflowScheduleOnListItem":
+ utils.addToPayload(opt,["itemId","listName","workflowName","startDataXML"]);
+ SOAPEnvelope.payload += "";
+ utils.addToPayload(opt,["MaximumRepeats","WorkdaysOnly"]);
+ SOAPEnvelope.payload += "";
+ utils.addToPayload(opt,["Type","CountBetweenIntervals"]);
+ SOAPEnvelope.payload += " ";
+ utils.addToPayload(opt,["EndOn","StartTime","EndTime"]);
+ SOAPEnvelope.payload += " ";
+ utils.addToPayload(opt,["updateIfExists"]);
+ break;
+ case "CheckGlobalReuseStatus":
+ utils.addToPayload(opt,["workflowName"]);
+ break;
+ case "CheckInForms":
+ utils.addToPayload(opt,["workflowConfiguration","activityConfiguration","formType"]);
+ break;
+ case "DelegateAllTasks":
+ utils.addToPayload(opt,["currentUser","newUser","sendNotification","comments","global"]);
+ break;
+ case "DelegateTask":
+ utils.addToPayload(opt,["spTaskId","taskListName","targetUserName","comments","sendNotification"]);
+ break;
+ case "DeleteLongTermDelegationRule":
+ utils.addToPayload(opt,["id"]);
+ break;
+ case "DeleteSnippet":
+ utils.addToPayload(opt,["snippetId"]);
+ break;
+ case "DeleteWorkflow":
+ utils.addToPayload(opt,["listId","workflowId","workflowType"]);
+ break;
+ case "ExportWorkflow":
+ utils.addToPayload(opt,["listName","workflowType","workflowName"]);
+ break;
+ case "FixWorkflowsInSiteFromTemplate":
+ utils.addToPayload(opt,["FixWorkflowsInSiteFromTemplate"]);
+ break;
+ case "GetFolders":
+ utils.addToPayload(opt,["listGuid"]);
+ break;
+ case "GetItemsPendingMyApproval":
+ utils.addToPayload(opt,["uniquenessInfo"]);
+ break;
+ case "GetListContentTypes":
+ utils.addToPayload(opt,["listGuid"]);
+ break;
+ case "GetOutcomesForFlexiTask":
+ utils.addToPayload(opt,["spTaskId","taskListName"]);
+ break;
+ case "GetRunningWorkflowTasks":
+ utils.addToPayload(opt,["fileUrl"]);
+ break;
+ case "GetRunningWorkflowTasksCollection":
+ utils.addToPayload(opt,["userlogin","teamsiteUrl","listName"]);
+ break;
+ case "GetRunningWorkflowTasksForCurrentUser":
+ utils.addToPayload(opt,["fileUrl"]);
+ break;
+ case "GetRunningWorkflowTasksForCurrentUserForListItem":
+ utils.addToPayload(opt,["itemId","listName"]);
+ break;
+ case "GetRunningWorkflowTasksForListItem":
+ utils.addToPayload(opt,["itemId","listName"]);
+ break;
+ case "GetTaskDetailsUsingStub":
+ utils.addToPayload(opt,["taskToken"]);
+ break;
+ case "GetTaskStubsForCurrentUser":
+ break;
+ case "GetWorkflowHistory":
+ utils.addToPayload(opt,["fileUrl","stateFilter","workflowNameFilter"]);
+ break;
+ case "GetWorkflowHistoryForListItem":
+ utils.addToPayload(opt,["itemId","listName","stateFilter","workflowNameFilter"]);
+ break;
+ case "HideTaskForApprover":
+ utils.addToPayload(opt,["approverId","contentDbId"]);
+ break;
+ case "HideWorkflow":
+ utils.addToPayload(opt,["siteId","instanceId"]);
+ break;
+ case "ProcessFlexiTaskResponse":
+ utils.addToPayload(opt,["comments","outcome","spTaskId","taskListName"]);
+ break;
+ case "ProcessFlexiTaskResponse2":
+ utils.addToPayload(opt,["comments","outcome","spTaskId","taskListName"]);
+ break;
+ case "ProcessTaskResponse":
+ utils.addToPayload(opt,["comments","outcome","spTaskId"]);
+ break;
+ case "ProcessTaskResponse2":
+ utils.addToPayload(opt,["comments","outcome","spTaskId","taskListName"]);
+ break;
+ case "ProcessTaskResponse3":
+ utils.addToPayload(opt,["comments","outcome","spTaskId","taskListName"]);
+ break;
+ case "ProcessTaskResponseUsingToken":
+ utils.addToPayload(opt,["comments","outcome","taskToken","customOutcome"]);
+ break;
+ case "PublishFromNWF":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFSkipValidation":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFSkipValidationNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFXml":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFXmlNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFXmlSkipValidation":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishFromNWFXmlSkipValidationNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName","saveIfCannotPublish"]);
+ break;
+ case "PublishWorkflow":
+ utils.addToPayload(opt,["wfName","activityConfigs","listId","contentTypeId","changeNotes"]);
+ break;
+ case "QueryForMessages":
+ utils.addToPayload(opt,["workflowInstanceId","messageId"]);
+ break;
+ case "RemoveWorkflowSchedule":
+ utils.addToPayload(opt,["fileUrl","workflowName"]);
+ break;
+ case "RemoveWorkflowScheduleOnListItem":
+ utils.addToPayload(opt,["itemId","listName","workflowName"]);
+ break;
+ case "SaveFromNWF":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName"]);
+ break;
+ case "SaveFromNWFNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName"]);
+ break;
+ case "SaveFromNWFXml":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName"]);
+ break;
+ case "SaveFromNWFXmlNoOverwrite":
+ utils.addToPayload(opt,["workflowFile","listName","workflowName"]);
+ break;
+ case "SaveSnippet":
+ utils.addToPayload(opt,["snippetName","activityConfigs"]);
+ break;
+ case "SaveTemplate":
+ utils.addToPayload(opt,["templateName","templateDescription","category","activityConfigs"]);
+ break;
+ case "SaveTemplate2":
+ utils.addToPayload(opt,["templateName","templateDescription","category","activityConfigs","lcid"]);
+ break;
+ case "SaveWorkflow":
+ utils.addToPayload(opt,["wfName","activityConfigs","listId","contentTypeId","changeNotes"]);
+ break;
+ case "SnippetExists":
+ utils.addToPayload(opt,["snippetName"]);
+ break;
+ case "StartSiteWorkflow":
+ utils.addToPayload(opt,["workflowName","associationData"]);
+ break;
+ case "StartWorkflow":
+ utils.addToPayload(opt,["fileUrl","workflowName","associationData"]);
+ break;
+ case "StartWorkflowOnListItem":
+ utils.addToPayload(opt,["itemId","listName","workflowName","associationData"]);
+ break;
+ case "TemplateExists":
+ utils.addToPayload(opt,["templateName"]);
+ break;
+ case "TerminateWorkflow":
+ utils.addToPayload(opt,["listId","itemId","instanceId"]);
+ break;
+ case "TerminateWorkflowByName":
+ utils.addToPayload(opt,["fileUrl","workflowName","terminatePreviousInstances"]);
+ break;
+ case "TerminateWorkflowByNameForListItem":
+ utils.addToPayload(opt,["listName","itemId","workflowName","terminatePreviousInstances"]);
+ break;
+ case "WorkflowExists":
+ utils.addToPayload(opt,["workflowName","listId","workflowType"]);
+ break;
+ case "WorkflowFormProductSelected":
+ utils.addToPayload(opt,["workflowConfiguration","activityConfiguration","product","formType"]);
+ break;
+ default:
+ break;
+ }//end switch
+
+ // Glue together the pieces of the SOAP message
+ var msg = SOAPEnvelope.header + SOAPEnvelope.opheader + SOAPEnvelope.payload + SOAPEnvelope.opfooter + SOAPEnvelope.footer;
+
+ // Check to see if we've already cached the results
+ var cachedPromise;
+ if (opt.cacheXML) {
+ cachedPromise = promisesCache[msg];
+ }
+
+ if (typeof cachedPromise === "undefined") {
+
+ // Finally, make the Ajax call
+ var p = $.ajax({
+ // The relative URL for the AJAX call
+ url: ajaxURL,
+ // By default, the AJAX calls are asynchronous. You can specify false to require a synchronous call.
+ async: opt.async,
+ // Before sending the msg, need to send the request header
+ beforeSend: function (xhr) {
+ // If we need to pass the SOAPAction, do so
+ if (WSops[opt.operation][1]) {
+ xhr.setRequestHeader("SOAPAction", SOAPAction);
+ }
+ },
+ // Always a POST
+ type: "POST",
+ // Here is the SOAP request we've built above
+ data: msg,
+ // We're getting XML; tell jQuery so that it doesn't need to do a best guess
+ dataType: "xml",
+ // and this is its content type
+ contentType: "text/xml;charset='utf-8'",
+ complete: function (xData, Status) {
+ // When the call is complete, call the completefunc if there is one
+ if ($.isFunction(opt.completefunc)) {
+ opt.completefunc(xData, Status);
+
+ }
+ }
+ });
+ if(opt.cacheXML) {
+ promisesCache[msg] = p;
+ }
+
+ // Return the promise
+ return p;
+
+ } else {
+
+ // Call the completefunc if there is one
+ if ($.isFunction(opt.completefunc)) {
+ cachedPromise.done(function(data, status, jqXHR){
+ opt.completefunc(jqXHR, status);
+ });
+
+ }
+ // Return the cached promise
+ return cachedPromise;
+ }
+ };//end NintexServices
+
// Defaults added as a function in our library means that the caller can override the defaults
// for their session by calling this function. Each operation requires a different set of options;
@@ -1341,4 +1725,4 @@ define([
}; // End $.fn.SPServices.defaults
-});
+});
\ No newline at end of file
diff --git a/src/utils/constants.js b/src/utils/constants.js
index c2e6092..cf20ac2 100644
--- a/src/utils/constants.js
+++ b/src/utils/constants.js
@@ -21,6 +21,7 @@ define([], function () {
// String constants
// General
SCHEMASharePoint: "http://schemas.microsoft.com/sharepoint",
+ SCHEMANintex: "http://nintex.com",
multiLookupPrefix: "MultiLookupPicker",
multiLookupPrefix2013: "MultiLookup",
diff --git a/tests/jasmine/SpecRunner.html b/tests/jasmine/SpecRunner.html
new file mode 100644
index 0000000..68016f6
--- /dev/null
+++ b/tests/jasmine/SpecRunner.html
@@ -0,0 +1,26 @@
+
+
+
+ Jasmine Spec Runner v2.4.1
+
+ ');
+ } else if (value.jasmineToString) {
+ this.emitScalar(value.jasmineToString());
+ } else if (typeof value === 'string') {
+ this.emitString(value);
+ } else if (j$.isSpy(value)) {
+ this.emitScalar('spy on ' + value.and.identity());
+ } else if (value instanceof RegExp) {
+ this.emitScalar(value.toString());
+ } else if (typeof value === 'function') {
+ this.emitScalar('Function');
+ } else if (typeof value.nodeType === 'number') {
+ this.emitScalar('HTMLNode');
+ } else if (value instanceof Date) {
+ this.emitScalar('Date(' + value + ')');
+ } else if (value.toString && typeof value === 'object' && !(value instanceof Array) && value.toString !== Object.prototype.toString) {
+ this.emitScalar(value.toString());
+ } else if (j$.util.arrayContains(this.seen, value)) {
+ this.emitScalar('');
+ } else if (j$.isArray_(value) || j$.isA_('Object', value)) {
+ this.seen.push(value);
+ if (j$.isArray_(value)) {
+ this.emitArray(value);
+ } else {
+ this.emitObject(value);
+ }
+ this.seen.pop();
+ } else {
+ this.emitScalar(value.toString());
+ }
+ } finally {
+ this.ppNestLevel_--;
+ }
+ };
+
+ PrettyPrinter.prototype.iterateObject = function(obj, fn) {
+ for (var property in obj) {
+ if (!Object.prototype.hasOwnProperty.call(obj, property)) { continue; }
+ fn(property, obj.__lookupGetter__ ? (!j$.util.isUndefined(obj.__lookupGetter__(property)) &&
+ obj.__lookupGetter__(property) !== null) : false);
+ }
+ };
+
+ PrettyPrinter.prototype.emitArray = j$.unimplementedMethod_;
+ PrettyPrinter.prototype.emitObject = j$.unimplementedMethod_;
+ PrettyPrinter.prototype.emitScalar = j$.unimplementedMethod_;
+ PrettyPrinter.prototype.emitString = j$.unimplementedMethod_;
+
+ function StringPrettyPrinter() {
+ PrettyPrinter.call(this);
+
+ this.string = '';
+ }
+
+ j$.util.inherit(StringPrettyPrinter, PrettyPrinter);
+
+ StringPrettyPrinter.prototype.emitScalar = function(value) {
+ this.append(value);
+ };
+
+ StringPrettyPrinter.prototype.emitString = function(value) {
+ this.append('\'' + value + '\'');
+ };
+
+ StringPrettyPrinter.prototype.emitArray = function(array) {
+ if (this.ppNestLevel_ > j$.MAX_PRETTY_PRINT_DEPTH) {
+ this.append('Array');
+ return;
+ }
+ var length = Math.min(array.length, j$.MAX_PRETTY_PRINT_ARRAY_LENGTH);
+ this.append('[ ');
+ for (var i = 0; i < length; i++) {
+ if (i > 0) {
+ this.append(', ');
+ }
+ this.format(array[i]);
+ }
+ if(array.length > length){
+ this.append(', ...');
+ }
+
+ var self = this;
+ var first = array.length === 0;
+ this.iterateObject(array, function(property, isGetter) {
+ if (property.match(/^\d+$/)) {
+ return;
+ }
+
+ if (first) {
+ first = false;
+ } else {
+ self.append(', ');
+ }
+
+ self.formatProperty(array, property, isGetter);
+ });
+
+ this.append(' ]');
+ };
+
+ StringPrettyPrinter.prototype.emitObject = function(obj) {
+ var constructorName = obj.constructor ? j$.fnNameFor(obj.constructor) : 'null';
+ this.append(constructorName);
+
+ if (this.ppNestLevel_ > j$.MAX_PRETTY_PRINT_DEPTH) {
+ return;
+ }
+
+ var self = this;
+ this.append('({ ');
+ var first = true;
+
+ this.iterateObject(obj, function(property, isGetter) {
+ if (first) {
+ first = false;
+ } else {
+ self.append(', ');
+ }
+
+ self.formatProperty(obj, property, isGetter);
+ });
+
+ this.append(' })');
+ };
+
+ StringPrettyPrinter.prototype.formatProperty = function(obj, property, isGetter) {
+ this.append(property);
+ this.append(': ');
+ if (isGetter) {
+ this.append('');
+ } else {
+ this.format(obj[property]);
+ }
+ };
+
+ StringPrettyPrinter.prototype.append = function(value) {
+ this.string += value;
+ };
+
+ return function(value) {
+ var stringPrettyPrinter = new StringPrettyPrinter();
+ stringPrettyPrinter.format(value);
+ return stringPrettyPrinter.string;
+ };
+};
+
+getJasmineRequireObj().QueueRunner = function(j$) {
+
+ function once(fn) {
+ var called = false;
+ return function() {
+ if (!called) {
+ called = true;
+ fn();
+ }
+ };
+ }
+
+ function QueueRunner(attrs) {
+ this.queueableFns = attrs.queueableFns || [];
+ this.onComplete = attrs.onComplete || function() {};
+ this.clearStack = attrs.clearStack || function(fn) {fn();};
+ this.onException = attrs.onException || function() {};
+ this.catchException = attrs.catchException || function() { return true; };
+ this.userContext = attrs.userContext || {};
+ this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout};
+ this.fail = attrs.fail || function() {};
+ }
+
+ QueueRunner.prototype.execute = function() {
+ this.run(this.queueableFns, 0);
+ };
+
+ QueueRunner.prototype.run = function(queueableFns, recursiveIndex) {
+ var length = queueableFns.length,
+ self = this,
+ iterativeIndex;
+
+
+ for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
+ var queueableFn = queueableFns[iterativeIndex];
+ if (queueableFn.fn.length > 0) {
+ attemptAsync(queueableFn);
+ return;
+ } else {
+ attemptSync(queueableFn);
+ }
+ }
+
+ var runnerDone = iterativeIndex >= length;
+
+ if (runnerDone) {
+ this.clearStack(this.onComplete);
+ }
+
+ function attemptSync(queueableFn) {
+ try {
+ queueableFn.fn.call(self.userContext);
+ } catch (e) {
+ handleException(e, queueableFn);
+ }
+ }
+
+ function attemptAsync(queueableFn) {
+ var clearTimeout = function () {
+ Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]);
+ },
+ next = once(function () {
+ clearTimeout(timeoutId);
+ self.run(queueableFns, iterativeIndex + 1);
+ }),
+ timeoutId;
+
+ next.fail = function() {
+ self.fail.apply(null, arguments);
+ next();
+ };
+
+ if (queueableFn.timeout) {
+ timeoutId = Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [function() {
+ var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
+ onException(error);
+ next();
+ }, queueableFn.timeout()]]);
+ }
+
+ try {
+ queueableFn.fn.call(self.userContext, next);
+ } catch (e) {
+ handleException(e, queueableFn);
+ next();
+ }
+ }
+
+ function onException(e) {
+ self.onException(e);
+ }
+
+ function handleException(e, queueableFn) {
+ onException(e);
+ if (!self.catchException(e)) {
+ //TODO: set a var when we catch an exception and
+ //use a finally block to close the loop in a nice way..
+ throw e;
+ }
+ }
+ };
+
+ return QueueRunner;
+};
+
+getJasmineRequireObj().ReportDispatcher = function() {
+ function ReportDispatcher(methods) {
+
+ var dispatchedMethods = methods || [];
+
+ for (var i = 0; i < dispatchedMethods.length; i++) {
+ var method = dispatchedMethods[i];
+ this[method] = (function(m) {
+ return function() {
+ dispatch(m, arguments);
+ };
+ }(method));
+ }
+
+ var reporters = [];
+
+ this.addReporter = function(reporter) {
+ reporters.push(reporter);
+ };
+
+ return this;
+
+ function dispatch(method, args) {
+ for (var i = 0; i < reporters.length; i++) {
+ var reporter = reporters[i];
+ if (reporter[method]) {
+ reporter[method].apply(reporter, args);
+ }
+ }
+ }
+ }
+
+ return ReportDispatcher;
+};
+
+
+getJasmineRequireObj().SpyRegistry = function(j$) {
+
+ function SpyRegistry(options) {
+ options = options || {};
+ var currentSpies = options.currentSpies || function() { return []; };
+
+ this.spyOn = function(obj, methodName) {
+ if (j$.util.isUndefined(obj)) {
+ throw new Error('spyOn could not find an object to spy upon for ' + methodName + '()');
+ }
+
+ if (j$.util.isUndefined(methodName)) {
+ throw new Error('No method name supplied');
+ }
+
+ if (j$.util.isUndefined(obj[methodName])) {
+ throw new Error(methodName + '() method does not exist');
+ }
+
+ if (obj[methodName] && j$.isSpy(obj[methodName])) {
+ //TODO?: should this return the current spy? Downside: may cause user confusion about spy state
+ throw new Error(methodName + ' has already been spied upon');
+ }
+
+ var descriptor;
+ try {
+ descriptor = Object.getOwnPropertyDescriptor(obj, methodName);
+ } catch(e) {
+ // IE 8 doesn't support `definePropery` on non-DOM nodes
+ }
+
+ if (descriptor && !(descriptor.writable || descriptor.set)) {
+ throw new Error(methodName + ' is not declared writable or has no setter');
+ }
+
+ var spy = j$.createSpy(methodName, obj[methodName]);
+
+ currentSpies().push({
+ spy: spy,
+ baseObj: obj,
+ methodName: methodName,
+ originalValue: obj[methodName]
+ });
+
+ obj[methodName] = spy;
+
+ return spy;
+ };
+
+ this.clearSpies = function() {
+ var spies = currentSpies();
+ for (var i = 0; i < spies.length; i++) {
+ var spyEntry = spies[i];
+ spyEntry.baseObj[spyEntry.methodName] = spyEntry.originalValue;
+ }
+ };
+ }
+
+ return SpyRegistry;
+};
+
+getJasmineRequireObj().SpyStrategy = function() {
+
+ function SpyStrategy(options) {
+ options = options || {};
+
+ var identity = options.name || 'unknown',
+ originalFn = options.fn || function() {},
+ getSpy = options.getSpy || function() {},
+ plan = function() {};
+
+ this.identity = function() {
+ return identity;
+ };
+
+ this.exec = function() {
+ return plan.apply(this, arguments);
+ };
+
+ this.callThrough = function() {
+ plan = originalFn;
+ return getSpy();
+ };
+
+ this.returnValue = function(value) {
+ plan = function() {
+ return value;
+ };
+ return getSpy();
+ };
+
+ this.returnValues = function() {
+ var values = Array.prototype.slice.call(arguments);
+ plan = function () {
+ return values.shift();
+ };
+ return getSpy();
+ };
+
+ this.throwError = function(something) {
+ var error = (something instanceof Error) ? something : new Error(something);
+ plan = function() {
+ throw error;
+ };
+ return getSpy();
+ };
+
+ this.callFake = function(fn) {
+ plan = fn;
+ return getSpy();
+ };
+
+ this.stub = function(fn) {
+ plan = function() {};
+ return getSpy();
+ };
+ }
+
+ return SpyStrategy;
+};
+
+getJasmineRequireObj().Suite = function(j$) {
+ function Suite(attrs) {
+ this.env = attrs.env;
+ this.id = attrs.id;
+ this.parentSuite = attrs.parentSuite;
+ this.description = attrs.description;
+ this.expectationFactory = attrs.expectationFactory;
+ this.expectationResultFactory = attrs.expectationResultFactory;
+ this.throwOnExpectationFailure = !!attrs.throwOnExpectationFailure;
+
+ this.beforeFns = [];
+ this.afterFns = [];
+ this.beforeAllFns = [];
+ this.afterAllFns = [];
+ this.disabled = false;
+
+ this.children = [];
+
+ this.result = {
+ id: this.id,
+ description: this.description,
+ fullName: this.getFullName(),
+ failedExpectations: []
+ };
+ }
+
+ Suite.prototype.expect = function(actual) {
+ return this.expectationFactory(actual, this);
+ };
+
+ Suite.prototype.getFullName = function() {
+ var fullName = this.description;
+ for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+ if (parentSuite.parentSuite) {
+ fullName = parentSuite.description + ' ' + fullName;
+ }
+ }
+ return fullName;
+ };
+
+ Suite.prototype.disable = function() {
+ this.disabled = true;
+ };
+
+ Suite.prototype.pend = function(message) {
+ this.markedPending = true;
+ };
+
+ Suite.prototype.beforeEach = function(fn) {
+ this.beforeFns.unshift(fn);
+ };
+
+ Suite.prototype.beforeAll = function(fn) {
+ this.beforeAllFns.push(fn);
+ };
+
+ Suite.prototype.afterEach = function(fn) {
+ this.afterFns.unshift(fn);
+ };
+
+ Suite.prototype.afterAll = function(fn) {
+ this.afterAllFns.push(fn);
+ };
+
+ Suite.prototype.addChild = function(child) {
+ this.children.push(child);
+ };
+
+ Suite.prototype.status = function() {
+ if (this.disabled) {
+ return 'disabled';
+ }
+
+ if (this.markedPending) {
+ return 'pending';
+ }
+
+ if (this.result.failedExpectations.length > 0) {
+ return 'failed';
+ } else {
+ return 'finished';
+ }
+ };
+
+ Suite.prototype.isExecutable = function() {
+ return !this.disabled;
+ };
+
+ Suite.prototype.canBeReentered = function() {
+ return this.beforeAllFns.length === 0 && this.afterAllFns.length === 0;
+ };
+
+ Suite.prototype.getResult = function() {
+ this.result.status = this.status();
+ return this.result;
+ };
+
+ Suite.prototype.sharedUserContext = function() {
+ if (!this.sharedContext) {
+ this.sharedContext = this.parentSuite ? clone(this.parentSuite.sharedUserContext()) : {};
+ }
+
+ return this.sharedContext;
+ };
+
+ Suite.prototype.clonedSharedUserContext = function() {
+ return clone(this.sharedUserContext());
+ };
+
+ Suite.prototype.onException = function() {
+ if (arguments[0] instanceof j$.errors.ExpectationFailed) {
+ return;
+ }
+
+ if(isAfterAll(this.children)) {
+ var data = {
+ matcherName: '',
+ passed: false,
+ expected: '',
+ actual: '',
+ error: arguments[0]
+ };
+ this.result.failedExpectations.push(this.expectationResultFactory(data));
+ } else {
+ for (var i = 0; i < this.children.length; i++) {
+ var child = this.children[i];
+ child.onException.apply(child, arguments);
+ }
+ }
+ };
+
+ Suite.prototype.addExpectationResult = function () {
+ if(isAfterAll(this.children) && isFailure(arguments)){
+ var data = arguments[1];
+ this.result.failedExpectations.push(this.expectationResultFactory(data));
+ if(this.throwOnExpectationFailure) {
+ throw new j$.errors.ExpectationFailed();
+ }
+ } else {
+ for (var i = 0; i < this.children.length; i++) {
+ var child = this.children[i];
+ try {
+ child.addExpectationResult.apply(child, arguments);
+ } catch(e) {
+ // keep going
+ }
+ }
+ }
+ };
+
+ function isAfterAll(children) {
+ return children && children[0].result.status;
+ }
+
+ function isFailure(args) {
+ return !args[0];
+ }
+
+ function clone(obj) {
+ var clonedObj = {};
+ for (var prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ clonedObj[prop] = obj[prop];
+ }
+ }
+
+ return clonedObj;
+ }
+
+ return Suite;
+};
+
+if (typeof window == void 0 && typeof exports == 'object') {
+ exports.Suite = jasmineRequire.Suite;
+}
+
+getJasmineRequireObj().Timer = function() {
+ var defaultNow = (function(Date) {
+ return function() { return new Date().getTime(); };
+ })(Date);
+
+ function Timer(options) {
+ options = options || {};
+
+ var now = options.now || defaultNow,
+ startTime;
+
+ this.start = function() {
+ startTime = now();
+ };
+
+ this.elapsed = function() {
+ return now() - startTime;
+ };
+ }
+
+ return Timer;
+};
+
+getJasmineRequireObj().TreeProcessor = function() {
+ function TreeProcessor(attrs) {
+ var tree = attrs.tree,
+ runnableIds = attrs.runnableIds,
+ queueRunnerFactory = attrs.queueRunnerFactory,
+ nodeStart = attrs.nodeStart || function() {},
+ nodeComplete = attrs.nodeComplete || function() {},
+ orderChildren = attrs.orderChildren || function(node) { return node.children; },
+ stats = { valid: true },
+ processed = false,
+ defaultMin = Infinity,
+ defaultMax = 1 - Infinity;
+
+ this.processTree = function() {
+ processNode(tree, false);
+ processed = true;
+ return stats;
+ };
+
+ this.execute = function(done) {
+ if (!processed) {
+ this.processTree();
+ }
+
+ if (!stats.valid) {
+ throw 'invalid order';
+ }
+
+ var childFns = wrapChildren(tree, 0);
+
+ queueRunnerFactory({
+ queueableFns: childFns,
+ userContext: tree.sharedUserContext(),
+ onException: function() {
+ tree.onException.apply(tree, arguments);
+ },
+ onComplete: done
+ });
+ };
+
+ function runnableIndex(id) {
+ for (var i = 0; i < runnableIds.length; i++) {
+ if (runnableIds[i] === id) {
+ return i;
+ }
+ }
+ }
+
+ function processNode(node, parentEnabled) {
+ var executableIndex = runnableIndex(node.id);
+
+ if (executableIndex !== undefined) {
+ parentEnabled = true;
+ }
+
+ parentEnabled = parentEnabled && node.isExecutable();
+
+ if (!node.children) {
+ stats[node.id] = {
+ executable: parentEnabled && node.isExecutable(),
+ segments: [{
+ index: 0,
+ owner: node,
+ nodes: [node],
+ min: startingMin(executableIndex),
+ max: startingMax(executableIndex)
+ }]
+ };
+ } else {
+ var hasExecutableChild = false;
+
+ var orderedChildren = orderChildren(node);
+
+ for (var i = 0; i < orderedChildren.length; i++) {
+ var child = orderedChildren[i];
+
+ processNode(child, parentEnabled);
+
+ if (!stats.valid) {
+ return;
+ }
+
+ var childStats = stats[child.id];
+
+ hasExecutableChild = hasExecutableChild || childStats.executable;
+ }
+
+ stats[node.id] = {
+ executable: hasExecutableChild
+ };
+
+ segmentChildren(node, orderedChildren, stats[node.id], executableIndex);
+
+ if (!node.canBeReentered() && stats[node.id].segments.length > 1) {
+ stats = { valid: false };
+ }
+ }
+ }
+
+ function startingMin(executableIndex) {
+ return executableIndex === undefined ? defaultMin : executableIndex;
+ }
+
+ function startingMax(executableIndex) {
+ return executableIndex === undefined ? defaultMax : executableIndex;
+ }
+
+ function segmentChildren(node, orderedChildren, nodeStats, executableIndex) {
+ var currentSegment = { index: 0, owner: node, nodes: [], min: startingMin(executableIndex), max: startingMax(executableIndex) },
+ result = [currentSegment],
+ lastMax = defaultMax,
+ orderedChildSegments = orderChildSegments(orderedChildren);
+
+ function isSegmentBoundary(minIndex) {
+ return lastMax !== defaultMax && minIndex !== defaultMin && lastMax < minIndex - 1;
+ }
+
+ for (var i = 0; i < orderedChildSegments.length; i++) {
+ var childSegment = orderedChildSegments[i],
+ maxIndex = childSegment.max,
+ minIndex = childSegment.min;
+
+ if (isSegmentBoundary(minIndex)) {
+ currentSegment = {index: result.length, owner: node, nodes: [], min: defaultMin, max: defaultMax};
+ result.push(currentSegment);
+ }
+
+ currentSegment.nodes.push(childSegment);
+ currentSegment.min = Math.min(currentSegment.min, minIndex);
+ currentSegment.max = Math.max(currentSegment.max, maxIndex);
+ lastMax = maxIndex;
+ }
+
+ nodeStats.segments = result;
+ }
+
+ function orderChildSegments(children) {
+ var specifiedOrder = [],
+ unspecifiedOrder = [];
+
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i],
+ segments = stats[child.id].segments;
+
+ for (var j = 0; j < segments.length; j++) {
+ var seg = segments[j];
+
+ if (seg.min === defaultMin) {
+ unspecifiedOrder.push(seg);
+ } else {
+ specifiedOrder.push(seg);
+ }
+ }
+ }
+
+ specifiedOrder.sort(function(a, b) {
+ return a.min - b.min;
+ });
+
+ return specifiedOrder.concat(unspecifiedOrder);
+ }
+
+ function executeNode(node, segmentNumber) {
+ if (node.children) {
+ return {
+ fn: function(done) {
+ nodeStart(node);
+
+ queueRunnerFactory({
+ onComplete: function() {
+ nodeComplete(node, node.getResult());
+ done();
+ },
+ queueableFns: wrapChildren(node, segmentNumber),
+ userContext: node.sharedUserContext(),
+ onException: function() {
+ node.onException.apply(node, arguments);
+ }
+ });
+ }
+ };
+ } else {
+ return {
+ fn: function(done) { node.execute(done, stats[node.id].executable); }
+ };
+ }
+ }
+
+ function wrapChildren(node, segmentNumber) {
+ var result = [],
+ segmentChildren = stats[node.id].segments[segmentNumber].nodes;
+
+ for (var i = 0; i < segmentChildren.length; i++) {
+ result.push(executeNode(segmentChildren[i].owner, segmentChildren[i].index));
+ }
+
+ if (!stats[node.id].executable) {
+ return result;
+ }
+
+ return node.beforeAllFns.concat(result).concat(node.afterAllFns);
+ }
+ }
+
+ return TreeProcessor;
+};
+
+getJasmineRequireObj().Any = function(j$) {
+
+ function Any(expectedObject) {
+ if (typeof expectedObject === 'undefined') {
+ throw new TypeError(
+ 'jasmine.any() expects to be passed a constructor function. ' +
+ 'Please pass one or use jasmine.anything() to match any object.'
+ );
+ }
+ this.expectedObject = expectedObject;
+ }
+
+ Any.prototype.asymmetricMatch = function(other) {
+ if (this.expectedObject == String) {
+ return typeof other == 'string' || other instanceof String;
+ }
+
+ if (this.expectedObject == Number) {
+ return typeof other == 'number' || other instanceof Number;
+ }
+
+ if (this.expectedObject == Function) {
+ return typeof other == 'function' || other instanceof Function;
+ }
+
+ if (this.expectedObject == Object) {
+ return typeof other == 'object';
+ }
+
+ if (this.expectedObject == Boolean) {
+ return typeof other == 'boolean';
+ }
+
+ return other instanceof this.expectedObject;
+ };
+
+ Any.prototype.jasmineToString = function() {
+ return '';
+ };
+
+ return Any;
+};
+
+getJasmineRequireObj().Anything = function(j$) {
+
+ function Anything() {}
+
+ Anything.prototype.asymmetricMatch = function(other) {
+ return !j$.util.isUndefined(other) && other !== null;
+ };
+
+ Anything.prototype.jasmineToString = function() {
+ return '';
+ };
+
+ return Anything;
+};
+
+getJasmineRequireObj().ArrayContaining = function(j$) {
+ function ArrayContaining(sample) {
+ this.sample = sample;
+ }
+
+ ArrayContaining.prototype.asymmetricMatch = function(other) {
+ var className = Object.prototype.toString.call(this.sample);
+ if (className !== '[object Array]') { throw new Error('You must provide an array to arrayContaining, not \'' + this.sample + '\'.'); }
+
+ for (var i = 0; i < this.sample.length; i++) {
+ var item = this.sample[i];
+ if (!j$.matchersUtil.contains(other, item)) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ ArrayContaining.prototype.jasmineToString = function () {
+ return '';
+ };
+
+ return ArrayContaining;
+};
+
+getJasmineRequireObj().ObjectContaining = function(j$) {
+
+ function ObjectContaining(sample) {
+ this.sample = sample;
+ }
+
+ function getPrototype(obj) {
+ if (Object.getPrototypeOf) {
+ return Object.getPrototypeOf(obj);
+ }
+
+ if (obj.constructor.prototype == obj) {
+ return null;
+ }
+
+ return obj.constructor.prototype;
+ }
+
+ function hasProperty(obj, property) {
+ if (!obj) {
+ return false;
+ }
+
+ if (Object.prototype.hasOwnProperty.call(obj, property)) {
+ return true;
+ }
+
+ return hasProperty(getPrototype(obj), property);
+ }
+
+ ObjectContaining.prototype.asymmetricMatch = function(other) {
+ if (typeof(this.sample) !== 'object') { throw new Error('You must provide an object to objectContaining, not \''+this.sample+'\'.'); }
+
+ for (var property in this.sample) {
+ if (!hasProperty(other, property) ||
+ !j$.matchersUtil.equals(this.sample[property], other[property])) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ ObjectContaining.prototype.jasmineToString = function() {
+ return '';
+ };
+
+ return ObjectContaining;
+};
+
+getJasmineRequireObj().StringMatching = function(j$) {
+
+ function StringMatching(expected) {
+ if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
+ throw new Error('Expected is not a String or a RegExp');
+ }
+
+ this.regexp = new RegExp(expected);
+ }
+
+ StringMatching.prototype.asymmetricMatch = function(other) {
+ return this.regexp.test(other);
+ };
+
+ StringMatching.prototype.jasmineToString = function() {
+ return '';
+ };
+
+ return StringMatching;
+};
+
+getJasmineRequireObj().errors = function() {
+ function ExpectationFailed() {}
+
+ ExpectationFailed.prototype = new Error();
+ ExpectationFailed.prototype.constructor = ExpectationFailed;
+
+ return {
+ ExpectationFailed: ExpectationFailed
+ };
+};
+getJasmineRequireObj().matchersUtil = function(j$) {
+ // TODO: what to do about jasmine.pp not being inject? move to JSON.stringify? gut PrettyPrinter?
+
+ return {
+ equals: function(a, b, customTesters) {
+ customTesters = customTesters || [];
+
+ return eq(a, b, [], [], customTesters);
+ },
+
+ contains: function(haystack, needle, customTesters) {
+ customTesters = customTesters || [];
+
+ if ((Object.prototype.toString.apply(haystack) === '[object Array]') ||
+ (!!haystack && !haystack.indexOf))
+ {
+ for (var i = 0; i < haystack.length; i++) {
+ if (eq(haystack[i], needle, [], [], customTesters)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ return !!haystack && haystack.indexOf(needle) >= 0;
+ },
+
+ buildFailureMessage: function() {
+ var args = Array.prototype.slice.call(arguments, 0),
+ matcherName = args[0],
+ isNot = args[1],
+ actual = args[2],
+ expected = args.slice(3),
+ englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+
+ var message = 'Expected ' +
+ j$.pp(actual) +
+ (isNot ? ' not ' : ' ') +
+ englishyPredicate;
+
+ if (expected.length > 0) {
+ for (var i = 0; i < expected.length; i++) {
+ if (i > 0) {
+ message += ',';
+ }
+ message += ' ' + j$.pp(expected[i]);
+ }
+ }
+
+ return message + '.';
+ }
+ };
+
+ function isAsymmetric(obj) {
+ return obj && j$.isA_('Function', obj.asymmetricMatch);
+ }
+
+ function asymmetricMatch(a, b) {
+ var asymmetricA = isAsymmetric(a),
+ asymmetricB = isAsymmetric(b);
+
+ if (asymmetricA && asymmetricB) {
+ return undefined;
+ }
+
+ if (asymmetricA) {
+ return a.asymmetricMatch(b);
+ }
+
+ if (asymmetricB) {
+ return b.asymmetricMatch(a);
+ }
+ }
+
+ // Equality function lovingly adapted from isEqual in
+ // [Underscore](http://underscorejs.org)
+ function eq(a, b, aStack, bStack, customTesters) {
+ var result = true;
+
+ var asymmetricResult = asymmetricMatch(a, b);
+ if (!j$.util.isUndefined(asymmetricResult)) {
+ return asymmetricResult;
+ }
+
+ for (var i = 0; i < customTesters.length; i++) {
+ var customTesterResult = customTesters[i](a, b);
+ if (!j$.util.isUndefined(customTesterResult)) {
+ return customTesterResult;
+ }
+ }
+
+ if (a instanceof Error && b instanceof Error) {
+ return a.message == b.message;
+ }
+
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+ if (a === b) { return a !== 0 || 1 / a == 1 / b; }
+ // A strict comparison is necessary because `null == undefined`.
+ if (a === null || b === null) { return a === b; }
+ var className = Object.prototype.toString.call(a);
+ if (className != Object.prototype.toString.call(b)) { return false; }
+ switch (className) {
+ // Strings, numbers, dates, and booleans are compared by value.
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return a == String(b);
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+ // other numeric values.
+ return a != +a ? b != +b : (a === 0 ? 1 / a == 1 / b : a == +b);
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a == +b;
+ // RegExps are compared by their source patterns and flags.
+ case '[object RegExp]':
+ return a.source == b.source &&
+ a.global == b.global &&
+ a.multiline == b.multiline &&
+ a.ignoreCase == b.ignoreCase;
+ }
+ if (typeof a != 'object' || typeof b != 'object') { return false; }
+
+ var aIsDomNode = j$.isDomNode(a);
+ var bIsDomNode = j$.isDomNode(b);
+ if (aIsDomNode && bIsDomNode) {
+ // At first try to use DOM3 method isEqualNode
+ if (a.isEqualNode) {
+ return a.isEqualNode(b);
+ }
+ // IE8 doesn't support isEqualNode, try to use outerHTML && innerText
+ var aIsElement = a instanceof Element;
+ var bIsElement = b instanceof Element;
+ if (aIsElement && bIsElement) {
+ return a.outerHTML == b.outerHTML;
+ }
+ if (aIsElement || bIsElement) {
+ return false;
+ }
+ return a.innerText == b.innerText && a.textContent == b.textContent;
+ }
+ if (aIsDomNode || bIsDomNode) {
+ return false;
+ }
+
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = aStack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (aStack[length] == a) { return bStack[length] == b; }
+ }
+ // Add the first object to the stack of traversed objects.
+ aStack.push(a);
+ bStack.push(b);
+ var size = 0;
+ // Recursively compare objects and arrays.
+ // Compare array lengths to determine if a deep comparison is necessary.
+ if (className == '[object Array]' && a.length !== b.length) {
+ result = false;
+ }
+
+ if (result) {
+ // Objects with different constructors are not equivalent, but `Object`s
+ // or `Array`s from different frames are.
+ if (className !== '[object Array]') {
+ var aCtor = a.constructor, bCtor = b.constructor;
+ if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&
+ isFunction(bCtor) && bCtor instanceof bCtor)) {
+ return false;
+ }
+ }
+ // Deep compare objects.
+ for (var key in a) {
+ if (has(a, key)) {
+ // Count the expected number of properties.
+ size++;
+ // Deep compare each member.
+ if (!(result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters))) { break; }
+ }
+ }
+ // Ensure that both objects contain the same number of properties.
+ if (result) {
+ for (key in b) {
+ if (has(b, key) && !(size--)) { break; }
+ }
+ result = !size;
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ aStack.pop();
+ bStack.pop();
+
+ return result;
+
+ function has(obj, key) {
+ return Object.prototype.hasOwnProperty.call(obj, key);
+ }
+
+ function isFunction(obj) {
+ return typeof obj === 'function';
+ }
+ }
+};
+
+getJasmineRequireObj().toBe = function() {
+ function toBe() {
+ return {
+ compare: function(actual, expected) {
+ return {
+ pass: actual === expected
+ };
+ }
+ };
+ }
+
+ return toBe;
+};
+
+getJasmineRequireObj().toBeCloseTo = function() {
+
+ function toBeCloseTo() {
+ return {
+ compare: function(actual, expected, precision) {
+ if (precision !== 0) {
+ precision = precision || 2;
+ }
+
+ return {
+ pass: Math.abs(expected - actual) < (Math.pow(10, -precision) / 2)
+ };
+ }
+ };
+ }
+
+ return toBeCloseTo;
+};
+
+getJasmineRequireObj().toBeDefined = function() {
+ function toBeDefined() {
+ return {
+ compare: function(actual) {
+ return {
+ pass: (void 0 !== actual)
+ };
+ }
+ };
+ }
+
+ return toBeDefined;
+};
+
+getJasmineRequireObj().toBeFalsy = function() {
+ function toBeFalsy() {
+ return {
+ compare: function(actual) {
+ return {
+ pass: !!!actual
+ };
+ }
+ };
+ }
+
+ return toBeFalsy;
+};
+
+getJasmineRequireObj().toBeGreaterThan = function() {
+
+ function toBeGreaterThan() {
+ return {
+ compare: function(actual, expected) {
+ return {
+ pass: actual > expected
+ };
+ }
+ };
+ }
+
+ return toBeGreaterThan;
+};
+
+
+getJasmineRequireObj().toBeLessThan = function() {
+ function toBeLessThan() {
+ return {
+
+ compare: function(actual, expected) {
+ return {
+ pass: actual < expected
+ };
+ }
+ };
+ }
+
+ return toBeLessThan;
+};
+getJasmineRequireObj().toBeNaN = function(j$) {
+
+ function toBeNaN() {
+ return {
+ compare: function(actual) {
+ var result = {
+ pass: (actual !== actual)
+ };
+
+ if (result.pass) {
+ result.message = 'Expected actual not to be NaN.';
+ } else {
+ result.message = function() { return 'Expected ' + j$.pp(actual) + ' to be NaN.'; };
+ }
+
+ return result;
+ }
+ };
+ }
+
+ return toBeNaN;
+};
+
+getJasmineRequireObj().toBeNull = function() {
+
+ function toBeNull() {
+ return {
+ compare: function(actual) {
+ return {
+ pass: actual === null
+ };
+ }
+ };
+ }
+
+ return toBeNull;
+};
+
+getJasmineRequireObj().toBeTruthy = function() {
+
+ function toBeTruthy() {
+ return {
+ compare: function(actual) {
+ return {
+ pass: !!actual
+ };
+ }
+ };
+ }
+
+ return toBeTruthy;
+};
+
+getJasmineRequireObj().toBeUndefined = function() {
+
+ function toBeUndefined() {
+ return {
+ compare: function(actual) {
+ return {
+ pass: void 0 === actual
+ };
+ }
+ };
+ }
+
+ return toBeUndefined;
+};
+
+getJasmineRequireObj().toContain = function() {
+ function toContain(util, customEqualityTesters) {
+ customEqualityTesters = customEqualityTesters || [];
+
+ return {
+ compare: function(actual, expected) {
+
+ return {
+ pass: util.contains(actual, expected, customEqualityTesters)
+ };
+ }
+ };
+ }
+
+ return toContain;
+};
+
+getJasmineRequireObj().toEqual = function() {
+
+ function toEqual(util, customEqualityTesters) {
+ customEqualityTesters = customEqualityTesters || [];
+
+ return {
+ compare: function(actual, expected) {
+ var result = {
+ pass: false
+ };
+
+ result.pass = util.equals(actual, expected, customEqualityTesters);
+
+ return result;
+ }
+ };
+ }
+
+ return toEqual;
+};
+
+getJasmineRequireObj().toHaveBeenCalled = function(j$) {
+
+ function toHaveBeenCalled() {
+ return {
+ compare: function(actual) {
+ var result = {};
+
+ if (!j$.isSpy(actual)) {
+ throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+ }
+
+ if (arguments.length > 1) {
+ throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+ }
+
+ result.pass = actual.calls.any();
+
+ result.message = result.pass ?
+ 'Expected spy ' + actual.and.identity() + ' not to have been called.' :
+ 'Expected spy ' + actual.and.identity() + ' to have been called.';
+
+ return result;
+ }
+ };
+ }
+
+ return toHaveBeenCalled;
+};
+
+getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
+
+ function toHaveBeenCalledTimes() {
+ return {
+ compare: function(actual, expected) {
+ if (!j$.isSpy(actual)) {
+ throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+ }
+
+ var args = Array.prototype.slice.call(arguments, 0),
+ result = { pass: false };
+
+ if(!expected){
+ throw new Error('Expected times failed is required as an argument.');
+ }
+
+ actual = args[0];
+ var calls = actual.calls.count();
+ var timesMessage = expected === 1 ? 'once' : expected + ' times';
+ result.pass = calls === expected;
+ result.message = result.pass ?
+ 'Expected spy ' + actual.and.identity() + ' not to have been called ' + timesMessage + '. It was called ' + calls + ' times.' :
+ 'Expected spy ' + actual.and.identity() + ' to have been called ' + timesMessage + '. It was called ' + calls + ' times.';
+ return result;
+ }
+ };
+ }
+
+ return toHaveBeenCalledTimes;
+};
+
+getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
+
+ function toHaveBeenCalledWith(util, customEqualityTesters) {
+ return {
+ compare: function() {
+ var args = Array.prototype.slice.call(arguments, 0),
+ actual = args[0],
+ expectedArgs = args.slice(1),
+ result = { pass: false };
+
+ if (!j$.isSpy(actual)) {
+ throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+ }
+
+ if (!actual.calls.any()) {
+ result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but it was never called.'; };
+ return result;
+ }
+
+ if (util.contains(actual.calls.allArgs(), expectedArgs, customEqualityTesters)) {
+ result.pass = true;
+ result.message = function() { return 'Expected spy ' + actual.and.identity() + ' not to have been called with ' + j$.pp(expectedArgs) + ' but it was.'; };
+ } else {
+ result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but actual calls were ' + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + '.'; };
+ }
+
+ return result;
+ }
+ };
+ }
+
+ return toHaveBeenCalledWith;
+};
+
+getJasmineRequireObj().toMatch = function(j$) {
+
+ function toMatch() {
+ return {
+ compare: function(actual, expected) {
+ if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
+ throw new Error('Expected is not a String or a RegExp');
+ }
+
+ var regexp = new RegExp(expected);
+
+ return {
+ pass: regexp.test(actual)
+ };
+ }
+ };
+ }
+
+ return toMatch;
+};
+
+getJasmineRequireObj().toThrow = function(j$) {
+
+ function toThrow(util) {
+ return {
+ compare: function(actual, expected) {
+ var result = { pass: false },
+ threw = false,
+ thrown;
+
+ if (typeof actual != 'function') {
+ throw new Error('Actual is not a Function');
+ }
+
+ try {
+ actual();
+ } catch (e) {
+ threw = true;
+ thrown = e;
+ }
+
+ if (!threw) {
+ result.message = 'Expected function to throw an exception.';
+ return result;
+ }
+
+ if (arguments.length == 1) {
+ result.pass = true;
+ result.message = function() { return 'Expected function not to throw, but it threw ' + j$.pp(thrown) + '.'; };
+
+ return result;
+ }
+
+ if (util.equals(thrown, expected)) {
+ result.pass = true;
+ result.message = function() { return 'Expected function not to throw ' + j$.pp(expected) + '.'; };
+ } else {
+ result.message = function() { return 'Expected function to throw ' + j$.pp(expected) + ', but it threw ' + j$.pp(thrown) + '.'; };
+ }
+
+ return result;
+ }
+ };
+ }
+
+ return toThrow;
+};
+
+getJasmineRequireObj().toThrowError = function(j$) {
+ function toThrowError () {
+ return {
+ compare: function(actual) {
+ var threw = false,
+ pass = {pass: true},
+ fail = {pass: false},
+ thrown;
+
+ if (typeof actual != 'function') {
+ throw new Error('Actual is not a Function');
+ }
+
+ var errorMatcher = getMatcher.apply(null, arguments);
+
+ try {
+ actual();
+ } catch (e) {
+ threw = true;
+ thrown = e;
+ }
+
+ if (!threw) {
+ fail.message = 'Expected function to throw an Error.';
+ return fail;
+ }
+
+ if (!(thrown instanceof Error)) {
+ fail.message = function() { return 'Expected function to throw an Error, but it threw ' + j$.pp(thrown) + '.'; };
+ return fail;
+ }
+
+ if (errorMatcher.hasNoSpecifics()) {
+ pass.message = 'Expected function not to throw an Error, but it threw ' + j$.fnNameFor(thrown) + '.';
+ return pass;
+ }
+
+ if (errorMatcher.matches(thrown)) {
+ pass.message = function() {
+ return 'Expected function not to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() + '.';
+ };
+ return pass;
+ } else {
+ fail.message = function() {
+ return 'Expected function to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() +
+ ', but it threw ' + errorMatcher.thrownDescription(thrown) + '.';
+ };
+ return fail;
+ }
+ }
+ };
+
+ function getMatcher() {
+ var expected = null,
+ errorType = null;
+
+ if (arguments.length == 2) {
+ expected = arguments[1];
+ if (isAnErrorType(expected)) {
+ errorType = expected;
+ expected = null;
+ }
+ } else if (arguments.length > 2) {
+ errorType = arguments[1];
+ expected = arguments[2];
+ if (!isAnErrorType(errorType)) {
+ throw new Error('Expected error type is not an Error.');
+ }
+ }
+
+ if (expected && !isStringOrRegExp(expected)) {
+ if (errorType) {
+ throw new Error('Expected error message is not a string or RegExp.');
+ } else {
+ throw new Error('Expected is not an Error, string, or RegExp.');
+ }
+ }
+
+ function messageMatch(message) {
+ if (typeof expected == 'string') {
+ return expected == message;
+ } else {
+ return expected.test(message);
+ }
+ }
+
+ return {
+ errorTypeDescription: errorType ? j$.fnNameFor(errorType) : 'an exception',
+ thrownDescription: function(thrown) {
+ var thrownName = errorType ? j$.fnNameFor(thrown.constructor) : 'an exception',
+ thrownMessage = '';
+
+ if (expected) {
+ thrownMessage = ' with message ' + j$.pp(thrown.message);
+ }
+
+ return thrownName + thrownMessage;
+ },
+ messageDescription: function() {
+ if (expected === null) {
+ return '';
+ } else if (expected instanceof RegExp) {
+ return ' with a message matching ' + j$.pp(expected);
+ } else {
+ return ' with message ' + j$.pp(expected);
+ }
+ },
+ hasNoSpecifics: function() {
+ return expected === null && errorType === null;
+ },
+ matches: function(error) {
+ return (errorType === null || error instanceof errorType) &&
+ (expected === null || messageMatch(error.message));
+ }
+ };
+ }
+
+ function isStringOrRegExp(potential) {
+ return potential instanceof RegExp || (typeof potential == 'string');
+ }
+
+ function isAnErrorType(type) {
+ if (typeof type !== 'function') {
+ return false;
+ }
+
+ var Surrogate = function() {};
+ Surrogate.prototype = type.prototype;
+ return (new Surrogate()) instanceof Error;
+ }
+ }
+
+ return toThrowError;
+};
+
+getJasmineRequireObj().interface = function(jasmine, env) {
+ var jasmineInterface = {
+ describe: function(description, specDefinitions) {
+ return env.describe(description, specDefinitions);
+ },
+
+ xdescribe: function(description, specDefinitions) {
+ return env.xdescribe(description, specDefinitions);
+ },
+
+ fdescribe: function(description, specDefinitions) {
+ return env.fdescribe(description, specDefinitions);
+ },
+
+ it: function() {
+ return env.it.apply(env, arguments);
+ },
+
+ xit: function() {
+ return env.xit.apply(env, arguments);
+ },
+
+ fit: function() {
+ return env.fit.apply(env, arguments);
+ },
+
+ beforeEach: function() {
+ return env.beforeEach.apply(env, arguments);
+ },
+
+ afterEach: function() {
+ return env.afterEach.apply(env, arguments);
+ },
+
+ beforeAll: function() {
+ return env.beforeAll.apply(env, arguments);
+ },
+
+ afterAll: function() {
+ return env.afterAll.apply(env, arguments);
+ },
+
+ expect: function(actual) {
+ return env.expect(actual);
+ },
+
+ pending: function() {
+ return env.pending.apply(env, arguments);
+ },
+
+ fail: function() {
+ return env.fail.apply(env, arguments);
+ },
+
+ spyOn: function(obj, methodName) {
+ return env.spyOn(obj, methodName);
+ },
+
+ jsApiReporter: new jasmine.JsApiReporter({
+ timer: new jasmine.Timer()
+ }),
+
+ jasmine: jasmine
+ };
+
+ jasmine.addCustomEqualityTester = function(tester) {
+ env.addCustomEqualityTester(tester);
+ };
+
+ jasmine.addMatchers = function(matchers) {
+ return env.addMatchers(matchers);
+ };
+
+ jasmine.clock = function() {
+ return env.clock;
+ };
+
+ return jasmineInterface;
+};
+
+getJasmineRequireObj().version = function() {
+ return '2.4.1';
+};
diff --git a/tests/jasmine/lib/jasmine-2.4.1/jasmine_favicon.png b/tests/jasmine/lib/jasmine-2.4.1/jasmine_favicon.png
new file mode 100644
index 0000000..3b84583
Binary files /dev/null and b/tests/jasmine/lib/jasmine-2.4.1/jasmine_favicon.png differ
diff --git a/tests/jasmine/spec/NintexServicesSpec.js b/tests/jasmine/spec/NintexServicesSpec.js
new file mode 100644
index 0000000..0059de9
--- /dev/null
+++ b/tests/jasmine/spec/NintexServicesSpec.js
@@ -0,0 +1,109 @@
+describe("NintexServices", function() {
+
+ var WEBURL = "{InsertTestSiteHere}";
+ var TESTLIST = "Tasks";
+ var TESTWFNAME = "TaskWFSave";
+ var TESTLISTID = null;
+ var TESTWFID = null;
+
+ $().SPServices({
+ webURL: WEBURL,
+ operation: "GetList",
+ listName: TESTLIST,
+ async: false,
+ completefunc: function(xData, Status){
+ TESTLISTID = $(xData.responseXML).find("List").attr("ID");
+ }
+ });//End Get List id
+ beforeEach(function() {
+
+ });//end beforeEach
+
+ it("should exist", function(){
+ expect($().NintexServices).toBeDefined();
+ });
+
+ it("TESTLISTID should not be null", function(){
+ expect(TESTLISTID).not.toBe(null);
+ });
+
+ it("show work with SaveFromNWF operation", function(){
+ $().NintexServices({
+ webURL: WEBURL,
+ operation: "SaveFromNWF",
+ workflowFile: BASE64ENCODEDWF,
+ listName: "Tasks",
+ workflowName: TESTWFNAME,
+ async: false,
+ completefunc: function(xData, Status) {
+ expect(Status).toEqual('success');
+ TESTWFID = $(xData.responseXML).find("WorkflowId").text();
+ expect(TESTWFID).not.toBe(null);
+ }
+ });
+ });
+
+ //Export Workflow
+ it("should work with ExportWorkflow operation", function(){
+ $().NintexServices({
+ webURL: WEBURL,
+ operation: "ExportWorkflow",
+ listName: "Tasks",
+ workflowType: "list",
+ workflowName: TESTWFNAME,
+ async: false,
+ completefunc: function(xData, Status) {
+ expect(Status).toEqual('success');
+ }
+ });
+ });
+
+ //Workflow Exists
+ it("should work with WorkflowExists operation", function(){
+ $().NintexServices({
+ webURL: WEBURL,
+ operation: "WorkflowExists",
+ workflowName: TESTWFNAME,
+ listId: TESTWFID,
+ workflowType: "list",
+ async: false,
+ completefunc: function(xData, Status) {
+ expect(Status).toEqual('success');
+ expect($(xData.responseXML).find("WorkflowExistsResult").text()).toEqual("NameUsedInOtherList");
+ }
+ });
+ });
+
+ //Delete Workflow
+ it("should work with DeleteWorkflow operation", function(){
+ $().NintexServices({
+ webURL: WEBURL,
+ operation: "DeleteWorkflow",
+ listId: TESTLISTID,
+ workflowId: TESTWFID,
+ workflowType: "list",
+ async: false,
+ completefunc: function(xData, Status) {
+ expect(Status).toEqual('success');
+ }
+ });
+ });
+
+ //Workflow Exists
+ it(TESTWFNAME + " should not exist", function(){
+ $().NintexServices({
+ webURL: WEBURL,
+ operation: "WorkflowExists",
+ workflowName: TESTWFNAME,
+ listId: TESTWFID,
+ workflowType: "list",
+ async: false,
+ completefunc: function(xData, Status) {
+ expect(Status).toEqual('success');
+ expect($(xData.responseXML).find("WorkflowExistsResult").text()).toEqual("NameNotUsed");
+ }
+ });
+ });
+
+
+});
diff --git a/tests/jasmine/src/Base64EncodedWF.js b/tests/jasmine/src/Base64EncodedWF.js
new file mode 100644
index 0000000..d7d61dd
--- /dev/null
+++ b/tests/jasmine/src/Base64EncodedWF.js
@@ -0,0 +1 @@
+var BASE64ENCODEDWF = "<?xml version="1.0" encoding="utf-8"?><ExportedWorkflowWithListMetdata xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><ExportedWorkflowSeralized>&lt;?xml version="1.0" encoding="utf-8"?&gt;&lt;ExportedWorkflow xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;&lt;Title&gt;TaskWF&lt;/Title&gt;&lt;Description /&gt;&lt;Configurations&gt;&lt;ActionConfigs&gt;&lt;NWActionConfig LCustLbl="false" RCustLbl="false" TCustLbl="false" BCustLbl="false" ShowCustomComments="false" CommentType="Auto"&gt;&lt;HideUI&gt;false&lt;/HideUI&gt;&lt;Enabled&gt;true&lt;/Enabled&gt;&lt;InheritedEnabled&gt;true&lt;/InheritedEnabled&gt;&lt;BLabel /&gt;&lt;LLabel /&gt;&lt;RLabel /&gt;&lt;TLabel /&gt;&lt;CustomComments /&gt;&lt;ExpectedDuration&gt;-1&lt;/ExpectedDuration&gt;&lt;Assembly&gt;Nintex.Workflow, Version=1.0.0.0, Culture=neutral, PublicKeyToken=913f6bae0ca5ae12&lt;/Assembly&gt;&lt;Type&gt;Nintex.Workflow.Activities.Adapters.NWWorkflowVariablesAdapter&lt;/Type&gt;&lt;IsValid&gt;true&lt;/IsValid&gt;&lt;ConditionUse&gt;None&lt;/ConditionUse&gt;&lt;Parameters&gt;&lt;Parameter Name="StartManually"&gt;&lt;PrimitiveValue Value="true" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartOnCreate"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartOnChange"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="WorkflowName"&gt;&lt;PrimitiveValue Value="TaskWF" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="WorkflowDescription"&gt;&lt;PrimitiveValue Value="" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="WorkflowDuration"&gt;&lt;PrimitiveValue Value="-1" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="TaskListId"&gt;&lt;PrimitiveValue Value="Workflow Tasks" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartPage"&gt;&lt;PrimitiveValue Value="_layouts/NintexWorkflow/StartWorkflow.aspx" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="VerboseLogging"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="Category"&gt;&lt;PrimitiveValue Value="List" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="ContentType"&gt;&lt;PrimitiveValue Value="" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartOnCreateCondition"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartOnChangeCondition"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="HistoryLogging"&gt;&lt;PrimitiveValue Value="true" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="RequireManagePermission"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="HistoryListName"&gt;&lt;PrimitiveValue Value="NintexWorkflowHistory" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="ChangeComments"&gt;&lt;PrimitiveValue Value="" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="Id"&gt;&lt;PrimitiveValue Value="{4A455228-5700-4410-A6D2-4C407012D3F1}" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="SkipValidation"&gt;&lt;PrimitiveValue Value="false" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="ContentTypeName"&gt;&lt;PrimitiveValue Value="All" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="DisplayStatusColumn"&gt;&lt;PrimitiveValue Value="true" ValueType="Boolean" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartFromMenu"&gt;&lt;PrimitiveValue Value="false" ValueType="Boolean" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="StartFromMenuLabel"&gt;&lt;PrimitiveValue Value="" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="EcbId"&gt;&lt;PrimitiveValue Value="00000000-0000-0000-0000-000000000000" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="CustomActionSequence"&gt;&lt;PrimitiveValue Value="0" ValueType="Number" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="CustomActionIcon"&gt;&lt;PrimitiveValue Value="_layouts/NintexWorkflow/Images/StartWorkflowECB.png" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;Parameter Name="UsesConditionalStart"&gt;&lt;PrimitiveValue Value="true" ValueType="Boolean" /&gt;&lt;/Parameter&gt;&lt;/Parameters&gt;&lt;WorkflowVariables /&gt;&lt;Outcomes /&gt;&lt;AssociationColumns /&gt;&lt;StartOnCreateConditions /&gt;&lt;StartOnChangeConditions /&gt;&lt;LogMessage&gt;false&lt;/LogMessage&gt;&lt;HistoryNote /&gt;&lt;HasDefaultMessage&gt;false&lt;/HasDefaultMessage&gt;&lt;UserContext&gt;Default&lt;/UserContext&gt;&lt;SelectedUserContext&gt;Default&lt;/SelectedUserContext&gt;&lt;CustomWorkflowStatuses /&gt;&lt;ExtensionProperties /&gt;&lt;/NWActionConfig&gt;&lt;NWActionConfig LCustLbl="false" RCustLbl="false" TCustLbl="false" BCustLbl="false" ShowCustomComments="false" CommentType="Auto"&gt;&lt;HideUI&gt;false&lt;/HideUI&gt;&lt;Enabled&gt;true&lt;/Enabled&gt;&lt;InheritedEnabled&gt;true&lt;/InheritedEnabled&gt;&lt;BLabel /&gt;&lt;LLabel /&gt;&lt;RLabel /&gt;&lt;TLabel&gt;Log in history list&lt;/TLabel&gt;&lt;CustomComments /&gt;&lt;ExpectedDuration&gt;-1&lt;/ExpectedDuration&gt;&lt;Assembly&gt;Nintex.Workflow, Version=1.0.0.0, Culture=neutral, PublicKeyToken=913f6bae0ca5ae12&lt;/Assembly&gt;&lt;Type&gt;Nintex.Workflow.Activities.Adapters.NWWriteToHistoryListAdapter&lt;/Type&gt;&lt;IsValid&gt;true&lt;/IsValid&gt;&lt;ConditionUse&gt;None&lt;/ConditionUse&gt;&lt;Parameters&gt;&lt;Parameter Name="Message"&gt;&lt;PrimitiveValue Value="Hello World" ValueType="Text" /&gt;&lt;/Parameter&gt;&lt;/Parameters&gt;&lt;Outcomes /&gt;&lt;AssociationColumns /&gt;&lt;StartOnCreateConditions /&gt;&lt;StartOnChangeConditions /&gt;&lt;LogMessage&gt;false&lt;/LogMessage&gt;&lt;HistoryNote /&gt;&lt;HasDefaultMessage&gt;false&lt;/HasDefaultMessage&gt;&lt;UserContext&gt;Default&lt;/UserContext&gt;&lt;SelectedUserContext&gt;Default&lt;/SelectedUserContext&gt;&lt;CustomWorkflowStatuses /&gt;&lt;ExtensionProperties /&gt;&lt;/NWActionConfig&gt;&lt;/ActionConfigs&gt;&lt;/Configurations&gt;&lt;Id&gt;afc4a32b-8a48-4e1b-a00e-36deb2cdb526&lt;/Id&gt;&lt;/ExportedWorkflow&gt;</ExportedWorkflowSeralized><ListReferences><ListReference><ContentTypes><ContentTypeReference><Id>0x0108007F5490137E20AD47A3AA000B333FD9D0</Id><Name>Task</Name></ContentTypeReference><ContentTypeReference><Id>0x0120009DD36C28CC33AF498B8214D72837DABF</Id><Name>Folder</Name></ContentTypeReference><ContentTypeReference><Id>0x01200400BBFBE6493C0670468053BFF53A3C433F</Id><Name>Summary Task</Name></ContentTypeReference></ContentTypes><IsSourceList>true</IsSourceList><Fields><FieldReference><InternalName>Title</InternalName><DisplayName>Title</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>Predecessors</InternalName><DisplayName>Predecessors</DisplayName><FieldType>Lookup</FieldType></FieldReference><FieldReference><InternalName>Priority</InternalName><DisplayName>Priority</DisplayName><FieldType>Choice</FieldType></FieldReference><FieldReference><InternalName>Status</InternalName><DisplayName>Task Status</DisplayName><FieldType>Choice</FieldType></FieldReference><FieldReference><InternalName>PercentComplete</InternalName><DisplayName>% Complete</DisplayName><FieldType>Number</FieldType></FieldReference><FieldReference><InternalName>AssignedTo</InternalName><DisplayName>Assigned To</DisplayName><FieldType>User</FieldType></FieldReference><FieldReference><InternalName>TaskGroup</InternalName><DisplayName>Task Group</DisplayName><FieldType>User</FieldType></FieldReference><FieldReference><InternalName>Body</InternalName><DisplayName>Body</DisplayName><FieldType>Note</FieldType></FieldReference><FieldReference><InternalName>StartDate</InternalName><DisplayName>Start Date</DisplayName><FieldType>DateTime</FieldType></FieldReference><FieldReference><InternalName>DueDate</InternalName><DisplayName>Due Date</DisplayName><FieldType>DateTime</FieldType></FieldReference><FieldReference><InternalName>WorkflowLink</InternalName><DisplayName>Related Content</DisplayName><FieldType>URL</FieldType></FieldReference><FieldReference><InternalName>OffsiteParticipant</InternalName><DisplayName>External Participant</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>OffsiteParticipantReason</InternalName><DisplayName>External Participant Reason</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>WorkflowOutcome</InternalName><DisplayName>Outcome</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>WorkflowName</InternalName><DisplayName>Workflow Name</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>ID</InternalName><DisplayName>ID</DisplayName><FieldType>Counter</FieldType></FieldReference><FieldReference><InternalName>ContentType</InternalName><DisplayName>Content Type</DisplayName><FieldType>Computed</FieldType></FieldReference><FieldReference><InternalName>Modified</InternalName><DisplayName>Modified</DisplayName><FieldType>DateTime</FieldType></FieldReference><FieldReference><InternalName>Created</InternalName><DisplayName>Created</DisplayName><FieldType>DateTime</FieldType></FieldReference><FieldReference><InternalName>Author</InternalName><DisplayName>Created By</DisplayName><FieldType>User</FieldType></FieldReference><FieldReference><InternalName>Editor</InternalName><DisplayName>Modified By</DisplayName><FieldType>User</FieldType></FieldReference><FieldReference><InternalName>_UIVersionString</InternalName><DisplayName>Version</DisplayName><FieldType>Text</FieldType></FieldReference><FieldReference><InternalName>Attachments</InternalName><DisplayName>Attachments</DisplayName><FieldType>Attachments</FieldType></FieldReference><FieldReference><InternalName>Edit</InternalName><DisplayName>Edit</DisplayName><FieldType>Computed</FieldType></FieldReference><FieldReference><InternalName>LinkTitleNoMenu</InternalName><DisplayName>Title</DisplayName><FieldType>Computed</FieldType></FieldReference><FieldReference><InternalName>LinkTitle</InternalName><DisplayName>Title</DisplayName><FieldType>Computed</FieldType></FieldReference><FieldReference><InternalName>DocIcon</InternalName><DisplayName>Type</DisplayName><FieldType>Computed</FieldType></FieldReference><FieldReference><InternalName>ItemChildCount</InternalName><DisplayName>Item Child Count</DisplayName><FieldType>Lookup</FieldType></FieldReference><FieldReference><InternalName>FolderChildCount</InternalName><DisplayName>Folder Child Count</DisplayName><FieldType>Lookup</FieldType></FieldReference></Fields><ListName>Tasks</ListName><ListId>59e29fbd-dce8-4b66-ac0f-5771e3a7bb10</ListId></ListReference></ListReferences><Version>23130</Version><WorkflowType>List</WorkflowType><WorkflowId>4a455228-5700-4410-a6d2-4c407012d3f1</WorkflowId></ExportedWorkflowWithListMetdata>"
\ No newline at end of file
diff --git a/tests/jasmine/src/jquery-1.11.3.min.js b/tests/jasmine/src/jquery-1.11.3.min.js
new file mode 100644
index 0000000..0f60b7b
--- /dev/null
+++ b/tests/jasmine/src/jquery-1.11.3.min.js
@@ -0,0 +1,5 @@
+/*! jQuery v1.11.3 | (c) 2005, 2015 jQuery Foundation, Inc. | jquery.org/license */
+!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k={},l="1.11.3",m=function(a,b){return new m.fn.init(a,b)},n=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,o=/^-ms-/,p=/-([\da-z])/gi,q=function(a,b){return b.toUpperCase()};m.fn=m.prototype={jquery:l,constructor:m,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=m.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return m.each(this,a,b)},map:function(a){return this.pushStack(m.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},m.extend=m.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||m.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(m.isPlainObject(c)||(b=m.isArray(c)))?(b?(b=!1,f=a&&m.isArray(a)?a:[]):f=a&&m.isPlainObject(a)?a:{},g[d]=m.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},m.extend({expando:"jQuery"+(l+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===m.type(a)},isArray:Array.isArray||function(a){return"array"===m.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){return!m.isArray(a)&&a-parseFloat(a)+1>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==m.type(a)||a.nodeType||m.isWindow(a))return!1;try{if(a.constructor&&!j.call(a,"constructor")&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(k.ownLast)for(b in a)return j.call(a,b);for(b in a);return void 0===b||j.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(b){b&&m.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(o,"ms-").replace(p,q)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=r(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(n,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(r(Object(a))?m.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(g)return g.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=r(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(f=a[b],b=a,a=f),m.isFunction(a)?(c=d.call(arguments,2),e=function(){return a.apply(b||this,c.concat(d.call(arguments)))},e.guid=a.guid=a.guid||m.guid++,e):void 0},now:function(){return+new Date},support:k}),m.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function r(a){var b="length"in a&&a.length,c=m.type(a);return"function"===c||m.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var s=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C=1<<31,D={}.hasOwnProperty,E=[],F=E.pop,G=E.push,H=E.push,I=E.slice,J=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},K="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",L="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",N=M.replace("w","w#"),O="\\["+L+"*("+M+")(?:"+L+"*([*^$|!~]?=)"+L+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+N+"))|)"+L+"*\\]",P=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+O+")*)|.*)\\)|)",Q=new RegExp(L+"+","g"),R=new RegExp("^"+L+"+|((?:^|[^\\\\])(?:\\\\.)*)"+L+"+$","g"),S=new RegExp("^"+L+"*,"+L+"*"),T=new RegExp("^"+L+"*([>+~]|"+L+")"+L+"*"),U=new RegExp("="+L+"*([^\\]'\"]*?)"+L+"*\\]","g"),V=new RegExp(P),W=new RegExp("^"+N+"$"),X={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M.replace("w","w*")+")"),ATTR:new RegExp("^"+O),PSEUDO:new RegExp("^"+P),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+K+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},Y=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,$=/^[^{]+\{\s*\[native \w/,_=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,aa=/[+~]/,ba=/'|\\/g,ca=new RegExp("\\\\([\\da-f]{1,6}"+L+"?|("+L+")|.)","ig"),da=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ea=function(){m()};try{H.apply(E=I.call(v.childNodes),v.childNodes),E[v.childNodes.length].nodeType}catch(fa){H={apply:E.length?function(a,b){G.apply(a,I.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s,w,x;if((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,d=d||[],k=b.nodeType,"string"!=typeof a||!a||1!==k&&9!==k&&11!==k)return d;if(!e&&p){if(11!==k&&(f=_.exec(a)))if(j=f[1]){if(9===k){if(h=b.getElementById(j),!h||!h.parentNode)return d;if(h.id===j)return d.push(h),d}else if(b.ownerDocument&&(h=b.ownerDocument.getElementById(j))&&t(b,h)&&h.id===j)return d.push(h),d}else{if(f[2])return H.apply(d,b.getElementsByTagName(a)),d;if((j=f[3])&&c.getElementsByClassName)return H.apply(d,b.getElementsByClassName(j)),d}if(c.qsa&&(!q||!q.test(a))){if(s=r=u,w=b,x=1!==k&&a,1===k&&"object"!==b.nodeName.toLowerCase()){o=g(a),(r=b.getAttribute("id"))?s=r.replace(ba,"\\$&"):b.setAttribute("id",s),s="[id='"+s+"'] ",l=o.length;while(l--)o[l]=s+ra(o[l]);w=aa.test(a)&&pa(b.parentNode)||b,x=o.join(",")}if(x)try{return H.apply(d,w.querySelectorAll(x)),d}catch(y){}finally{r||b.removeAttribute("id")}}}return i(a.replace(R,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||C)-(~a.sourceIndex||C);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function pa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=g.documentElement,e=g.defaultView,e&&e!==e.top&&(e.addEventListener?e.addEventListener("unload",ea,!1):e.attachEvent&&e.attachEvent("onunload",ea)),p=!f(g),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(g.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=$.test(g.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!g.getElementsByName||!g.getElementsByName(u).length}),c.getById?(d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return p?b.getElementsByClassName(a):void 0},r=[],q=[],(c.qsa=$.test(g.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="b;b++)d+=a[b].value;return d}function sa(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=x++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[w,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[u]||(b[u]={}),(h=i[d])&&h[0]===w&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function ta(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function ua(a,b,c){for(var d=0,e=b.length;e>d;d++)ga(a,b[d],c);return c}function va(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function wa(a,b,c,d,e,f){return d&&!d[u]&&(d=wa(d)),e&&!e[u]&&(e=wa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||ua(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:va(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=va(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?J(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=va(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):H.apply(g,r)})}function xa(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=sa(function(a){return a===b},h,!0),l=sa(function(a){return J(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];f>i;i++)if(c=d.relative[a[i].type])m=[sa(ta(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return wa(i>1&&ta(m),i>1&&ra(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(R,"$1"),c,e>i&&xa(a.slice(i,e)),f>e&&xa(a=a.slice(e)),f>e&&ra(a))}m.push(c)}return ta(m)}function ya(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,m,o,p=0,q="0",r=f&&[],s=[],t=j,u=f||e&&d.find.TAG("*",k),v=w+=null==t?1:Math.random()||.1,x=u.length;for(k&&(j=g!==n&&g);q!==x&&null!=(l=u[q]);q++){if(e&&l){m=0;while(o=a[m++])if(o(l,g,h)){i.push(l);break}k&&(w=v)}c&&((l=!o&&l)&&p--,f&&r.push(l))}if(p+=q,c&&q!==p){m=0;while(o=b[m++])o(r,s,g,h);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=F.call(i));s=va(s)}H.apply(i,s),k&&!f&&s.length>0&&p+b.length>1&&ga.uniqueSort(i)}return k&&(w=v,j=t),r};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=xa(b[c]),f[u]?d.push(f):e.push(f);f=A(a,ya(e,d)),f.selector=a}return f},i=ga.select=function(a,b,e,f){var i,j,k,l,m,n="function"==typeof a&&a,o=!f&&g(a=n.selector||a);if(e=e||[],1===o.length){if(j=o[0]=o[0].slice(0),j.length>2&&"ID"===(k=j[0]).type&&c.getById&&9===b.nodeType&&p&&d.relative[j[1].type]){if(b=(d.find.ID(k.matches[0].replace(ca,da),b)||[])[0],!b)return e;n&&(b=b.parentNode),a=a.slice(j.shift().value.length)}i=X.needsContext.test(a)?0:j.length;while(i--){if(k=j[i],d.relative[l=k.type])break;if((m=d.find[l])&&(f=m(k.matches[0].replace(ca,da),aa.test(j[0].type)&&pa(b.parentNode)||b))){if(j.splice(i,1),a=f.length&&ra(j),!a)return H.apply(e,f),e;break}}}return(n||h(a,o))(f,b,!p,e,aa.test(a)&&pa(b.parentNode)||b),e},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("div"))}),ja(function(a){return a.innerHTML="h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},W=/^(?:checkbox|radio)$/i;!function(){var a=y.createElement("input"),b=y.createElement("div"),c=y.createDocumentFragment();if(b.innerHTML=" a \s*$/g,ra={option:[1,""," "],legend:[1,""," "],area:[1,""," "],param:[1,""," "],thead:[1,""],tr:[2,""],col:[2,""],td:[3,""],_default:k.htmlSerialize?[0,"",""]:[1,"X","
"]},sa=da(y),ta=sa.appendChild(y.createElement("div"));ra.optgroup=ra.option,ra.tbody=ra.tfoot=ra.colgroup=ra.caption=ra.thead,ra.th=ra.td;function ua(a,b){var c,d,e=0,f=typeof a.getElementsByTagName!==K?a.getElementsByTagName(b||"*"):typeof a.querySelectorAll!==K?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||m.nodeName(d,b)?f.push(d):m.merge(f,ua(d,b));return void 0===b||b&&m.nodeName(a,b)?m.merge([a],f):f}function va(a){W.test(a.type)&&(a.defaultChecked=a.checked)}function wa(a,b){return m.nodeName(a,"table")&&m.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function xa(a){return a.type=(null!==m.find.attr(a,"type"))+"/"+a.type,a}function ya(a){var b=pa.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function za(a,b){for(var c,d=0;null!=(c=a[d]);d++)m._data(c,"globalEval",!b||m._data(b[d],"globalEval"))}function Aa(a,b){if(1===b.nodeType&&m.hasData(a)){var c,d,e,f=m._data(a),g=m._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)m.event.add(b,c,h[c][d])}g.data&&(g.data=m.extend({},g.data))}}function Ba(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!k.noCloneEvent&&b[m.expando]){e=m._data(b);for(d in e.events)m.removeEvent(b,d,e.handle);b.removeAttribute(m.expando)}"script"===c&&b.text!==a.text?(xa(b).text=a.text,ya(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),k.html5Clone&&a.innerHTML&&!m.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&W.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}}m.extend({clone:function(a,b,c){var d,e,f,g,h,i=m.contains(a.ownerDocument,a);if(k.html5Clone||m.isXMLDoc(a)||!ga.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(ta.innerHTML=a.outerHTML,ta.removeChild(f=ta.firstChild)),!(k.noCloneEvent&&k.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||m.isXMLDoc(a)))for(d=ua(f),h=ua(a),g=0;null!=(e=h[g]);++g)d[g]&&Ba(e,d[g]);if(b)if(c)for(h=h||ua(a),d=d||ua(f),g=0;null!=(e=h[g]);g++)Aa(e,d[g]);else Aa(a,f);return d=ua(f,"script"),d.length>0&&za(d,!i&&ua(a,"script")),d=h=e=null,f},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,l,n=a.length,o=da(b),p=[],q=0;n>q;q++)if(f=a[q],f||0===f)if("object"===m.type(f))m.merge(p,f.nodeType?[f]:f);else if(la.test(f)){h=h||o.appendChild(b.createElement("div")),i=(ja.exec(f)||["",""])[1].toLowerCase(),l=ra[i]||ra._default,h.innerHTML=l[1]+f.replace(ia,"<$1>")+l[2],e=l[0];while(e--)h=h.lastChild;if(!k.leadingWhitespace&&ha.test(f)&&p.push(b.createTextNode(ha.exec(f)[0])),!k.tbody){f="table"!==i||ka.test(f)?""!==l[1]||ka.test(f)?0:h:h.firstChild,e=f&&f.childNodes.length;while(e--)m.nodeName(j=f.childNodes[e],"tbody")&&!j.childNodes.length&&f.removeChild(j)}m.merge(p,h.childNodes),h.textContent="";while(h.firstChild)h.removeChild(h.firstChild);h=o.lastChild}else p.push(b.createTextNode(f));h&&o.removeChild(h),k.appendChecked||m.grep(ua(p,"input"),va),q=0;while(f=p[q++])if((!d||-1===m.inArray(f,d))&&(g=m.contains(f.ownerDocument,f),h=ua(o.appendChild(f),"script"),g&&za(h),c)){e=0;while(f=h[e++])oa.test(f.type||"")&&c.push(f)}return h=null,o},cleanData:function(a,b){for(var d,e,f,g,h=0,i=m.expando,j=m.cache,l=k.deleteExpando,n=m.event.special;null!=(d=a[h]);h++)if((b||m.acceptData(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)n[e]?m.event.remove(d,e):m.removeEvent(d,e,g.handle);j[f]&&(delete j[f],l?delete d[i]:typeof d.removeAttribute!==K?d.removeAttribute(i):d[i]=null,c.push(f))}}}),m.fn.extend({text:function(a){return V(this,function(a){return void 0===a?m.text(this):this.empty().append((this[0]&&this[0].ownerDocument||y).createTextNode(a))},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=wa(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=wa(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?m.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||m.cleanData(ua(c)),c.parentNode&&(b&&m.contains(c.ownerDocument,c)&&za(ua(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&m.cleanData(ua(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&m.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return m.clone(this,a,b)})},html:function(a){return V(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(fa,""):void 0;if(!("string"!=typeof a||ma.test(a)||!k.htmlSerialize&&ga.test(a)||!k.leadingWhitespace&&ha.test(a)||ra[(ja.exec(a)||["",""])[1].toLowerCase()])){a=a.replace(ia,"<$1>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(m.cleanData(ua(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,m.cleanData(ua(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,l=this.length,n=this,o=l-1,p=a[0],q=m.isFunction(p);if(q||l>1&&"string"==typeof p&&!k.checkClone&&na.test(p))return this.each(function(c){var d=n.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(l&&(i=m.buildFragment(a,this[0].ownerDocument,!1,this),c=i.firstChild,1===i.childNodes.length&&(i=c),c)){for(g=m.map(ua(i,"script"),xa),f=g.length;l>j;j++)d=i,j!==o&&(d=m.clone(d,!0,!0),f&&m.merge(g,ua(d,"script"))),b.call(this[j],d,j);if(f)for(h=g[g.length-1].ownerDocument,m.map(g,ya),j=0;f>j;j++)d=g[j],oa.test(d.type||"")&&!m._data(d,"globalEval")&&m.contains(h,d)&&(d.src?m._evalUrl&&m._evalUrl(d.src):m.globalEval((d.text||d.textContent||d.innerHTML||"").replace(qa,"")));i=c=null}return this}}),m.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){m.fn[a]=function(a){for(var c,d=0,e=[],g=m(a),h=g.length-1;h>=d;d++)c=d===h?this:this.clone(!0),m(g[d])[b](c),f.apply(e,c.get());return this.pushStack(e)}});var Ca,Da={};function Ea(b,c){var d,e=m(c.createElement(b)).appendTo(c.body),f=a.getDefaultComputedStyle&&(d=a.getDefaultComputedStyle(e[0]))?d.display:m.css(e[0],"display");return e.detach(),f}function Fa(a){var b=y,c=Da[a];return c||(c=Ea(a,b),"none"!==c&&c||(Ca=(Ca||m("")).appendTo(b.documentElement),b=(Ca[0].contentWindow||Ca[0].contentDocument).document,b.write(),b.close(),c=Ea(a,b),Ca.detach()),Da[a]=c),c}!function(){var a;k.shrinkWrapBlocks=function(){if(null!=a)return a;a=!1;var b,c,d;return c=y.getElementsByTagName("body")[0],c&&c.style?(b=y.createElement("div"),d=y.createElement("div"),d.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(d).appendChild(b),typeof b.style.zoom!==K&&(b.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:1px;width:1px;zoom:1",b.appendChild(y.createElement("div")).style.width="5px",a=3!==b.offsetWidth),c.removeChild(d),a):void 0}}();var Ga=/^margin/,Ha=new RegExp("^("+S+")(?!px)[a-z%]+$","i"),Ia,Ja,Ka=/^(top|right|bottom|left)$/;a.getComputedStyle?(Ia=function(b){return b.ownerDocument.defaultView.opener?b.ownerDocument.defaultView.getComputedStyle(b,null):a.getComputedStyle(b,null)},Ja=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ia(a),g=c?c.getPropertyValue(b)||c[b]:void 0,c&&(""!==g||m.contains(a.ownerDocument,a)||(g=m.style(a,b)),Ha.test(g)&&Ga.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0===g?g:g+""}):y.documentElement.currentStyle&&(Ia=function(a){return a.currentStyle},Ja=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ia(a),g=c?c[b]:void 0,null==g&&h&&h[b]&&(g=h[b]),Ha.test(g)&&!Ka.test(b)&&(d=h.left,e=a.runtimeStyle,f=e&&e.left,f&&(e.left=a.currentStyle.left),h.left="fontSize"===b?"1em":g,g=h.pixelLeft+"px",h.left=d,f&&(e.left=f)),void 0===g?g:g+""||"auto"});function La(a,b){return{get:function(){var c=a();if(null!=c)return c?void delete this.get:(this.get=b).apply(this,arguments)}}}!function(){var b,c,d,e,f,g,h;if(b=y.createElement("div"),b.innerHTML=" a a ").append(m.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},m.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){m.fn[b]=function(a){return this.on(b,a)}}),m.expr.filters.animated=function(a){return m.grep(m.timers,function(b){return a===b.elem}).length};var cc=a.document.documentElement;function dc(a){return m.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}m.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=m.css(a,"position"),l=m(a),n={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=m.css(a,"top"),i=m.css(a,"left"),j=("absolute"===k||"fixed"===k)&&m.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),m.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(n.top=b.top-h.top+g),null!=b.left&&(n.left=b.left-h.left+e),"using"in b?b.using.call(a,n):l.css(n)}},m.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){m.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,m.contains(b,e)?(typeof e.getBoundingClientRect!==K&&(d=e.getBoundingClientRect()),c=dc(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===m.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),m.nodeName(a[0],"html")||(c=a.offset()),c.top+=m.css(a[0],"borderTopWidth",!0),c.left+=m.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-m.css(d,"marginTop",!0),left:b.left-c.left-m.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||cc;while(a&&!m.nodeName(a,"html")&&"static"===m.css(a,"position"))a=a.offsetParent;return a||cc})}}),m.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);m.fn[a]=function(d){return V(this,function(a,d,e){var f=dc(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?m(f).scrollLeft():e,c?e:m(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),m.each(["top","left"],function(a,b){m.cssHooks[b]=La(k.pixelPosition,function(a,c){return c?(c=Ja(a,b),Ha.test(c)?m(a).position()[b]+"px":c):void 0})}),m.each({Height:"height",Width:"width"},function(a,b){m.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){m.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return V(this,function(b,c,d){var e;return m.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?m.css(b,c,g):m.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),m.fn.size=function(){return this.length},m.fn.andSelf=m.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return m});var ec=a.jQuery,fc=a.$;return m.noConflict=function(b){return a.$===m&&(a.$=fc),b&&a.jQuery===m&&(a.jQuery=ec),m},typeof b===K&&(a.jQuery=a.$=m),m});