private IValueNode ReplaceVariable(
VariableNode variable,
IInputType type)
{
if (_variables.TryGetVariable(
variable.Name.Value,
out object v))
{
if (!type.ClrType.IsInstanceOfType(v) &&
!_typeConversion.TryConvert(
typeof(object),
type.ClrType,
v,
out v))
{
// TODO : resource
// TODO : path?
throw new QueryException(
ErrorBuilder.New()
.SetMessage(
"Unable to convert the specified " +
"variable value.")
.Build());
}
return(type.ParseValue(v));
}
return(type.ParseValue(null));
}
public IReadOnlyDictionary <NameString, ArgumentValue> CoerceArguments(
IVariableCollection variables,
ITypeConversion converter)
{
if (_hasArgumentErrors)
{
throw new QueryException(_args.Values.Select(t => t.Error));
}
if (_vars == null)
{
return(_args);
}
var args = _args.ToDictionary(t => t.Key, t => t.Value);
foreach (KeyValuePair <NameString, VariableValue> var in _vars)
{
IError error = null;
if (!variables.TryGetVariable(
var.Value.VariableName,
out object value))
{
value = var.Value.DefaultValue is IValueNode literal
? var.Value.Type.ParseLiteral(literal)
: value = var.Value.DefaultValue;
if (var.Value.Type.IsNonNullType() && value is null)
{
error = ErrorBuilder.New()
.SetMessage(string.Format(
CultureInfo.InvariantCulture,
TypeResources.ArgumentValueBuilder_NonNull,
var.Key,
TypeVisualizer.Visualize(var.Value.Type)))
.AddLocation(Selection)
.SetExtension(_argumentProperty, Path.New(var.Key))
.SetPath(_path)
.Build();
}
}
if (error is null)
{
args[var.Key] = new ArgumentValue(var.Value.Type, value);
}
else
{
throw new QueryException(error);
}
}
return(args);
}
public IReadOnlyDictionary <NameString, ArgumentValue> CoerceArguments(
IVariableCollection variables,
ITypeConversion converter)
{
if (_hasArgumentErrors)
{
throw new QueryException(_args.Values.Select(t => t.Error));
}
if (_vars == null)
{
return(_args);
}
var args = _args.ToDictionary(t => t.Key, t => t.Value);
foreach (KeyValuePair <NameString, VariableValue> var in _vars)
{
if (!variables.TryGetVariable(
var.Value.VariableName,
out object value))
{
value = var.Value.DefaultValue;
}
IError error = InputTypeNonNullCheck.CheckForNullValueViolation(
var.Key,
var.Value.Type,
value,
converter,
message => ErrorBuilder.New()
.SetMessage(message)
.SetPath(_path.AppendOrCreate(ResponseName))
.AddLocation(Selection)
.SetExtension("argument", var.Key)
.Build());
if (error is null)
{
args[var.Key] = new ArgumentValue(var.Value.Type, value);
}
else
{
throw new QueryException(error);
}
}
return(args);
}
private static object CoerceArgumentValue(
InputField argument,
IVariableCollection variables,
IDictionary <string, IValueNode> argumentValues)
{
if (argumentValues.TryGetValue(argument.Name,
out IValueNode literal))
{
if (literal is VariableNode variable)
{
if (variables.TryGetVariable(
variable.Name.Value, out object value))
{
return(value);
}
return(ParseLiteral(argument.Type, argument.DefaultValue));
}
return(ParseLiteral(argument.Type, literal));
}
return(ParseLiteral(argument.Type, argument.DefaultValue));
}
private static bool TryParseValue(
IValueNode valueNode,
IVariableCollection variables,
out int value)
{
if (valueNode is VariableNode variable)
{
return(variables.TryGetVariable(
variable.Name.Value, out value));
}
else if (valueNode is IntValueNode literal)
{
return(int.TryParse(
literal.Value,
NumberStyles.Integer,
CultureInfo.InvariantCulture, out value));
}
value = default;
return(false);
}
