private string WithUrl(string url)
{
var uri = new Uri(url, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
throw new ArgumentException($"Url must be an absolute URI rather than relative. '{url}'", nameof(url));
}
if (uri.Query.Length > 0)
{
MatchUrlWithQuery = true;
if (QueryParams.Any())
{
throw new ArgumentException($"Url must not contain QueryString as request has already been configured to match containing a QueryParam. {QueryParams.Keys.Flat()}");
}
if (m_ParentTrackingBuilder.HasMatchUrlWithQueryParams())
{
throw new ArgumentException($"Url must not contain QueryString as request matches already exist with <c>ContainingQueryParam</c>. '{url}'", nameof(url));
}
}
return(url);
}
private void AddQueryParams(StringBuilder uriBuilder)
{
if (!QueryParams.Any())
{
return;
}
if (!uriBuilder.ToString().Contains("?"))
{
uriBuilder.Append("?");
}
for (var i = 0; i < QueryParams.Count; i++)
{
var(key, value) = QueryParams.ElementAt(i);
uriBuilder.Append($"{key}={value}");
var isLast = i == QueryParams.Count - 1;
if (!isLast)
{
uriBuilder.Append("&");
}
}
}
private void AddQueryParams(StringBuilder uriBuilder)
{
if (!QueryParams.Any())
{
return;
}
if (!uriBuilder.ToString().Contains("?"))
{
uriBuilder.Append("?");
}
for (var i = 0; i < QueryParams.Count; i++)
{
var kvp = QueryParams.ElementAt(i);
uriBuilder.AppendFormat("{0}={1}", kvp.Key, kvp.Value);
var isLast = i == QueryParams.Count - 1;
if (!isLast)
{
uriBuilder.Append("&");
}
}
}
public string ToLocalPath(String fileName = null)
{
var res = Url.Trim('/').Replace("/", "\\");
if (QueryParams != null && QueryParams.Any())
{
res = res + "\\" + CalculateMD5Hash(JsonConvert.SerializeObject(QueryParams));
}
if (fileName == null)
{
return(res);
}
return(res + "\\" + fileName);
}
protected StatementSyntax GetPaginatedQueryParams()
{
if (QueryParams.Any())
{
var queryParamDeclaration = new PaginatedQueryParamLocalDeclarationSyntax
{
Name = "queryParams",
MyParams = QueryParams,
}.GetSyntax();
return(queryParamDeclaration);
}
return(default(StatementSyntax));
}
public override string ToString()
{
string result;
if (QueryParams != null && QueryParams.Any())
{
var query = string.Join("&", QueryParams.Select(x => $"{x.Key}={UrlEncoder.Default.Encode(x.Value)}"));
result = $"{Method} {Url}?{query} {Protocol}\r\n";
}
else
{
result = $"{Method} {Url} {Protocol}\r\n";
}
if (Headers.Count > 0)
{
result += string.Join("\r\n", Headers.Select(h => $"{h.Key}: {h.Value}")) + "\r\n";
}
else
{
result += "User-Agent: xxx (shell 1)\r\n";
}
if (!string.IsNullOrEmpty(Body))
{
if (!Headers.ContainsKey("Content-Length"))
{
result += $"Content-Length: {Body.Length}\r\n";
}
result += $"\r\n{Body}";
}
result += "\r\n";
var len = result.Length;
return($"{len} {Status}\n{result}");
}
public override LocalDeclarationStatementSyntax GetSyntax()
{
var paramArgList = new List <SyntaxNodeOrToken>();
paramArgList.Add(GetLiteralArg("path", Path));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
if (PathParams.Any())
{
paramArgList.Add(GetVariableArg("pathParams", "pathParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (QueryParams.Any())
{
paramArgList.Add(GetVariableArg("queryParams", "queryParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (BodyParams.Any())
{
paramArgList.Add(GetVariableArg("bodyParams", "bodyParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
paramArgList.Add(GetMemberAccessArg("method", "HttpMethods", HttpMethod));
return(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("Func"))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SeparatedList <TypeSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.IdentifierName(ListOptionsName),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("Task"))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("ResponsePage"))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(Returns)))))))
}))))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("paginatedFunc"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ParenthesizedLambdaExpression(
getFunctionBlock(paramArgList)
)
.WithAsyncKeyword(
SyntaxFactory.Token(SyntaxKind.AsyncKeyword))
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList <ParameterSyntax>(
SyntaxFactory.Parameter(
SyntaxFactory.Identifier("_options"))
.WithType(
SyntaxFactory.IdentifierName(ListOptionsName)))))))))));
}
public override StatementSyntax GetSyntax()
{
var paramArgList = new List <SyntaxNodeOrToken>();
paramArgList.Add(GetLiteralArg("path", Path));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
if (PathParams.Any())
{
paramArgList.Add(GetVariableArg("pathParams", "pathParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (QueryParams.Any())
{
paramArgList.Add(GetVariableArg("queryParams", "queryParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (FileParams.Any())
{
paramArgList.Add(GetVariableArg("fileParams", "fileParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (FormParams.Any())
{
paramArgList.Add(GetVariableArg("formParams", "formParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (BodyParams.Any(b => b.External != true))
{
paramArgList.Add(GetVariableArg("bodyParams", "bodyParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (BodyParams.Any(b => b.External == true && !b.Key.EndsWith("request")))
{
paramArgList.Add(GetVariableArg("externalBodyParams", "externalBodyParams"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (HasRequest)
{
paramArgList.Add(GetVariableArg("request", "objectToUnpack"));
paramArgList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
paramArgList.Add(GetMemberAccessArg("method", "HttpMethods", HttpMethod));
var statementBody = SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Client"),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("CallApi"))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(Returns))))))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
paramArgList.ToArray()
))));
if (IsVoidTask)
{
return(SyntaxFactory.ExpressionStatement(statementBody));
}
return(SyntaxFactory.ReturnStatement(statementBody));
}
protected List <StatementSyntax> GetMethodBodyParams(bool ignoreQuery = false)
{
var methodBody = new List <StatementSyntax>();
if (PathParams.Any())
{
var pathDeclaration = new DictionaryParamaterLocalDeclarationSyntax
{
Name = "pathParams",
MyParams = PathParams,
}.GetSyntax();
methodBody.Add(pathDeclaration);
}
if (QueryParams.Any() && !ignoreQuery)
{
var queryParamDeclaration = new DictionaryParamaterLocalDeclarationSyntax
{
Name = "queryParams",
MyParams = QueryParams,
}.GetSyntax();
methodBody.Add(queryParamDeclaration);
}
if (FileParams.Any())
{
var fileParamDeclaration = new DictionaryParamaterLocalDeclarationSyntax
{
Name = "fileParams",
MyParams = FileParams,
VarType = "Stream",
}.GetSyntax();
methodBody.Add(fileParamDeclaration);
}
if (FormParams.Any())
{
var formParamDeclaration = new DictionaryParamaterLocalDeclarationSyntax
{
Name = "formParams",
MyParams = FormParams,
}.GetSyntax();
methodBody.Add(formParamDeclaration);
}
if (BodyParams.Any(b => b.External != true))
{
var bodyParamDeclaration = new BodyParameterContainer
{
Name = "bodyParams",
BodyType = UseAnnonBody ? "Annonymous" : Returns,
BodyParams = BodyParams.Where(b => b.External != true && !b.Key.EndsWith("request")).ToList(),
}.GetSyntax();
methodBody.Add(bodyParamDeclaration);
}
// add external body params
if (BodyParams.Any(b => b.External == true && !b.Key.EndsWith("request")))
{
var bodyParamDeclaration = new BodyParameterContainer
{
Name = "externalBodyParams",
BodyType = "Annonymous",
BodyParams = BodyParams.Where(b => b.External == true && !b.Key.EndsWith("request")).ToList(),
}.GetSyntax();
methodBody.Add(bodyParamDeclaration);
}
return(methodBody);
}
