Merge pull request #15109 from abpframework/auto-merge/rel-7-0/1587

Merge branch dev with rel-7.0

npm/ng-packs/packages/components/tree/src/lib/components/tree.component.ts

@@ -8,7 +8,7 @@ import {
   Output,
   TemplateRef,
   ViewEncapsulation,
-  OnInit
+  OnInit,
 } from '@angular/core';
 import { NzFormatBeforeDropEvent, NzFormatEmitEvent } from 'ng-zorro-antd/tree';
 import { of } from 'rxjs';
@@ -34,11 +34,11 @@ export class TreeComponent implements OnInit {
 
   constructor(
     private lazyLoadService: LazyLoadService,
-    subscriptionService: SubscriptionService,
+    private subscriptionService: SubscriptionService,
     @Optional()
     @Inject(DISABLE_TREE_STYLE_LOADING_TOKEN)
     private disableTreeStyleLoading: boolean | undefined,
-  ) { }
+  ) {}
 
   @ContentChild('menu') menu: TemplateRef<any>;
   @ContentChild(TreeNodeTemplateDirective) customNodeTemplate: TreeNodeTemplateDirective;
@@ -64,7 +64,7 @@ export class TreeComponent implements OnInit {
   };
 
   ngOnInit() {
-    this.loadStyle()
+    this.loadStyle();
   }
 
   private loadStyle() {
@@ -76,7 +76,7 @@ export class TreeComponent implements OnInit {
     );
     this.subscriptionService.addOne(loaded$);
   }
-  
+
   onSelectedNodeChange(node) {
     this.selectedNode = node.origin.entity;
     if (this.changeCheckboxWithNode) {

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 },