public FunctionMappings()
: base()
{
FunctionMapping mapping = new FunctionMapping(typeof(Functions), "Like", 2, "{0} LIKE {1}");
this.Add(mapping);
}
public override DynamicMetaObject BindInvokeMember(
InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var expressionFunctionConstructor = typeof(ExpressionFunction).GetConstructor(new[] { typeof(string), typeof(IEnumerable<object>) });
if (FunctionMapping.ContainsFunction(binder.Name, args.Length))
{
var expression = Expression.New(CtorWithExpressionAndExpressionFunction,
Expression.Convert(Expression, LimitType),
Expression.New(expressionFunctionConstructor,
Expression.Constant(binder.Name),
Expression.NewArrayInit(typeof(object), args.Select(x => Expression.Convert(x.Expression, typeof(object))))));
return new DynamicMetaObject(
expression,
BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
if (string.Equals(binder.Name, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) ||
string.Equals(binder.Name, ODataLiteral.All, StringComparison.OrdinalIgnoreCase))
{
var expression = Expression.New(CtorWithExpressionAndExpressionFunction,
Expression.Convert(Expression, LimitType),
Expression.New(expressionFunctionConstructor,
Expression.Constant(binder.Name),
Expression.NewArrayInit(typeof(object), args.Select(x => Expression.Convert(x.Expression, typeof(object))))));
return new DynamicMetaObject(
expression,
BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
if (string.Equals(binder.Name, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) ||
string.Equals(binder.Name, ODataLiteral.Is, StringComparison.OrdinalIgnoreCase) ||
string.Equals(binder.Name, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase) ||
string.Equals(binder.Name, ODataLiteral.As, StringComparison.OrdinalIgnoreCase))
{
var functionName = string.Equals(binder.Name, ODataLiteral.Is, StringComparison.OrdinalIgnoreCase)
? ODataLiteral.IsOf
: string.Equals(binder.Name, ODataLiteral.As, StringComparison.OrdinalIgnoreCase)
? ODataLiteral.Cast
: binder.Name;
var isNullProperty = typeof(DynamicODataExpression).GetProperty(nameof(IsNull));
var expressionFunctionArguments = Expression.Condition(Expression.MakeMemberAccess(Expression.Convert(Expression, LimitType), isNullProperty),
Expression.Convert(Expression, typeof(object)),
Expression.Convert(args.First().Expression, typeof(object)));
var expression = Expression.New(CtorWithExpressionAndExpressionFunction,
Expression.Convert(Expression, LimitType),
Expression.New(expressionFunctionConstructor,
Expression.Constant(functionName),
Expression.NewArrayInit(typeof(object), expressionFunctionArguments)));
return new DynamicMetaObject(
expression,
BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
return base.BindInvokeMember(binder, args);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public FunctionColumnMapping(
IProperty property,
FunctionColumn column,
FunctionMapping viewMapping)
: base(property, column, viewMapping)
{
}
internal static FunctionMapping ReadFunctionMapping(XmlReader reader)
{
if (!IsInNamespace(reader) || (reader.LocalName != "Function"))
{
throw Error.UnexpectedElement("Function", string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", new object[] { reader.Prefix, string.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName }));
}
ValidateAttributes(reader, new string[] { "Name", "Method", "IsComposable" });
FunctionMapping mapping = new FunctionMapping();
mapping.MethodName = RequiredAttribute(reader, "Method");
mapping.Name = OptionalAttribute(reader, "Name");
mapping.IsComposable = OptionalBoolAttribute(reader, "IsComposable", false);
if (reader.IsEmptyElement)
{
reader.Skip();
return(mapping);
}
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement)
{
if ((reader.NodeType == XmlNodeType.Whitespace) || !IsInNamespace(reader))
{
reader.Skip();
continue;
}
string localName = reader.LocalName;
if (localName == null)
{
goto Label_016C;
}
if (!(localName == "Parameter"))
{
if (localName == "ElementType")
{
goto Label_014A;
}
if (localName == "Return")
{
goto Label_015E;
}
goto Label_016C;
}
mapping.Parameters.Add(ReadParameterMapping(reader));
goto Label_01BC;
Label_014A:
mapping.Types.Add(ReadElementTypeMapping(null, reader));
goto Label_01BC;
Label_015E:
mapping.FunReturn = ReadReturnMapping(reader);
goto Label_01BC;
Label_016C :;
throw Error.UnrecognizedElement(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", new object[] { reader.Prefix, string.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName }));
Label_01BC:
reader.MoveToContent();
}
reader.ReadEndElement();
return(mapping);
}
/**
* retrieve function defintions using contract as an identifier to traverse the FunctionMapping.
*/
public HashSet <FunctionDefinition> returnFunctionDefs(ContractDefinition contract)
{
if (FunctionMapping.ContainsKey(contract))
{
return(FunctionMapping[contract]);
}
return(new HashSet <FunctionDefinition>());
}
private string FormatMappedFunction(ExpressionContext context, FunctionMapping mapping)
{
var mappedFunction = mapping.FunctionMapper(
Function.FunctionName, _functionCaller, Function.Arguments).Function;
var formattedArguments = string.Join(",",
(IEnumerable <object>)mappedFunction.Arguments.Select(x => FormatExpression(x, context)));
return($"{mappedFunction.FunctionName}({formattedArguments})");
}
private static FunctionDefinition CreateFunctionDefinition(string functionName, int argumentCount, string mappedFunctionName,
Func <FunctionDefinition, Func <string, ODataExpression, IEnumerable <object>, ODataExpression> > mapper, AdapterVersion adapterVersion = AdapterVersion.Any)
{
var functionCall = new ExpressionFunction.FunctionCall(functionName, argumentCount);
var functionMapping = new FunctionMapping(mappedFunctionName);
var function = new FunctionDefinition(functionCall, functionMapping, adapterVersion);
functionMapping.FunctionMapper = mapper(function);
return(function);
}
public IEnumerable <PhysicianMaster> Search(string firstName, string lastName, string zipcode, int pageNumber, int pageSize, out int totalRecords)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(adapter);
var query = (from pm in linqMetaData.PhysicianMaster where pm.IsActive select pm);
if (!string.IsNullOrEmpty(zipcode))
{
//query = (from q in query where q.PracticeZip == zipcode select q);
var zipInRange = _zipcodeRepository.GetZipCodesInRadius(zipcode, 10);
var zipCodesInRange = zipInRange != null?zipInRange.Select(zcir => zcir.Zip).ToList() : null;
if (!(zipCodesInRange == null || zipCodesInRange.IsEmpty()))
{
var mapping = new FunctionMapping(this.GetType(), "IndexOf", 2, " charindex({0}, {1})");
if (linqMetaData.CustomFunctionMappings == null)
{
linqMetaData.CustomFunctionMappings = new FunctionMappingStore();
}
linqMetaData.CustomFunctionMappings.Add(mapping);
mapping = new FunctionMapping(typeof(Convert), "ToString", 1, "',' + Convert(varchar, {0}) + ','");
linqMetaData.CustomFunctionMappings.Add(mapping);
string zipIdstring = "," + string.Join(",", zipCodesInRange) + ",";
query = from pm in linqMetaData.PhysicianMaster
where pm.IsActive && IndexOf(Convert.ToString(pm.PracticeZip), zipIdstring) > 0
select pm;
}
}
if (!string.IsNullOrEmpty(firstName))
{
query = (from q in query where q.FirstName.Contains(firstName) select q);
}
if (!string.IsNullOrEmpty(lastName))
{
query = (from q in query where q.LastName.Contains(lastName) select q);
}
query = (from q in query orderby q.FirstName, q.LastName, q.PhysicianMasterId select q);
totalRecords = query.Count();
var entities = query.TakePage(pageNumber, pageSize).ToList();
return(Mapper.Map <IEnumerable <PhysicianMasterEntity>, IEnumerable <PhysicianMaster> >(entities));
}
}
public void Should_map_complex_parameter()
{
mapping.Map(x => x.GetCustomersByName(
FunctionMapping <object> .Parameter <string>(
param => param.Named("Foo").DbType("Bar")
)
));
mapping.ToXml().Single()
.ShouldHaveElement("Parameter")
.ShouldHaveAttribute("Parameter", "name")
.ShouldHaveAttribute("Name", "Foo")
.ShouldHaveAttribute("DbType", "Bar");
}
private static FunctionMapping FromSourceMapping(FunctionMapping mapping)
{
var selector = mapping.ResultSelector;
var func = mapping.Function;
Debug.Assert(selector != null);
LiftModelToViewItem(ref selector);
if (func is Count)
{
func = new Sum();
}
return(new FunctionMapping(selector, selector, func));
}
//Function to insert a function into the specified contract.
public void InsertFunctionInContract(ContractDefinition contract, FunctionDefinition funcDef)
{
if (FunctionMapping.ContainsKey(contract) == false)
{
Debug.Assert(!FunctionSignatureMapping.ContainsKey(contract));
FunctionMapping[contract] = new HashSet <FunctionDefinition>();
FunctionSignatureMapping[contract] = new HashSet <string>();
}
Debug.Assert(!FunctionMapping[contract].Contains(funcDef), $"Repeated function warning: {funcDef.Name}");
FunctionMapping[contract].Add(funcDef);
string signature = Conversion_Utility_Tool.ComputeFunctionSignature(funcDef);
FunctionSignatureMapping[contract].Add(signature);
Debug.Assert(!FunctionToContractMap.ContainsKey(funcDef), $" Repeated function warning: {funcDef.Name}");
FunctionToContractMap[funcDef] = contract;
}
public void Should_obtain_parameter_for_complex_method()
{
Expression <Func <FunctionMappingParserTester, object> > expr =
x => x.GetCustomersByName(
FunctionMapping <FunctionParameterMappingTester> .Parameter <string>(param =>
param.DbType("foo")
)
);
var visitor = new FunctionMappingExpressionParser(expr);
var results = visitor.Process();
results.Parameters.Length.ShouldEqual(1);
var parameter = results.Parameters[0];
parameter.Attributes["Parameter"].ShouldEqual("name");
parameter.Attributes["DbType"].ShouldEqual("foo");
}
public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
ConstructorInfo ctor;
Expression[] ctorArguments;
if (FunctionMapping.ContainsFunction(binder.Name, 0))
{
ctor = CtorWithExpressionAndString;
ctorArguments = new Expression[] { Expression.Convert(Expression, LimitType), Expression.Constant(binder.Name) };
}
else
{
Expression<Func<bool, ODataExpression, string>> calculateReference = (hv, e) => hv && !string.IsNullOrEmpty(e.Reference)
? string.Join("/", e.Reference, binder.Name)
: binder.Name;
var referenceExpression = Expression.Invoke(calculateReference, Expression.Constant(HasValue), Expression.Convert(Expression, LimitType));
ctor = CtorWithString;
ctorArguments = new Expression[] { referenceExpression };
}
return new DynamicMetaObject(
Expression.New(ctor, ctorArguments),
BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
internal static FunctionMapping ReadFunctionMapping(XmlReader reader)
{
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Function)
{
throw Error.UnexpectedElement(XmlMappingConstant.Function, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.Method,
XmlMappingConstant.IsComposable
});
FunctionMapping fm = new FunctionMapping();
fm.MethodName = RequiredAttribute(reader, XmlMappingConstant.Method);
fm.Name = OptionalAttribute(reader, XmlMappingConstant.Name);
fm.IsComposable = OptionalBoolAttribute(reader, XmlMappingConstant.IsComposable, false);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader))
{
reader.Skip();
continue;
}
switch (reader.LocalName)
{
case XmlMappingConstant.Parameter:
fm.Parameters.Add(ReadParameterMapping(reader));
break;
case XmlMappingConstant.ElementType:
fm.Types.Add(ReadElementTypeMapping(null, reader));
break;
case XmlMappingConstant.Return:
fm.FunReturn = ReadReturnMapping(reader);
break;
default:
throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
else
{
// no content is okay
reader.Skip();
}
return(fm);
}
/// <summary>
/// The call for this function is generated in order to simplify the filtering below. This is not usually necessary for IQueryable<object>
/// However, LLBLGen has problems with IQuerable when the type is casted to object, so the proper typed call is generated above and this generic is called.
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="dataTableInit"></param>
/// <param name="model"></param>
/// <returns></returns>
private static JsonResult Query <TEntity>(DataTablesInitializationModel <TEntity> dataTableInit, DataTablesRequestModel model)
{
// Get source model used to create the view.
var source = dataTableInit.Source;
// get IQueryable type of object passed in, this makes the work below generalized for any type
/*var source2 = source as IQueryable<PatientEntity>;
* if(source2 != null)
* {
* source2 = source2.Where(x => Convert.ToString(x.BirthDate, new DateTimeFormatInfo(){ShortDatePattern = }).Contains("fe"));
*
* var result = source2.ToList();
* }
*/
// start with the source, then add on each filter
var count = source.Count();
var displayCount = count;
if (!String.IsNullOrEmpty(model.sSearch))
{
var llblGenProProvider = source.Provider as LLBLGenProProvider;
if (llblGenProProvider != null)
{
var dateConverter = new FunctionMapping(typeof(DateTime), "ToString", 0,
@"CONVERT(nvarchar(2), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 6, 2))) + '/' + CONVERT(nvarchar(2), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 9, 2))) + '/' + CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 1, 4))) + ' ' + CASE WHEN CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) > 12 THEN CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) - 12) ELSE CONVERT(nvarchar(4), CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2))) END +':' +SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 15, 2) + ':' + SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 18, 2) + CASE WHEN CONVERT(int, SUBSTRING(CONVERT(nvarchar(23), {0}, 121), 12, 2)) > 11 THEN ' PM' ELSE ' AM' END");
//var indexOf = new FunctionMapping(typeof(string), "IndexOf", 1, "PATINDEX('%{1}%', {0}) - 1");
//var indexOf2 = new FunctionMapping(typeof(string), "IndexOf", 2, "PATINDEX('%{1}%', {0}) - 1");
if ((llblGenProProvider).CustomFunctionMappings == null)
{
(llblGenProProvider).CustomFunctionMappings = new FunctionMappingStore();
}
(llblGenProProvider).CustomFunctionMappings.Add(dateConverter);
//(llblGenProProvider).CustomFunctionMappings.Add(indexOf);
//(llblGenProProvider).CustomFunctionMappings.Add(indexOf2);
// ^--- Doesn't work for no apparent reason but would make the Search() function a lot simpler.
}
// search all specified columns for the specified string
source = source.Search(dataTableInit.Columns, model.sSearch, !(source.Provider is LLBLGenProProvider));
displayCount = source.Count();
}
// sort the result based on the model, this calls OrderBy on multiple columns sequentially
if (model.Sorts.Any())
{
source = source.Sort(dataTableInit.Columns, model.Sorts);
}
// filter page based on start and length, this is like the SQL LIMIT directive
if (model.iDisplayLength > 0)
{
source = source.Skip(model.iDisplayStart).Take(model.iDisplayLength);
}
// now build the response
var response = new DataTablesResponseModel
{
sEcho = model.sEcho.Value,
iTotalRecords = count,
iTotalDisplayRecords = displayCount
};
// loop through each item and output JSON
foreach (TEntity entity in source.ToList())
{
var row = response.NewRow();
row.SetRowId(string.Empty + entity.GetHashCode());
foreach (var column in dataTableInit.Columns)
{
// if the column specifies a formatting function
if (column.Format != null)
{
var method = column.Format.Compile();
row.PushColumn(method.Invoke(entity).ToString());
}
else
{
var value = DataBinder.Eval(entity, column.ColumnName);
row.PushColumn(value != null ? value.ToString() : "");
}
}
}
return(new JsonResult
{
Data = response,
ContentType = null,
ContentEncoding = null,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public void Setup()
{
mapping = new FunctionMapping<FunctionMappingTester>();
}
public void Setup()
{
mapping = new FunctionMapping <FunctionMappingTester>();
}
public FunctionDefinition(ExpressionFunction.FunctionCall functionCall, FunctionMapping functionMapping, AdapterVersion adapterVersion = AdapterVersion.Any)
{
FunctionCall = functionCall;
FunctionMapping = functionMapping;
AdapterVersion = adapterVersion;
}
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method)
{
this.model = model;
this.map = map;
this.method = method;
this.rowTypes = _emptyTypes;
if (map.Types.Count == 0 && this.method.ReturnType == typeof(IMultipleResults))
{
throw Error.NoResultTypesDeclaredForFunction(method.Name);
}
else if (map.Types.Count > 1 && this.method.ReturnType != typeof(IMultipleResults))
{
throw Error.TooManyResultTypesDeclaredForFunction(method.Name);
}
else if (map.Types.Count == 1 && this.method.ReturnType != typeof(IMultipleResults))
{
Type elementType = TypeSystem.GetElementType(method.ReturnType);
this.rowTypes = new List <MetaType>(1)
{
this.GetMetaType(map.Types[0], elementType)
}.AsReadOnly();
}
else if (map.Types.Count > 0)
{
List <MetaType> rowTypes = new List <MetaType>();
foreach (TypeMapping rtm in map.Types)
{
Type elementType = model.FindType(rtm.Name);
if (elementType == null)
{
throw Error.CouldNotFindElementTypeInModel(rtm.Name);
}
MetaType mt = this.GetMetaType(rtm, elementType);
// Only add unique meta types
if (!rowTypes.Contains(mt))
{
rowTypes.Add(mt);
}
}
this.rowTypes = rowTypes.AsReadOnly();
}
else if (map.FunReturn != null)
{
this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn);
}
// Parameters.
ParameterInfo[] pis = this.method.GetParameters();
if (pis.Length > 0)
{
List <MetaParameter> mps = new List <MetaParameter>(pis.Length);
if (this.map.Parameters.Count != pis.Length)
{
throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName);
}
for (int i = 0; i < pis.Length; i++)
{
mps.Add(new MappedParameter(pis[i], this.map.Parameters[i]));
}
this.parameters = mps.AsReadOnly();
}
else
{
this.parameters = _emptyParameters;
}
}
// Methods
internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method)
{
this.model = model;
this.map = map;
this.method = method;
rowTypes = _emptyTypes;
if ((map.Types.Count == 0) && (this.method.ReturnType == typeof(IMultipleResults)))
{
throw Error.NoResultTypesDeclaredForFunction(method.Name);
}
if ((map.Types.Count > 1) && (this.method.ReturnType != typeof(IMultipleResults)))
{
throw Error.TooManyResultTypesDeclaredForFunction(method.Name);
}
if ((map.Types.Count == 1) && (this.method.ReturnType != typeof(IMultipleResults)))
{
Type elementType = TypeSystem.GetElementType(method.ReturnType);
var list = new List <MetaType>(1)
{
GetMetaType(map.Types[0], elementType)
};
rowTypes = list.AsReadOnly();
}
else if (map.Types.Count > 0)
{
var list2 = new List <MetaType>();
foreach (TypeMapping mapping in map.Types)
{
Type type2 = model.FindType(mapping.Name);
if (type2 == null)
{
throw Error.CouldNotFindElementTypeInModel(mapping.Name);
}
MetaType metaType = this.GetMetaType(mapping, type2);
if (!list2.Contains(metaType))
{
list2.Add(metaType);
}
}
this.rowTypes = list2.AsReadOnly();
}
else if (map.FunReturn != null)
{
this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn);
}
ParameterInfo[] parameters = this.method.GetParameters();
if (parameters.Length > 0)
{
var list3 = new List <MetaParameter>(parameters.Length);
if (this.map.Parameters.Count != parameters.Length)
{
throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName);
}
for (int i = 0; i < parameters.Length; i++)
{
list3.Add(new MappedParameter(parameters[i], this.map.Parameters[i]));
}
this.parameters = list3.AsReadOnly();
}
else
{
this.parameters = _emptyParameters;
}
}
private string FormatFunction(ExpressionContext context)
{
var adapterVersion = context.Session?.Adapter.AdapterVersion ?? AdapterVersion.Default;
if (FunctionToOperatorMapping.TryGetOperatorMapping(_functionCaller, Function, adapterVersion, out var operatorMapping))
{
return(FormatMappedOperator(context, operatorMapping));
}
if (FunctionMapping.TryGetFunctionMapping(Function.FunctionName, Function.Arguments.Count, adapterVersion, out var functionMapping))
{
return(FormatMappedFunction(context, functionMapping));
}
else if (string.Equals(Function.FunctionName, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) ||
string.Equals(Function.FunctionName, ODataLiteral.All, StringComparison.OrdinalIgnoreCase))
{
return(FormatAnyAllFunction(context));
}
else if (string.Equals(Function.FunctionName, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) ||
string.Equals(Function.FunctionName, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase))
{
return(FormatIsOfCastFunction(context));
}
else if (string.Equals(Function.FunctionName, "get_Item", StringComparison.Ordinal) &&
Function.Arguments.Count == 1)
{
return(FormatArrayIndexFunction(context));
}
else if (string.Equals(Function.FunctionName, "HasFlag", StringComparison.Ordinal) &&
Function.Arguments.Count == 1)
{
return(FormatEnumHasFlagFunction(context));
}
else if (string.Equals(Function.FunctionName, "ToString", StringComparison.Ordinal) &&
Function.Arguments.Count == 0)
{
return(FormatToStringFunction(context));
}
else if (Function.Arguments.Count == 1)
{
var val = Function.Arguments.First();
if (val.Value != null)
{
var formattedVal = ODataExpression.FromValue(
string.Equals(Function.FunctionName, "ToBoolean", StringComparison.Ordinal) ? Convert.ToBoolean(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToByte", StringComparison.Ordinal) ? Convert.ToByte(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToChar", StringComparison.Ordinal) ? Convert.ToChar(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToDateTime", StringComparison.Ordinal) ? Convert.ToDateTime(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToDecimal", StringComparison.Ordinal) ? Convert.ToDecimal(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToDouble", StringComparison.Ordinal) ? Convert.ToDouble(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToInt16", StringComparison.Ordinal) ? Convert.ToInt16(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToInt32", StringComparison.Ordinal) ? Convert.ToInt32(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToInt64", StringComparison.Ordinal) ? Convert.ToInt64(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToSByte", StringComparison.Ordinal) ? Convert.ToSByte(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToSingle", StringComparison.Ordinal) ? Convert.ToSingle(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToString", StringComparison.Ordinal) ? Convert.ToString(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToUInt16", StringComparison.Ordinal) ? Convert.ToUInt16(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToUInt32", StringComparison.Ordinal) ? Convert.ToUInt32(val.Value, CultureInfo.InvariantCulture) :
string.Equals(Function.FunctionName, "ToUInt64", StringComparison.Ordinal) ? Convert.ToUInt64(val.Value, CultureInfo.InvariantCulture)
: null);
if (formattedVal.Value != null)
{
return(FormatExpression(formattedVal, context));
}
}
}
throw new NotSupportedException($"The function {Function.FunctionName} is not supported or called with wrong number of arguments");
}
