private List <MemberDeclarationSyntax> CreateMembers(string className)
{
var result = new List <MemberDeclarationSyntax>();
// Add Field
////result.Add(CreateActionResultField());
// Add Constructor
result.AddRange(CreateConstructor(className, "result"));
// Methods
result.AddRange(CreateMethods(className));
// Add Implicit Operator for ActionResult
////result.Add(
//// CreateImplicitOperatorForActionResult(className)
//// .WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResultsImplicitOperator(className)));
// Add Implicit Operator
var implicitOperator = CreateImplicitOperator(className, ApiOperation.Responses);
if (implicitOperator != null)
{
result.Add(
implicitOperator
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResultsImplicitOperator(className)));
}
return(result);
}
public bool GenerateCode()
{
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Endpoints,
FocusOnSegmentName);
// Create class
// TODO: var classDeclaration = SyntaxClassDeclarationFactory.CreateWithInterface(classTypeName, interfaceTypeName)
var classDeclaration = SyntaxClassDeclarationFactory.Create(EndpointTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResults(ApiOperation, FocusOnSegmentName));
classDeclaration = classDeclaration.AddMembers(CreateFieldIHttpClientFactory());
classDeclaration = classDeclaration.AddMembers(CreateFieldIHttpExchangeFactory());
classDeclaration = classDeclaration.AddMembers(CreateConstructor());
classDeclaration = classDeclaration.AddMembers(CreateMembers());
// TODO: Imp. this.
var usedApiOperations = new List <OpenApiOperation>();
// Add using statement to compilationUnit
var includeRestResults = classDeclaration
.Select <IdentifierNameSyntax>()
.Any(x => x.Identifier.ValueText.Contains(
$"({Microsoft.OpenApi.Models.NameConstants.Pagination}<",
StringComparison.Ordinal));
compilationUnit = compilationUnit.AddUsingStatements(
ProjectEndpointsFactory.CreateUsingList(
ApiProjectOptions,
FocusOnSegmentName,
usedApiOperations,
includeRestResults,
HasSharedResponseContract(),
forClient: true));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Endpoints,
FocusOnSegmentName);
// Create interface
var interfaceDeclaration = SyntaxInterfaceDeclarationFactory.Create(InterfaceTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResults(ApiOperation, FocusOnSegmentName));
// Create interface-method
interfaceDeclaration = interfaceDeclaration.AddMembers(CreateMembers());
//// TODO: var methodDeclaration = ...
// Add using statement to compilationUnit
var includeRestResults = interfaceDeclaration
.Select <IdentifierNameSyntax>()
.Any(x => x.Identifier.ValueText.Contains(
$"({Microsoft.OpenApi.Models.NameConstants.Pagination}<",
StringComparison.Ordinal));
compilationUnit = compilationUnit.AddUsingStatements(
ProjectApiClientFactory.CreateUsingListForEndpointInterface(
ApiProjectOptions,
includeRestResults,
OpenApiDocumentSchemaModelNameHelper.HasList(ResultTypeName),
OpenApiDocumentSchemaModelNameHelper.HasSharedResponseContract(
ApiProjectOptions.Document,
OperationSchemaMappings,
FocusOnSegmentName)));
// Add interface-method to interface
//// TODO: interfaceDeclaration = interfaceDeclaration.AddMembers(methodDeclaration);
// Add the interface to the namespace.
@namespace = @namespace.AddMembers(interfaceDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
var resultTypeName = ApiOperation.GetOperationName() + NameConstants.ContractResult;
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts,
FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.CreateWithInheritClassTypeAndSuppressMessageAttributeByCheckId(
resultTypeName,
"ResultBase",
1062,
"Should not throw ArgumentNullExceptions from implicit operators.")
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResults(ApiOperation, FocusOnSegmentName));
// Create members
var memberDeclarations = CreateMembers(resultTypeName);
// Add members to class
classDeclaration = memberDeclarations.Aggregate(
classDeclaration,
(current, memberDeclaration) => current.AddMembers(memberDeclaration));
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(
ProjectContractResultFactory.CreateUsingList(
ApiOperation.Responses,
ApiProjectOptions.ApiOptions.Generator.Response.UseProblemDetailsAsDefaultBody));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
var interfaceTypeName = "I" + ApiOperation.GetOperationName() + NameConstants.ContractHandler;
var parameterTypeName = ApiOperation.GetOperationName() + NameConstants.ContractParameters;
var resultTypeName = ApiOperation.GetOperationName() + NameConstants.ContractResult;
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts,
FocusOnSegmentName);
// Create interface
var interfaceDeclaration = SyntaxInterfaceDeclarationFactory.Create(interfaceTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForInterface(ApiOperation, FocusOnSegmentName));
// Create interface-method
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateInterfaceMethod(parameterTypeName, resultTypeName, HasParametersOrRequestBody)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForInterfaceMethod(GlobalPathParameters.Any() || ApiOperation.HasParametersOrRequestBody()));
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(ProjectContractInterfaceFactory.CreateUsingList());
// Add interface-method to interface
interfaceDeclaration = interfaceDeclaration.AddMembers(methodDeclaration);
// Add the interface to the namespace.
@namespace = @namespace.AddMembers(interfaceDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
DomainProjectOptions,
NameConstants.Handlers,
FocusOnSegmentName,
false);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.CreateWithInterface(HandlerTypeName, InterfaceTypeName)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForHandlers(ApiOperation, FocusOnSegmentName));
// Create members
var memberDeclarations = CreateMembers();
// Add members to class
classDeclaration = memberDeclarations.Aggregate(
classDeclaration,
(current, memberDeclaration) => current.AddMembers(memberDeclaration));
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(
ProjectHandlerFactory.CreateUsingList(
DomainProjectOptions,
FocusOnSegmentName));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
NamespaceDeclarationSyntax @namespace;
if (ApiSchema.IsSchemaEnumOrPropertyEnum())
{
IsEnum = true;
// Create a namespace
@namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts);
var apiEnumSchema = ApiSchema.GetEnumSchema();
// Create an enum
var enumDeclaration = SyntaxEnumFactory.Create(apiEnumSchema.Item1.EnsureFirstCharacterToUpper(), apiEnumSchema.Item2);
if (enumDeclaration.HasAttributeOfAttributeType(typeof(FlagsAttribute)))
{
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(new[] { "System" });
}
if (enumDeclaration.HasAttributeOfAttributeType(typeof(SuppressMessageAttribute)))
{
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(new[] { "System.Diagnostics.CodeAnalysis" });
}
// Add the enum to the namespace.
@namespace = @namespace.AddMembers(enumDeclaration);
}
else
{
// Create a namespace
@namespace = IsSharedContract
? SyntaxProjectFactory.CreateNamespace(ApiProjectOptions, NameConstants.Contracts)
: SyntaxProjectFactory.CreateNamespace(ApiProjectOptions, NameConstants.Contracts, FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(ApiSchemaKey.EnsureFirstCharacterToUpper())
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.Create(ApiSchema));
// Create class-properties and add to class
if (ApiSchema.Properties != null)
{
if (ApiSchema.Type == OpenApiDataTypeConstants.Array)
{
var(key, _) = ApiProjectOptions.Document.Components.Schemas.FirstOrDefault(x => x.Key.Equals(ApiSchema.Title, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(ApiSchema.Title))
{
ApiSchema.Title = ApiSchemaKey;
key = ApiSchemaKey;
}
if (string.IsNullOrEmpty(ApiSchema.Items.Title))
{
ApiSchema.Items.Title = ApiSchemaKey;
}
var title = key != null
? $"{ApiSchema.Title.EnsureFirstCharacterToUpperAndSingular()}List"
: ApiSchema.Title.EnsureFirstCharacterToUpper();
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateListAuto(ApiSchema.Items.Title, title)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateSummary($"A list of {ApiSchema.Items.Title}."));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
else
{
foreach (var property in ApiSchema.Properties)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
property,
ApiSchema.Required,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes)
.WithLeadingTrivia(SyntaxDocumentationFactory.Create(property.Value));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateToStringMethod(ApiSchema.Properties);
if (methodDeclaration != null)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForOverrideToString());
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
}
}
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(ProjectContractDataFactory.CreateUsingList(ApiSchema));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
}
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
private List <MemberDeclarationSyntax> CreateMethods(string className)
{
var result = new List <MemberDeclarationSyntax>();
var httpStatusCodes = ApiOperation.Responses.GetHttpStatusCodes();
foreach (var httpStatusCode in httpStatusCodes)
{
var isList = ApiOperation.Responses.IsSchemaTypeArrayForStatusCode(httpStatusCode);
var modelName = ApiOperation.Responses.GetModelNameForStatusCode(httpStatusCode);
var schema = ApiOperation.Responses.GetSchemaForStatusCode(httpStatusCode);
var useProblemDetails = ApiOperation.Responses.IsSchemaTypeProblemDetailsForStatusCode(httpStatusCode);
if (!useProblemDetails && ApiProjectOptions.ApiOptions.Generator.Response.UseProblemDetailsAsDefaultBody)
{
useProblemDetails = true;
}
MethodDeclarationSyntax?methodDeclaration;
switch (httpStatusCode)
{
case HttpStatusCode.OK:
var isPagination = ApiOperation.Responses.IsSchemaTypePaginationForStatusCode(httpStatusCode);
if (useProblemDetails)
{
if (string.IsNullOrEmpty(modelName))
{
if (schema != null && schema.IsSimpleDataType())
{
methodDeclaration = CreateTypeRequestObjectResult(className, httpStatusCode.ToNormalizedString(), schema.GetDataType(), "response", isList, isPagination);
}
else
{
methodDeclaration = CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull("CreateContentResult", className, httpStatusCode);
}
}
else
{
methodDeclaration = CreateTypeRequestObjectResult(className, httpStatusCode.ToNormalizedString(), modelName, "response", isList, isPagination);
}
}
else
{
if (string.IsNullOrEmpty(modelName))
{
if (schema != null && schema.IsSimpleDataType())
{
methodDeclaration = CreateTypeRequestObjectResult(className, httpStatusCode.ToNormalizedString(), schema.GetDataType(), "response", isList, isPagination);
}
else
{
methodDeclaration = CreateTypeRequestWithMessageAllowNull(className, httpStatusCode, nameof(OkObjectResult));
}
}
else
{
methodDeclaration = CreateTypeRequestObjectResult(className, httpStatusCode.ToNormalizedString(), modelName, "response", isList, isPagination);
}
}
break;
case HttpStatusCode.Created:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResult", className, httpStatusCode)
: CreateStatusCodeResult(className, httpStatusCode);
break;
case HttpStatusCode.Accepted:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateTypeRequest(className, httpStatusCode, nameof(AcceptedResult));
break;
case HttpStatusCode.NoContent:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateTypeRequest(className, httpStatusCode, nameof(NoContentResult));
break;
case HttpStatusCode.NotModified:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateStatusCodeResult(className, httpStatusCode);
break;
case HttpStatusCode.BadRequest:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithProblemDetailsWithMessage(className, httpStatusCode)
: CreateTypeRequestWithMessage(className, httpStatusCode, nameof(BadRequestObjectResult));
break;
case HttpStatusCode.Unauthorized:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateTypeRequest(className, httpStatusCode, nameof(UnauthorizedResult));
break;
case HttpStatusCode.Forbidden:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethod("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateStatusCodeResult(className, httpStatusCode);
break;
case HttpStatusCode.NotFound:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateTypeRequestWithMessageAllowNull(className, httpStatusCode, nameof(NotFoundObjectResult));
break;
case HttpStatusCode.Conflict:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull("CreateContentResultWithProblemDetails", className, httpStatusCode, "error")
: CreateTypeRequestWithMessageAllowNull(className, httpStatusCode, nameof(ConflictObjectResult), "error");
break;
case HttpStatusCode.MethodNotAllowed:
case HttpStatusCode.InternalServerError:
case HttpStatusCode.NotImplemented:
case HttpStatusCode.BadGateway:
case HttpStatusCode.ServiceUnavailable:
case HttpStatusCode.GatewayTimeout:
methodDeclaration = useProblemDetails
? CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull("CreateContentResultWithProblemDetails", className, httpStatusCode)
: CreateTypeRequestWithObject(className, httpStatusCode, nameof(ContentResult));
break;
default:
throw new NotImplementedException("Method: " + nameof(httpStatusCode) + " " + httpStatusCode);
}
result.Add(
methodDeclaration
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForResultsMethod(httpStatusCode)));
}
return(result);
}
public bool GenerateCode()
{
var parameterTypeName = ApiOperation.GetOperationName() + NameConstants.ContractParameters;
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts,
FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(parameterTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameters(ApiOperation, FocusOnSegmentName));
// Add properties to the class
if (GlobalPathParameters.Any())
{
foreach (var parameter in GlobalPathParameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameter,
ApiProjectOptions.UseNullableReferenceTypes,
ApiProjectOptions.IsForClient)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
if (ApiOperation.Parameters is not null)
{
foreach (var parameter in ApiOperation.Parameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameter,
ApiProjectOptions.UseNullableReferenceTypes,
ApiProjectOptions.IsForClient)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
var requestSchema = ApiOperation.RequestBody?.Content?.GetSchemaByFirstMediaType();
if (ApiOperation.RequestBody is not null &&
requestSchema is not null)
{
var isFormatTypeOfBinary = requestSchema.IsFormatTypeBinary();
var isItemsOfFormatTypeBinary = requestSchema.HasItemsWithFormatTypeBinary();
var requestBodyType = "string?";
if (requestSchema.Reference is not null)
{
requestBodyType = requestSchema.Reference.Id.EnsureFirstCharacterToUpper();
}
else if (isFormatTypeOfBinary)
{
requestBodyType = "IFormFile";
}
else if (isItemsOfFormatTypeBinary)
{
requestBodyType = "IFormFile";
}
else if (requestSchema.Items is not null)
{
requestBodyType = requestSchema.Items.Reference.Id.EnsureFirstCharacterToUpper();
}
PropertyDeclarationSyntax propertyDeclaration;
if (requestSchema.IsTypeArray())
{
if (ApiProjectOptions.IsForClient)
{
propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateListAuto(requestBodyType, NameConstants.Request)
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
else
{
propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateListAuto(requestBodyType, NameConstants.Request);
propertyDeclaration = requestSchema.HasItemsWithFormatTypeBinary()
? propertyDeclaration.AddFromFormAttribute()
: propertyDeclaration.AddFromBodyAttribute();
propertyDeclaration = propertyDeclaration
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
}
else
{
if (ApiProjectOptions.IsForClient)
{
propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameterLocation: null,
isNullable: false,
isRequired: true,
requestBodyType,
NameConstants.Request,
ApiProjectOptions.UseNullableReferenceTypes,
initializer: null)
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
else
{
propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameterLocation: null,
isNullable: false,
isRequired: true,
requestBodyType,
NameConstants.Request,
ApiProjectOptions.UseNullableReferenceTypes,
initializer: null);
propertyDeclaration = requestSchema.HasAnyPropertiesWithFormatTypeBinary() || requestSchema.HasAnyPropertiesAsArrayWithFormatTypeBinary()
? propertyDeclaration.AddFromFormAttribute()
: propertyDeclaration.AddFromBodyAttribute();
propertyDeclaration = propertyDeclaration
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
}
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateToStringMethod(GlobalPathParameters, ApiOperation.Parameters, ApiOperation.RequestBody);
if (methodDeclaration is not null)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForOverrideToString());
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
}
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(
ProjectApiFactory.CreateUsingListForContractParameter(
GlobalPathParameters,
ApiOperation.Parameters,
ApiOperation.RequestBody,
ApiProjectOptions.IsForClient));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
var parameterTypeName = ApiOperation.GetOperationName() + NameConstants.ContractParameters;
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts,
FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(parameterTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameters(ApiOperation, FocusOnSegmentName));
// Add properties to the class
if (GlobalPathParameters.Any())
{
foreach (var parameter in GlobalPathParameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(parameter, ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
if (ApiOperation.Parameters != null)
{
foreach (var parameter in ApiOperation.Parameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(parameter, ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
if (ApiOperation.RequestBody?.Content != null)
{
foreach (var item in ApiOperation.RequestBody.Content.Values)
{
if (item.Schema.Reference == null)
{
continue;
}
var requestBodyType = item.Schema.Reference.Id.EnsureFirstCharacterToUpper();
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
null,
false,
true,
requestBodyType,
NameConstants.Request,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes,
null)
.AddFromBodyAttribute()
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateToStringMethod(GlobalPathParameters, ApiOperation.Parameters, ApiOperation.RequestBody);
if (methodDeclaration != null)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForOverrideToString());
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
}
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(ProjectContractPropertyFactory.CreateUsingList(GlobalPathParameters, ApiOperation.Parameters, ApiOperation.RequestBody));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
var controllerTypeName = FocusOnSegmentName.EnsureFirstCharacterToUpper() + "Controller";
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Endpoints);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(controllerTypeName);
if (ApiProjectOptions.ApiOptions.Generator.UseAuthorization)
{
classDeclaration =
classDeclaration.AddAttributeLists(
SyntaxAttributeListFactory.Create(nameof(AuthorizeAttribute)));
}
classDeclaration =
classDeclaration.AddAttributeLists(
SyntaxAttributeListFactory.Create(nameof(ApiControllerAttribute)),
SyntaxAttributeListFactory.CreateWithOneItemWithOneArgument(nameof(RouteAttribute), $"api/{ApiProjectOptions.ApiVersion}/{FocusOnSegmentName}"))
.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(nameof(ControllerBase))))
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForEndpoints(FocusOnSegmentName));
// Create Methods
var usedApiOperations = new List <OpenApiOperation>();
foreach (var(key, value) in ApiProjectOptions.Document.GetPathsByBasePathSegmentName(FocusOnSegmentName))
{
var hasRouteParameters = value.HasParameters();
foreach (var apiOperation in value.Operations)
{
var methodDeclaration = CreateMembersForEndpoints(apiOperation, key, FocusOnSegmentName, hasRouteParameters)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForEndpointMethods(apiOperation, FocusOnSegmentName));
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
usedApiOperations.Add(apiOperation.Value);
}
}
// Create private part for methods
foreach (var(_, value) in ApiProjectOptions.Document.GetPathsByBasePathSegmentName(FocusOnSegmentName))
{
var hasRouteParameters = value.HasParameters();
foreach (var apiOperation in value.Operations)
{
var methodDeclaration = CreateMembersForEndpointsPrivateHelper(apiOperation, hasRouteParameters);
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
usedApiOperations.Add(apiOperation.Value);
}
}
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add using statement to compilationUnit
var includeRestResults = classDeclaration
.Select <IdentifierNameSyntax>()
.Any(x => x.Identifier.ValueText.Contains($"({Microsoft.OpenApi.Models.NameConstants.Pagination}<", StringComparison.Ordinal));
compilationUnit = compilationUnit.AddUsingStatements(
ProjectEndpointsFactory.CreateUsingList(
ApiProjectOptions,
FocusOnSegmentName,
usedApiOperations,
includeRestResults));
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
public bool GenerateCode()
{
var parameterTypeName = ApiOperation.GetOperationName() + NameConstants.ContractParameters;
// Create compilationUnit
var compilationUnit = SyntaxFactory.CompilationUnit();
// Create a namespace
var @namespace = SyntaxProjectFactory.CreateNamespace(
ApiProjectOptions,
NameConstants.Contracts,
FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(parameterTypeName)
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameters(ApiOperation, FocusOnSegmentName));
// Add properties to the class
if (GlobalPathParameters.Any())
{
foreach (var parameter in GlobalPathParameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameter,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes,
ApiProjectOptions.ForClient)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
if (ApiOperation.Parameters != null)
{
foreach (var parameter in ApiOperation.Parameters)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
parameter,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes,
ApiProjectOptions.ForClient)
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(parameter));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
var requestSchema = ApiOperation.RequestBody?.Content?.GetSchema();
if (ApiOperation.RequestBody != null && requestSchema != null)
{
var requestBodyType = requestSchema.Reference != null
? requestSchema.Reference.Id.EnsureFirstCharacterToUpper()
: requestSchema.Items.Reference.Id.EnsureFirstCharacterToUpper();
PropertyDeclarationSyntax propertyDeclaration;
if (requestSchema.Type == OpenApiDataTypeConstants.Array)
{
propertyDeclaration = ApiProjectOptions.ForClient
? SyntaxPropertyDeclarationFactory.CreateListAuto(
requestBodyType,
NameConstants.Request)
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody))
: SyntaxPropertyDeclarationFactory.CreateListAuto(
requestBodyType,
NameConstants.Request)
.AddFromBodyAttribute()
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
else
{
propertyDeclaration = ApiProjectOptions.ForClient
? SyntaxPropertyDeclarationFactory.CreateAuto(
parameterLocation: null,
isNullable: false,
isRequired: true,
requestBodyType,
NameConstants.Request,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes,
initializer: null)
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody))
: SyntaxPropertyDeclarationFactory.CreateAuto(
parameterLocation: null,
isNullable: false,
isRequired: true,
requestBodyType,
NameConstants.Request,
ApiProjectOptions.ApiOptions.Generator.UseNullableReferenceTypes,
initializer: null)
.AddFromBodyAttribute()
.AddValidationAttribute(new RequiredAttribute())
.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForParameter(ApiOperation.RequestBody));
}
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateToStringMethod(GlobalPathParameters, ApiOperation.Parameters, ApiOperation.RequestBody);
if (methodDeclaration != null)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForOverrideToString());
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
}
// Add using statement to compilationUnit
compilationUnit = compilationUnit.AddUsingStatements(
ProjectContractPropertyFactory.CreateUsingList(
GlobalPathParameters,
ApiOperation.Parameters,
ApiOperation.RequestBody,
ApiProjectOptions.ForClient));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Add namespace to compilationUnit
compilationUnit = compilationUnit.AddMembers(@namespace);
// Set code property
Code = compilationUnit;
return(true);
}
private NamespaceDeclarationSyntax GenerateCodeForOtherThanEnum(
ref CompilationUnitSyntax?compilationUnit)
{
// Create a namespace
var @namespace = IsSharedContract
? SyntaxProjectFactory.CreateNamespace(ApiProjectOptions, NameConstants.Contracts)
: SyntaxProjectFactory.CreateNamespace(ApiProjectOptions, NameConstants.Contracts, FocusOnSegmentName);
// Create class
var classDeclaration = SyntaxClassDeclarationFactory.Create(ApiSchemaKey.EnsureFirstCharacterToUpper())
.AddGeneratedCodeAttribute(ApiProjectOptions.ToolName, ApiProjectOptions.ToolVersion.ToString())
.WithLeadingTrivia(SyntaxDocumentationFactory.Create(ApiSchema));
var hasAnyPropertiesAsArrayWithFormatTypeBinary = ApiSchema.HasAnyPropertiesAsArrayWithFormatTypeBinary();
// Create class-properties and add to class
if (ApiSchema.Properties is not null)
{
if (ApiSchema.IsTypeArray() ||
hasAnyPropertiesAsArrayWithFormatTypeBinary)
{
var(key, _) = ApiProjectOptions.Document.Components.Schemas.FirstOrDefault(x =>
x.Key.Equals(ApiSchema.Title, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(ApiSchema.Title))
{
ApiSchema.Title = ApiSchemaKey;
key = ApiSchemaKey;
}
if (ApiSchema.Items is not null &&
string.IsNullOrEmpty(ApiSchema.Items.Title))
{
ApiSchema.Items.Title = ApiSchemaKey;
}
var title = key is not null
? $"{ApiSchema.Title.EnsureFirstCharacterToUpperAndSingular()}List"
: ApiSchema.Title.EnsureFirstCharacterToUpper();
var propertyDeclaration = hasAnyPropertiesAsArrayWithFormatTypeBinary
? SyntaxPropertyDeclarationFactory.CreateListAuto("IFormFile", ApiSchema.ExtractPropertyNameWhenHasAnyPropertiesOfArrayWithFormatTypeBinary())
.WithLeadingTrivia(
SyntaxDocumentationFactory.CreateSummary("A list of File(s)."))
: SyntaxPropertyDeclarationFactory.CreateListAuto(ApiSchema.Items !.Title, title)
.WithLeadingTrivia(
SyntaxDocumentationFactory.CreateSummary($"A list of {ApiSchema.Items.Title}."));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
else
{
foreach (var property in ApiSchema.Properties)
{
var propertyDeclaration = SyntaxPropertyDeclarationFactory.CreateAuto(
property,
ApiSchema.Required,
ApiProjectOptions.UseNullableReferenceTypes)
.WithLeadingTrivia(SyntaxDocumentationFactory.Create(property.Value));
classDeclaration = classDeclaration.AddMembers(propertyDeclaration);
}
}
var methodDeclaration = SyntaxMethodDeclarationFactory.CreateToStringMethod(ApiSchema.Properties);
if (methodDeclaration is not null)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxDocumentationFactory.CreateForOverrideToString());
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
}
}
// Add using statement to compilationUnit
compilationUnit = compilationUnit !.AddUsingStatements(ProjectApiFactory.CreateUsingListForContractModel(ApiSchema));
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
return(@namespace);
}
