Ejemplo n.º 1
0
        private ArgumentValue CreateArgumentValue(
            string responseName,
            IInputField argument,
            ArgumentNode?argumentValue,
            IValueNode value,
            bool isDefaultValue)
        {
            ArgumentNonNullValidator.ValidationResult validationResult =
                ArgumentNonNullValidator.Validate(argument, value, Path.New(argument.Name));

            if (argumentValue is not null && validationResult.HasErrors)
            {
                return(new ArgumentValue(
                           argument,
                           ErrorHelper.ArgumentNonNullError(
                               argumentValue,
                               responseName,
                               validationResult)));
            }

            if (argument.Type.IsLeafType() && CanBeCompiled(value))
            {
                try
                {
                    return(new ArgumentValue(
                               argument,
                               value.GetValueKind(),
                               true,
                               isDefaultValue,
                               ParseLiteral(argument, value),
                               value));
                }
                catch (SerializationException ex)
                {
                    if (argumentValue is not null)
                    {
                        return(new ArgumentValue(
                                   argument,
                                   ErrorHelper.ArgumentValueIsInvalid(argumentValue, responseName, ex)));
                    }

                    return(new ArgumentValue(
                               argument,
                               ErrorHelper.ArgumentDefaultValueIsInvalid(responseName, ex)));
                }
            }

            return(new ArgumentValue(
                       argument,
                       value.GetValueKind(),
                       false,
                       isDefaultValue,
                       null,
                       value));
        }
Ejemplo n.º 2
0
        private void CreateArgumentValue(
            FieldInfo fieldInfo,
            IInputField argument,
            IValueNode literal)
        {
            if (fieldInfo.Arguments == null)
            {
                fieldInfo.Arguments = new Dictionary <NameString, ArgumentValue>();
            }

            Report report = ArgumentNonNullValidator.Validate(
                argument.Type,
                literal,
                Path.New(argument.Name));

            if (report.HasErrors)
            {
                IError error = ErrorBuilder.New()
                               .SetMessage(string.Format(
                                               CultureInfo.InvariantCulture,
                                               TypeResources.ArgumentValueBuilder_NonNull,
                                               argument.Name,
                                               TypeVisualizer.Visualize(report.Type)))
                               .AddLocation(fieldInfo.Selection)
                               .SetExtension(_argumentProperty, report.Path.ToCollection())
                               .SetPath(fieldInfo.Path.AppendOrCreate(
                                            fieldInfo.ResponseName))
                               .Build();

                fieldInfo.Arguments[argument.Name] =
                    new ArgumentValue(argument, error);
            }
            else if (argument.Type.IsLeafType() && IsLeafLiteral(literal))
            {
                object coerced = CoerceArgumentValue(argument,
                                                     ParseLiteral(argument.Type, literal));
                fieldInfo.Arguments[argument.Name] =
                    new ArgumentValue(
                        argument,
                        literal.GetValueKind(),
                        coerced);
            }
            else
            {
                object coerced = CoerceArgumentValue(argument, literal);
                fieldInfo.Arguments[argument.Name] =
                    new ArgumentValue(
                        argument,
                        literal.GetValueKind(),
                        coerced);
            }
        }