Add support for header parameters in group parameter (#1249)

powershell/plugins/sdk-create-inline-properties.ts

@@ -349,6 +349,8 @@ function parameterGroupName(operationGroup: OperationGroup, operation: Operation
 
 async function implementGroupParameters(state: State) {
   const parameterGroup = new Map<string, ObjectSchema>();
+  const parameterGroupContainerHeader = new Map<string, boolean>();
+  const parameterGroupContainerOthers = new Map<string, boolean>();
   const parameterAdded = new Map<string, Array<string>>();
   for (const operationGroup of state.model.operationGroups) {
     for (const operation of operationGroup.operations) {
@@ -358,6 +360,11 @@ async function implementGroupParameters(state: State) {
       for (const parameter of [...(operation.requests && operation.requests.length > 0 ? operation.requests[0].parameters || [] : []), ...(operation.parameters || [])]) {
         if (parameter.extensions && parameter.extensions['x-ms-parameter-grouping']) {
           const key = parameterGroupName(operationGroup, operation, parameter.extensions['x-ms-parameter-grouping']);
+          if (parameter.protocol.http?.in === ParameterLocation.Header) {
+            parameterGroupContainerHeader.set(key, true);
+          } else {
+            parameterGroupContainerOthers.set(key, true);
+          }
           const groupObj = parameterGroup.get(key) || new ObjectSchema(key, '');
           if (!parameterGroup.has(key)) {
             groupObj.extensions = {};
@@ -395,6 +402,76 @@ async function implementGroupParameters(state: State) {
       operation.parameters = [...operationGroupParameters, ...(operation.parameters || [])];
     }
   }
+  implementGroupParametersForPagination(state, parameterGroup, parameterGroupContainerHeader, parameterGroupContainerOthers);
+}
+
+async function implementGroupParametersForPagination(state: State, GroupObjects: Map<string, ObjectSchema>, parameterGroupContainHeader: Map<string, boolean>, parameterGroupContainOthers: Map<string, boolean>) {
+  const parameterGroup = new Map<string, ObjectSchema>();
+  const parameterAdded = new Map<string, Array<string>>();
+  for (const operationGroup of state.model.operationGroups) {
+    for (const operation of operationGroup.operations) {
+      if (!(operation.extensions && operation.extensions['x-ms-pageable'])) {
+        // skip none pageable operations
+        continue;
+      }
+      const operationGroupParameters = new Array<Parameter>();
+      // value means if the parameter is required
+      const addedOperationGroupParameters = new Map<string, boolean>();
+      for (const parameter of [...(operation.requests && operation.requests.length > 0 ? operation.requests[0].parameters || [] : []), ...(operation.parameters || [])]) {
+        if (parameter.protocol.http?.in === ParameterLocation.Header && parameter.extensions && parameter.extensions['x-ms-parameter-grouping']) {
+          const key = parameterGroupName(operationGroup, operation, parameter.extensions['x-ms-parameter-grouping']);
+          if (parameterGroupContainHeader.get(key) && parameterGroupContainOthers.get(key)) {
+            const keyWithModel = `${key}Model`;
+            const groupObj = parameterGroup.get(keyWithModel) || new ObjectSchema(keyWithModel, '');
+            if (!parameterGroup.has(keyWithModel)) {
+              groupObj.extensions = {};
+              groupObj.extensions['x-ms-parameter-grouping'] = parameter.extensions['x-ms-parameter-grouping'];
+              parameterGroup.set(keyWithModel, groupObj);
+              parameterAdded.set(keyWithModel, []);
+              state.model.schemas.objects = state.model.schemas.objects || [];
+              state.model.schemas.objects.push(groupObj);
+            }
+            const prop = new Property(parameter.language.default.name, parameter.language.default.description, parameter.schema, {
+              required: parameter.required,
+            });
+            if (parameterAdded.has(keyWithModel) && (parameterAdded.get(keyWithModel) || []).indexOf(parameter.language.default.name) === -1) {
+              groupObj.addProperty(prop);
+              parameterAdded.set(keyWithModel, [...(parameterAdded.get(keyWithModel) || []), parameter.language.default.name]);
+            }
+            if (!addedOperationGroupParameters.has(keyWithModel)) {
+              addedOperationGroupParameters.set(keyWithModel, !!(parameter.required));
+              const groupParameter = new Parameter(camelCase(keyWithModel), '', groupObj);
+              groupParameter.protocol.http = groupParameter.protocol.http || new Protocol();
+              groupParameter.protocol.http.in = 'complexHeader';
+              operationGroupParameters.push(groupParameter);
+            } else {
+              if (!addedOperationGroupParameters.get(keyWithModel)) {
+                addedOperationGroupParameters.set(keyWithModel, !!(parameter.required));
+              }
+            }
+          } else if (parameterGroupContainHeader.get(key)) {
+            if (!addedOperationGroupParameters.has(key)) {
+              addedOperationGroupParameters.set(key, !!(parameter.required));
+              const groupParameter = new Parameter(camelCase(key), '', GroupObjects.get(key) || new ObjectSchema(key, ''));
+              groupParameter.protocol.http = groupParameter.protocol.http || new Protocol();
+              groupParameter.protocol.http.in = 'complexHeader';
+              operationGroupParameters.push(groupParameter);
+            } else {
+              if (!addedOperationGroupParameters.get(key)) {
+                addedOperationGroupParameters.set(key, !!(parameter.required));
+              }
+            }
+          }
+        } else {
+          continue;
+        }
+      }
+      for (const groupParameter of operationGroupParameters) {
+        groupParameter.required = addedOperationGroupParameters.get(pascalCase(groupParameter.language.default.name)) || false;
+      }
+      operation.parameters = [...operationGroupParameters, ...(operation.parameters || [])];
+    }
+  }
 }
 
 async function implementOdata(state: State) {

powershell/plugins/sdk-tweak-model.ts

@@ -172,7 +172,7 @@ function addNormalMethodParameterDeclaration(operation: Operation, state: State)
     bodyParameters = (operation.requests[0].parameters || []).filter(p => p.protocol.http?.in === ParameterLocation.Body);
   }
 
-  (operation.parameters || []).filter(p => p.implementation != 'Client' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])
+  (operation.parameters || []).filter(p => p.implementation != 'Client' && p.protocol.http?.in !== 'complexHeader' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])
     && !(p.required && p.schema.type === SchemaType.Choice && (<ChoiceSchema>p.schema).choices.length === 1)
     && !(p.required && p.schema.type === SchemaType.SealedChoice && (<SealedChoiceSchema>p.schema).choices.length === 1)).forEach(function (parameter) {
     let type = parameter.schema.language.csharp?.fullname || parameter.schema.language.csharp?.name || '';
@@ -237,7 +237,7 @@ function addPageableMethodParameterDeclaration(operation: Operation) {
   const headerParameters: Array<Parameter> = (operation.parameters || []).filter(p => p.implementation != 'Client' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])
     && !(p.required && p.schema.type === SchemaType.Choice && (<ChoiceSchema>p.schema).choices.length === 1)
     && !(p.required && p.schema.type === SchemaType.SealedChoice && (<SealedChoiceSchema>p.schema).choices.length === 1)
-    && p.protocol.http?.in === ParameterLocation.Header);
+    && (p.protocol.http?.in === ParameterLocation.Header || p.protocol.http?.in === 'complexHeader'));
 
   headerParameters.forEach(function (parameter) {
 

powershell/resources/templates/extensionMethod.ejs

@@ -9,7 +9,7 @@
         /// <param name='operations'>
         /// The operations group for this extension method.
         /// </param>
-<% if(method.parameters && !method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function (parameter) {-%>
+<% if(method.parameters && !method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && p.protocol.http?.in != 'complexHeader' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function (parameter) {-%>
         /// <param name='<%-parameter.language.default.name%>'>
         /// <%=parameter.language.default.description%>
         /// </param>
@@ -39,7 +39,7 @@
         /// <param name='operations'>
         /// The operations group for this extension method.
         /// </param>
-<% if(method.parameters && !method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && !p.readOnly).forEach(function (parameter) {-%>
+<% if(method.parameters && !method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && p.protocol.http?.in != 'complexHeader' && !p.readOnly && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function (parameter) {-%>
         /// <param name='<%-parameter.language.default.name%>'>
         /// <%=parameter.language.default.description%>
         /// </param>

powershell/resources/templates/method.ejs

@@ -5,7 +5,7 @@
         /// </summary>
 <% };-%>
 <%# ToDo: add remark if both description and summary is provided, question here is in m4, there is no summary provided-%>
-<%  if(method.parameters&&!method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function (parameter) {-%>
+<%  if(method.parameters&&!method.language.default.pageable?.nextPageOperation) { method.parameters.filter(p => p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && p.protocol.http?.in != 'complexHeader' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function (parameter) {-%>
 <%# ToDo: should use camel name instead of pascal name here -%>
         /// <param name='<%-parameter.language.default.name%>'>
         /// <%=parameter.language.default.description%>

powershell/resources/templates/methodBodyRestCall.ejs

@@ -19,6 +19,9 @@ if (method.extensions && method.extensions['x-ms-request-id']) {
             {
                 throw new Microsoft.Rest.ValidationException(Microsoft.Rest.ValidationRules.CannotBeNull, "nextPageLink");
             }
+<%(method.parameters || []).filter(p => p.protocol.http.in == 'complexHeader').forEach(function(parameter) {-%>
+<%-project.helper.PopulateGroupParameters(parameter)%>
+<%});-%>
 <% }else{-%> 
 <% (method.requests[0].parameters || []).filter(p=>p.protocol.http.in == 'body').forEach(function(parameter){-%>
 <%if(!(parameter.extensions && parameter.extensions['x-ms-client-flatten'])) {-%>
@@ -92,7 +95,7 @@ if (method.extensions && method.extensions['x-ms-request-id']) {
 <%});-%>               
 <% }else{-%>
 <%# ToDo: add support for Model.LogicalParameters.Where(p => !p.IsClientProperty)-%>
-<%method.parameters.filter(p => p.implementation != 'Client' && p.protocol.http.in != 'complex').forEach(function(p) {-%>
+<%method.parameters.filter(p => p.implementation != 'Client' && p.protocol.http.in != 'complex' && p.protocol.http.in != 'complexHeader').forEach(function(p) {-%>
                 tracingParameters.Add("<%-p.language.default.name%>", <%-p.language.default.name%>);
 <%});-%>
 <%# ToDo: currently we just add the unexpanded body parameter, and need to be fixed in the future %>

powershell/resources/templates/methodGroupInterfaceBody.ejs

@@ -10,7 +10,7 @@
         /// </remarks>
 <% };-%>
 <% if(!method.language.default.pageable?.nextPageOperation) {-%>
-<% method.parameters.filter(p=>p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function(parameter){-%>
+<% method.parameters.filter(p=>p.implementation != 'Client' && !project.helper.IsConstantParameter(p) && p.protocol.http?.in != 'complexHeader' && !(p.extensions && p.extensions['x-ms-parameter-grouping'])).forEach(function(parameter){-%>
         /// <param name='<%-parameter.language.default.name%>'>
         /// <%= parameter.language.default.description%>
         /// </param>