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