/// <summary>Adds a parameter value.</summary> /// <param name="type">Type of the parameter (must be 'Path' or 'Query').</param> /// <param name="name">Parameter name.</param> /// <param name="value">Parameter value.</param> public void AddParameter(RequestParameterType type, string name, string value) { name.ThrowIfNull("name"); if (value == null) { Logger.Warning("Add parameter should not get null values. type={0}, name={1}", type, name); return; } switch (type) { case RequestParameterType.Path: if (!PathParameters.ContainsKey(name)) { PathParameters[name] = new List <string> { value }; } else { PathParameters[name].Add(value); } break; case RequestParameterType.Query: QueryParameters.Add(new KeyValuePair <string, string>(name, value)); break; default: throw new ArgumentOutOfRangeException("type"); } }
public static IRequestBuilder With(this IRequestBuilder builder, RequestParameterType type, string name, object value) { IRequestParameter parameter; if (type == RequestParameterType.Body) { parameter = new RequestBody(name, value); } else if (type == RequestParameterType.File) { if (!(value is Stream)) { throw new ArgumentException(); } parameter = new RequestFile(name, name, (Stream)value); } else { if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } parameter = new SimpleRequestParameter(type, name, value); } return(builder.With(parameter)); }
private static IDictionary <string, object> ParametersDictionary(this IRestRequest request, RequestParameterType parameterType) { return(request.Parameters == null ? new Dictionary <string, object>() : request.Parameters.Where(x => x.Type == parameterType) .ToDictionary(x => x.Name, y => y.Value, StringComparer.OrdinalIgnoreCase)); }
public void AddParameter(string key, IEnumerable <string> values, RequestParameterType parameterType) { ValidateParameterType(parameterType); var parameterValues = values.Select(v => new RequestParameterValue(v, parameterType)); GetParameterValues(key).AddRange(parameterValues); }
public static IRequestBuilder With(this IRequestBuilder builder, RequestParameterType type, IEnumerable <KeyValuePair <string, object> > values) { foreach (var pair in values) { builder = builder.With(type, pair.Key, pair.Value); } return(builder); }
public static IRequestBuilder With(this IRequestBuilder builder, RequestParameterType type, object values) { if (values != null) { builder = builder.With(values.AsParameters(type).ToArray()); } return(builder); }
internal IEnumerable <KeyValuePair <string, string> > GetParameters(RequestParameterType parameterType) { foreach (var p in _parameters) { foreach (var value in p.Value) { if ((value.Type & parameterType) != 0) { yield return(new KeyValuePair <string, string>(p.Key, value.Value)); } } } }
protected override void Execute(CodeActivityContext context) { IOperationActivity sendRequest = SendRequest.Get(context); Type workflowCallbackInterfaceType = WorkflowCallbackInterfaceType.Get(context); Type requestParameterType = RequestParameterType.Get(context); Type responseResultType = ResponseResultType.Get(context); if (sendRequest != null && workflowCallbackInterfaceType != null && requestParameterType != null && responseResultType != null) { sendRequest.OperationNames.Set( typeof(WorkflowCallbackInterfaceInfo <>).MakeGenericType(workflowCallbackInterfaceType) .GetMethod(nameof(WorkflowCallbackInterfaceInfo <object> .GetOperationNames)).Invoke(null, new object[] { requestParameterType, responseResultType }) as IEnumerable <string>); } }
public SimpleRequestParameter(RequestParameterType type, string name, object value) { if (type == RequestParameterType.Body) { throw new ArgumentException(); } if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } Type = type; Name = name; Value = value; }
internal CodeTypeMemberCollection GenerateParameterProperty(IDiscoveryParameter parameter, IMethod method, CodeTypeDeclaration resourceClass, IEnumerable <string> usedNames) { // Get the name and return type of this parameter. string name = parameter.Name; CodeTypeReference returnType = ResourceBaseGenerator.GetParameterTypeReference( resourceClass, parameter); // Generate the property and field. CodeTypeMemberCollection newMembers = DecoratorUtil.CreateAutoProperty( name, parameter.Description, returnType, usedNames, parameter.IsRequired, null); // Add the KeyAttribute to the property. foreach (CodeTypeMember member in newMembers) { CodeMemberProperty property = member as CodeMemberProperty; if (property == null) { continue; } RequestParameterType requestParameterType = parameter.ParameterType == PathParameter ? RequestParameterType.Path : RequestParameterType.Query; // Declare the RequestParameter attribute. CodeTypeReference attributeType = new CodeTypeReference(typeof(RequestParameterAttribute)); // Generates something like.. // [Google.Apis.Util.RequestParameterAttribute("prettyPrint", // Google.Apis.Util.RequestParameterType.Query)] CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(attributeType); attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(parameter.Name))); attribute.Arguments.Add( new CodeAttributeArgument( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(RequestParameterType)), Enum.GetName(typeof(RequestParameterType), requestParameterType)))); property.CustomAttributes.Add(attribute); } return(newMembers); }
private void ValidateParameterType(RequestParameterType type) { var isBodyOnly = (type & RequestParameterType.Query) == 0; if (!isBodyOnly) { return; } if (!CanMethodHaveBody) { throw new ArgumentException($"{Method} cannot have body parameters"); } if (_content != null) { throw new ArgumentException("Cannot add body parameter. Request already has a body"); } }
/// <summary> /// Adds a parameter value. /// </summary> /// <param name="type">Type of the parameter (must be Path or Query).</param> /// <param name="name">Parameter name.</param> /// <param name="value">Parameter value.</param> public void AddParameter(RequestParameterType type, string name, string value) { switch (type) { case RequestParameterType.Path: if (string.IsNullOrEmpty(value)) { throw new ArgumentException("Path parameters cannot be null or empty."); } PathParameters.Add(name, value); break; case RequestParameterType.Query: if (value == null) // don't allow null values on query (empty value is valid) { break; } QueryParameters.Add(new KeyValuePair <string, string>(name, value)); break; default: throw new ArgumentOutOfRangeException("type"); } }
public JsonRpcRequestParameter(RequestParameterType type, object value) { Type = type; Value = value; }
public RequestParameterAttribute(RequestParameterType parameterType, string parameterName = null) { ParameterType = parameterType; ParameterName = parameterName; }
/// <summary> /// Attribute a property to be a part of a REST URI. /// </summary> /// <param name="name"> /// The name of the parameter. If the parameter is a path parameter this name /// will be used to substitute the string value into the path, replacing {name}. /// If the parameter is a query parameter, this parameter will be added to the /// query string, in the format "name=value". /// </param> /// <param name="type">The type of the parameter, either Path or Query.</param> public RequestParameterAttribute(string name, RequestParameterType type) { this.name = name; this.type = type; }
public static IEnumerable <IRequestParameter> AsParameters(this object obj, RequestParameterType type) { return(obj.GetType().GetTypeInfo() .GetProperties(BindingFlags.Public | BindingFlags.Instance) .Select(x => new SimpleRequestParameter(type, x.Name, x.GetValue(obj, null)))); }
/// <summary> /// Add a parameter value. /// </summary> /// <param name="type">Type of the parameter (must be Path or Query).</param> /// <param name="name">Parameter name.</param> /// <param name="value">Parameter value.</param> public void AddParameter(RequestParameterType type, string name, string value) { switch (type) { case RequestParameterType.Path: if (string.IsNullOrEmpty(value)) { throw new ArgumentException("Path parameters cannot be null or empty."); } PathParameters.Add(name, value); break; case RequestParameterType.Query: if (string.IsNullOrEmpty(value)) { break; } QueryParameters.Add(new KeyValuePair<string, string>(name, value)); break; default: throw new ArgumentOutOfRangeException("type"); } }
/// <summary>Constructs a new property attribute to be a part of a REST URI.</summary> /// <param name="name"> /// The name of the parameter. If the parameter is a path parameter this name will be used to substitute the /// string value into the path, replacing {name}. If the parameter is a query parameter, this parameter will be /// added to the query string, in the format "name=value". /// </param> /// <param name="type">The type of the parameter, either Path or Query.</param> public RequestParameterAttribute(string name, RequestParameterType type) { this.name = name; this.type = type; }
public static void AddParameter(this IRestRequest request, RequestParameterType type, string key, object value) { request.AddParameter(new SimpleRequestParameter(type, key, value)); }
/// <summary>Constructs a new property attribute to be a part of a REST URI.</summary> /// <param name="name"> /// The name of the parameter. If the parameter is a path parameter this name will be used to substitute the /// string value into the path, replacing {name}. If the parameter is a query parameter, this parameter will be /// added to the query string, in the format "name=value". /// </param> /// <param name="type">The type of the parameter, either Path, Query or UserDefinedQueries.</param> public RequestParameterAttribute(string name, RequestParameterType type) { Name = name; Type = type; }
private static bool HasParameters(this IRestRequest request, RequestParameterType parameterType) { return(request.Parameters != null && request.Parameters.Any(x => x.Type == parameterType)); }
public static bool HasParameter(this IRestRequest request, RequestParameterType type, string key) { return(request.ParametersDictionary(type).ContainsKey(key)); }
public RequestParameterValue(string value, RequestParameterType type) { Value = value; Type = type; }
public RequestParameterValue(object value, RequestParameterType type) { Value = value; Type = type; }
public RequestParameter(RequestParameterType _Type, string _Name, object _Data) { Type = _Type; Name = _Name; Data = _Data; }
/// <summary>Adds a parameter value.</summary> /// <param name="type">Type of the parameter (must be 'Path' or 'Query').</param> /// <param name="name">Parameter name.</param> /// <param name="value">Parameter value.</param> public void AddParameter(RequestParameterType type, string name, string value) { name.ThrowIfNull("name"); if (value == null) { Logger.Warning("Add parameter should not get null values. type={0}, name={1}", type, name); return; } switch (type) { case RequestParameterType.Path: if (!PathParameters.ContainsKey(name)) { PathParameters[name] = new List<string> { value }; } else { PathParameters[name].Add(value); } break; case RequestParameterType.Query: QueryParameters.Add(new KeyValuePair<string, string>(name, value)); break; default: throw new ArgumentOutOfRangeException("type"); } }
public RequestParameterAttribute(RequestParameterType parameterType) { ParameterType = parameterType; }
public RequestParameter(string _Name, object _Data) { Type = RequestParameterType.Default; Name = _Name; Data = _Data; }
public void AddParameter(string key, string value, RequestParameterType parameterType) { AddParameter(key, new RequestParameterValue(value, parameterType)); }