Cacher is the code snippet organizer for pro developers

var Adacta = Adacta || {};
Adacta.CRM = Adacta.CRM || {};
Adacta.CRM.CrmFormType = {
	Undefined: 0,
	Create: 1,
	Update: 2,
	ReadOnly: 3,
	Disabled: 4
} 

/* Math functions */
Adacta.CRM.Round = function (number, precision) {
    var factor = Math.pow(10, precision);
    var tempNumber = number * factor;
    var roundedTempNumber = Math.round(tempNumber);
    return roundedTempNumber / factor;
};

/* Get attribute value */
Adacta.CRM.GetControl = function (attributeName)
{
	var controlObj = Xrm.Page.getControl(attributeName);
	if (controlObj)
	{
		return controlObj;
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetControl', false);
	}
	return null;
}
Adacta.CRM.GetAttribute = function (attributeName)
{
	var controlObj = Xrm.Page.getAttribute(attributeName);
	if (controlObj)
	{
		return controlObj;
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetAttribute', false);
	}
	return null;
}
Adacta.CRM.GetLookupText = function (attributeName, defaultValue)
{
	var lookupAttributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (lookupAttributeObj)
	{
		var lookupValueObj = lookupAttributeObj.getValue();
		if (lookupValueObj && lookupValueObj.length > 0)
		{
			return lookupValueObj[0].name;
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetLookupText', false);
	}
	return defaultValue;
}
Adacta.CRM.GetLookupId = function (attributeName, defaultValue)
{
	var lookupAttributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (lookupAttributeObj)
	{
		var lookupValueObj = lookupAttributeObj.getValue();
		if (lookupValueObj && lookupValueObj.length > 0)
		{
			return lookupValueObj[0].id;
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetLookupId', false);
	}
	return defaultValue;
}
Adacta.CRM.GetLookupFieldValue = function (attributeName, defaultValue)
{
	var textSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (textSetattributeObj != null)
	{
		return textSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetLookupFieldValue', false);
	}
	return defaultValue;
}
Adacta.CRM.GetOptionSetValue = function (attributeName, defaultValue)
{
	var optionSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (optionSetattributeObj != null)
	{
		return optionSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetOptionSetValue', false);
	}
	return defaultValue;
}
Adacta.CRM.GetOptionSetText = function (attributeName, defaultValue)
{
	var optionSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (optionSetattributeObj != null)
	{
		return optionSetattributeObj.getText();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetOptionSetText', false);
	}
	return defaultValue;
}
Adacta.CRM.GetDecimalFieldValue = function (attributeName, defaultValue)
{
	var textSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (textSetattributeObj != null)
	{
		return textSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetDecimalFieldValue', false);
	}
	return defaultValue;
}                                        a
Adacta.CRM.GetNumberFieldValue = function (attributeName, defaultValue)
{
	var textSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (textSetattributeObj != null)
	{
		return textSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetNumberFieldValue', false);
	}
	return defaultValue;
}
Adacta.CRM.GetTextFieldValue = function (attributeName, defaultValue)
{
	var textSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (textSetattributeObj != null)
	{
		return textSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetTextFieldValue', false);
	}
	return defaultValue;
}
Adacta.CRM.GetBoolFieldValue = function (attributeName, defaultValue)
{
	var textSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (textSetattributeObj != null)
	{
		return textSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetBoolFieldValue', false);
	}
	return defaultValue;
}
Adacta.CRM.GetDateFieldValue = function (attributeName, defaultValue)
{
	var dateSetattributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (dateSetattributeObj != null)
	{
		return dateSetattributeObj.getValue();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.GetDateFieldValue', false);
	}
	return defaultValue;
} 

/* Set attribute value */
Adacta.CRM.SetTextFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetTextFieldValue', false);
	}
}
Adacta.CRM.SetDecimalFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetDecimalFieldValue', false);
	}
}
Adacta.CRM.SetDoubleFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetDoubleFieldValue', false);
	}
}
Adacta.CRM.SetNumberFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetNumberFieldValue', false);
	}
}
Adacta.CRM.SetCurrencyFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetCurrencyFieldValue', false);
	}
}
Adacta.CRM.SetBoolFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetBoolFieldValue', false);
	}
}
Adacta.CRM.SetOptionSetFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetOptionSetFieldValue', false);
	}
}
Adacta.CRM.SetDateFieldValue = function (attributeName, attributeValue, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(attributeValue);
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetDateFieldValue', false);
	}
}
Adacta.CRM.SetLookupFieldValue = function (attributeName, entityId, name, logicalName, ignoreFormWritable, fireOnChange, ignoreSetValueError)
{
	try
	{
		
		if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
		{
			return;
		}
		var attributeObj = Xrm.Page.getAttribute(attributeName);
		if (attributeObj)
		{
			if (entityId)
			{
				//the shananigans in this if, helps preventing crm from reissuing onchange event
				/*if (entityId.indexOf('{') == -1)
				{   
					entityId = '{' + entityId;
				}
				
				if (entityId.indexOf('}') == -1)
				{
					entityId = entityId + '}';
				}
			       
			    entityId = entityId.toUpperCase();*/
			    // replace {}
			    entityId = entityId.replace("{","").replace("}","")+"";
		    }
		    
		    if (typeof ignoreSetValueError != undefined && ignoreSetValueError)
		    {
				try
				{
					
					attributeObj.setValue(null);
					var lookupValue = new Array();
					lookupValue[0] = new Object();
					lookupValue[0].id = entityId;
					lookupValue[0].name = name;
					lookupValue[0].entityType = logicalName;
					attributeObj.setValue(lookupValue);					
				}
				catch(ie)
				{
					var lookupValue = new Array();
					lookupValue[0] = new Object();
					lookupValue[0].id = entityId;
					lookupValue[0].name = name;
					lookupValue[0].entityType = logicalName;
					attributeObj.setValue(lookupValue);
				}
			}
			else
			{
				var lookupValue = new Array();
				lookupValue[0] = new Object();
				lookupValue[0].id = entityId;
				lookupValue[0].name = name;
				lookupValue[0].entityType = logicalName;
				attributeObj.setValue(lookupValue);
			}
			if (fireOnChange)
			{
				Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
			}
			if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
			{
				attributeObj.setSubmitMode("always"); //readonly field, always submit
			}
			else
			{
				attributeObj.setSubmitMode("dirty");
			}
		}
		else
		{
			Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetLookupFieldValue', false);
		}
	}
	catch(e)
	{
		Adacta.CRM.WriteExceptionWithMessageToLog(e, 'Error setting value for field: ' + attributeName + '.', 'Adacta.CRM.SetLookupFieldValue', false);
		throw(e);
	}
}
Adacta.CRM.ClearFieldValue = function (attributeName, ignoreFormWritable, fireOnChange)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.data.entity.attributes.get(attributeName);
	if (attributeObj)
	{
		attributeObj.setValue(null);
		
		if (fireOnChange)
		{
			Adacta.CRM.ForceFieldChange(attributeName, ignoreFormWritable); //fire OnChange event handlers
		}
			
		if (Xrm.Page.getControl(attributeName) && Xrm.Page.getControl(attributeName).getDisabled())
		{
			attributeObj.setSubmitMode("always"); //readonly field, always submit
		}
		else
		{
			attributeObj.setSubmitMode("dirty");
		}
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.ClearFieldValue', false);
	}
}

/*Form Validation*/
Adacta.CRM.IsFormValid = function(showErrors)
{
	try
	{
		var valid = true;
		if (!Xrm || !Xrm.Page || !Xrm.Page.data || !Xrm.Page.data.entity || !Xrm.Page.data.entity.attributes)
		{
			return false;	
		}
		
		Adacta.CRM.ClearNotification('_FormValidation_');
		Xrm.Page.data.entity.attributes.forEach(function (attribute, index) {
			if (attribute.getRequiredLevel() == "required") {
				if(attribute.getValue() == null)
				{
					if(valid)
					{
						var control = attribute.controls.get(0);
						if (showErrors)
						{
							//Adacta.CRM.AddFormNotification = function (uniqueId, message, level)
							Adacta.CRM.AddFormNotification('_FormValidation_',control.getLabel() + ' is missing a value',1);
						}
					control.setFocus();
					}
					valid = false;
				}
			}
		});
		
		return valid;
	}
	catch(e)
	{
		Adacta.CRM.WriteExceptionToLog(e,'Adacta.CRM.IsFormValid', false);
	}
}

Adacta.CRM.SetFieldSubmitMode = function (attributeName, submitMode, ignoreFormWritable)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.getAttribute(attributeName);
	if (attributeObj)
	{
		attributeObj.setSubmitMode(submitMode);
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.SetFieldSubmitMode', false);
	}
}
Adacta.CRM.ForceFieldChange = function (attributeName, ignoreFormWritable)
{
	if (!Adacta.CRM.IsFormWritable() && !ignoreFormWritable)
	{
		return;
	}
	var attributeObj = Xrm.Page.getAttribute(attributeName);
	if (attributeObj)
	{
		attributeObj.fireOnChange();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + attributeName + ' not found.', 'Adacta.CRM.ForceFieldChange', false);
	}
} 

/*Form parameters*/
Adacta.CRM.GetFormParameter = function(name, defaultValue)
{
	try
	{
		var params = Xrm.Page.context.getQueryStringParameters();
		if (params)
		{
			var parameter = params[name];
			if (typeof parameter !== 'undefined')
			{
				return parameter;
			}
			return defaultValue;
		}
	}
	catch(e)
	{
		Adacta.CRM.WriteExceptionToLog(e,'Adacta.CRM.IsFormValid', false);
	}
}

/*Form type functions*/
Adacta.CRM.IsFormWritable = function ()
{
	var formType = Xrm.Page.ui.getFormType();
	return formType == Adacta.CRM.CrmFormType.Create || Adacta.CRM.CrmFormType.Update;
}
Adacta.CRM.IsCreateForm = function ()
{
	var formType = Xrm.Page.ui.getFormType();
	return formType == Adacta.CRM.CrmFormType.Create;
}
Adacta.CRM.IsUpdateForm = function ()
{
	var formType = Xrm.Page.ui.getFormType();
	return formType == Adacta.CRM.CrmFormType.Update;
} 

/*Visibility functions*/
Adacta.CRM.makeFieldMandatory = function (fieldName)
{
	var field = Xrm.Page.data.entity.attributes.get(fieldName);
	if (field)
	{
		field.setRequiredLevel('required');
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.makeFieldMandatory', false);
	}
}
Adacta.CRM.makeFieldNonMandatory = function (fieldName)
{
	try
	{
		var field = Xrm.Page.data.entity.attributes.get(fieldName);
		if (field)
		{
			field.setRequiredLevel('none');
		}
		else
		{
			Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.makeFieldNonMandatory', false);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.makeFieldRecommended = function (fieldName)
{
	var field = Xrm.Page.data.entity.attributes.get(fieldName);
	if (field)
	{
		field.setRequiredLevel('recommended');
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.makeFieldRecommended', false);
	}
}
Adacta.CRM.showField = function (fieldName)
{
	var field = Xrm.Page.ui.controls.get(fieldName);
	if (field)
	{
		field.setVisible(true);
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.showField', false);
	}
}
Adacta.CRM.setFocus = function (fieldName)
{
	var field = Xrm.Page.ui.controls.get(fieldName);
	if (field)
	{
		field.setFocus();
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.setFocus', false);
	}
}
Adacta.CRM.hideField = function (fieldName)
{
	var field = Xrm.Page.ui.controls.get(fieldName);
	if (field)
	{
		field.setVisible(false);
	}
	else
	{
		Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.hideField', false);
	}
}
Adacta.CRM.enableField = function (fieldName)
{
	try
    {
        var formState = Xrm.Page.ui.getFormType();
        if (formState == 3 || formState == 4) {
            return;
        }

		var control = Xrm.Page.ui.controls.get(fieldName);
		if (control)
		{
			control.setDisabled(false);
		}
		else
		{
			Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.enableField', false);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.disableField = function (fieldName, makeNonMandatory)
{
	try
    {
        var formState = Xrm.Page.ui.getFormType();
        if (formState == 3 || formState == 4) {
            return;
        }

		var control = Xrm.Page.ui.controls.get(fieldName);
		if (control)
		{
			control.setDisabled(true);
			
			if (makeNonMandatory)
			{
				Adacta.CRM.makeFieldNonMandatory(fieldName);
			}
		}
		else
		{
			Adacta.CRM.WriteToLog('Field: ' + fieldName + ' not found.', 'Adacta.CRM.disableField', false);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}

Adacta.CRM.showTab = function (tabName)
{
	try
	{
		Xrm.Page.ui.tabs.get(tabName).setVisible(true);
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.hideTab = function (tabName)
{
	try
	{
		Xrm.Page.ui.tabs.get(tabName).setVisible(false);
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.expandTab = function (tabName)
{
	try
	{
		Adacta.CRM.showTab(tabName);
		Xrm.Page.ui.tabs.get(tabName).setDisplayState('expanded');
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.collapseTab = function (tabName, hideTab, makeFieldsNonMandatory)
{
	try
	{
		var tab = Xrm.Page.ui.tabs.get(tabName);
		if (!tab)
		{
			Adacta.CRM.WriteToLog('Tab: ' + tabName + ' not found.', 'Adacta.CRM.collapseTab', false);
			return;
		}
		tab.setDisplayState('collapsed');
		
		if (hideTab)
		{
			Adacta.CRM.hideTab(tabName);
		}
		
		if (makeFieldsNonMandatory)
		{
			tab.sections.forEach(function (section, index) 
			{
			  Adacta.CRM.makeSectionFieldsNonMandatory(tabName, section.getName());
			});
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}

Adacta.CRM.hideSection = function (tabName, sectionName, makeFieldsNonMandatory)
{
	try
	{
		Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName).setVisible(false);
		if (makeFieldsNonMandatory)
		{
			Adacta.CRM.makeSectionFieldsNonMandatory(tabName, sectionName);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}

Adacta.CRM.showSection = function (tabName, sectionName)
{
	try
	{
		Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName).setVisible(true);
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.setHeaderFieldRequiredLevel = function (fieldName, requiredLevel)
{
	var field = Xrm.Page.getControl(fieldName);
	if (field)
	{
		field.setRequiredLevel('recommended');
	}
}
Adacta.CRM.makeSectionFieldsNonMandatory = function (tabName, sectionName)
{
	try
	{
		var section = Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName);
		if (!section)
		{
			return;
		}
		var controls = section.controls.get();
		var controlsLenght = controls.length;
		for (var i = 0; i < controlsLenght; i++)
		{
			var attribute = controls[i].getAttribute();
			if (attribute)
			{
				Adacta.CRM.makeFieldNonMandatory(attribute.getName());
			}
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.setSectionFieldsDisabled = function (tabName, sectionName)
{
	try
	{
		var section = Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName);
		if (!section)
		{
			return;
		}
		var controls = section.controls.get();
		var controlsLenght = controls.length;
		for (var i = 0; i < controlsLenght; i++)
		{
			controls[i].setDisabled(true);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}

Adacta.CRM.setSectionFieldsEnabled = function (tabName, sectionName)
{
	try
	{
		var section = Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName);
		if (!section)
		{
			return;
		}
		var controls = section.controls.get();
		var controlsLenght = controls.length;
		for (var i = 0; i < controlsLenght; i++)
		{
			controls[i].setDisabled(false);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}

Adacta.CRM.clearSectionFields = function (tabName, sectionName, fireOnChange)
{
	try
	{
		var section = Xrm.Page.ui.tabs.get(tabName).sections.get(sectionName);
		if (!section)
		{
			return;
		}
		var controls = section.controls.get();
		var controlsLenght = controls.length;
		for (var i = 0; i < controlsLenght; i++)
		{
			controls[i].getAttribute().setValue(null);
			//Adacta.CRM.ClearFieldValue(controls[i].getAttribute().getName(),false,fireOnChange);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.changeFieldLabel = function (fieldName, fieldLabel)
{
	try
	{
		var fieldControl = Xrm.Page.ui.controls.get(fieldName);
		if (fieldControl)
		{
			fieldControl.setLabel(fieldLabel);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.clearFieldNotifications = function (fieldName)
{
	try
	{
		var fieldControl = Xrm.Page.getControl(fieldName);
		if (fieldControl)
		{
			fieldControl.clearNotification();
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.setFieldNotifications = function (fieldName, message)
{
	try
	{
		var fieldControl = Xrm.Page.getControl(fieldName);
		if (fieldControl)
		{
			fieldControl.setNotification(message);
		}
	}
	catch (e)
	{}
} 

/*BPF Header field manipulation*/
Adacta.CRM.setHeaderFieldNonMandatory = function (fieldName)
{
	try
	{
		var headerControl = Xrm.Page.getControl('header_process_' + fieldName);
		if (headerControl)
		{
			var headerAttribute = headerControl.getAttribute();
			if (headerAttribute)
			{
				headerAttribute.setRequiredLevel('none');
			}
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.hideHeaderField = function (fieldName, show)
{
	try
	{
		var headerControl = Xrm.Page.getControl('header_process_' + fieldName);
		if (headerControl)
		{
			headerControl.setVisible(show);
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
} 

/*Form notifications*/
Adacta.CRM.ClearNotification = function (uniqueId)
{
	try
	{
		if (Notify !== undefined)
		{
			//use notify solution for notification
			if (Notify.remove = typeof fn === 'function')
			{
				Notify.remove(uniqueId);				
			}
		}
	}
	catch(e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
		try
		{
			Xrm.Page.ui.clearFormNotification(uniqueId);
		}
		catch(e2)
		{
			Adacta.CRM.WriteExceptionToLog(e2);
		}
	}
} 
Adacta.CRM.AddFormNotification = function (uniqueId, message, level)
{
	try
	{
		if (Notify !== undefined)
		{
			var notificationLevel = "";
			
			//just in case we get passed a numeric value
			switch(level)
			{
				case "1":
				{
					notificationLevel = "ERROR";
					break;
				}
				case "2":
				{
					notificationLevel = "INFO";
					break;
				}
				case "3":
				{
					notificationLevel = "WARNING";
					break;
				}
				default:
				{
					notificationLevel = level;
				}
			}
			
			//use notify solution for notification
			if (typeof Notify.add === 'function')
			{
				Notify.add(message,notificationLevel, uniqueId);
				return;
			}
		}
	}
	catch(e)
	{
		Adacta.CRM.WriteExceptionToLog(e);		
	}
	
	try
	{		
		//since notify.js supports more than CRM, and does not support numeric values we need to map to numeric		
		switch(level)
		{
			case "INFO":
			case "SUCCESS":
			case "QUESTION":
			case "LOADING":
			{
				level = 2
				break;
			}
			case "ERROR":
			{
				level = 1;
				break;
			}
			case "WARNING":
			{
				level = 3;
				break;
			}
			default:
			{
				level = 2;
				break;
			}
		}
		
		if (Xrm.Page.ui.setFormNotification !== undefined) 
		{           
		    if (!!uniqueId) 
		    {
		        Xrm.Page.ui.clearFormNotification(uniqueId);
		        if (level === 1) 
		        {
		            //Error
		            Xrm.Page.ui.setFormNotification(message, "ERROR", uniqueId);
		        }
		        if (level === 2) 
		        {
		            //Info
		            Xrm.Page.ui.setFormNotification(message, "INFO", uniqueId);
		        }
		        if (level === 3) 
		        {
		            //Warning
		            Xrm.Page.ui.setFormNotification(message, "WARNING", uniqueId);
		        }
		    } 
		    else 
		    {
		        var tempUniqueId = "formNotification00";
		        Xrm.Page.ui.clearFormNotification(tempUniqueId);
		        if (level === 1) 
		        {
		            //Error
		            Xrm.Page.ui.setFormNotification(message, "ERROR", tempUniqueId);
		        }
		        if (level === 2) 
		        {
		            //Info
		            Xrm.Page.ui.setFormNotification(message, "INFO", tempUniqueId);
		        }
		        if (level === 3) 
		        {
		            //Warning
		            Xrm.Page.ui.setFormNotification(message, "WARNING", tempUniqueId);
		        }
		    }
		}   
	}
	catch(e2)
	{
		Adacta.CRM.WriteExceptionToLog(e2);
	}
} 

/* General helper functions */
Adacta.CRM.MakeAllFieldsNonMandatory = function ()
{
	try{
		Xrm.Page.data.entity.attributes.forEach(function (attribute, index) {
		  var attributeName = attribute.getName();
		  Adacta.CRM.makeFieldNonMandatory(attributeName);
		});
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.MakeFieldReadOnly = function (control) {
    try {
        if (typeof control.getDisabled !== 'undefined' && !control.getDisabled()) {
            control.setDisabled(true);
        }
    }
    catch (e) {
        Adacta.CRM.WriteExceptionToLog(e);
    }
}
Adacta.CRM.MakeFieldsReadOnly = function ()
{
    try {
        var controls = Xrm.Page.ui.controls.get();
        for (var i in controls) {
            var control = controls[i];
            Adacta.CRM.MakeFieldReadOnly(control);
        }
    }
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.RefreshQuickViewForm = function (lookupFieldName)
{
	try
	{
		var fieldValue = Adacta.CRM.GetLookupFieldValue(lookupFieldName);
		var fieldControl = Xrm.Page.getControl(lookupFieldName);
		if (fieldValue && fieldControl)
		{
			Adacta.CRM.ClearFieldValue(lookupFieldName);
			Adacta.CRM.SetLookupFieldValue(lookupFieldName, fieldValue[0].id, fieldValue[0].name, fieldValue[0].entityType);
			//Adacta.CRM.ForceFieldChange(lookupFieldName);
			if (Xrm.Page.getControl(attributeName).getDisabled())
			{
				//no need to force submit of a readonly field since we did not change a thing
				Adacta.CRM.SetFieldSubmitMode(lookupFieldName, 'never');
			}
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
}
Adacta.CRM.GetCurrentUser = function ()
{
	return {
		id: Xrm.Page.context.getUserId(),
		name: Xrm.Page.context.getUserName(),
		logicalName: 'systemuser'
	};
}
Adacta.CRM.IsUserSystemAdministrator = function ()
{
	return XrmServiceToolkit.Soap.IsCurrentUserRole('System Administrator');
}
Adacta.CRM.GetFormDirtyFields = function ()
{
	try
	{
		var dirtyFields = [];
		var attributes = Xrm.Page.data.entity.attributes.get();
		for (var i in attributes)
		{
			var attribute = attributes[i];
			if (attribute.getIsDirty())
			{
				dirtyFields.push(attribute.getName());
				Adacta.CRM.WriteToLog("Dirty attribute:" + attribute.getName(), "Adacta.CRM.GetFormDirtyFields");
			}
		}
		return dirtyFields;
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
		return null;
	}
}
Adacta.CRM.OpenFormNewWindow = function (entityLogicalName, entityId, parameters)
{
	var windowOptions = {
		openInNewWindow: true
	};
	Xrm.Utility.openEntityForm(entityLogicalName, entityId, parameters, windowOptions);
} 

/* XrmServiceToolkit helper functions */
Adacta.CRM.TryGetXrmToolkitValue = function (xrmToolkitAttribute, defaultValue)
{
	try
	{
		if (xrmToolkitAttribute && xrmToolkitAttribute.id)
		{
			return {
				id: xrmToolkitAttribute.id,
				name: xrmToolkitAttribute.name,
				logicalName: xrmToolkitAttribute.logicalName
			}
		}
		if (!xrmToolkitAttribute)
		{
			return defaultValue;
		}
		return xrmToolkitAttribute.value;
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
		return defaultValue;
	}
} 

/* Form change functions */
Adacta.CRM.ChangeForm = function (newFormId)
{
	try
	{
		var formItem = Xrm.Page.ui.formSelector.getCurrentItem();
		if (formItem == null)
		{
			return;
		}
		var currentFormId = formItem.getId().toLowerCase();
		newFormId = newFormId.toLowerCase();
		if (currentFormId != newFormId)
		{
			//change the form cause ids are different
			var availableForms = Xrm.Page.ui.formSelector.items.get();
			for (var i in availableForms)
			{
				var form = availableForms[i];
				if (form.getId().toLowerCase() == newFormId.toLowerCase())
				{
					form.navigate();
					return true;
				}
			}
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e);
	}
	return false;
} 

/* Quick forms */
Adacta.CRM.RefreshQuickView = function(qvFormName)
{
	try
	{		
		var quickViewControl = Xrm.Page.ui.quickForms.get(qvFormName);
		if (quickViewControl != undefined)
		{
			quickViewControl.refresh();
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionToLog(e,"Adacta.CRM.RefreshQuickView");
	}
}

/* prefilter lookup function */
Adacta.CRM.PreFilterLookup = function () {

    var preFilterByValue = function (controlName, value, filterByAttributeName) {
        try {
            var control = Xrm.Page.getControl(controlName);

            if (!control) {
                Adacta.CRM.WriteToLog("Unable to find control with name:" + controlName, "Adacta.CRM.PreFilterLookup.SimplePreFilter");
                return;
            }

            control.addPreSearch(function () {
                try {
                    if (value != null) {
                        fetchXml = "<filter type='and'><condition attribute='" + filterByAttributeName + "' operator='eq' value='" + value + "' /></filter>";
                        Xrm.Page.getControl(controlName).addCustomFilter(fetchXml);
                    }
                }
                catch (e) {
                    Adacta.CRM.WriteExceptionWithMessageToLog(e, "Error executing preSearchFilterFunction for control: " + controlName, 'Adacta.CRM.PreFilterLookup.SimplePrefilter.addPreSearch', true);
                }
            });
        }
        catch (e) {
            Adacta.CRM.WriteExceptionWithMessageToLog(e, "Error appying preFilterByValue for control: " + controlName, 'Adacta.CRM.PreFilterLookup.PreFilterByValue', true);
        }
    }

	var simplePreFilter = function (controlName, valueAttributeName, filterByAttributeName) 
	{
        try {
            var valueAttributeObject = Xrm.Page.data.entity.attributes.get(valueAttributeName);

            var attributeValue = null;
            if (valueAttributeObject != null) {
                attributeValue = valueAttributeObject.getValue();
                if (attributeValue && attributeValue.length && attributeValue.length > 0) {
                    attributeValue = attributeValue[0].id;
                }
            }
            else {
                Adacta.CRM.WriteToLog('Field [valueAttributeName]: ' + valueAttributeName + ' not found.', 'Adacta.CRM.PreFilterLookup.SimplePreFilter', false);
            }

            preFilterByValue(controlName, attributeValue, filterByAttributeName);
        }
        catch (e) {
            Adacta.CRM.WriteExceptionWithMessageToLog(e, "Error appying simplePreFilter for control: " + controlName, 'Adacta.CRM.PreFilterLookup.SimplePrefilter', true);
        }
	}
	
	var complexPreFilter = function (controlName, fetchXmlFilter) 
	{
		try
		{
			var control = Xrm.Page.getControl(controlName);
			
			if (!control)
			{
				Adacta.CRM.WriteToLog("Unable to find control with name:" + controlName, "Adacta.CRM.PreFilterLookup.complexPreFilter");
				return;
			}
			
			control.addPreSearch(function () 
			{
				try
				{
					if (fetchXmlFilter != null && fetchXmlFilter !== '') 
				    {
				        Xrm.Page.getControl(controlName).addCustomFilter(fetchXmlFilter);
					}
				}
				catch(e)
				{
					Adacta.CRM.WriteExceptionWithMessageToLog(e, "Error executing preSearchFilterFunction for control: " + controlName, 'Adacta.CRM.PreFilterLookup.complexPreFilter.addPreSearch', true);
				}
			});	
		}
		catch(e)
		{
			Adacta.CRM.WriteExceptionWithMessageToLog(e, "Error appying simpleFilter for control: " + controlName, 'Adacta.CRM.PreFilterLookup.complexPreFilter', true);
		}
	}
	
    return {
        PreFilterByValue: preFilterByValue,
		SimplePrefilter: simplePreFilter,
		ComplexPrefilter : complexPreFilter 
	};
}();

/* comparison functions */
Adacta.CRM.AreIdsEqual = function (id1, id2)
{
	if (typeof id1 === 'undefined' || typeof id2 === 'undefined' || id1==null || id2==null)
	{
		return false;
	}
	//remove the brackets and change case
	id1 = id1.replace(/{|}|/gi,'').toUpperCase();
	id2 = id2.replace(/{|}|/gi,'').toUpperCase();
	
	return id1 == id2;
}

/* Diagnostics & logging functions */
Adacta.CRM.GetDirtyFields = function()
{
	try
	{
		var attributes = Xrm.Page.data.entity.attributes.get() ;
		for (var i in attributes)
		{
			var attribute = attributes[i];
			if (attribute.getIsDirty() || attribute.getSubmitMode() == "always")
			{
				console.log("Attribute dirty: " + attribute.getName());
			}
		}
	}
	catch (e)
	{
		Adacta.CRM.WriteExceptionWithMessageToLog(e, 'Adacta.CRM.PreFilterLookup.complexPreFilter', false);
	}
}
Adacta.CRM.WriteToLog = function (message, component, writeToTrace)
{
	try
	{
		var date = new Date();
		if (component)
		{
			console.log(date.toLocaleString() + ":" + component + ": " + message);
		}
		else
		{
			console.log(date.toLocaleString() + ":" + message);
		}
	}
	catch (e)
	{}
}
Adacta.CRM.WriteExceptionToLog = function (e, component, writeToTrace)
{
	try
	{
		var date = new Date();
		if (component)
		{
			console.log(date.toLocaleString() + ":" + component + ": " +  e.message);
		}
		else
		{
			console.log(date.toLocaleString() + ":" +  e.message);
		}
		if (typeof e.stack != 'undefined')
		{
			console.log(date.toLocaleString() + ":" + e.stack);
		}		
	}
	catch (e)
	{}
}
Adacta.CRM.WriteExceptionWithMessageToLog = function (e, message, component, writeToTrace)
{
	try
	{
		var date = new Date();
		if (component)
		{
			console.log(date.toLocaleString() + ":" + component + ": " + message);
		}
		else
		{
			console.log(date.toLocaleString() + ":" + message);
		}
		
		console.log(date.toLocaleString() + ":" + e.message);
		
		if (typeof e.stack != 'undefined')
		{
			console.log(date.toLocaleString() + ":" + e.stack);
		}
	}
	catch (e)
	{}
}
Adacta.CRM.PopulateOptionSet = function (attributeName, optionsarray)
{
	try
	{
		var pickList = Xrm.Page.getControl(attributeName);
    	var removeoptions = pickList.getOptions();
    	var setoptions = [];
    	
    	//check allowed options
    	for (var i = 0; i < removeoptions.length; i++){
    		for (var j = 0; j < optionsarray.length; j++){
    			if(removeoptions[i].value==optionsarray[j].value){
    				setoptions.push(optionsarray[j]);
    			}
    		}
    	}
    	
    	//remove all options
    	for (var i = 0; i < removeoptions.length; i++) 
        pickList.removeOption(removeoptions[i].value);
        
        //set new options
        for (var i = 0; i < setoptions.length; i++) 
        pickList.addOption(setoptions[i]);
        
	}	
	catch(e)
	{
		Adacta.CRM.WriteToLog(e.message,'Adacta.CRM.PopulateOptionSet');
	}
}
Adacta.CRM.ReplaceAll = function(targetString, findString, replaceString, ignore) 
{
    return targetString.replace(new RegExp(findString.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(replaceString)=="string")?replaceString.replace(/\$/g,"$$$$"):replaceString);
} 

/* Check if user is in array of roles */
Adacta.CRM.IsInSecurityRoles = function (roles) {

    var fetch = "<fetch mapping='logical' version='1.0' >" +
        "<entity name= 'systemuser' >" +
        "<attribute name='systemuserid' />" +
        "<filter type='and' >" +
        "<condition attribute='systemuserid' operator='eq-userid' />" +
        "</filter>" +
        "<link-entity name='systemuserroles' from='systemuserid' to='systemuserid' link-type='inner' >" +
        "<link-entity name='role' from='roleid' to='roleid' link-type='inner' >" +
        "<filter type='or' >";
    roles.forEach(function (role) {
        fetch += "<condition attribute='name' operator='eq' value='" + role + "' />";
    });
    fetch += "</filter>" +
        "</link-entity>" +
        "</link-entity>" +
        "</entity >" +
        "</fetch >";

    var results = XrmServiceToolkit.Soap.Fetch(fetch);

    if (results == null || results == undefined || results.length == 0)
        return false;

    return true;
};