rewrite

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

ui/src/app/api/models.ts

@@ -1,16 +1,18 @@
 /* tslint:disable */
 /* eslint-disable */
-export { AddCommentReq } from './models/add-comment-req';
-export { AddCommentRsp } from './models/add-comment-rsp';
-export { AddPackageReq } from './models/add-package-req';
-export { AddPackageRsp } from './models/add-package-rsp';
 export { Comment } from './models/comment';
-export { Error } from './models/error';
+export { CommentsCreateReq } from './models/comments-create-req';
+export { CommentsCreateRsp } from './models/comments-create-rsp';
+export { CommentsDeleteRsp } from './models/comments-delete-rsp';
+export { CommentsListRsp } from './models/comments-list-rsp';
+export { CommentsLookupRsp } from './models/comments-lookup-rsp';
 export { ErrorRsp } from './models/error-rsp';
-export { GetCommentsRsp } from './models/get-comments-rsp';
-export { GetModuleRsp } from './models/get-module-rsp';
-export { ListPackageRsp } from './models/list-package-rsp';
 export { Module } from './models/module';
+export { ModulesListRsp } from './models/modules-list-rsp';
 export { Package } from './models/package';
-export { UpdatePackageReq } from './models/update-package-req';
-export { UpdatePackageRsp } from './models/update-package-rsp';
+export { PackagesCreateReq } from './models/packages-create-req';
+export { PackagesCreateRsp } from './models/packages-create-rsp';
+export { PackagesDeleteRsp } from './models/packages-delete-rsp';
+export { PackagesListRsp } from './models/packages-list-rsp';
+export { PackagesUpdateReq } from './models/packages-update-req';
+export { PackagesUpdateRsp } from './models/packages-update-rsp';

ui/src/app/api/models/add-comment-rsp.ts

@@ -1,5 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export interface AddCommentRsp {
-  id?: number;
-}

ui/src/app/api/models/comments-create-req.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-export interface AddCommentReq {
-  idPackage?: number;
+export interface CommentsCreateReq {
+  package_id?: number;
   text?: string;
 }

ui/src/app/api/models/comments-create-rsp.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+import { Comment } from './comment';
+export interface CommentsCreateRsp {
+  comment?: Comment;
+}

ui/src/app/api/models/comments-delete-rsp.ts

@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+export interface CommentsDeleteRsp {
+}

ui/src/app/api/models/comments-list-rsp.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 import { Comment } from './comment';
-export interface GetCommentsRsp {
+export interface CommentsListRsp {
   comments?: Array<Comment>;
 }

ui/src/app/api/models/comments-lookup-rsp.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+import { Comment } from './comment';
+export interface CommentsLookupRsp {
+  comment?: Comment;
+}

ui/src/app/api/models/error-rsp.ts

@@ -1,6 +1,8 @@
 /* tslint:disable */
 /* eslint-disable */
-import { Error } from './error';
 export interface ErrorRsp {
-  error?: Error;
+  code?: string;
+  details?: string;
+  title?: string;
+  uuid?: string;
 }

ui/src/app/api/models/error.ts

@@ -1,8 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export interface Error {
-  code?: string;
-  details?: string;
-  title?: string;
-  uuid?: string;
-}

ui/src/app/api/models/module.ts

@@ -1,9 +1,11 @@
 /* tslint:disable */
 /* eslint-disable */
 export interface Module {
+  created?: string;
   id?: number;
   last_version?: string;
   name?: string;
   package?: number;
+  updated?: string;
   version?: string;
 }

ui/src/app/api/models/modules-list-rsp.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 import { Module } from './module';
-export interface GetModuleRsp {
+export interface ModulesListRsp {
   modules?: Array<Module>;
 }

ui/src/app/api/models/package.ts

@@ -2,9 +2,11 @@
 /* eslint-disable */
 export interface Package {
   comments?: Array<number>;
+  created?: string;
   id?: number;
   issues?: Array<number>;
   modules?: Array<number>;
   name?: string;
+  updated?: string;
   url?: string;
 }

ui/src/app/api/models/packages-create-req.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-export interface AddPackageReq {
+export interface PackagesCreateReq {
   modules?: Array<number>;
   name?: string;
   url?: string;

ui/src/app/api/models/packages-create-rsp.ts

@@ -1,5 +1,5 @@
 /* tslint:disable */
 /* eslint-disable */
-export interface AddPackageRsp {
+export interface PackagesCreateRsp {
   status?: string;
 }

ui/src/app/api/models/packages-delete-rsp.ts

@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+export interface PackagesDeleteRsp {
+}

ui/src/app/api/models/packages-list-rsp.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 import { Package } from './package';
-export interface ListPackageRsp {
+export interface PackagesListRsp {
   packages?: Array<Package>;
 }

ui/src/app/api/models/packages-update-req.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-export interface UpdatePackageReq {
+export interface PackagesUpdateReq {
   id?: number;
   issues?: Array<number>;
   modules?: Array<number>;

ui/src/app/api/models/packages-update-rsp.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+import { Package } from './package';
+export interface PackagesUpdateRsp {
+  package?: Package;
+}

ui/src/app/api/models/update-package-rsp.ts

@@ -1,5 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export interface UpdatePackageRsp {
-  id?: number;
-}

ui/src/app/api/services/pkgdash-service.service.ts

@@ -10,15 +10,18 @@ import { ApiConfiguration } from '../api-configuration';
 import { StrictHttpResponse } from '../strict-http-response';
 import { RequestBuilder } from '../request-builder';
 
-import { AddCommentReq } from '../models/add-comment-req';
-import { AddCommentRsp } from '../models/add-comment-rsp';
-import { AddPackageReq } from '../models/add-package-req';
-import { AddPackageRsp } from '../models/add-package-rsp';
-import { GetCommentsRsp } from '../models/get-comments-rsp';
-import { GetModuleRsp } from '../models/get-module-rsp';
-import { ListPackageRsp } from '../models/list-package-rsp';
-import { UpdatePackageReq } from '../models/update-package-req';
-import { UpdatePackageRsp } from '../models/update-package-rsp';
+import { CommentsCreateReq } from '../models/comments-create-req';
+import { CommentsCreateRsp } from '../models/comments-create-rsp';
+import { CommentsDeleteRsp } from '../models/comments-delete-rsp';
+import { CommentsListRsp } from '../models/comments-list-rsp';
+import { CommentsLookupRsp } from '../models/comments-lookup-rsp';
+import { ModulesListRsp } from '../models/modules-list-rsp';
+import { PackagesCreateReq } from '../models/packages-create-req';
+import { PackagesCreateRsp } from '../models/packages-create-rsp';
+import { PackagesDeleteRsp } from '../models/packages-delete-rsp';
+import { PackagesListRsp } from '../models/packages-list-rsp';
+import { PackagesUpdateReq } from '../models/packages-update-req';
+import { PackagesUpdateRsp } from '../models/packages-update-rsp';
 
 @Injectable({ providedIn: 'root' })
 export class PkgdashServiceService extends BaseService {
@@ -26,24 +29,26 @@ export class PkgdashServiceService extends BaseService {
     super(config, http);
   }
 
-  /** Path part for operation `getComments()` */
-  static readonly GetCommentsPath = '/v1/comment';
+  /** Path part for operation `commentsLookup()` */
+  static readonly CommentsLookupPath = '/v1/comments/{id}/comments';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `getComments()` instead.
+   * To access only the response body, use `commentsLookup()` instead.
    *
    * This method doesn't expect any request body.
    */
-  getComments$Response(
-    params?: {
-      id?: Array<number>;
+  commentsLookup$Response(
+    params: {
+      id: number;
+      package_id?: number;
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<GetCommentsRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.GetCommentsPath, 'get');
+  ): Observable<StrictHttpResponse<CommentsLookupRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.CommentsLookupPath, 'get');
     if (params) {
-      rb.query('id', params.id, {});
+      rb.path('id', params.id, {});
+      rb.query('package_id', params.package_id, {});
     }
 
     return this.http.request(
@@ -51,46 +56,45 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<GetCommentsRsp>;
+        return r as StrictHttpResponse<CommentsLookupRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `getComments$Response()` instead.
+   * To access the full response (for headers, for example), `commentsLookup$Response()` instead.
    *
    * This method doesn't expect any request body.
    */
-  getComments(
-    params?: {
-      id?: Array<number>;
+  commentsLookup(
+    params: {
+      id: number;
+      package_id?: number;
     },
     context?: HttpContext
-  ): Observable<GetCommentsRsp> {
-    return this.getComments$Response(params, context).pipe(
-      map((r: StrictHttpResponse<GetCommentsRsp>): GetCommentsRsp => r.body)
+  ): Observable<CommentsLookupRsp> {
+    return this.commentsLookup$Response(params, context).pipe(
+      map((r: StrictHttpResponse<CommentsLookupRsp>): CommentsLookupRsp => r.body)
     );
   }
 
-  /** Path part for operation `getModule()` */
-  static readonly GetModulePath = '/v1/module';
+  /** Path part for operation `modulesList()` */
+  static readonly ModulesListPath = '/v1/modules';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `getModule()` instead.
+   * To access only the response body, use `modulesList()` instead.
    *
    * This method doesn't expect any request body.
    */
-  getModule$Response(
+  modulesList$Response(
     params?: {
-      id?: Array<number>;
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<GetModuleRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.GetModulePath, 'get');
+  ): Observable<StrictHttpResponse<ModulesListRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.ModulesListPath, 'get');
     if (params) {
-      rb.query('id', params.id, {});
     }
 
     return this.http.request(
@@ -98,44 +102,87 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<GetModuleRsp>;
+        return r as StrictHttpResponse<ModulesListRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `getModule$Response()` instead.
+   * To access the full response (for headers, for example), `modulesList$Response()` instead.
    *
    * This method doesn't expect any request body.
    */
-  getModule(
+  modulesList(
     params?: {
-      id?: Array<number>;
     },
     context?: HttpContext
-  ): Observable<GetModuleRsp> {
-    return this.getModule$Response(params, context).pipe(
-      map((r: StrictHttpResponse<GetModuleRsp>): GetModuleRsp => r.body)
+  ): Observable<ModulesListRsp> {
+    return this.modulesList$Response(params, context).pipe(
+      map((r: StrictHttpResponse<ModulesListRsp>): ModulesListRsp => r.body)
     );
   }
 
-  /** Path part for operation `addPackage()` */
-  static readonly AddPackagePath = '/v1/package';
+  /** Path part for operation `packagesList()` */
+  static readonly PackagesListPath = '/v1/packages';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `addPackage()` instead.
+   * To access only the response body, use `packagesList()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  packagesList$Response(
+    params?: {
+    },
+    context?: HttpContext
+  ): Observable<StrictHttpResponse<PackagesListRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.PackagesListPath, 'get');
+    if (params) {
+    }
+
+    return this.http.request(
+      rb.build({ responseType: 'json', accept: 'application/json', context })
+    ).pipe(
+      filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
+      map((r: HttpResponse<any>) => {
+        return r as StrictHttpResponse<PackagesListRsp>;
+      })
+    );
+  }
+
+  /**
+   * This method provides access only to the response body.
+   * To access the full response (for headers, for example), `packagesList$Response()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  packagesList(
+    params?: {
+    },
+    context?: HttpContext
+  ): Observable<PackagesListRsp> {
+    return this.packagesList$Response(params, context).pipe(
+      map((r: StrictHttpResponse<PackagesListRsp>): PackagesListRsp => r.body)
+    );
+  }
+
+  /** Path part for operation `packagesCreate()` */
+  static readonly PackagesCreatePath = '/v1/packages';
+
+  /**
+   * This method provides access to the full `HttpResponse`, allowing access to response headers.
+   * To access only the response body, use `packagesCreate()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  addPackage$Response(
+  packagesCreate$Response(
     params: {
-      body: AddPackageReq
+      body: PackagesCreateReq
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<AddPackageRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.AddPackagePath, 'post');
+  ): Observable<StrictHttpResponse<PackagesCreateRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.PackagesCreatePath, 'post');
     if (params) {
       rb.body(params.body, 'application/json');
     }
@@ -145,45 +192,45 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<AddPackageRsp>;
+        return r as StrictHttpResponse<PackagesCreateRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `addPackage$Response()` instead.
+   * To access the full response (for headers, for example), `packagesCreate$Response()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  addPackage(
+  packagesCreate(
     params: {
-      body: AddPackageReq
+      body: PackagesCreateReq
     },
     context?: HttpContext
-  ): Observable<AddPackageRsp> {
-    return this.addPackage$Response(params, context).pipe(
-      map((r: StrictHttpResponse<AddPackageRsp>): AddPackageRsp => r.body)
+  ): Observable<PackagesCreateRsp> {
+    return this.packagesCreate$Response(params, context).pipe(
+      map((r: StrictHttpResponse<PackagesCreateRsp>): PackagesCreateRsp => r.body)
     );
   }
 
-  /** Path part for operation `updateInfo()` */
-  static readonly UpdateInfoPath = '/v1/package/{id}';
+  /** Path part for operation `packagesUpdate()` */
+  static readonly PackagesUpdatePath = '/v1/packages/{id}';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `updateInfo()` instead.
+   * To access only the response body, use `packagesUpdate()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  updateInfo$Response(
+  packagesUpdate$Response(
     params: {
       id: number;
-      body: UpdatePackageReq
+      body: PackagesUpdateReq
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<UpdatePackageRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.UpdateInfoPath, 'post');
+  ): Observable<StrictHttpResponse<PackagesUpdateRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.PackagesUpdatePath, 'put');
     if (params) {
       rb.path('id', params.id, {});
       rb.body(params.body, 'application/json');
@@ -194,48 +241,142 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<UpdatePackageRsp>;
+        return r as StrictHttpResponse<PackagesUpdateRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `updateInfo$Response()` instead.
+   * To access the full response (for headers, for example), `packagesUpdate$Response()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  updateInfo(
+  packagesUpdate(
     params: {
       id: number;
-      body: UpdatePackageReq
+      body: PackagesUpdateReq
     },
     context?: HttpContext
-  ): Observable<UpdatePackageRsp> {
-    return this.updateInfo$Response(params, context).pipe(
-      map((r: StrictHttpResponse<UpdatePackageRsp>): UpdatePackageRsp => r.body)
+  ): Observable<PackagesUpdateRsp> {
+    return this.packagesUpdate$Response(params, context).pipe(
+      map((r: StrictHttpResponse<PackagesUpdateRsp>): PackagesUpdateRsp => r.body)
     );
   }
 
-  /** Path part for operation `addComment()` */
-  static readonly AddCommentPath = '/v1/package/{pkg}/comment';
+  /** Path part for operation `packagesDelete()` */
+  static readonly PackagesDeletePath = '/v1/packages/{id}';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `addComment()` instead.
+   * To access only the response body, use `packagesDelete()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  packagesDelete$Response(
+    params: {
+      id: number;
+    },
+    context?: HttpContext
+  ): Observable<StrictHttpResponse<PackagesDeleteRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.PackagesDeletePath, 'delete');
+    if (params) {
+      rb.path('id', params.id, {});
+    }
+
+    return this.http.request(
+      rb.build({ responseType: 'json', accept: 'application/json', context })
+    ).pipe(
+      filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
+      map((r: HttpResponse<any>) => {
+        return r as StrictHttpResponse<PackagesDeleteRsp>;
+      })
+    );
+  }
+
+  /**
+   * This method provides access only to the response body.
+   * To access the full response (for headers, for example), `packagesDelete$Response()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  packagesDelete(
+    params: {
+      id: number;
+    },
+    context?: HttpContext
+  ): Observable<PackagesDeleteRsp> {
+    return this.packagesDelete$Response(params, context).pipe(
+      map((r: StrictHttpResponse<PackagesDeleteRsp>): PackagesDeleteRsp => r.body)
+    );
+  }
+
+  /** Path part for operation `commentsList()` */
+  static readonly CommentsListPath = '/v1/packages/{package_id}/comments';
+
+  /**
+   * This method provides access to the full `HttpResponse`, allowing access to response headers.
+   * To access only the response body, use `commentsList()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  commentsList$Response(
+    params: {
+      package_id: number;
+    },
+    context?: HttpContext
+  ): Observable<StrictHttpResponse<CommentsListRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.CommentsListPath, 'get');
+    if (params) {
+      rb.path('package_id', params.package_id, {});
+    }
+
+    return this.http.request(
+      rb.build({ responseType: 'json', accept: 'application/json', context })
+    ).pipe(
+      filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
+      map((r: HttpResponse<any>) => {
+        return r as StrictHttpResponse<CommentsListRsp>;
+      })
+    );
+  }
+
+  /**
+   * This method provides access only to the response body.
+   * To access the full response (for headers, for example), `commentsList$Response()` instead.
+   *
+   * This method doesn't expect any request body.
+   */
+  commentsList(
+    params: {
+      package_id: number;
+    },
+    context?: HttpContext
+  ): Observable<CommentsListRsp> {
+    return this.commentsList$Response(params, context).pipe(
+      map((r: StrictHttpResponse<CommentsListRsp>): CommentsListRsp => r.body)
+    );
+  }
+
+  /** Path part for operation `commentsCreate()` */
+  static readonly CommentsCreatePath = '/v1/packages/{package_id}/comments';
+
+  /**
+   * This method provides access to the full `HttpResponse`, allowing access to response headers.
+   * To access only the response body, use `commentsCreate()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  addComment$Response(
+  commentsCreate$Response(
     params: {
-      pkg: string;
-      body: AddCommentReq
+      package_id: number;
+      body: CommentsCreateReq
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<AddCommentRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.AddCommentPath, 'post');
+  ): Observable<StrictHttpResponse<CommentsCreateRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.CommentsCreatePath, 'post');
     if (params) {
-      rb.path('pkg', params.pkg, {});
+      rb.path('package_id', params.package_id, {});
       rb.body(params.body, 'application/json');
     }
 
@@ -244,45 +385,49 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<AddCommentRsp>;
+        return r as StrictHttpResponse<CommentsCreateRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `addComment$Response()` instead.
+   * To access the full response (for headers, for example), `commentsCreate$Response()` instead.
    *
    * This method sends `application/json` and handles request body of type `application/json`.
    */
-  addComment(
+  commentsCreate(
     params: {
-      pkg: string;
-      body: AddCommentReq
+      package_id: number;
+      body: CommentsCreateReq
     },
     context?: HttpContext
-  ): Observable<AddCommentRsp> {
-    return this.addComment$Response(params, context).pipe(
-      map((r: StrictHttpResponse<AddCommentRsp>): AddCommentRsp => r.body)
+  ): Observable<CommentsCreateRsp> {
+    return this.commentsCreate$Response(params, context).pipe(
+      map((r: StrictHttpResponse<CommentsCreateRsp>): CommentsCreateRsp => r.body)
     );
   }
 
-  /** Path part for operation `listPackage()` */
-  static readonly ListPackagePath = '/v1/packages';
+  /** Path part for operation `commentsDelete()` */
+  static readonly CommentsDeletePath = '/v1/packages/{package_id}/comments/{id}';
 
   /**
    * This method provides access to the full `HttpResponse`, allowing access to response headers.
-   * To access only the response body, use `listPackage()` instead.
+   * To access only the response body, use `commentsDelete()` instead.
    *
    * This method doesn't expect any request body.
    */
-  listPackage$Response(
-    params?: {
+  commentsDelete$Response(
+    params: {
+      package_id: number;
+      id: number;
     },
     context?: HttpContext
-  ): Observable<StrictHttpResponse<ListPackageRsp>> {
-    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.ListPackagePath, 'get');
+  ): Observable<StrictHttpResponse<CommentsDeleteRsp>> {
+    const rb = new RequestBuilder(this.rootUrl, PkgdashServiceService.CommentsDeletePath, 'delete');
     if (params) {
+      rb.path('package_id', params.package_id, {});
+      rb.path('id', params.id, {});
     }
 
     return this.http.request(
@@ -290,24 +435,26 @@ export class PkgdashServiceService extends BaseService {
     ).pipe(
       filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<ListPackageRsp>;
+        return r as StrictHttpResponse<CommentsDeleteRsp>;
       })
     );
   }
 
   /**
    * This method provides access only to the response body.
-   * To access the full response (for headers, for example), `listPackage$Response()` instead.
+   * To access the full response (for headers, for example), `commentsDelete$Response()` instead.
    *
    * This method doesn't expect any request body.
    */
-  listPackage(
-    params?: {
+  commentsDelete(
+    params: {
+      package_id: number;
+      id: number;
     },
     context?: HttpContext
-  ): Observable<ListPackageRsp> {
-    return this.listPackage$Response(params, context).pipe(
-      map((r: StrictHttpResponse<ListPackageRsp>): ListPackageRsp => r.body)
+  ): Observable<CommentsDeleteRsp> {
+    return this.commentsDelete$Response(params, context).pipe(
+      map((r: StrictHttpResponse<CommentsDeleteRsp>): CommentsDeleteRsp => r.body)
     );
   }
 

ui/src/app/app.module.ts

@@ -3,10 +3,12 @@ import { BrowserModule } from '@angular/platform-browser';
 
 import { AppRoutingModule } from './app-routing.module';
 import { AppComponent } from './app.component';
+import { DashboardComponent } from './dashboard/dashboard.component';
 
 @NgModule({
   declarations: [
-    AppComponent
+    AppComponent,
+    DashboardComponent,
   ],
   imports: [
     BrowserModule,

ui/src/app/dashboard/dashboard.component.html

@@ -0,0 +1 @@
+<p>dashboard works!</p>

ui/src/app/dashboard/dashboard.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { DashboardComponent } from './dashboard.component';
+
+describe('DashboardComponent', () => {
+  let component: DashboardComponent;
+  let fixture: ComponentFixture<DashboardComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ DashboardComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(DashboardComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

ui/src/app/dashboard/dashboard.component.ts

@@ -0,0 +1,15 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+  selector: 'app-dashboard',
+  templateUrl: './dashboard.component.html',
+  styleUrls: ['./dashboard.component.scss']
+})
+export class DashboardComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

ui/src/index.html

@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
   <meta charset="utf-8">
-  <title>Ui</title>
+  <title>UI</title>
   <base href="/">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="icon" type="image/x-icon" href="favicon.ico">