Merge pull request #15102 from abpframework/issue/11244-Generate_proxy_issue_with_c#_nested_class

implement generate-proxy nested c# classes #11244

npm/ng-packs/packages/schematics/src/commands/api/index.ts

@@ -26,6 +26,8 @@ import {
   ModelGeneratorParams,
   removeDefaultPlaceholders,
   resolveProject,
+  sanitizeTypeNames,
+  sanitizeControllerTypeNames,
   serializeParameters,
 } from '../../utils';
 import * as cases from '../../utils/text';
@@ -45,6 +47,7 @@ export default function (schema: GenerateProxySchema) {
       const readProxyConfig = createProxyConfigReader(targetPath);
       const createProxyConfigWriter = createProxyConfigWriterCreator(targetPath);
       const data = readProxyConfig(tree);
+      data.types = sanitizeTypeNames(data.types);
       const types = data.types;
       const modules = data.modules;
       const serviceType = schema.serviceType || defaultEServiceType;
@@ -55,7 +58,11 @@ export default function (schema: GenerateProxySchema) {
         throw new SchematicsException(interpolate(Exception.InvalidModule, moduleName));
 
       const apiName = definition.remoteServiceName;
-      const controllers = filterControllersByServiceType(serviceType, definition.controllers);
+      data.modules[moduleName].controllers = sanitizeControllerTypeNames(definition.controllers);
+      const controllers = filterControllersByServiceType(
+        serviceType,
+        data.modules[moduleName].controllers,
+      );
       const serviceImports: Record<string, string[]> = {};
       const generateServices = createServiceGenerator({
         targetPath,
@@ -173,7 +180,7 @@ function createServiceGenerator(params: ServiceGeneratorParams) {
 }
 
 function filterControllersByServiceType(
-  serviceType: eServiceType,
+  serviceType: string,
   controllers: Record<string, Controller>,
 ): Controller[] {
   const itShouldBeIntegratedService = serviceType === eServiceType.Integration;

npm/ng-packs/packages/schematics/src/models/api-definition.ts

@@ -39,6 +39,24 @@ export interface Controller {
 
 export interface InterfaceDef {
   type: string;
+  name: string;
+  methods: InterfaceMethodDef[];
+}
+export interface InterfaceMethodDef {
+  name: string;
+  parametersOnMethod: InterfaceParameterOnMethodDef[];
+  returnValue: {
+    type: string;
+    typeSimple: string;
+  };
+}
+export interface InterfaceParameterOnMethodDef {
+  name: string;
+  typeAsString: string;
+  type: string;
+  typeSimple: string;
+  isOptional: boolean;
+  defaultValue: unknown;
 }
 
 export interface Action {

npm/ng-packs/packages/schematics/src/utils/common.ts

@@ -1,6 +1,7 @@
 import { SchematicsException, Tree } from '@angular-devkit/schematics';
 import * as ts from 'typescript';
 import { Exception } from '../enums';
+import { Controller, Type } from '../models';
 
 export function interpolate(text: string, ...params: (string | number | boolean)[]) {
   params.forEach((param, i) => {
@@ -24,8 +25,8 @@ export function readFileInTree(tree: Tree, filePath: string): ts.SourceFile {
   return ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true);
 }
 
-export function removeDefaultPlaceholders<T>(oldParams: T) {
-  const newParams: Record<string, any> = {};
+export function removeDefaultPlaceholders<T extends { [key: string]: any }>(oldParams: T) {
+  const newParams: Record<string, string | undefined> = {};
 
   Object.entries(oldParams).forEach(([key, value]) => {
     newParams[key] = value === '__default' ? undefined : value;
@@ -33,3 +34,54 @@ export function removeDefaultPlaceholders<T>(oldParams: T) {
 
   return newParams as T;
 }
+
+const sanitizeTypeNameRegExp = /\+/g;
+const sanitizeTypeName = (name: string) => name.replace(sanitizeTypeNameRegExp, '_');
+
+export function sanitizeControllerTypeNames(
+  controllers: Record<string, Controller>,
+): Record<string, Controller> {
+  Object.values(controllers).forEach(controller => {
+    controller.interfaces.forEach(i => {
+      i.methods.forEach(m => {
+        m.returnValue.type = sanitizeTypeName(m.returnValue.type);
+        m.returnValue.typeSimple = sanitizeTypeName(m.returnValue.typeSimple);
+        m.parametersOnMethod.forEach(p => {
+          p.type = sanitizeTypeName(p.type);
+          p.typeAsString = sanitizeTypeName(p.typeAsString);
+          p.typeSimple = sanitizeTypeName(p.typeSimple);
+        });
+      });
+    });
+
+    Object.values(controller.actions).forEach(a => {
+      a.returnValue.type = sanitizeTypeName(a.returnValue.type);
+      a.returnValue.typeSimple = sanitizeTypeName(a.returnValue.typeSimple);
+      a.parametersOnMethod.forEach(p => {
+        p.type = sanitizeTypeName(p.type);
+        p.typeAsString = sanitizeTypeName(p.typeAsString);
+        p.typeSimple = sanitizeTypeName(p.typeSimple);
+      });
+      a.parameters.forEach(p => {
+        p.type = sanitizeTypeName(p.type);
+        p.typeSimple = sanitizeTypeName(p.typeSimple);
+      });
+    });
+  });
+
+  return controllers;
+}
+
+export function sanitizeTypeNames(types: Record<string, Type>): Record<string, Type> {
+  // sanitize typeNames, type, and typeSimple on properties
+  return Object.entries(types).reduce((acc, [key, value]) => {
+    const sanitized = sanitizeTypeName(key);
+    const properties =
+      value.properties?.map(p => {
+        const t = sanitizeTypeName(p.type);
+        const t2 = sanitizeTypeName(p.typeSimple);
+        return { ...p, type: t, typeSimple: t2 };
+      }) || null;
+    return { ...acc, [sanitized]: { ...value, properties } };
+  }, {});
+}

npm/ng-packs/packages/schematics/src/utils/source.ts

@@ -32,7 +32,7 @@ async function getApiDefinition(sourceUrl: string) {
   let body: ApiDefinition;
 
   try {
-    ({ body } = await got(url, {
+    ({ body } = await got<ApiDefinition>(url, {
       responseType: 'json',
       searchParams: { includeTypes: true },
       https: { rejectUnauthorized: false },