/// <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 header assignment statements.
/// </summary>
/// <param name="options">The options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/></returns>
/// <remarks>
/// request.Headers.TryAddWithoutValidation("Accept", "application/json");
/// request.Headers.TryAddWithoutValidation("User-Agent", "curl/7.60.0");
/// </remarks>
private IEnumerable <StatementSyntax> CreateHeaderAssignmentStatements(CurlOptions options)
{
if (!options.HasHeaders && !options.HasCookies)
{
return(Enumerable.Empty <ExpressionStatementSyntax>());
}
var statements = new LinkedList <ExpressionStatementSyntax>();
foreach (var header in options.Headers)
{
if (string.Equals(header.Key, HeaderNames.ContentType, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
var tryAddHeaderStatement = CreateTryAddHeaderStatement(
RoslynExtensions.CreateStringLiteralArgument(header.Key),
RoslynExtensions.CreateStringLiteralArgument(header.Value));
statements.AddLast(tryAddHeaderStatement);
}
if (options.HasCookies)
{
statements.AddLast(
CreateTryAddHeaderStatement(
RoslynExtensions.CreateStringLiteralArgument("Cookie"),
RoslynExtensions.CreateStringLiteralArgument(options.CookieValue)));
}
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
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)));
}
public MethodCollector(string csProjPath, IEnumerable <string> conditinalSymbols)
{
this.csProjPath = csProjPath;
var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult();
this.typeReferences = new ReferenceSymbols(compilation);
var bothInterfaces = compilation.GetNamedTypeSymbols()
.Where(x => x.TypeKind == TypeKind.Interface)
.Where(x =>
{
var all = x.AllInterfaces;
if (all.Any(y => y == typeReferences.IServiceMarker) || all.Any(y => y == typeReferences.IStreamingHubMarker))
{
return(true);
}
return(false);
})
.ToArray();
serviceInterfaces = bothInterfaces
.Where(x => x.AllInterfaces.Any(y => y == typeReferences.IServiceMarker) && x.AllInterfaces.All(y => y != typeReferences.IStreamingHubMarker))
.Distinct()
.ToArray();
hubInterfaces = bothInterfaces
.Where(x => x.AllInterfaces.Any(y => y == typeReferences.IStreamingHubMarker))
.Distinct()
.ToArray();
}
/// <summary>
/// Generate the HttpClient using statements with empty using block.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="UsingStatementSyntax"/>.</returns>
/// <remarks>
/// using (var httpClient = new HttpClient())
/// {
/// }
/// </remarks>
private UsingStatementSyntax CreateHttpClientUsing(CurlOptions curlOptions)
{
var argumentSyntax = ShouldGenerateHandler(curlOptions)
? new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(HandlerVariableName)) }
: new ArgumentSyntax[0];
return(RoslynExtensions.CreateUsingStatement(HttpClientVariableName, nameof(HttpClient), argumentSyntax));
}
public static async Task <MethodCollector> CreateCollector(string csProjPath, IEnumerable <string> conditinalSymbols,
string framework, bool quiet)
{
MSBuildLocator.RegisterDefaults();
var compilation = await RoslynExtensions.GetCompilationFromProject(csProjPath, framework, quiet,
conditinalSymbols.ToArray());
return(new MethodCollector(csProjPath, compilation));
}
/// <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 ExpressionStatementSyntax CreateStringContentAssignmentStatement(CurlOptions curlOptions)
{
var stringContentCreation = CreateStringContentCreation(curlOptions);
return(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
"Content",
stringContentCreation))
.AppendWhiteSpace());
}
/// <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>
/// Generates the basic authorization statements.
/// </summary>
/// <param name="options">The options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var base64authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes("username:password"));
/// request.Headers.TryAddWithoutValidation("Authorization", $"Basic {base64authorization}");
/// </remarks>
private StatementSyntax[] CreateBasicAuthorizationStatements(CurlOptions options)
{
var authorizationEncodingStatement = CreateBasicAuthorizationEncodingStatement(options);
var interpolatedStringExpression = RoslynExtensions.CreateInterpolatedStringExpression("Basic ", SyntaxFactory.IdentifierName(Base64AuthorizationVariableName));
var tryAddHeaderStatement = CreateTryAddHeaderStatement(
RoslynExtensions.CreateStringLiteralArgument("Authorization"),
SyntaxFactory.Argument(interpolatedStringExpression))
.AppendWhiteSpace();
return(new StatementSyntax[] { authorizationEncodingStatement, tryAddHeaderStatement });
}
public AssemblyAttributeCollector(string csProjPath, IEnumerable <string> conditinalSymbols)
{
this.csProjPath = csProjPath;
var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult();
this.keyTupleMarker = compilation.GetTypeByMetadataName("ZeroFormatter.IKeyTuple");
var marker = compilation.GetTypeByMetadataName(HintAttributeDefinition.FullName);
var attributes = compilation.Assembly.GetAttributes();
this.hintAttributes = attributes.Where(x => x.AttributeClass == marker).ToArray();
}
/// <summary>
/// Generate the HttpClient using statements with empty using block.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="UsingStatementSyntax"/>.</returns>
/// <remarks>
/// using (var httpClient = new HttpClient())
/// {
/// }
/// </remarks>
private UsingStatementSyntax CreateHttpClientUsing(CurlOptions curlOptions)
{
var argumentSyntax = ShouldGenerateHandler(curlOptions)
? new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(HandlerVariableName)) }
: new ArgumentSyntax[0];
var usingStatement = RoslynExtensions.CreateUsingStatement(HttpClientVariableName, nameof(HttpClient), argumentSyntax);
return(usingStatement
.PrependComment("// In production code, don't destroy the HttpClient through using, but better use IHttpClientFactory factory or at least reuse an existing HttpClient instance"
+ Chars.NewLineString + "// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/http-requests"
+ Chars.NewLineString + "// https://www.aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/"));
}
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>
/// 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> CreateBasicAuthorizationStatements(CurlOptions options)
{
var authorizationEncodingStatement = CreateBasicAuthorizationEncodingStatement(options);
var stringStartToken = SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken);
var interpolatedStringContentSyntaxs = new SyntaxList <InterpolatedStringContentSyntax>()
.Add(SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.InterpolatedStringTextToken, "Basic ", null, SyntaxTriviaList.Empty)))
.Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(Base64AuthorizationVariableName)));
var interpolatedStringArgument = SyntaxFactory.Argument(SyntaxFactory.InterpolatedStringExpression(stringStartToken, interpolatedStringContentSyntaxs));
var tryAddHeaderStatement = CreateTryAddHeaderStatement(RoslynExtensions.CreateStringLiteralArgument("Authorization"), interpolatedStringArgument)
.AppendWhiteSpace();
return(new StatementSyntax[] { authorizationEncodingStatement, tryAddHeaderStatement });
}
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>
/// 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>
/// 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>
/// 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 async Task <Document> Initialize(Document document, FieldDeclarationSyntax localDeclaration,
CancellationToken cancellationToken)
{
var tree = await document.GetSyntaxTreeAsync(cancellationToken);
var root = tree.GetRoot(cancellationToken);
var constructors = root.DescendantNodes().OfType <ConstructorDeclarationSyntax>().ToList();
var csor = constructors.FirstOrDefault();
SyntaxNode visitingRoot = root;
if (csor == null)
{
var oldClass = localDeclaration.FirstAncestorOrSelf <ClassDeclarationSyntax>();
var className = oldClass.Identifier.ToString();
var paramList = RoslynExtensions.GenerateParameters(new[] { localDeclaration.Declaration.Type });
var newCtor = SyntaxFactory.ConstructorDeclaration(
attributeLists: SyntaxFactory.List(new AttributeListSyntax[] { }),
modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
identifier: oldClass.Identifier,
parameterList: paramList,
initializer: null,
body: SyntaxFactory.Block(new[] { RoslynExtensions.GenerateCtorStatement(RoslynExtensions.GetFieldName(localDeclaration), RoslynExtensions.GetFieldVariableName(localDeclaration.Declaration.Type)) }),
semicolonToken: default(SyntaxToken)
);
csor = newCtor;
visitingRoot = root.InsertNodesAfter(localDeclaration, new[] { newCtor });
}
var cr = new ConstructorRewriter(csor, localDeclaration);
var newRoot = cr.Visit(visitingRoot).WithAdditionalAnnotations(Formatter.Annotation);
//var workspace = MSBuildWorkspace.Create();
//var formatted = Formatter.Format(newRoot, workspace);
return(document.WithSyntaxRoot(newRoot));
}
/// <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);
}
public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax constructorDeclaration)
{
if (constructor == constructorDeclaration)
{
var type = field.Declaration.Type;
var variable = RoslynExtensions.GetFieldName(field);
string parameter = variable;
if (variable.StartsWith("_"))
{
parameter = variable.Substring(1);
}
else
{
variable = "this." + variable;
}
//var typeString = type.ToString();
//if (typeString.StartsWith("I"))
//name = typeString.Substring(1);
//name = Char.ToLowerInvariant(name[0]) + name.Substring(1);
var p = SyntaxFactory.Parameter(
new SyntaxList <AttributeListSyntax>(),
new SyntaxTokenList(),
type,
SyntaxFactory.Identifier(parameter),
null);
var parameters = constructorDeclaration.ParameterList.AddParameters(p);
var body = constructorDeclaration.Body;
var statement = SyntaxFactory.ParseStatement(variable + " = " + parameter + ";" + Environment.NewLine);//.WithLeadingTrivia(SyntaxFactory.Tab, SyntaxFactory.Tab);
body = body.AddStatements(statement);
return(constructorDeclaration.WithParameterList(parameters).WithBody(body)); //(BlockSyntax)formatted);
}
return(base.VisitConstructorDeclaration(constructorDeclaration));
}
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);
}
public MethodCollector(string csProjPath, IEnumerable <string> conditinalSymbols)
{
this.csProjPath = csProjPath;
var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult();
this.typeReferences = new ReferenceSymbols(compilation);
var marker = compilation.GetTypeByMetadataName("MagicOnion.IServiceMarker");
baseInterface = compilation.GetTypeByMetadataName("MagicOnion.IService`1");
serviceTypes = compilation.GetNamedTypeSymbols()
.Where(t => t.AllInterfaces.Any(x => x == marker))
.ToArray();
interfaces = serviceTypes
.Concat(serviceTypes.SelectMany(x => x.AllInterfaces))
.Distinct()
.Where(x => x != marker)
.Where(t => t != baseInterface)
.Where(x => !x.IsGenericType || x.ConstructedFrom != baseInterface)
.ToArray();
}
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);
}
