public override object VisitValue(GraphQLParser.ValueContext context)
{
if (context.STRING() != null)
{
return(context.STRING().GetText());
}
if (context.NUMBER() != null)
{
return(context.NUMBER().GetText());
}
if (context.BOOLEAN() != null)
{
return(context.BOOLEAN().GetText());
}
if (context.@enum() != null)
{
return(context.@enum().GetText());
}
if (context.array() != null)
{
return(Visit(context.array()));
}
if (context.@object() != null)
{
return(Visit(context.@object()));
}
return(null);
}
public override object VisitValue(GraphQLParser.ValueContext context)
{
if (context.StringValue() != null)
{
var val = new StringValue(context.StringValue().GetText());
NewNode(val, context);
return(val);
}
if (context.IntValue() != null)
{
var value = context.IntValue().GetText();
int intResult;
if (int.TryParse(value, out intResult))
{
var val = new IntValue(intResult);
NewNode(val, context);
return(val);
}
// If the value doesn't fit in an integer, revert to using long...
long longResult;
if (long.TryParse(value, out longResult))
{
var val = new LongValue(longResult);
NewNode(val, context);
return(val);
}
}
if (context.FloatValue() != null)
{
var val = new FloatValue(double.Parse(context.FloatValue().GetText()));
NewNode(val, context);
return(val);
}
if (context.BooleanValue() != null)
{
var val = new BooleanValue(bool.Parse(context.BooleanValue().GetText()));
NewNode(val, context);
return(val);
}
if (context.enumValue() != null)
{
var val = new EnumValue(context.enumValue().GetText());
NewNode(val, context);
return(val);
}
if (context.arrayValue() != null)
{
return(Visit(context.arrayValue()));
}
if (context.objectValue() != null)
{
return(Visit(context.objectValue()));
}
return(null);
}
Object CoerceDocumentValue(__Type argumentType, String argumentName, GraphQLParser.ValueContext val)
{
try
{
if (val is GraphQLParser.StringValueContext)
{
var typedVal = Trim(((GraphQLParser.StringValueContext)val).GetText());
if (argumentType.kind == __TypeKind.ENUM)
{
return(Enum.Parse(argumentType.dotNetType, typedVal));
}
else if (argumentType.kind == __TypeKind.SCALAR)
{
if (TypeCheck.IsNumeric(argumentType.dotNetType))
{
Error($"Cannot convert string to numeric value", val);
}
else if (TypeCheck.IsString(argumentType.dotNetType))
{
return(typedVal);
}
else if (TypeCheck.IsDateTime(argumentType.dotNetType))
{
return(DateTime.Parse(typedVal));
}
}
}
else if (val is GraphQLParser.BooleanValueContext)
{
var typedVal = (val.GetText() == "true") ? true : false;
if (argumentType.kind == __TypeKind.SCALAR)
{
if (TypeCheck.IsBoolean(argumentType.dotNetType))
{
return(typedVal);
}
else if (TypeCheck.IsNumeric(argumentType.dotNetType))
{
if (typedVal)
{
return(1);
}
return(0);
}
else if (TypeCheck.IsString(argumentType.dotNetType))
{
if (typedVal)
{
return("true");
}
return(false);
}
}
}
else if (val is GraphQLParser.NumberValueContext)
{
var typedValue = Convert.ToDouble(val.GetText());
if (TypeCheck.IsNumeric(argumentType.dotNetType))
{
if (argumentType.dotNetType == typeof(int))
{
return((int)typedValue);
}
else if (argumentType.dotNetType == typeof(short))
{
return((short)typedValue);
}
else if (argumentType.dotNetType == typeof(uint))
{
return((uint)typedValue);
}
else if (argumentType.dotNetType == typeof(uint))
{
return((uint)typedValue);
}
else if (argumentType.dotNetType == typeof(float))
{
return((float)typedValue);
}
else
{
return(typedValue);
}
}
else if (TypeCheck.IsString(argumentType.dotNetType))
{
return(typedValue.ToString());
}
else if (TypeCheck.IsBoolean(argumentType.dotNetType))
{
if (typedValue == 0.0)
{
return(false);
}
return(true);
}
}
else if (val is GraphQLParser.ObjectValueContext)
{
var jsonObj = GraphQlJson.FromJSonString(val.GetText(), argumentType.dotNetType, true);
return(jsonObj);
}
else if (val is GraphQLParser.EnumValueContext)
{
return(Enum.Parse(argumentType.dotNetType, val.GetText()));
}
else if (val is GraphQLParser.ArrayValueContext)
{
List <Object> objects = new List <object>();
foreach (var c in ((GraphQLParser.ArrayValueContext)val).array().value())
{
objects.Add(CoerceDocumentValue(argumentType.ofType, argumentName, c));
}
return(objects);
}
Error(
$"Encountered unexpected DotNetType when coercing value - {argumentName} - {argumentType.dotNetType.Name}",
val);
return(0);
}
catch (Exception e)
{
Error(
$"Error - '{e.Message}' trying to coerce '{argumentName}' of type '{val.GetType().Name}' to '{argumentType.kind}' with DotNetType: '{argumentType.dotNetType.Name}' ",
val);
return(0);
}
}
void ValidateArgumentType(GraphQLParser.ValueContext value, __Type input)
{
var checkType = input;
// NON_NULL is indicator that type is necessary ofType represents underlying
if (input.kind == __TypeKind.NON_NULL)
{
checkType = input.ofType;
}
if (value is GraphQLParser.StringValueContext)
{
if (checkType.kind != __TypeKind.SCALAR && (TypeCheck.IsString(checkType.dotNetType) == false && TypeCheck.IsEnum(checkType.dotNetType) == false))
{
Error($"String value in argument does not match input type - {checkType.name}", value);
}
}
else if (value is GraphQLParser.BooleanValueContext)
{
if (checkType.kind != __TypeKind.SCALAR && checkType.dotNetType != typeof(bool))
{
Error($"Boolean value in argument does not match checkType - {checkType.name}", value);
}
}
else if (value is GraphQLParser.NumberValueContext)
{
if (checkType.kind != __TypeKind.SCALAR && TypeCheck.IsNumeric(checkType.dotNetType) == false)
{
Error($"Numeric value in argument does not match checkType - {checkType.name}", value);
}
}
else if (value is GraphQLParser.ObjectValueContext)
{
if (checkType.kind != __TypeKind.INPUT_OBJECT)
{
Error($"Object value in argument does not match checkType - {checkType.name}", value);
}
}
else if (value is GraphQLParser.EnumValueContext)
{
if (checkType.kind != __TypeKind.ENUM)
{
Error($"Enum value in argument does not match checkType - {checkType.name}", value);
}
}
else if (value is GraphQLParser.ArrayValueContext)
{
if (checkType.kind != __TypeKind.LIST)
{
Error($"Enum value in argument does not match checkType - {checkType.name}", value);
}
var lst = value as GraphQLParser.ArrayValueContext;
foreach (var v in lst.array().value())
{
ValidateArgumentType(v, checkType.ofType);
}
}
else
{
Error($"Unexpected value type - {value.GetType()}", value);
}
}
