Multiple form fields autocomplete for SharePoint 20102013 using JavaScript

Introduction 

Filling forms could be painful sometimes, especially for forms with many fields. In this article I'll describe approach which can simplify forms filling significantly. In my case I needed to implement order form interface. In fact it contains a lot of fields I can prefill based on chosen customer, such as address, ZIP code and account number. All of this data is already stored in separate list called "Customers directory". 

Final requirements could looks like this:

When user starts typing in the customer field, I need to suggest list of customer names from Curtomers directory. When user chooses customer from suggestions list, I need to read data multiple field values from Customers directory and fill corresponding fields in the order form. User can correct filled values later if needed. 

To implement such functionality I used to use JavaScript and this case is not an exception. There are many reasons for this:  

• It well fits Office 365 restrictions.
• It easily migrates from older SharePoint versions.
• It is easily to debug without slow SharePoint solution deployment.
• REST SharePoint 2013 API or SPServices are almost such powerful as server code.
• Finally I just like it. 

In this article I'll use SPServices jQuery plugin for communication with SharePoint services. It works for SharePoint 2013 as well as for SharePoint 2010. I'll also use jQuery UI Autocomplete plugin to implement suggestions functionality.

plumFormAutocomplete plugin works well for single field as much as for multiple fields.  Plugin supports text fields only.

Plugin in action looks like this:

How to use plumFormAutocomplete jQuery plugin 

You can use this plugin without looking into the code. Firstly, I'll describe how to use it, then if you still will be interested, you can look inside plugin implementation.

Prerequisites

If you don't have jQuery, jQuery UI or SPServices, you can download fresh version from official sites. For tutorial purposes I assume that names of downloaded files and folders are following:

• jquery.min.js 
• jquery.SPervices.min.js  
• jquery-ui-1.10.3.custom.min.js
• jquery-ui-1.10.3.custom.min.css
• css folder for jQuery UI

I also assume that you have jquery.plumFormAutocomplete.js downloaded from source code of this article (Source code download link).

Upload jquery.min.js, jquery.SPServices.min.js, jquery-ui-1.10.3.custom.min.js and jquery.plumFormAutocomplete.js files to Style Library within your site collection. You also need to upload jQuery UI CSS styles located in the same folder with jquery-ui-1.10.3.custom.min.js. Then open New or Edit form, where autocomplete plugin will be used and add js and CSS links to placeholder PlaceHolderAdditionalPageHead.  You can use following snippet: 

<SharePoint:ScriptLink runat="server" 
  Name="~SiteCollection/Style Library/jquery.min.js" Language="javascript"/>
<SharePoint:ScriptLink runat="server" 
  Name="~SiteCollection/Style Library/jquery.SPServices.min.js" Language="javascript"/>
<SharePoint:ScriptLink runat="server" 
  Name="~SiteCollection/Style Library/jquery-ui-1.10.3/jquery-ui-1.10.3.custom.
    min.js" Language="javascript"/>       
<SharePoint:ScriptLink runat="server" 
  Name="~SiteCollection/Style Library/jquery.plumFormAutocomplete.js" Language="javascript"/>        
<SharePoint:CSSRegistration name="<% $SPUrl:~SiteCollection/Style Library/
  jquery-ui-1.10.3/css/smoothness/jquery-ui-1.10.3.custom.min.css%>" runat="server"/>

Configure and call plugin  

Now you are ready to configure and call plugin. For my case plugin call looks like this:

//get control for autocomplete field
var fieldControl = $.getFieldControl('Title');
                
//call autocomplete plugin for field control
fieldControl.plumFormAutocomplete({
	sourceList: 'Customers directory',
	sourceMatchField: 'Title',
	labelFields: ['Title', 'ZIPCode'],
	labelSeparator: ', ',
	fillConcatenatedLabel: false,
	fieldsMapping: [{sourceField: 'Address', targetField: 'CustAddress'},
			{sourceField: 'AccountNumber', targetField: 'CustAccountNumber'},
			{sourceField: 'ZIPCode', targetField: 'CustZIPCode'}]
});

You can wrap plugin call inside jQuery $(document).ready() function to ensure that code will be executed after page is loaded.

Let us look at this code sample in more detail. Code is divided into two parts:

1. Get control for autocomplete field
2. Call autocomplete plugin for field control

For the first step you need to specify internal name of autocomplete field for getFieldControl function. It is 'Title' in my case.

In the second step you need to call plugin for received autocomplete field and configure plugin options. Plugin options are structured as a single object as any jQuery plugin options.

Plugin options

• sourceList - name or GUID of source list, where suggestions will be taken. It is Customers directory in my case.
• sourceMatchField - internal name of the field in the source list. This field will be used to find matching list items for autocomplete keywords.
• labelFields - an optional parameter, you can specify source list field internal names array. All field values for these  fields will be concatenated with labelSeparator and displayed in autocomplete suggestion as a single string like this: Value1, Value2, ..., ValueN.
• labelSeparator - an optional parameter, it is separator for labelFields concatenation, for example it could be comma with space (', ').
• fillConcatenatedLabel - an optional parameter, set true if you need to fill autocomplete textbox with all concatenated labelFields values, set false if you need to fill autocomplete text box only with single field value.
• fieldsMapping - an optional parameter, it is an array of field mapping objects. Each object declares mapping from source list field to target list field. In my case names of source and target fields are the same. For example Address in Customer directory and Address in Orders list.

Mapping object has following syntax:

{sourceField: 'Internal name of source field', targetField: 'Internal name of target field'}  

Note: You can specify only non optional parameters, plugin will work correctly. This plugin works well as single field autocomplete too, just do not fill optional parameters.

Plugin configuration without optional parameters could look like this:

fieldControl.plumFormAutocomplete({
    sourceList: 'Customers directory',
    sourceMatchField: 'Title'
});

Internal implementation of the plugin

Let us look at the full plugin source code. You can download it here.

There are three major part inside the code:

1. Getting text field input. 
2. Apply jQueryUIi autocomplete plugin and SPServices to get suggestions.
3. Implementing helper functions.

To get field input I used jQuery selectors and simple regular expression. Unfortunately SharePoint doesn't provide any method to get field controls from JavaScript, it only stores field internal name inside html comment in the following format:

<!-- FieldName="Title"
FieldInternalName="Title"
FieldType="SPFieldText"
-->  

So, I had to parse it to find control I needed. Final function was added to jQuery:

JavaScript

//function gets text field control by internal name
$.getFieldControl = function (fieldInternalName) {
  var regexStr = 'FieldInternalName="' + fieldInternalName + '"'
  var regex = new RegExp(regexStr, 'i');
  var fieldCell = $('td.ms-formbody').filter(function () { 
    return (regex).test($(this).html()) 
  });
  return $(fieldCell.find('input')[0]);
} 

In the next step I applied jQuery UI autocomplete plugin and implemented source and select plugin functions. Source function calls source list using SPServices and CAML to get suggestions. When suggestion found, I store all mapped field values inside autcomplete object:

JavaScript

source: function (request, response) {
    var autocompleteVals = [];
    var k = 0;

    $().SPServices({
        operation: "GetListItems",
        async: false,
        listName: options.sourceList,
        CAMLViewFields: getViewFields(options.fieldsMapping),
        CAMLQuery: getCamlQuery(options.sourceMatchField, request.term),
        completefunc: function (xData, Status) {
            $(xData.responseXML).SPFilterNode("z:row").each(function () {
                var queryResult = this;
                var fieldsValues = getFieldsValues(options.fieldsMapping, queryResult);                            
                var labelText = getLabelText(fieldsValues);
                autocompleteVals[k] = {
                    label: labelText,
                    value: options.fillConcatenatedLabel ? labelText  : 
                      extractFieldValue(fieldsValues, options.sourceMatchField), 
                    fieldsValues: fieldsValues
                };

                k++;
                
                function getLabelText(fieldValues){
                    var result = '';
                    if(options.labelFields){
                        for(i = 0; i < options.labelFields.length; i++)
                        {	                            		
                            var fieldName = options.labelFields[i];
                            var fieldVal = extractFieldValue(fieldValues, fieldName);
                            if(fieldVal != ''){
                            	if(i > 0){
                                	result += options.labelSeparator;
                            	}
                                result += fieldVal;
                            }
                        }	                            	
                    } else {
                         result += extractFieldValue(fieldValues, options.sourceMatchField);
                    }
                    return result;
                }
            });
            response(autocompleteVals);
        }
    });
}

Select function fills values inside mapped fields according to matched item from source lists. It reads values stored inside ui.item and fills corresponding fields based on suggestion selection.

JavaScript

select: function (event, ui) {
    //Fill all depended fields
    $.each(ui.item.fieldsValues, function () {
        var fieldVal = this;
        var fieldInput = $.getFieldControl(fieldVal.key);

        var outputVal = fieldVal.value;
        if (outputVal) {
            var lookupSeparator = ';#';
            if (outputVal.indexOf(lookupSeparator) != -1) {
                var ind = outputVal.indexOf(lookupSeparator);
                var length = lookupSeparator.length;
                var startInd = ind + length;
                outputVal = outputVal.substring(startInd, outputVal.lenght)
            }

            fieldInput.val(outputVal);
        }
    });
}

Maybe you discovered that there are three helper functions inside plugin: getFieldsValues, getViewFields, and getCamlQuery.

getFieldsValues parses SPServices response and fills autocomplete object according to specified fields mapping.

JavaScript

//get values for all mapped fields
function getFieldsValues(fieldsMapping, queryResult) {
    var result = [];
    $.each(fieldsMapping, function () {
        var fieldMapping = this;
        var val = $(queryResult).attr("ows_" + fieldMapping.sourceField)
        result.push({ key: fieldMapping.targetField, value: val, sourceKey: fieldMapping.sourceField});
    });
    
    var sourceVal = $(queryResult).attr("ows_" + options.sourceMatchField);
    result.push({ value: sourceVal , sourceKey: options.sourceMatchField});
    
    return result;
}

getViewFields generates ViewFields xml for CAML query according to fields mapping.

JavaScript

//get view fields for all mapped fields
function getViewFields(fieldsMapping) {
    var result = "<ViewFields>";
    var isSourceFieldAdded = false;

	if(fieldsMapping){
		$.each(fieldsMapping, function () {
            var mapping = this;
            var viewField = "<FieldRef Name='" + 
                    mapping.sourceField + "'/>";
            result += viewField;
        });
        
        isSourceFieldAdded = fieldsMapping.filter(function(){
				            	return this.sourceField == options.sourceMatchField;
    						 }).length > 0;
	}            
                
	if(!isSourceFieldAdded){			
		result += "<FieldRef Name='" + options.sourceMatchField + "'/>";
	}            
    
    result += "</ViewFields>";
    return result;
}

getCamlQuery generates CAML query according to filter column internal name and keyword from input.

JavaScript

//get CAML query for keyword
function getCamlQuery(colname, keyword) {
    var where = "<Where><Contains><FieldRef Name='" + colname + 
      "'></FieldRef><Value Type='Text'>" + keyword + 
      "</Value></Contains></Where>"
    var orderBy = "<OrderBy><FieldRef Name='" + colname + "' Ascending='True' /></OrderBy>"
    var query = "<Query>" + where + orderBy + "</Query>";
    return query;
}

• Source code download link

Updates

03.10.2013

• Additional optional parameters added: labelFields, labelSeparator, fillConcatenatedLabel.
• Reading lookup fields from source list implemented. 
• Minor bug fixes.