/// <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));
}
