/// <summary>
/// Generate the statements for pem certificate configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>>
/// X509Certificate2.CreateFromPemFile("cert.pem", "private.pem");
/// </remarks>
private static ExpressionSyntax CreatePemCertificateStatements(CurlOptions curlOptions)
{
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
string methodName = null;
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
methodName = "CreateFromEncryptedPemFile";
}
else
{
methodName = "CreateFromPemFile";
}
if (curlOptions.HasKey)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.KeyFileName));
}
var createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(X509Certificate2ClassName, methodName, newCertificateArguments.ToArray());
var pfxTypeExpression = RoslynExtensions.CreateMemberAccessExpression("X509ContentType", "Pfx");
createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(createFromPemInvocationExpression, "Export", SyntaxFactory.Argument(pfxTypeExpression));
return(RoslynExtensions.CreateObjectCreationExpression(X509Certificate2ClassName, SyntaxFactory.Argument(createFromPemInvocationExpression)));
}
public ExpressionStatementSyntax CreateSetHttpVersionStatement(CurlOptions options)
{
var arguments = new LinkedList <ArgumentSyntax>();
var majorVersionArgument = options.HttpVersion switch
{
HttpVersion.Http09 => RoslynExtensions.CreateIntLiteralArgument(0),
HttpVersion.Http10 => RoslynExtensions.CreateIntLiteralArgument(1),
HttpVersion.Http11 => RoslynExtensions.CreateIntLiteralArgument(1),
HttpVersion.Http20 => RoslynExtensions.CreateIntLiteralArgument(2),
HttpVersion.Http30 => RoslynExtensions.CreateIntLiteralArgument(3),
_ => throw new ArgumentOutOfRangeException()
};
arguments.AddLast(majorVersionArgument);
var minorVersionArgument = options.HttpVersion switch
{
HttpVersion.Http09 => RoslynExtensions.CreateIntLiteralArgument(9),
HttpVersion.Http11 => RoslynExtensions.CreateIntLiteralArgument(1),
_ => RoslynExtensions.CreateIntLiteralArgument(0)
};
arguments.AddLast(minorVersionArgument);
var versionObjectCreationExpression =
RoslynExtensions.CreateObjectCreationExpression("Version", arguments.ToArray());
return(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
"Version",
versionObjectCreationExpression)));
}
/// <summary>
/// Generates the string content creation expression.
/// </summary>
/// <param name="contentSyntax">The content syntax.</param>
/// <returns>
/// <see cref="ObjectCreationExpressionSyntax" /> expression.
/// </returns>
/// <remarks>
/// new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json")
/// </remarks>
private ObjectCreationExpressionSyntax CreateStringContentCreation(ArgumentSyntax contentSyntax)
{
var arguments = new LinkedList <ArgumentSyntax>();
arguments.AddLast(contentSyntax);
var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray());
return(stringContentCreation);
}
private UsingStatementSyntax CreateRequestUsingStatement(CurlOptions curlOptions)
{
var methodNameArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.HttpMethod);
var httpMethodArgument = RoslynExtensions.CreateObjectCreationExpression(nameof(HttpMethod), methodNameArgument);
var urlArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.Url.ToString());
return(RoslynExtensions.CreateUsingStatement(
RequestVariableName,
nameof(HttpRequestMessage),
SyntaxFactory.Argument(httpMethodArgument),
urlArgument));
}
/// <summary>
/// Generates the new byte array content expression.
/// </summary>
/// <param name="fileName">The file name.</param>
/// <returns><see cref="ObjectCreationExpressionSyntax"/> expression.</returns>
/// <remarks>
/// new ByteArrayContent(File.ReadAllBytes("file1.txt"))
/// </remarks>
private ObjectCreationExpressionSyntax CreateNewByteArrayContentExpression(string fileName)
{
var fileReadExpression = RoslynExtensions.CreateInvocationExpression(
"File",
"ReadAllBytes",
RoslynExtensions.CreateStringLiteralArgument(fileName));
var byteArrayContentExpression = RoslynExtensions.CreateObjectCreationExpression(
"ByteArrayContent",
SyntaxFactory.Argument(fileReadExpression));
return(byteArrayContentExpression);
}
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartContent))));
if (!string.IsNullOrEmpty(curlOptions.Payload))
{
var stringContentCreation = CreateStringContentCreation(curlOptions);
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(stringContentCreation)));
statements.AddLast(addStatement.AppendWhiteSpace());
}
foreach (var file in curlOptions.Files)
{
var fileReadExpression = RoslynExtensions.CreateInvocationExpression(
"File",
"ReadAllBytes",
RoslynExtensions.CreateStringLiteralArgument(file));
var byteArrayContentExpression = RoslynExtensions.CreateObjectCreationExpression(
"ByteArrayContent",
SyntaxFactory.Argument(fileReadExpression));
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(byteArrayContentExpression)));
statements.AddLast(addStatement);
}
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generate the statements for p12 certificate configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>>
/// new X509Certificate2("certificate.crt", "password")
/// </remarks>
private static ExpressionSyntax CreateP12CertificateStatements(CurlOptions curlOptions)
{
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
X509Certificate2ClassName,
newCertificateArguments.ToArray());
return(newCertificateExpression);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <param name="result">The result.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(
CurlOptions curlOptions,
ConvertResult <string> result)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy)
{
if (IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
else
{
result.Warnings.Add($"Proxy scheme \"{curlOptions.ProxyUri.Scheme}\" is not supported");
}
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
private ObjectCreationExpressionSyntax CreateStringContentCreation(CurlOptions curlOptions)
{
var arguments = new LinkedList <ArgumentSyntax>();
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.Payload));
var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType);
if (contentHeader.Any())
{
arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8")));
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentHeader.First()));
}
var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray());
return(stringContentCreation);
}
/// <summary>
/// Generates the string content creation expression.
/// </summary>
/// <param name="contentSyntax">The content syntax.</param>
/// <param name="curlOptions">The curl options.</param>
/// <returns>
/// <see cref="ObjectCreationExpressionSyntax" /> expression.
/// </returns>
/// <remarks>
/// new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json")
/// </remarks>
private ObjectCreationExpressionSyntax CreateStringContentCreation(ArgumentSyntax contentSyntax, CurlOptions curlOptions)
{
var arguments = new LinkedList <ArgumentSyntax>();
arguments.AddLast(contentSyntax);
var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType).FirstOrDefault();
if (!string.IsNullOrEmpty(contentHeader))
{
var contentTypeValues = contentHeader.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8")));
arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentTypeValues[0].Trim()));
}
var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray());
return(stringContentCreation);
}
/// <summary>
/// Generate the statements for WebProxy object configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// handler.Proxy = new WebProxy("http://localhost:1080/") { UseDefaultCredentials = true }
/// </remarks>
private AssignmentExpressionSyntax CreateProxyStatements(CurlOptions curlOptions)
{
InitializerExpressionSyntax initializer = null;
if (curlOptions.UseDefaultProxyCredentials)
{
var defaultCredentialsAssignment = SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName("UseDefaultCredentials"),
SyntaxFactory.LiteralExpression(
SyntaxKind.TrueLiteralExpression,
SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>();
syntaxList = syntaxList.Add(defaultCredentialsAssignment);
initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, syntaxList);
}
if (curlOptions.HasProxyUserName)
{
var proxyCredentialsArguments = new LinkedList <ArgumentSyntax>();
proxyCredentialsArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUserName));
proxyCredentialsArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyPassword));
var defaultCredentialsAssignment = SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName("Credentials"),
RoslynExtensions.CreateObjectCreationExpression("NetworkCredential", proxyCredentialsArguments.ToArray()));
var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>().Add(defaultCredentialsAssignment);
initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, syntaxList);
}
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression(
"WebProxy",
initializer,
RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
return(memberAssignmentExpression);
}
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableInitializationExpression(
HandlerVariableName,
RoslynExtensions.CreateObjectCreationExpression(nameof(HttpClientHandler)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression))
.AppendWhiteSpace());
}
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = CreateProxyStatements(curlOptions);
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
if (curlOptions.Insecure)
{
var parameterListSyntax = RoslynExtensions.CreateParameterListSyntax(
"requestMessage",
"certificate",
"chain",
"policyErrors");
var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
parameterListSyntax,
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ServerCertificateCustomValidationCallback",
lambdaExpression))));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generate the HttpRequestMessage using statements with statements inside the using blocks.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="UsingStatementSyntax"/>.</returns>
/// <remarks>
/// using (var request = new HttpRequestMessage(new HttpMethod("GET"), "https://github.com/"))
/// {
/// var response = await httpClient.SendAsync(request);
/// }
/// </remarks>
private IEnumerable <UsingStatementSyntax> CreateRequestUsingStatements(CurlOptions curlOptions)
{
var innerBlock = SyntaxFactory.Block();
var methodNameArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.HttpMethod);
var httpMethodArgument = RoslynExtensions.CreateObjectCreationExpression(nameof(HttpMethod), methodNameArgument);
var urlArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.GetFullUrl());
var requestUsingStatement = RoslynExtensions.CreateUsingStatement(
RequestVariableName,
nameof(HttpRequestMessage),
SyntaxFactory.Argument(httpMethodArgument),
urlArgument);
var statements = CreateHeaderAssignmentStatements(curlOptions);
innerBlock = innerBlock.AddStatements(statements.ToArray());
if (!string.IsNullOrEmpty(curlOptions.UserPasswordPair))
{
var basicAuthorizationStatements = CreateBasicAuthorizationStatements(curlOptions);
innerBlock = innerBlock.AddStatements(basicAuthorizationStatements);
}
var requestInnerBlocks = new LinkedList <UsingStatementSyntax>();
if (curlOptions.HasDataPayload && !curlOptions.ForceGet)
{
var assignmentExpression = CreateStringContentAssignmentStatement(curlOptions);
requestInnerBlocks.AddLast(
requestUsingStatement.WithStatement(innerBlock.AddStatements(assignmentExpression.ToArray())));
}
else if (curlOptions.HasFormPayload)
{
var multipartContentStatements = CreateMultipartContentStatements(curlOptions);
requestInnerBlocks.AddLast(
requestUsingStatement.WithStatement(innerBlock.AddStatements(multipartContentStatements.ToArray())));
}
else if (curlOptions.HasFilePayload)
{
foreach (var file in curlOptions.UploadFiles)
{
// NOTE that you must use a trailing / on the last directory to really prove to
// Curl that there is no file name or curl will think that your last directory name is the remote file name to use.
if (!string.IsNullOrEmpty(curlOptions.Url.PathAndQuery) &&
curlOptions.Url.PathAndQuery.EndsWith('/'))
{
var objectCreationExpressionSyntaxs = requestUsingStatement.DescendantNodes()
.OfType <ObjectCreationExpressionSyntax>()
.First(
t => t.Type is IdentifierNameSyntax identifier &&
identifier.Identifier.ValueText == nameof(HttpRequestMessage));
var s = objectCreationExpressionSyntaxs.ArgumentList.Arguments.Last();
requestUsingStatement = requestUsingStatement.ReplaceNode(
s,
RoslynExtensions.CreateStringLiteralArgument(curlOptions.GetUrlForFileUpload(file).ToString()));
}
var byteArrayContentExpression = CreateNewByteArrayContentExpression(file);
requestInnerBlocks.AddLast(requestUsingStatement.WithStatement(innerBlock.AddStatements(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
byteArrayContentExpression))
.AppendWhiteSpace())));
}
}
else if (curlOptions.HttpVersionSpecified)
{
var httpVersionStatement = CreateSetHttpVersionStatement(curlOptions);
innerBlock = innerBlock.AddStatements(httpVersionStatement);
}
var sendStatement = CreateSendStatement();
if (!requestInnerBlocks.Any())
{
return(new List <UsingStatementSyntax> {
requestUsingStatement.WithStatement(innerBlock.AddStatements(sendStatement))
});
}
return(requestInnerBlocks.Select(i => i.WithStatement(((BlockSyntax)i.Statement).AddStatements(sendStatement))));
}
/// <summary>
/// Generates the multipart content statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var multipartContent = new MultipartFormDataContent();
/// multipartContent.Add(new StringContent("John"), "name");
/// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("D:\\text.txt")), "shoesize", Path.GetFileName("D:\\text.txt"));
/// request.Content = multipartContent;
/// </remarks>
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartFormDataContent))));
foreach (var data in curlOptions.FormData)
{
StatementSyntax addStatement;
if (data.Type == UploadDataType.Inline)
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
else if (data.Type == UploadDataType.BinaryFile)
{
var contentExpression = CreateNewByteArrayContentExpression(data.Content);
var getFileNameSyntax = RoslynExtensions.CreateInvocationExpression(
nameof(Path),
nameof(Path.GetFileName),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name),
SyntaxFactory.Argument(getFileNameSyntax)));
}
else
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
SyntaxFactory.Argument(CreateFileReadAllTextExpression(data.Content)));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
statements.AddLast(addStatement);
}
statements.AddLast(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
SyntaxFactory.IdentifierName(MultipartVariableName))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generates the multipart content statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var multipartContent = new MultipartFormDataContent();
/// multipartContent.Add(new StringContent("John"), "name");
/// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("D:\\text.txt")), "shoesize", Path.GetFileName("D:\\text.txt"));
/// request.Content = multipartContent;
/// </remarks>
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartFormDataContent))));
int fileCounter = 1;
foreach (var data in curlOptions.FormData)
{
StatementSyntax addStatement;
if (data.Type == UploadDataType.Inline)
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
else if (data.Type == UploadDataType.BinaryFile)
{
var getFileNameArgument = string.IsNullOrEmpty(data.FileName)
? SyntaxFactory.Argument(
RoslynExtensions.CreateInvocationExpression(
nameof(Path),
nameof(Path.GetFileName),
RoslynExtensions.CreateStringLiteralArgument(data.Content)))
: RoslynExtensions.CreateStringLiteralArgument(data.FileName);
// If the file has content type, we should add it to ByteArrayContent headers
var contentExpression = CreateNewByteArrayContentExpression(data.Content);
ExpressionSyntax contentArgumentExpression;
if (string.IsNullOrEmpty(data.ContentType))
{
contentArgumentExpression = contentExpression;
}
else
{
var byteArrayVariableName = "file" + fileCounter;
var byteArrayContentInitialization = RoslynExtensions.CreateVariableInitializationExpression(byteArrayVariableName, contentExpression);
statements.AddLast(SyntaxFactory.LocalDeclarationStatement(byteArrayContentInitialization));
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
byteArrayVariableName,
"Headers",
"Add",
RoslynExtensions.CreateStringLiteralArgument("Content-Type"),
RoslynExtensions.CreateStringLiteralArgument(data.ContentType))));
contentArgumentExpression = SyntaxFactory.IdentifierName(byteArrayVariableName);
}
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentArgumentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name),
getFileNameArgument));
}
else
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
SyntaxFactory.Argument(CreateFileReadAllTextExpression(data.Content)));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
statements.AddLast(addStatement);
}
statements.AddLast(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
SyntaxFactory.IdentifierName(MultipartVariableName))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}