Summary

Class:	Xrm.Oss.XTL.Interpreter.FunctionHandlers
Assembly:	Xrm.Oss.XTL.Templating
File(s):	D:\Entwicklung\Xrm-Templating-Language\src\lib\Xrm.Oss.XTL.Interpreter\FunctionHandlers.cs
Covered lines:	1072
Uncovered lines:	8
Coverable lines:	1080
Total lines:	1181
Line coverage:	99.2% (1072 of 1080)
Covered branches:	325
Total branches:	444
Branch coverage:	73.1% (325 of 444)

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage	Crap Score
GetConfig(...)	5	8	100%	100%	30
.cctor()	1	0	100%	100%	2
Compare(...)	2	2	75%	66.67%	6
CheckedCast(...)	5	16	66.67%	77.78%	30
FetchSnippetByUniqueName(...)	1	0	100%	100%	2
FetchSnippet(...)	6	16	100%	100%	42

File(s)

D:\Entwicklung\Xrm-Templating-Language\src\lib\Xrm.Oss.XTL.Interpreter\FunctionHandlers.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections;
		3		using System.Collections.Generic;
		4		using System.Globalization;
		5		using System.IO;
		6		using System.Linq;
		7		using System.Text;
		8		using System.Text.RegularExpressions;
		9		using Microsoft.Crm.Sdk.Messages;
		10		using Microsoft.Xrm.Sdk;
		11		using Microsoft.Xrm.Sdk.Messages;
		12		using Microsoft.Xrm.Sdk.Metadata;
		13		using Microsoft.Xrm.Sdk.Query;
		14		using Xrm.Oss.FluentQuery;
		15		using static Xrm.Oss.XTL.Interpreter.XTLInterpreter;
		16
		17		namespace Xrm.Oss.XTL.Interpreter
		18		{
		19		#pragma warning disable S1104 // Fields should not have public accessibility
		20		public static class FunctionHandlers
		21		{
		22		private static ConfigHandler GetConfig(List<ValueExpression> parameters)
	176	23		{
	441	24		return new ConfigHandler((Dictionary<string, object>) parameters.LastOrDefault(p => p?.Value is Dictionary<s
	176	25		}
		26
	2	27		public static FunctionHandler Not = (primary, service, tracing, organizationConfig, parameters) =>
	5	28		{
	5	29		var target = parameters.FirstOrDefault();
	5	30		var result = !CheckedCast<bool>(target?.Value, "Not expects a boolean input, consider using one of the Is me
	2	31
	5	32		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	5	33		};
		34
	2	35		public static FunctionHandler First = (primary, service, tracing, organizationConfig, parameters) =>
	6	36		{
	6	37		if (parameters.Count != 1)
	2	38		{
	2	39		throw new InvalidPluginExecutionException("First expects a list as only parameter!");
	2	40		}
	2	41
	7	42		var firstParam = CheckedCast<List<ValueExpression>>(parameters.FirstOrDefault().Value, string.Empty, false)?
	6	43		var entityCollection = CheckedCast<EntityCollection>(parameters.FirstOrDefault().Value, string.Empty, false)
	2	44
	6	45		if (firstParam == null && entityCollection == null)
	2	46		{
	2	47		throw new InvalidPluginExecutionException("First expects a list or EntityCollection as input");
	2	48		}
	2	49
	6	50		return new ValueExpression(string.Empty, firstParam?.FirstOrDefault() ?? entityCollection?.FirstOrDefault())
	6	51		};
		52
	2	53		public static FunctionHandler Last = (primary, service, tracing, organizationConfig, parameters) =>
	3	54		{
	3	55		if (parameters.Count != 1)
	2	56		{
	2	57		throw new InvalidPluginExecutionException("Last expects a list as only parameter!");
	2	58		}
	2	59
	3	60		var firstParam = CheckedCast<List<ValueExpression>>(parameters.FirstOrDefault().Value, string.Empty, false)?
	3	61		var entityCollection = CheckedCast<EntityCollection>(parameters.FirstOrDefault().Value, string.Empty, false)
	2	62
	3	63		if (firstParam == null && entityCollection == null)
	2	64		{
	2	65		throw new InvalidPluginExecutionException("Last expects a list or EntityCollection as input");
	2	66		}
	2	67
	3	68		return new ValueExpression(string.Empty, firstParam?.LastOrDefault() ?? entityCollection?.LastOrDefault());
	3	69		};
		70
	2	71		public static FunctionHandler IsLess = (primary, service, tracing, organizationConfig, parameters) =>
	8	72		{
	8	73		bool result = Compare(parameters) < 0;
	2	74
	8	75		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	8	76		};
		77
	2	78		public static FunctionHandler IsLessEqual = (primary, service, tracing, organizationConfig, parameters) =>
	5	79		{
	5	80		bool result = Compare(parameters) <= 0;
	2	81
	5	82		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	5	83		};
		84
	2	85		public static FunctionHandler IsGreater = (primary, service, tracing, organizationConfig, parameters) =>
	8	86		{
	8	87		bool result = Compare(parameters) > 0;
	2	88
	8	89		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	8	90		};
		91
	2	92		public static FunctionHandler IsGreaterEqual = (primary, service, tracing, organizationConfig, parameters) =>
	5	93		{
	5	94		bool result = Compare(parameters) >= 0;
	2	95
	5	96		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	5	97		};
		98
		99		private static int Compare(List<ValueExpression> parameters)
	18	100		{
	18	101		if (parameters.Count != 2)
	0	102		{
	0	103		throw new InvalidPluginExecutionException("IsLess expects exactly 2 parameters!");
		104		}
		105
	18	106		var actual = CheckedCast<IComparable>(parameters[0].Value, "Actual value is not comparable");
	18	107		var expected = CheckedCast<IComparable>(parameters[1].Value, "Expected value is not comparable");
		108
		109		// Negative: actual is less than expected, 0: equal, 1: actual is greater than expected
	18	110		return actual.CompareTo(expected);
	18	111		}
		112
	2	113		public static FunctionHandler IsEqual = (primary, service, tracing, organizationConfig, parameters) =>
	17	114		{
	17	115		if (parameters.Count != 2)
	2	116		{
	2	117		throw new InvalidPluginExecutionException("IsEqual expects exactly 2 parameters!");
	2	118		}
	2	119
	17	120		var expected = parameters[0];
	17	121		var actual = parameters[1];
	17	122		var tempGuid = Guid.Empty;
	2	123
	17	124		var falseReturn = new ValueExpression(bool.FalseString, false);
	17	125		var trueReturn = new ValueExpression(bool.TrueString, true);
	2	126
	17	127		if (expected.Value == null && actual.Value == null)
	2	128		{
	2	129		return trueReturn;
	2	130		}
	2	131
	17	132		if (expected.Value == null && actual.Value != null)
	2	133		{
	2	134		return falseReturn;
	2	135		}
	2	136
	17	137		if (expected.Value != null && actual.Value == null)
	2	138		{
	2	139		return falseReturn;
	2	140		}
	2	141
	36	142		if (new[] { expected.Value, actual.Value }.All(v => v is int || v is OptionSetValue))
	6	143		{
	6	144		var values = new[] { expected.Value, actual.Value }
	14	145		.Select(v => v is OptionSetValue ? ((OptionSetValue)v).Value : (int)v)
	6	146		.ToList();
	2	147
	6	148		var optionSetResult = values[0].Equals(values[1]);
	6	149		return new ValueExpression(optionSetResult.ToString(CultureInfo.InvariantCulture), optionSetResult);
	2	150		}
	28	151		else if (new[] { expected.Value, actual.Value }.All(v => v is Guid || (v is string && Guid.TryParse((string)
	6	152		{
	6	153		var values = new[] { expected.Value, actual.Value }
	6	154		.Select(v =>
	14	155		{
	14	156		if (v is Guid)
	10	157		{
	10	158		return (Guid) v;
	6	159		}
	6	160
	10	161		if (v is string)
	10	162		{
	10	163		return tempGuid;
	6	164		}
	6	165
	6	166		if (v is EntityReference)
	6	167		{
	6	168		return ((EntityReference) v).Id;
	6	169		}
	6	170
	6	171		if (v is Entity)
	6	172		{
	6	173		return ((Entity) v).Id;
	6	174		}
	6	175
	6	176		return Guid.Empty;
	14	177		})
	6	178		.ToList();
	2	179
	6	180		var guidResult = values[0].Equals(values[1]);
	6	181		return new ValueExpression(guidResult.ToString(CultureInfo.InvariantCulture), guidResult);
	2	182		}
	2	183		else
	9	184		{
	9	185		var result = expected.Value.Equals(actual.Value);
	2	186
	9	187		return new ValueExpression(result.ToString(CultureInfo.InvariantCulture), result);
	2	188		}
	17	189		};
		190
	2	191		public static FunctionHandler And = (primary, service, tracing, organizationConfig, parameters) =>
	8	192		{
	8	193		if (parameters.Count < 2)
	2	194		{
	2	195		throw new InvalidPluginExecutionException("And expects at least 2 conditions!");
	2	196		}
	2	197
	26	198		if (parameters.Any(p => !(p.Value is bool)))
	2	199		{
	2	200		throw new InvalidPluginExecutionException("And: All conditions must be booleans!");
	2	201		}
	2	202
	21	203		if (parameters.All(p => (bool)p.Value))
	4	204		{
	4	205		return new ValueExpression(bool.TrueString, true);
	2	206		}
	2	207
	6	208		return new ValueExpression(bool.FalseString, false);
	8	209		};
		210
	2	211		public static FunctionHandler Or = (primary, service, tracing, organizationConfig, parameters) =>
	6	212		{
	6	213		if (parameters.Count < 2)
	2	214		{
	2	215		throw new InvalidPluginExecutionException("Or expects at least 2 conditions!");
	2	216		}
	2	217
	17	218		if (parameters.Any(p => !(p.Value is bool)))
	2	219		{
	2	220		throw new InvalidPluginExecutionException("Or: All conditions must be booleans!");
	2	221		}
	2	222
	14	223		if (parameters.Any(p => (bool)p.Value))
	5	224		{
	5	225		return new ValueExpression(bool.TrueString, true);
	2	226		}
	2	227
	3	228		return new ValueExpression(bool.FalseString, false);
	6	229		};
		230
	2	231		public static FunctionHandler IsNull = (primary, service, tracing, organizationConfig, parameters) =>
	22	232		{
	22	233		var target = parameters.FirstOrDefault();
	2	234
	22	235		if (target.Value == null)
	10	236		{
	10	237		return new ValueExpression(bool.TrueString, true);
	2	238		}
	2	239
	14	240		return new ValueExpression(bool.FalseString, false);
	22	241		};
		242
	2	243		public static FunctionHandler If = (primary, service, tracing, organizationConfig, parameters) =>
	27	244		{
	27	245		if (parameters.Count != 3)
	2	246		{
	2	247		throw new InvalidPluginExecutionException("If-Then-Else expects exactly three parameters: Condition, Tru
	2	248		}
	2	249
	27	250		var condition = CheckedCast<bool>(parameters[0]?.Value, "If condition must be a boolean!");
	27	251		var trueAction = parameters[1];
	27	252		var falseAction = parameters[2];
	2	253
	27	254		if (condition)
	15	255		{
	15	256		tracing.Trace("Executing true condition");
	28	257		return new ValueExpression(new Lazy<ValueExpression>(() => trueAction));
	2	258		}
	2	259
	14	260		tracing.Trace("Executing false condition");
	26	261		return new ValueExpression(new Lazy<ValueExpression>(() => falseAction));
	27	262		};
		263
	2	264		public static FunctionHandler GetPrimaryRecord = (primary, service, tracing, organizationConfig, parameters) =>
	12	265		{
	12	266		if (primary == null)
	2	267		{
	2	268		return new ValueExpression(null);
	2	269		}
	2	270
	12	271		return new ValueExpression(string.Empty, primary);
	12	272		};
		273
	2	274		public static FunctionHandler GetRecordUrl = (primary, service, tracing, organizationConfig, parameters) =>
	13	275		{
	13	276		if (organizationConfig == null || string.IsNullOrEmpty(organizationConfig.OrganizationUrl))
	2	277		{
	2	278		throw new InvalidPluginExecutionException("GetRecordUrl can't find the Organization Url inside the plugi
	2	279		}
	2	280
	32	281		if (!parameters.All(p => p.Value is EntityReference || p.Value is Entity || p.Value is Dictionary<string, ob
	2	282		{
	2	283		throw new InvalidPluginExecutionException("Only Entity Reference and Entity ValueExpressions are support
	2	284		}
	2	285
	32	286		var refs = parameters.Where(p => p != null && !(p?.Value is Dictionary<string, object>)).Select(e =>
	24	287		{
	24	288		var entityReference = e.Value as EntityReference;
	13	289
	26	290		if (entityReference != null) {
	15	291		return new
	15	292		{
	15	293		Id = entityReference.Id,
	15	294		LogicalName = entityReference.LogicalName
	15	295		};
	13	296		}
	13	297
	22	298		var entity = e.Value as Entity;
	13	299
	22	300		return new
	22	301		{
	22	302		Id = entity.Id,
	22	303		LogicalName = entity.LogicalName
	22	304		};
	24	305		});
	13	306		var organizationUrl = organizationConfig.OrganizationUrl.EndsWith("/") ? organizationConfig.OrganizationUrl
	2	307
	13	308		var config = GetConfig(parameters);
	13	309		var linkText = config.GetValue<string>("linkText", "linkText must be a string");
	13	310		var appId = config.GetValue<string>("appId", "appId must be a string");
	2	311
	13	312		var urls = string.Join(Environment.NewLine, refs.Select(e =>
	24	313		{
	24	314		var url = $"{organizationUrl}main.aspx?etn={e.LogicalName}&id={e.Id}&newWindow=true&pagetype=entityrecor
	24	315		return $"<a href=\"{url}\">{(string.IsNullOrEmpty(linkText) ? url : linkText)}</a>";
	24	316		}));
	2	317
	13	318		return new ValueExpression(urls, urls);
	13	319		};
		320
	2	321		public static FunctionHandler GetOrganizationUrl = (primary, service, tracing, organizationConfig, parameters) =
	4	322		{
	4	323		if (organizationConfig == null || string.IsNullOrEmpty(organizationConfig.OrganizationUrl))
	2	324		{
	2	325		throw new InvalidPluginExecutionException("GetOrganizationUrl can't find the Organization Url inside the
	2	326		}
	2	327
	4	328		var config = GetConfig(parameters);
	4	329		var linkText = config.GetValue<string>("linkText", "linkText must be a string", string.Empty);
	4	330		var urlSuffix = config.GetValue<string>("urlSuffix", "urlSuffix must be a string", string.Empty);
	4	331		var asHtml = config.GetValue<bool>("asHtml", "asHtml must be a boolean");
	2	332
	4	333		if (asHtml)
	4	334		{
	4	335		var url = $"{organizationConfig.OrganizationUrl}{urlSuffix}";
	4	336		var href = $"<a href=\"{url}\">{(string.IsNullOrEmpty(linkText) ? url : linkText)}</a>";
	4	337		return new ValueExpression(href, href);
	2	338		}
	2	339		else
	2	340		{
	2	341		return new ValueExpression(organizationConfig.OrganizationUrl, organizationConfig.OrganizationUrl);
	2	342		}
	4	343		};
		344
	2	345		public static FunctionHandler Union = (primary, service, tracing, organizationConfig, parameters) =>
	6	346		{
	6	347		if (parameters.Count < 2)
	2	348		{
	2	349		throw new InvalidPluginExecutionException("Union function needs at least two parameters: Arrays to union
	2	350		}
	2	351
	6	352		var union = parameters.Select(p =>
	16	353		{
	16	354		if (p == null)
	6	355		{
	6	356		return null;
	6	357		}
	6	358
	16	359		return p.Value as List<ValueExpression>;
	16	360		})
	16	361		.Where(p => p != null)
	16	362		.SelectMany(p => p)
	6	363		.ToList();
	2	364
	6	365		return new ValueExpression(null, union);
	6	366		};
		367
	2	368		public static FunctionHandler Map = (primary, service, tracing, organizationConfig, parameters) =>
	3	369		{
	3	370		if (parameters.Count < 2)
	2	371		{
	2	372		throw new InvalidPluginExecutionException("Map function needs at least an array with data and a function
	2	373		}
	2	374
	3	375		var config = GetConfig(parameters);
	2	376
	3	377		var values = parameters[0].Value as List<ValueExpression>;
	2	378
	3	379		if (!(values is IEnumerable))
	2	380		{
	2	381		throw new InvalidPluginExecutionException("Map needs an array as first parameter.");
	2	382		}
	2	383
	3	384		var lambda = parameters[1].Value as Func<List<ValueExpression>, ValueExpression>;
	2	385
	3	386		if (lambda == null)
	2	387		{
	2	388		throw new InvalidPluginExecutionException("Lambda function must be a proper arrow function");
	2	389		}
	2	390
	7	391		return new ValueExpression(null, values.Select(v => lambda(new List<ValueExpression> { v })).ToList());
	3	392		};
		393
	2	394		public static FunctionHandler Sort = (primary, service, tracing, organizationConfig, parameters) =>
	6	395		{
	6	396		if (parameters.Count < 1)
	2	397		{
	2	398		throw new InvalidPluginExecutionException("Sort function needs at least an array to sort and optionally
	2	399		}
	2	400
	6	401		var config = GetConfig(parameters);
	2	402
	6	403		var values = parameters[0].Value as List<ValueExpression>;
	2	404
	6	405		if (!(values is IEnumerable))
	2	406		{
	2	407		throw new InvalidPluginExecutionException("Sort needs an array as first parameter.");
	2	408		}
	2	409
	6	410		var descending = config.GetValue<bool>("descending", "descending must be a bool");
	6	411		var property = config.GetValue<string>("property", "property must be a string");
	2	412
	6	413		if (string.IsNullOrEmpty(property))
	3	414		{
	3	415		if (descending)
	2	416		{
	2	417		return new ValueExpression(null, values.OrderByDescending(v => v.Value).ToList());
	2	418		}
	2	419		else
	3	420		{
	7	421		return new ValueExpression(null, values.OrderBy(v => v.Value).ToList());
	2	422		}
	2	423		}
	2	424		else
	5	425		{
	5	426		if (descending)
	3	427		{
	5	428		return new ValueExpression(null, values.OrderByDescending(v => (v.Value as Entity)?.GetAttributeValu
	2	429		}
	2	430		else
	4	431		{
	8	432		return new ValueExpression(null, values.OrderBy(v => (v.Value as Entity)?.GetAttributeValue<object>(
	2	433		}
	2	434		}
	6	435		};
		436
	2	437		private static Func<string, IOrganizationService, Dictionary<string, string>> RetrieveColumnNames = (entityName,
	19	438		{
	19	439		return ((RetrieveEntityResponse)service.Execute(new RetrieveEntityRequest
	19	440		{
	19	441		EntityFilters = EntityFilters.Attributes,
	19	442		LogicalName = entityName,
	19	443		RetrieveAsIfPublished = false
	19	444		}))
	19	445		.EntityMetadata
	19	446		.Attributes
	87	447		.ToDictionary(a => a.LogicalName, a => a?.DisplayName?.UserLocalizedLabel?.Label ?? a.LogicalName);
	19	448		};
		449
	2	450		public static FunctionHandler RenderRecordTable = (primary, service, tracing, organizationConfig, parameters) =>
	19	451		{
	19	452		tracing.Trace("Parsing parameters");
	2	453
	19	454		if (parameters.Count < 3)
	2	455		{
	2	456		throw new InvalidPluginExecutionException("RecordTable needs at least 3 parameters: Entities, entity nam
	2	457		}
	2	458
	19	459		var records = CheckedCast<List<ValueExpression>>(parameters[0].Value, "RecordTable requires the first parame
	48	460		.Select(p => (p as ValueExpression)?.Value)
	19	461		.Cast<Entity>()
	19	462		.ToList();
	2	463
	19	464		tracing.Trace($"Records: {records.Count}");
	2	465
	2	466		// We need the entity name although it should be set in the record. If no records are passed, we would fail
	19	467		var entityName = CheckedCast<string>(parameters[1]?.Value, "Second parameter of the RecordTable function nee
	2	468
	19	469		if (string.IsNullOrEmpty(entityName))
	2	470		{
	2	471		throw new InvalidPluginExecutionException("Second parameter of the RecordTable function needs to be the
	2	472		}
	2	473
	2	474		// We need the column names explicitly, since CRM does not return new ValueExpression(null)-valued columns,
	19	475		var displayColumns = CheckedCast<List<ValueExpression>>(parameters[2]?.Value, "List of column names for reco
	48	476		.Select(p => p.Value)
	48	477		.Select(p => p is Dictionary<string, object> ? (Dictionary<string, object>) p : new Dictionary<string, o
	19	478		.ToList();
	2	479
	19	480		tracing.Trace("Retrieving column names");
	19	481		var columnNames = RetrieveColumnNames(entityName, service);
	19	482		tracing.Trace($"Column names done");
	2	483
	19	484		var config = GetConfig(parameters);
	19	485		var addRecordUrl = config.GetValue<bool>("addRecordUrl", "When setting addRecordUrl, value must be a boolean
	2	486
	19	487		var tableStyle = config.GetValue("tableStyle", "tableStyle must be a string!", string.Empty);
	2	488
	19	489		if (!string.IsNullOrEmpty(tableStyle))
	4	490		{
	4	491		tableStyle = $" style=\"{tableStyle}\"";
	4	492		}
	2	493
	19	494		var tableHeadStyle = config.GetValue("headerStyle", "headerStyle must be a string!", @"border:1px solid blac
	19	495		var tableDataStyle = config.GetValue("dataStyle", "dataStyle must be a string!", @"border:1px solid black;pa
	2	496
	19	497		var evenDataStyle = config.GetValue<string>("evenDataStyle", "evenDataStyle must be a string!");
	19	498		var unevenDataStyle = config.GetValue<string>("unevenDataStyle", "unevenDataStyle must be a string!");
	2	499
	19	500		tracing.Trace("Parsed parameters");
	2	501
	2	502		// Create table header
	19	503		var stringBuilder = new StringBuilder($"<table{tableStyle}>\n<tr>");
	111	504		foreach (var column in displayColumns)
	31	505		{
	31	506		var name = string.Empty;
	31	507		var columnName = column.ContainsKey("name") ? column["name"] as string : string.Empty;
	2	508
	31	509		if (columnName.Contains(":"))
	3	510		{
	3	511		name = columnName.Substring(columnName.IndexOf(':') + 1);
	3	512		}
	2	513		else
	30	514		{
	30	515		name = columnNames.ContainsKey(columnName) ? columnNames[columnName] : columnName;
	30	516		}
	2	517
	31	518		if (column.ContainsKey("label"))
	9	519		{
	9	520		name = column["label"] as string;
	9	521		}
	2	522
	31	523		if (column.ContainsKey("style"))
	6	524		{
	6	525		if (!column.ContainsKey("mergeStyle") || (bool) column["mergeStyle"])
	4	526		{
	4	527		stringBuilder.AppendLine($"<th style=\"{tableHeadStyle}{column["style"]}\">{name}</th>");
	4	528		}
	2	529		else
	4	530		{
	4	531		stringBuilder.AppendLine($"<th style=\"{column["style"]}\">{name}</th>");
	4	532		}
	6	533		}
	2	534		else
	27	535		{
	27	536		stringBuilder.AppendLine($"<th style=\"{tableHeadStyle}\">{name}</th>");
	27	537		}
	31	538		}
	2	539
	2	540		// Add column for url if wanted
	19	541		if (addRecordUrl)
	5	542		{
	5	543		stringBuilder.AppendLine($"<th style=\"{tableHeadStyle}\">URL</th>");
	5	544		}
	19	545		stringBuilder.AppendLine("</tr>");
	2	546
	19	547		if (records != null)
	19	548		{
	94	549		for (var i = 0; i < records.Count; i++)
	31	550		{
	31	551		var record = records[i];
	31	552		var isEven = i % 2 == 0;
	31	553		var lineStyle = (isEven ? evenDataStyle : unevenDataStyle) ?? tableDataStyle;
	2	554
	31	555		stringBuilder.AppendLine("<tr>");
	2	556
	191	557		foreach (var column in displayColumns)
	53	558		{
	53	559		var columnName = column.ContainsKey("name") ? column["name"] as string : string.Empty;
	53	560		columnName = columnName.Contains(":") ? columnName.Substring(0, columnName.IndexOf(':')) : colum
	2	561
	53	562		var renderFunction = column.ContainsKey("renderFunction") ? column["renderFunction"] as Func<Lis
	53	563		var entityConfig = column.ContainsKey("nameByEntity") ? column["nameByEntity"] as Dictionary<str
	2	564
	53	565		if (entityConfig != null && entityConfig.ContainsKey(record.LogicalName))
	4	566		{
	4	567		columnName = entityConfig[record.LogicalName] as string;
	4	568		}
	2	569
	53	570		var staticValues = column.ContainsKey("staticValueByEntity") ? column["staticValueByEntity"] as
	2	571
	2	572		string value;
	2	573
	53	574		if (staticValues != null && staticValues.ContainsKey(record.LogicalName))
	4	575		{
	4	576		value = staticValues[record.LogicalName] as string;
	4	577		}
	49	578		else if (renderFunction != null)
	3	579		{
	3	580		var rowRecord = new ValueExpression(null, record);
	3	581		var rowColumnName = new ValueExpression(columnName, columnName);
		582
	3	583		value = renderFunction(new List<ValueExpression> { rowRecord, rowColumnName })?.Text;
	3	584		}
		585		else
	46	586		{
	46	587		value = PropertyStringifier.Stringify(columnName, record, service, config);
	46	588		}
		589
	51	590		if (column.ContainsKey("style"))
	8	591		{
	8	592		if (!column.ContainsKey("mergeStyle") || (bool)column["mergeStyle"])
	4	593		{
	4	594		stringBuilder.AppendLine($"<td style=\"{lineStyle}{column["style"]}\">{value}</td>");
	4	595		}
		596		else
	4	597		{
	4	598		stringBuilder.AppendLine($"<td style=\"{column["style"]}\">{value}</td>");
	4	599		}
	8	600		}
		601		else
	43	602		{
	43	603		stringBuilder.AppendLine($"<td style=\"{lineStyle}\">{value}</td>");
	43	604		}
	51	605		}
		606
	29	607		if (addRecordUrl)
	6	608		{
	6	609		stringBuilder.AppendLine($"<td style=\"{lineStyle}\">{GetRecordUrl(primary, service, tracing, or
	6	610		}
		611
	29	612		stringBuilder.AppendLine("</tr>");
	29	613		}
	17	614		}
		615
	17	616		stringBuilder.AppendLine("</table>");
	17	617		var table = stringBuilder.ToString();
		618
	17	619		return new ValueExpression(table, table);
	17	620		};
		621
	2	622		public static FunctionHandler Fetch = (primary, service, tracing, organizationConfig, parameters) =>
	24	623		{
	24	624		if (parameters.Count < 1)
	2	625		{
	2	626		throw new InvalidPluginExecutionException("Fetch needs at least one parameter: Fetch XML.");
	2	627		}
	2	628
	24	629		var fetch = parameters[0].Value as string;
	2	630
	24	631		if (string.IsNullOrEmpty(fetch))
	2	632		{
	2	633		throw new InvalidPluginExecutionException("First parameter of Fetch function needs to be a fetchXml stri
	2	634		}
	2	635
	24	636		var references = new List<object> { primary.Id };
	2	637
	24	638		if (parameters.Count > 1)
	5	639		{
	5	640		if (!(parameters[1].Value is List<ValueExpression>))
	2	641		{
	2	642		throw new InvalidPluginExecutionException("Fetch parameters must be an array expression");
	2	643		}
	2	644
	5	645		var @params = parameters[1].Value as List<ValueExpression>;
	2	646
	5	647		if (@params is IEnumerable)
	5	648		{
	17	649		foreach (var item in @params)
	5	650		{
	5	651		var reference = item.Value as EntityReference;
	5	652		if (reference != null)
	4	653		{
	4	654		references.Add(reference.Id);
	4	655		continue;
	2	656		}
	2	657
	3	658		var entity = item.Value as Entity;
	3	659		if (entity != null)
	2	660		{
	2	661		references.Add(entity.Id);
	2	662		continue;
	2	663		}
	2	664
	3	665		var optionSet = item.Value as OptionSetValue;
	3	666		if (optionSet != null)
	2	667		{
	2	668		references.Add(optionSet.Value);
	2	669		continue;
	2	670		}
	2	671
	3	672		references.Add(item.Value);
	3	673		}
	5	674		}
	5	675		}
	2	676
	24	677		var records = new List<object>();
	2	678
	24	679		var query = fetch;
	2	680
	24	681		if (primary != null)
	24	682		{
	24	683		query = query.Replace("{0}", references[0].ToString());
	24	684		}
	2	685
	24	686		tracing.Trace("Replacing references");
	2	687
	24	688		var referenceRegex = new Regex("{([0-9]+)}", RegexOptions.Compiled | RegexOptions.CultureInvariant);
	24	689		query = referenceRegex.Replace(query, match =>
	27	690		{
	27	691		var capture = match.Groups[1].Value;
	27	692		var referenceNumber = int.Parse(capture);
	24	693
	27	694		if (referenceNumber >= references.Count)
	24	695		{
	24	696		throw new InvalidPluginExecutionException($"You tried using reference {referenceNumber} in fetch, bu
	24	697		}
	24	698
	27	699		return references[referenceNumber]?.ToString();
	27	700		});
	2	701
	24	702		tracing.Trace("References replaced");
	24	703		tracing.Trace($"Executing fetch: {query}");
	24	704		records.AddRange(service.RetrieveMultiple(new FetchExpression(query)).Entities);
	2	705
	54	706		return new ValueExpression(string.Empty, records.Select(r => new ValueExpression(string.Empty, r)).ToList())
	24	707		};
		708
	2	709		public static FunctionHandler GetValue = (primary, service, tracing, organizationConfig, parameters) =>
	108	710		{
	108	711		if (primary == null)
	2	712		{
	2	713		return new ValueExpression(null);
	2	714		}
	2	715
	108	716		var field = parameters.FirstOrDefault()?.Text;
	2	717
	108	718		if (string.IsNullOrEmpty(field))
	2	719		{
	2	720		throw new InvalidPluginExecutionException("First parameter of Value function needs to be the field name
	2	721		}
	2	722
	108	723		var target = primary;
	108	724		var config = GetConfig(parameters);
	2	725
	108	726		if (config.Contains("explicitTarget"))
	10	727		{
	10	728		if (config.IsSet("explicitTarget"))
	9	729		{
	9	730		var explicitTarget = config.GetValue<Entity>("explicitTarget", "explicitTarget must be an entity!");
	2	731
	9	732		target = explicitTarget;
	9	733		}
	2	734		else
	3	735		{
	3	736		return new ValueExpression(string.Empty, string.Empty);
	2	737		}
	9	738		}
	2	739
	107	740		if (field == null)
	2	741		{
	2	742		throw new InvalidPluginExecutionException("Value requires a field target string as input");
	2	743		}
	2	744
	107	745		return DataRetriever.ResolveTokenValue(field, target, service, config);
	108	746		};
		747
	2	748		public static FunctionHandler Join = (primary, service, tracing, organizationConfig, parameters) =>
	9	749		{
	9	750		if (parameters.Count < 2)
	2	751		{
	2	752		throw new InvalidPluginExecutionException("Join function needs at lease two parameters: Separator and an
	2	753		}
	2	754
	9	755		var separator = parameters.FirstOrDefault()?.Text;
	2	756
	9	757		if (string.IsNullOrEmpty(separator))
	2	758		{
	2	759		throw new InvalidPluginExecutionException("First parameter of Join function needs to be the separator st
	2	760		}
	2	761
	9	762		var values = parameters[1].Value as List<ValueExpression>;
	2	763
	9	764		if (!(values is IEnumerable))
	2	765		{
	2	766		throw new InvalidPluginExecutionException("The values parameter needs to be an enumerable, please wrap t
	2	767		}
	2	768
	9	769		var config = GetConfig(parameters);
	9	770		var removeEmptyEntries = false;
	2	771
	9	772		if (parameters.Count > 2 && parameters[2].Value is bool)
	5	773		{
	5	774		removeEmptyEntries = (bool) parameters[2].Value;
	5	775		}
	2	776
	9	777		var valuesToConcatenate = values
	33	778		.Where(v => !removeEmptyEntries || !string.IsNullOrEmpty(v.Text))
	31	779		.Select(v => v.Text);
	2	780
	9	781		var joined = string.Join(separator, valuesToConcatenate);
	2	782
	9	783		return new ValueExpression(joined, joined);
	9	784		};
		785
	2	786		public static FunctionHandler NewLine = (primary, service, tracing, organizationConfig, parameters) =>
	3	787		{
	3	788		return new ValueExpression(Environment.NewLine, Environment.NewLine);
	3	789		};
		790
	2	791		public static FunctionHandler Concat = (primary, service, tracing, organizationConfig, parameters) =>
	5	792		{
	5	793		var text = "";
	2	794
	31	795		foreach (var parameter in parameters)
	12	796		{
	12	797		text += parameter.Text;
	12	798		}
	2	799
	5	800		return new ValueExpression(text, text);
	5	801		};
		802
		803		private static T CheckedCast<T>(object input, string errorMessage, bool failOnError = true)
	156	804		{
	156	805		var value = input;
		806
	156	807		if (input is Money)
	0	808		{
	0	809		value = (input as Money).Value;
	0	810		}
		811
	156	812		if (input is OptionSetValue)
	0	813		{
	0	814		value = (input as OptionSetValue).Value;
	0	815		}
		816
	156	817		if (!(value is T))
	6	818		{
	6	819		if (failOnError)
	1	820		{
	1	821		throw new InvalidPluginExecutionException(errorMessage);
		822		}
		823
	5	824		return default(T);
		825		}
		826
	150	827		return (T)value;
	155	828		}
		829
	2	830		public static FunctionHandler Substring = (primary, service, tracing, organizationConfig, parameters) =>
	11	831		{
	11	832		if (parameters.Count < 2)
	3	833		{
	3	834		throw new InvalidPluginExecutionException("Substring expects at least two parameters: text, start index
	2	835		}
	2	836
	10	837		var text = parameters[0].Text;
	10	838		var startIndex = CheckedCast<int>(parameters[1].Value, "Start index parameter must be an int!");
	9	839		var length = -1;
	2	840
	9	841		if (parameters.Count > 2)
	8	842		{
	8	843		length = CheckedCast<int>(parameters[2].Value, "Length parameter must be an int!");
	8	844		}
	2	845
	9	846		var subString = length > -1 ? text.Substring(startIndex, length) : text.Substring(startIndex);
	9	847		return new ValueExpression(subString, subString);
	9	848		};
		849
	2	850		public static FunctionHandler IndexOf = (primary, service, tracing, organizationConfig, parameters) =>
	4	851		{
	4	852		if (parameters.Count < 2)
	3	853		{
	3	854		throw new InvalidPluginExecutionException("IndexOf needs a source string and a string to search for");
	2	855		}
	2	856
	3	857		var value = CheckedCast<string>(parameters[0].Value, "Source must be a string");
	3	858		var searchText = CheckedCast<string>(parameters[1].Value, "Search text must be a string");
	2	859
	3	860		var config = GetConfig(parameters);
	3	861		var ignoreCase = config.GetValue<bool>("ignoreCase", "ignoreCase must be a boolean!");
	2	862
	3	863		var index = value.IndexOf(searchText, ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringCompa
	2	864
	3	865		return new ValueExpression(index.ToString(), index);
	3	866		};
		867
	2	868		public static FunctionHandler Replace = (primary, service, tracing, organizationConfig, parameters) =>
	4	869		{
	4	870		if (parameters.Count < 3)
	3	871		{
	3	872		throw new InvalidPluginExecutionException("Replace expects three parameters: text input, regex pattern,
	2	873		}
	2	874
	3	875		var input = parameters[0].Text;
	3	876		var pattern = parameters[1].Text;
	3	877		var replacement = parameters[2].Text;
	2	878
	3	879		var replaced = Regex.Replace(input, pattern, replacement);
	2	880
	3	881		return new ValueExpression(replaced, replaced);
	3	882		};
		883
	2	884		public static FunctionHandler Array = (primary, service, tracing, organizationConfig, parameters) =>
	34	885		{
	95	886		return new ValueExpression(string.Join(", ", parameters.Select(p => p.Text)), parameters);
	34	887		};
		888
	2	889		public static FunctionHandler DateTimeNow = (primary, service, tracing, organizationConfig, parameters) =>
	3	890		{
	3	891		var date = DateTime.Now;
	3	892		return new ValueExpression(date.ToString("o", CultureInfo.InvariantCulture), date);
	3	893		};
		894
	2	895		public static FunctionHandler DateTimeUtcNow = (primary, service, tracing, organizationConfig, parameters) =>
	5	896		{
	5	897		var date = DateTime.UtcNow;
	5	898		return new ValueExpression(date.ToString("o", CultureInfo.InvariantCulture), date);
	5	899		};
		900
	2	901		public static FunctionHandler Static = (primary, service, tracing, organizationConfig, parameters) =>
	8	902		{
	8	903		if (parameters.Count < 1)
	2	904		{
	2	905		throw new InvalidOperationException("You have to pass a static value");
	2	906		}
	2	907
	8	908		var parameter = parameters[0];
	8	909		return new ValueExpression(parameter.Text, parameter.Value);
	8	910		};
		911
	2	912		public static FunctionHandler DateToString = (primary, service, tracing, organizationConfig, parameters) =>
	5	913		{
	5	914		if (parameters.Count < 1)
	2	915		{
	2	916		throw new Exception("No date to stringify");
	2	917		}
	2	918
	5	919		var date = CheckedCast<DateTime>(parameters[0].Value, "You need to pass a date");
	5	920		var config = GetConfig(parameters);
	5	921		var format = config.GetValue<string>("format", "format must be a string!");
	2	922
	5	923		if (!string.IsNullOrEmpty(format))
	5	924		{
	5	925		return new ValueExpression(date.ToString(format), date.ToString(format));
	2	926		}
	2	927
	2	928		return new ValueExpression(date.ToString(CultureInfo.InvariantCulture), date.ToString(CultureInfo.InvariantC
	5	929		};
		930
	2	931		public static FunctionHandler Format = (primary, service, tracing, organizationConfig, parameters) =>
	8	932		{
	8	933		if (parameters.Count < 2)
	3	934		{
	3	935		throw new InvalidPluginExecutionException("Format needs a value to format and a config for defining furt
	2	936		}
	2	937
	7	938		var value = parameters[0].Value;
	7	939		var config = GetConfig(parameters);
	7	940		var format = config.GetValue<string>("format", "format must be a string!");
	2	941
	7	942		var knownTypes = new Dictionary<Type, Func<object, ValueExpression>>
	7	943		{
	12	944		{ typeof(Money), (obj) => { var val = obj as Money; var formatted = string.Format(CultureInfo.InvariantC
	7	945		};
	2	946
	7	947		if(knownTypes.ContainsKey(value.GetType()))
	3	948		{
	3	949		return knownTypes[value.GetType()](value);
	2	950		}
	2	951		else
	6	952		{
	6	953		var formatted = string.Format(CultureInfo.InvariantCulture, format, value);
	6	954		return new ValueExpression(formatted, formatted);
	2	955		}
	7	956		};
		957
		958		private static Entity FetchSnippetByUniqueName(string uniqueName, IOrganizationService service)
	6	959		{
	6	960		var fetch = $@"<fetch no-lock=""true"">
	6	961		<entity name=""oss_xtlsnippet"">
	6	962		<attribute name=""oss_xtlexpression"" />
	6	963		<attribute name=""oss_containsplaintext"" />
	6	964		<filter operator=""and"">
	6	965		<condition attribute=""oss_uniquename"" operator=""eq"" value=""{uniqueName}"" />
	6	966		</filter>
	6	967		</entity>
	6	968		</fetch>";
		969
	6	970		var snippet = service.RetrieveMultiple(new FetchExpression(fetch))
	6	971		.Entities
	6	972		.FirstOrDefault();
		973
	6	974		return snippet;
	6	975		}
		976
		977		private static Entity FetchSnippet(string name, string filter, Entity primary, OrganizationConfig organizationCo
	6	978		{
	6	979		var uniqueNameSnippet = FetchSnippetByUniqueName(name, service);
		980
	6	981		if (uniqueNameSnippet != null)
	1	982		{
	1	983		tracing.Trace("Found snippet by unique name");
	1	984		return uniqueNameSnippet;
		985		}
		986
	5	987		if (!string.IsNullOrEmpty(filter))
	3	988		{
	3	989		tracing.Trace("Processing tokens in custom snippet filter");
	3	990		}
		991
	5	992		var fetch = $@"<fetch no-lock=""true"">
	5	993		<entity name=""oss_xtlsnippet"">
	5	994		<attribute name=""oss_xtlexpression"" />
	5	995		<attribute name=""oss_containsplaintext"" />
	5	996		<filter operator=""and"">
	5	997		<condition attribute=""oss_name"" operator=""eq"" value=""{name}"" />
	5	998		{ (!string.IsNullOrEmpty(filter) ? TokenMatcher.ProcessTokens(filter, primary, organizationConfi
	5	999		</filter>
	5	1000		</entity>
	5	1001		</fetch>";
		1002
	5	1003		if (!string.IsNullOrEmpty(filter))
	3	1004		{
	3	1005		tracing.Trace("Done processing tokens in custom snippet filter");
	3	1006		}
		1007
	5	1008		var snippet = service.RetrieveMultiple(new FetchExpression(fetch))
	5	1009		.Entities
	5	1010		.FirstOrDefault();
		1011
	5	1012		return snippet;
	6	1013		}
		1014
	2	1015		public static FunctionHandler Snippet = (primary, service, tracing, organizationConfig, parameters) =>
	9	1016		{
	9	1017		if (parameters.Count < 1)
	3	1018		{
	3	1019		throw new InvalidPluginExecutionException("Snippet needs at least a name as first parameter and optional
	2	1020		}
	2	1021
	8	1022		var name = CheckedCast<string>(parameters[0].Value, "Name must be a string!");
	8	1023		var config = GetConfig(parameters);
	2	1024
	8	1025		var filter = config?.GetValue<string>("filter", "filter must be a string containing your fetchXml filter, wh
	2	1026
	8	1027		var snippet = FetchSnippet(name, filter, primary, organizationConfig, service, tracing);
	2	1028
	8	1029		if (snippet == null)
	2	1030		{
	2	1031		tracing.Trace("Failed to find a snippet matching the input");
	2	1032		return new ValueExpression(string.Empty, null);
	2	1033		}
	2	1034
	8	1035		var containsPlainText = snippet.GetAttributeValue<bool>("oss_containsplaintext");
	8	1036		var value = snippet.GetAttributeValue<string>("oss_xtlexpression");
	2	1037
	2	1038		// Wrap it in ${{ ... }} block
	8	1039		var processedValue = containsPlainText ? value : $"${{{{ {value} }}}}";
	2	1040
	8	1041		tracing.Trace("Processing snippet tokens");
	2	1042
	8	1043		var result = TokenMatcher.ProcessTokens(processedValue, primary, organizationConfig, service, tracing);
	2	1044
	8	1045		tracing.Trace("Done processing snippet tokens");
	2	1046
	8	1047		return new ValueExpression(result, result);
	8	1048		};
		1049
	2	1050		public static FunctionHandler ConvertDateTime = (primary, service, tracing, organizationConfig, parameters) =>
	7	1051		{
	7	1052		if (parameters.Count < 2)
	2	1053		{
	2	1054		throw new InvalidPluginExecutionException("Convert DateTime needs a DateTime and a config for defining f
	2	1055		}
	2	1056
	7	1057		var date = CheckedCast<DateTime>(parameters[0].Value, "You need to pass a date");
	7	1058		var config = GetConfig(parameters);
	2	1059
	7	1060		var timeZoneId = config.GetValue<string>("timeZoneId", "timeZoneId must be a string");
	7	1061		var userId = config.GetValue<EntityReference>("userId", "userId must be an EntityReference");
	2	1062
	7	1063		if (userId == null && string.IsNullOrEmpty(timeZoneId))
	2	1064		{
	2	1065		throw new InvalidPluginExecutionException("You need to either set a userId for converting to a user's co
	2	1066		}
	2	1067
	7	1068		if (userId != null)
	5	1069		{
	5	1070		var userSettings = service.Retrieve("usersettings", userId.Id, new ColumnSet("timezonecode"));
	5	1071		var timeZoneCode = userSettings.GetAttributeValue<int>("timezonecode");
	2	1072
	5	1073		timeZoneId = service.Query("timezonedefinition")
	5	1074		.IncludeColumns("standardname")
	8	1075		.Where(e => e
	11	1076		.Attribute(a => a
	11	1077		.Named("timezonecode")
	11	1078		.Is(ConditionOperator.Equal)
	11	1079		.To(timeZoneCode)
	8	1080		)
	5	1081		)
	5	1082		.Retrieve()
	5	1083		.FirstOrDefault()
	5	1084		?.GetAttributeValue<string>("standardname");
	5	1085		}
	2	1086
	7	1087		if (string.IsNullOrEmpty(timeZoneId))
	2	1088		{
	2	1089		throw new InvalidPluginExecutionException("Failed to retrieve timeZoneId, can't convert datetime");
	2	1090		}
	2	1091
	7	1092		var timeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
	7	1093		var localTime = TimeZoneInfo.ConvertTime(date, timeZone);
	7	1094		var text = localTime.ToString(config.GetValue<string>("format", "format must be a string", "g"), CultureInfo
	2	1095
	7	1096		return new ValueExpression(text, localTime);
	7	1097		};
		1098
	2	1099		public static FunctionHandler RetrieveAudit = (primary, service, tracing, organizationConfig, parameters) =>
	3	1100		{
	3	1101		var firstParam = parameters.FirstOrDefault()?.Value;
	3	1102		var reference = (firstParam as Entity)?.ToEntityReference() ?? firstParam as EntityReference;
	3	1103		var config = GetConfig(parameters);
	2	1104
	3	1105		if (firstParam != null && reference == null)
	2	1106		{
	2	1107		throw new InvalidPluginExecutionException("RetrieveAudit: First Parameter must be an Entity or EntityRef
	2	1108		}
	2	1109
	3	1110		if (reference == null)
	2	1111		{
	2	1112		return new ValueExpression(string.Empty, null);
	2	1113		}
	2	1114
	3	1115		var field = CheckedCast<string>(parameters[1]?.Value, "RetrieveAudit: fieldName must be a string");
	2	1116
	3	1117		var request = new RetrieveRecordChangeHistoryRequest
	3	1118		{
	3	1119		Target = reference
	3	1120		};
	3	1121		var audit = service.Execute(request) as RetrieveRecordChangeHistoryResponse;
	2	1122
	3	1123		var auditValue = audit.AuditDetailCollection.AuditDetails.Select(d =>
	4	1124		{
	4	1125		var detail = d as AttributeAuditDetail;
	3	1126
	4	1127		if (detail == null)
	3	1128		{
	3	1129		return null;
	3	1130		}
	3	1131
	4	1132		var oldValue = detail.OldValue.GetAttributeValue<object>(field);
	3	1133
	4	1134		return Tuple.Create(PropertyStringifier.Stringify(field, detail.OldValue, service, config), oldValue);
	4	1135		})
	4	1136		.FirstOrDefault(t => t != null);
	2	1137
	3	1138		return new ValueExpression(auditValue?.Item1 ?? string.Empty, auditValue?.Item2);
	3	1139		};
		1140
	2	1141		public static FunctionHandler GetRecordId = (primary, service, tracing, organizationConfig, parameters) =>
	9	1142		{
	9	1143		var firstParam = parameters.FirstOrDefault()?.Value;
	9	1144		var reference = (firstParam as Entity)?.ToEntityReference() ?? firstParam as EntityReference;
	9	1145		var config = GetConfig(parameters);
	2	1146
	9	1147		if (firstParam != null && reference == null)
	2	1148		{
	2	1149		throw new InvalidPluginExecutionException("RecordId: First Parameter must be an Entity or EntityReferenc
	2	1150		}
	2	1151
	9	1152		if (reference == null)
	2	1153		{
	2	1154		return new ValueExpression(string.Empty, null);
	2	1155		}
	2	1156
	9	1157		var textValue = reference.Id.ToString(config.GetValue<string>("format", "format must be a string", "D"));
	2	1158
	9	1159		return new ValueExpression(textValue, reference.Id);
	9	1160		};
		1161
	2	1162		public static FunctionHandler GetRecordLogicalName = (primary, service, tracing, organizationConfig, parameters)
	4	1163		{
	4	1164		var firstParam = parameters.FirstOrDefault()?.Value;
	4	1165		var reference = (firstParam as Entity)?.ToEntityReference() ?? firstParam as EntityReference;
	2	1166
	4	1167		if (firstParam != null && reference == null)
	2	1168		{
	2	1169		throw new InvalidPluginExecutionException("RecordLogicalName: First Parameter must be an Entity or Entit
	2	1170		}
	2	1171
	4	1172		if (reference == null)
	2	1173		{
	2	1174		return new ValueExpression(string.Empty, null);
	2	1175		}
	2	1176
	4	1177		return new ValueExpression(reference.LogicalName, reference.LogicalName);
	4	1178		};
		1179		}
		1180		}
		1181		#pragma warning restore S1104 // Fields should not have public accessibility