/// <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))); }
/// <summary> /// Generates the file read all text expression. /// </summary> /// <param name="fileName">Name of the file.</param> /// <returns> /// <see cref="InvocationExpressionSyntax" /> expression. /// </returns> /// <remarks> /// File.ReadAllText("file name.txt") /// </remarks> private InvocationExpressionSyntax CreateFileReadAllTextExpression(string fileName) { return(RoslynExtensions.CreateInvocationExpression( "File", "ReadAllText", RoslynExtensions.CreateStringLiteralArgument(fileName))); }
/// <summary> /// Generates the headers adding statement. /// </summary> /// <param name="keyArgumentSyntax">The header key argument syntax.</param> /// <param name="valueArgumentSyntax">The header value argument syntax.</param> /// <returns><see cref="ExpressionStatementSyntax"/> statement.</returns> /// <remarks> /// request.Headers.TryAddWithoutValidation("Accept", "application/json"); /// </remarks> private ExpressionStatementSyntax CreateTryAddHeaderStatement(ArgumentSyntax keyArgumentSyntax, ArgumentSyntax valueArgumentSyntax) { var invocationExpressionSyntax = RoslynExtensions.CreateInvocationExpression( RequestVariableName, "Headers", "TryAddWithoutValidation", keyArgumentSyntax, valueArgumentSyntax); return(SyntaxFactory.ExpressionStatement(invocationExpressionSyntax)); }
/// <summary> /// Generate the statements for sending a HttpRequestMessage. /// </summary> /// <returns><see cref="LocalDeclarationStatementSyntax"/> statement.</returns> /// <remarks> /// var response = await httpClient.SendAsync(request); /// </remarks> private LocalDeclarationStatementSyntax CreateSendStatement() { var invocationExpressionSyntax = RoslynExtensions.CreateInvocationExpression( HttpClientVariableName, "SendAsync", SyntaxFactory.Argument(SyntaxFactory.IdentifierName(RequestVariableName))); var awaitExpression = SyntaxFactory.AwaitExpression(invocationExpressionSyntax); var declarationSyntax = RoslynExtensions.CreateVariableInitializationExpression("response", awaitExpression); return(SyntaxFactory.LocalDeclarationStatement(declarationSyntax)); }
/// <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> /// Generates the multipart content statements. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="StatementSyntax"/>.</returns> /// <remarks> /// var multipartContent = new MultipartContent(); /// multipartContent.Add(new StringContent("test", Encoding.UTF8, "application/x-www-form-urlencoded")); /// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("file1.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(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.DataFiles) { var byteArrayContentExpression = CreateNewByteArrayContentExpression(file); var addStatement = SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( MultipartVariableName, MultipartAddMethodName, SyntaxFactory.Argument(byteArrayContentExpression))); statements.AddLast(addStatement); } statements.AddLast(SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( RequestVariableName, RequestContentPropertyName, SyntaxFactory.IdentifierName(MultipartVariableName)))); statements.TryAppendWhiteSpaceAtEnd(); return(statements); }
/// <summary> /// Generates the basic authorization encoding statement. /// </summary> /// <param name="options">The options.</param> /// <returns><see cref="LocalDeclarationStatementSyntax"/> statement.</returns> /// <remarks> /// var base64authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes("username:password")); /// </remarks> private LocalDeclarationStatementSyntax CreateBasicAuthorizationEncodingStatement(CurlOptions options) { var asciiGetBytesInvocation = RoslynExtensions.CreateInvocationExpression( "Encoding", "ASCII", "GetBytes", RoslynExtensions.CreateStringLiteralArgument(options.UserPasswordPair)); var convertToBase64Invocation = RoslynExtensions.CreateInvocationExpression( "Convert", "ToBase64String", SyntaxFactory.Argument(asciiGetBytesInvocation)); var declarationSyntax = RoslynExtensions.CreateVariableInitializationExpression( Base64AuthorizationVariableName, convertToBase64Invocation); return(SyntaxFactory.LocalDeclarationStatement(declarationSyntax)); }
private static IEnumerable <MemberDeclarationSyntax> CreateCertificateStatement(CurlOptions curlOptions) { var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>(); var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "ClientCertificateOptions", RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual")); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression))); var certificateCreationStatement = curlOptions.CertificateType switch { CertificateType.P12 => CreateP12CertificateStatements(curlOptions), CertificateType.Pem => CreatePemCertificateStatements(curlOptions), _ => throw new ArgumentOutOfRangeException(nameof(curlOptions.CertificateType), $"Unsupported certificate type {curlOptions.CertificateType}") }; var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression( HandlerVariableName, "ClientCertificates", "Add", SyntaxFactory.Argument(certificateCreationStatement)); if (curlOptions.CertificateType == CertificateType.Pem) { certificateAssignmentExpression = certificateAssignmentExpression .PrependComment( Chars.NewLineString + "// PEM certificates support requires .NET 5 and higher" + Chars.NewLineString + "// Export to PFX is needed because of this bug https://github.com/dotnet/runtime/issues/23749#issuecomment-747407051" ); } statementSyntaxs.AddLast(SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression))); return(statementSyntaxs); }
/// <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); }
/// <summary> /// Generates the string content creation statements. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="StatementSyntax"/>.</returns> /// <remarks> /// request.Content = new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json"); /// </remarks> private IEnumerable <StatementSyntax> CreateStringContentAssignmentStatement(CurlOptions curlOptions) { var expressions = new LinkedList <ExpressionSyntax>(); foreach (var data in curlOptions.UploadData) { if (data.IsUrlEncoded) { ExpressionSyntax dataExpression; if (data.IsFile) { dataExpression = CreateFileReadAllTextExpression(data.Content); } else { dataExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(data.Content)); } dataExpression = RoslynExtensions.CreateInvocationExpression("Uri", "EscapeDataString", SyntaxFactory.Argument(dataExpression)); if (data.HasName) { dataExpression = RoslynExtensions.CreateInterpolatedStringExpression($"{data.Name}=", dataExpression); } expressions.AddLast(dataExpression); continue; } if (data.Type == UploadDataType.BinaryFile) { var readFileExpression = CreateFileReadAllTextExpression(data.Content); expressions.AddLast(readFileExpression); continue; } if (data.Type == UploadDataType.InlineFile) { var readFileExpression = CreateFileReadAllTextExpression(data.Content); var replaceNewLines = RoslynExtensions.CreateInvocationExpression( "Regex", "Replace", SyntaxFactory.Argument(readFileExpression), RoslynExtensions.CreateStringLiteralArgument(@"(?:\r\n|\n|\r)"), SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("string", "Empty"))); expressions.AddLast(replaceNewLines); continue; } expressions.AddLast( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(data.Content))); } var statements = new LinkedList <StatementSyntax>(); ArgumentSyntax stringContentArgumentSyntax; if (expressions.Count > 1) { var contentListVariableName = "contentList"; statements.AddLast( SyntaxFactory.LocalDeclarationStatement( RoslynExtensions.CreateVariableFromNewObjectExpression(contentListVariableName, "List<string>"))); foreach (var expression in expressions) { statements.AddLast( SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( contentListVariableName, "Add", SyntaxFactory.Argument(expression)))); } stringContentArgumentSyntax = SyntaxFactory.Argument( RoslynExtensions.CreateInvocationExpression( "string", "Join", RoslynExtensions.CreateStringLiteralArgument("&"), SyntaxFactory.Argument(SyntaxFactory.IdentifierName(contentListVariableName)))); } else { stringContentArgumentSyntax = SyntaxFactory.Argument(expressions.First.Value); } var stringContentCreation = CreateStringContentCreation( stringContentArgumentSyntax); statements.AddLast( SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( RequestVariableName, RequestContentPropertyName, stringContentCreation))); var memberAccessExpressionSyntax = RoslynExtensions.CreateMemberAccessExpression( RoslynExtensions.CreateMemberAccessExpression( RoslynExtensions.CreateMemberAccessExpression(RequestVariableName, RequestContentPropertyName), "Headers"), "ContentType"); statements.AddLast( SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( memberAccessExpressionSyntax, RoslynExtensions.CreateInvocationExpression("MediaTypeHeaderValue", "Parse", RoslynExtensions.CreateStringLiteralArgument(curlOptions.GetHeader(HeaderNames.ContentType)))))); statements.TryAppendWhiteSpaceAtEnd(); return(statements); }
/// <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> /// 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); }