public ClientMethod(string name, RestClientMethod restClientMethod, string?description, Diagnostic diagnostics) { Name = name; RestClientMethod = restClientMethod; Description = description; Diagnostics = diagnostics; }
private void WriteOperation(CodeWriter writer, RestClientMethod operation, bool async) { using var methodScope = writer.AmbientScope(); CSharpType?bodyType = operation.ReturnType; CSharpType?headerModelType = operation.HeaderModel?.Type; CSharpType responseType = bodyType switch { null when headerModelType != null => new CSharpType(typeof(ResponseWithHeaders <>), headerModelType), { } when headerModelType == null => new CSharpType(typeof(Response <>), bodyType), { } => new CSharpType(typeof(ResponseWithHeaders <>), bodyType, headerModelType),
private IEnumerable <PagingMethod> BuildPagingMethods() { foreach (var operation in _operationGroup.Operations) { Paging?paging = operation.Language.Default.Paging; if (paging == null || operation.IsLongRunning) { continue; } foreach (var serviceRequest in operation.Requests) { RestClientMethod method = RestClient.GetOperationMethod(serviceRequest); RestClientMethod?nextPageMethod = RestClient.GetNextOperationMethod(serviceRequest); if (!(method.Responses.SingleOrDefault(r => r.ResponseBody != null)?.ResponseBody is ObjectResponseBody objectResponseBody)) { throw new InvalidOperationException($"Method {method.Name} has to have a return value"); } TypeProvider implementation = objectResponseBody.Type.Implementation; if (!(implementation is ObjectType type)) { throw new InvalidOperationException($"The return type of {method.Name} has to be an object schema to be used in paging"); } string?nextLinkName = paging.NextLinkName; string itemName = paging.ItemName ?? "value"; ObjectTypeProperty itemProperty = type.GetPropertyBySerializedName(itemName); ObjectTypeProperty?nextLinkProperty = null; if (!string.IsNullOrWhiteSpace(nextLinkName)) { nextLinkProperty = type.GetPropertyBySerializedName(nextLinkName); } if (!(itemProperty.SchemaProperty?.Schema is ArraySchema arraySchema)) { throw new InvalidOperationException($"{itemName} property has to be an array schema, actual {itemProperty.SchemaProperty?.Schema}"); } CSharpType itemType = _context.TypeFactory.CreateType(arraySchema.ElementType, false); yield return(new PagingMethod( method, nextPageMethod, method.Name, nextLinkProperty?.Declaration.Name, itemProperty.Declaration.Name, itemType, new Diagnostic($"{Declaration.Name}.{method.Name}"))); } } }
private void WriteStartOperationOperation(CodeWriter writer, LongRunningOperationMethod lroMethod, bool async) { RestClientMethod originalMethod = lroMethod.StartMethod; CSharpType returnType = async ? new CSharpType(typeof(Task <>), lroMethod.Operation.Type) : lroMethod.Operation.Type; Parameter[] parameters = originalMethod.Parameters; writer.WriteXmlDocumentationSummary(originalMethod.Description); foreach (Parameter parameter in parameters) { writer.WriteXmlDocumentationParameter(parameter.Name, parameter.Description); } writer.WriteXmlDocumentationParameter("cancellationToken", "The cancellation token to use."); string asyncText = async ? "async " : string.Empty; writer.Append($"public virtual {asyncText}{returnType} {CreateStartOperationName(lroMethod.Name, async)}("); foreach (Parameter parameter in parameters) { writer.WriteParameter(parameter); } writer.Line($"{typeof(CancellationToken)} cancellationToken = default)"); using (writer.Scope()) { writer.WriteParameterNullChecks(parameters); WriteDiagnosticScope(writer, lroMethod.Diagnostics, writer => { string awaitText = async ? "await" : string.Empty; string configureText = async ? ".ConfigureAwait(false)" : string.Empty; writer.Append($"var originalResponse = {awaitText} RestClient.{CreateMethodName(originalMethod.Name, async)}("); foreach (Parameter parameter in parameters) { writer.Append($"{parameter.Name}, "); } writer.Line($"cancellationToken){configureText};"); writer.Append($"return new {lroMethod.Operation.Type}({ClientDiagnosticsField}, {PipelineField}, RestClient.{CreateRequestMethodName(originalMethod.Name)}("); foreach (Parameter parameter in parameters) { writer.Append($"{parameter.Name}, "); } writer.RemoveTrailingComma(); writer.Line($").Request, originalResponse);"); }); } writer.Line(); }
private IEnumerable <LongRunningOperationMethod> BuildLongRunningOperationMethods() { foreach (var operation in _operationGroup.Operations) { if (operation.IsLongRunning) { foreach (var serviceRequest in operation.Requests) { var name = operation.CSharpName(); RestClientMethod startMethod = RestClient.GetOperationMethod(serviceRequest); yield return(new LongRunningOperationMethod( name, _context.Library.FindLongRunningOperation(operation), startMethod, new Diagnostic($"{Declaration.Name}.Start{name}") )); } } } }
private IEnumerable <ClientMethod> BuildMethods() { foreach (var operation in _operationGroup.Operations) { if (operation.IsLongRunning || operation.Language.Default.Paging != null) { continue; } foreach (var request in operation.Requests) { var name = operation.CSharpName(); RestClientMethod startMethod = RestClient.GetOperationMethod(request); yield return(new ClientMethod( name, startMethod, BuilderHelpers.EscapeXmlDescription(operation.Language.Default.Description), new Diagnostic($"{Declaration.Name}.{name}", Array.Empty <DiagnosticAttribute>()))); } } }
private IEnumerable <RestClientMethod> BuildAllMethods() { foreach (var operation in _operationGroup.Operations) { foreach (var serviceRequest in operation.Requests) { RestClientMethod method = GetOperationMethod(serviceRequest); yield return(method); } } foreach (var operation in _operationGroup.Operations) { foreach (var serviceRequest in operation.Requests) { // remove duplicates when GetNextPage method is not autogenerated if (GetNextOperationMethod(serviceRequest) is {} nextOperationMethod&& operation.Language.Default.Paging?.NextLinkOperation == null) { yield return(nextOperationMethod); } } } }
private void WriteRequestCreation(CodeWriter writer, RestClientMethod clientMethod) { using var methodScope = writer.AmbientScope(); var methodName = CreateRequestMethodName(clientMethod.Name); writer.Append($"internal {typeof(HttpMessage)} {methodName}("); var parameters = clientMethod.Parameters; foreach (Parameter clientParameter in parameters) { writer.Append($"{clientParameter.Type} {clientParameter.Name:D},"); } writer.RemoveTrailingComma(); writer.Line($")"); using (writer.Scope()) { var message = new CodeWriterDeclaration("message"); var request = new CodeWriterDeclaration("request"); var uri = new CodeWriterDeclaration("uri"); writer.Line($"var {message:D} = {PipelineField}.CreateMessage();"); writer.Line($"var {request:D} = {message}.Request;"); var method = clientMethod.Request.HttpMethod; writer.Line($"{request}.Method = {typeof(RequestMethod)}.{method.ToRequestMethodName()};"); writer.Line($"var {uri:D} = new RawRequestUriBuilder();"); foreach (var segment in clientMethod.Request.PathSegments) { if (!segment.Value.IsConstant && segment.Value.Reference.Name == "nextLink") { if (segment.IsRaw) { // Artificial nextLink needs additional logic for relative versus absolute links WritePathSegment(writer, uri, segment, "AppendRawNextLink"); } else { // Natural nextLink parameters need to use a different method to parse path and query elements WritePathSegment(writer, uri, segment, "AppendRaw"); } } else { WritePathSegment(writer, uri, segment); } } //TODO: Duplicate code between query and header parameter processing logic foreach (var queryParameter in clientMethod.Request.Query) { WriteQueryParameter(writer, uri, queryParameter); } writer.Line($"{request}.Uri = {uri};"); foreach (var header in clientMethod.Request.Headers) { WriteHeader(writer, request, header); } switch (clientMethod.Request.Body) { case SchemaRequestBody body: using (WriteValueNullCheck(writer, body.Value)) { WriteSerializeContent( writer, request, body.Serialization, w => WriteConstantOrParameter(w, body.Value, ignoreNullability: true)); } break; case BinaryRequestBody binaryBody: using (WriteValueNullCheck(writer, binaryBody.Value)) { writer.Append($"{request}.Content = {typeof(RequestContent)}.Create("); WriteConstantOrParameter(writer, binaryBody.Value); writer.Line($");"); } break; case TextRequestBody textBody: using (WriteValueNullCheck(writer, textBody.Value)) { writer.Append($"{request}.Content = new {typeof(StringRequestContent)}("); WriteConstantOrParameter(writer, textBody.Value); writer.Line($");"); } break; case FlattenedSchemaRequestBody flattenedSchemaRequestBody: var modelVariable = new CodeWriterDeclaration("model"); writer.Append($"var {modelVariable:D} = ") .WriteInitialization(flattenedSchemaRequestBody.ObjectType, flattenedSchemaRequestBody.Initializers) .Line($";"); WriteSerializeContent( writer, request, flattenedSchemaRequestBody.Serialization, w => w.Append(modelVariable)); break; case null: break; default: throw new NotImplementedException(clientMethod.Request.Body?.GetType().FullName); } writer.Line($"return {message};"); } writer.Line(); }