@harbor/ui
Version:
Harbor shared UI components based on Clarity and Angular6
256 lines (255 loc) • 22.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
import { throwError as observableThrowError } from "rxjs";
import { Injectable, Inject } from "@angular/core";
import { Http, ResponseContentType } from "@angular/http";
import { map, catchError } from "rxjs/operators";
import { SERVICE_CONFIG } from "../service.config";
import { HTTP_JSON_OPTIONS, HTTP_GET_OPTIONS } from "../utils";
/**
* Define service methods for handling the helmchart related things.
* Loose couple with project module.
*
* *
* @abstract
* class RepositoryService
* @abstract
*/
export class HelmChartService {
}
if (false) {
/**
* Get all helm charts info
* ** deprecated param projectName Id of the project
* ** deprecated param queryParams options params for query data
* @abstract
* @param {?} projectName
* @param {?=} queryParams
* @return {?}
*/
HelmChartService.prototype.getHelmCharts = function (projectName, queryParams) { };
/**
* Delete an helmchart
* ** deprecated param projectId Id of the project
* ** deprecated param chartId ID of helmChart in this specific project
* @abstract
* @param {?} projectId
* @param {?} chartName
* @return {?}
*/
HelmChartService.prototype.deleteHelmChart = function (projectId, chartName) { };
/**
* Get all the versions of helmchart
* ** deprecated param projectName Id of the project
* ** deprecated param chartName ID of the helm chart
* ** deprecated param queryParams option params for query
* @abstract
* @param {?} projectName
* @param {?} chartName
* @return {?}
*/
HelmChartService.prototype.getChartVersions = function (projectName, chartName) { };
/**
* Delete a version of helmchart
* ** deprecated param projectName ID of the project
* ** deprecated param chartName ID of the chart you want to delete
* ** deprecated param version name of the version
* @abstract
* @param {?} projectName
* @param {?} chartName
* @param {?} version
* @return {?}
*/
HelmChartService.prototype.deleteChartVersion = function (projectName, chartName, version) { };
/**
* Get the all details of an helmchart
* ** deprecated param projectName ID of the project
* ** deprecated param chartname ID of the chart
* ** deprecated param version name of the chart's version
* ** deprecated param queryParams options
* @abstract
* @param {?} projectName
* @param {?} chartname
* @param {?} version
* @return {?}
*/
HelmChartService.prototype.getChartDetail = function (projectName, chartname, version) { };
/**
* Download an specific verison
* ** deprecated param projectName ID of the project
* ** deprecated param filename ID of the helm chart
* ** deprecated param version Name of version
* ** deprecated param queryParams options
* @abstract
* @param {?} projectName
* @param {?} filename
* @return {?}
*/
HelmChartService.prototype.downloadChart = function (projectName, filename) { };
/**
* Upload chart and prov files to chartmuseam
* ** deprecated param projectName Name of the project
* ** deprecated param chart chart file
* ** deprecated param prov prov file
* @abstract
* @param {?} projectName
* @param {?} chart
* @param {?} prov
* @return {?}
*/
HelmChartService.prototype.uploadChart = function (projectName, chart, prov) { };
}
/**
* Implement default service for helm chart.
*/
export class HelmChartDefaultService extends HelmChartService {
/**
* @param {?} http
* @param {?} config
*/
constructor(http, config) {
super();
this.http = http;
this.config = config;
}
/**
* @param {?} res
* @return {?}
*/
extractData(res) {
if (res.text() === "") {
return [];
}
return res.json() || [];
}
/**
* @param {?} error
* @return {?}
*/
handleErrorObservable(error) {
return observableThrowError(error.message || error);
}
/**
* @param {?} projectName
* @return {?}
*/
getHelmCharts(projectName) {
if (!projectName) {
return observableThrowError("Bad argument, No project id to get helm charts");
}
return this.http
.get(`${this.config.helmChartEndpoint}/${projectName}/charts`, HTTP_GET_OPTIONS)
.pipe(map(response => this.extractData(response), catchError(error => this.handleErrorObservable(error))));
}
/**
* @param {?} projectId
* @param {?} chartName
* @return {?}
*/
deleteHelmChart(projectId, chartName) {
if (!chartName) {
observableThrowError("Bad argument");
}
return this.http
.delete(`${this.config.helmChartEndpoint}/${projectId}/charts/${chartName}`)
.pipe(map(response => {
return this.extractData(response);
}))
.pipe(catchError(this.handleErrorObservable));
}
/**
* @param {?} projectName
* @param {?} chartName
* @return {?}
*/
getChartVersions(projectName, chartName) {
return this.http.get(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}`, HTTP_GET_OPTIONS)
.pipe(map(response => this.extractData(response)), catchError(this.handleErrorObservable));
}
/**
* @param {?} projectName
* @param {?} chartName
* @param {?} version
* @return {?}
*/
deleteChartVersion(projectName, chartName, version) {
return this.http.delete(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}/${version}`, HTTP_JSON_OPTIONS)
.pipe(map(response => {
return this.extractData(response);
}))
.pipe(catchError(this.handleErrorObservable));
}
/**
* @param {?} projectName
* @param {?} chartName
* @param {?} version
* @return {?}
*/
getChartDetail(projectName, chartName, version) {
return this.http.get(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}/${version}`)
.pipe(map(response => {
return this.extractData(response);
}))
.pipe(catchError(this.handleErrorObservable));
}
/**
* @param {?} projectName
* @param {?} filename
* @return {?}
*/
downloadChart(projectName, filename) {
return this.http.get(`${this.config.downloadChartEndpoint}/${projectName}/${filename}`, {
responseType: ResponseContentType.Blob,
})
.pipe(map(response => {
return {
filename: filename.split('/')[1],
data: response.blob()
};
}))
.pipe(catchError(this.handleErrorObservable));
}
/**
* @param {?} projectName
* @param {?=} chart
* @param {?=} prov
* @return {?}
*/
uploadChart(projectName, chart, prov) {
/** @type {?} */
let formData = new FormData();
/** @type {?} */
let uploadURL = `${this.config.helmChartEndpoint}/${projectName}/charts`;
if (chart) {
formData.append('chart', chart);
}
if (prov) {
formData.append('prov', prov);
if (!chart) {
uploadURL = `${this.config.helmChartEndpoint}/${projectName}/prov`;
}
}
return this.http.post(uploadURL, formData, {
responseType: ResponseContentType.Json
})
.pipe(map(response => this.extractData(response)))
.pipe(catchError(this.handleErrorObservable));
}
}
HelmChartDefaultService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
HelmChartDefaultService.ctorParameters = () => [
{ type: Http },
{ type: undefined, decorators: [{ type: Inject, args: [SERVICE_CONFIG,] }] }
];
if (false) {
/** @type {?} */
HelmChartDefaultService.prototype.http;
/** @type {?} */
HelmChartDefaultService.prototype.config;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helm-chart.service.js","sourceRoot":"ng://@harbor/ui/","sources":["src/service/helm-chart.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport {throwError as observableThrowError,  Observable } from \"rxjs\";\nimport { Injectable, Inject } from \"@angular/core\";\nimport { Http, Response, ResponseContentType } from \"@angular/http\";\nimport { map, catchError } from \"rxjs/operators\";\nimport {HttpErrorResponse} from \"@angular/common/http\";\n\nimport { RequestQueryParams } from \"./RequestQueryParams\";\nimport { HelmChartItem, HelmChartVersion, HelmChartDetail } from \"./interface\";\nimport { SERVICE_CONFIG, IServiceConfig } from \"../service.config\";\nimport { HTTP_JSON_OPTIONS, HTTP_GET_OPTIONS } from \"../utils\";\n\n\n/**\n * Define service methods for handling the helmchart related things.\n * Loose couple with project module.\n *\n **\n * @abstract\n * class RepositoryService\n */\nexport abstract class HelmChartService {\n  /**\n   * Get all helm charts info\n   *  ** deprecated param projectName Id of the project\n   *  ** deprecated param queryParams options params for query data\n   */\n  abstract getHelmCharts(\n    projectName: string,\n    queryParams?: RequestQueryParams\n  ): Observable<HelmChartItem[]>;\n\n  /**\n   * Delete an helmchart\n   *  ** deprecated param projectId Id of the project\n   *  ** deprecated param chartId ID of helmChart in this specific project\n   */\n  abstract deleteHelmChart(projectId: number | string, chartName: string): Observable<any>;\n\n  /**\n   * Get all the versions of helmchart\n   *  ** deprecated param projectName Id of the project\n   *  ** deprecated param chartName ID of the helm chart\n   *  ** deprecated param queryParams option params for query\n   */\n  abstract getChartVersions(\n    projectName: string,\n    chartName: string,\n  ): Observable<HelmChartVersion[]>;\n\n  /**\n   * Delete a version of helmchart\n   *  ** deprecated param projectName ID of the project\n   *  ** deprecated param chartName ID of the chart you want to delete\n   *  ** deprecated param version name of the version\n   */\n  abstract deleteChartVersion(projectName: string, chartName: string, version: string): Observable<any>;\n\n  /**\n   * Get the all details of an helmchart\n   *  ** deprecated param projectName ID of the project\n   *  ** deprecated param chartname ID of the chart\n   *  ** deprecated param version name of the chart's version\n   *  ** deprecated param queryParams options\n   */\n  abstract getChartDetail(\n    projectName: string,\n    chartname: string,\n    version: string,\n  ): Observable<HelmChartDetail>;\n\n  /**\n   * Download an specific verison\n   *  ** deprecated param projectName ID of the project\n   *  ** deprecated param filename ID of the helm chart\n   *  ** deprecated param version Name of version\n   *  ** deprecated param queryParams options\n   */\n  abstract downloadChart(\n    projectName: string,\n    filename: string,\n  ): Observable<any>;\n\n  /**\n   * Upload chart and prov files to chartmuseam\n   *  ** deprecated param projectName Name of the project\n   *  ** deprecated param chart chart file\n   *  ** deprecated param prov prov file\n   */\n  abstract uploadChart (\n    projectName: string,\n    chart: File,\n    prov: File\n  ): Observable<any>;\n}\n\n/**\n * Implement default service for helm chart.\n */\n@Injectable()\nexport class HelmChartDefaultService extends HelmChartService {\n  constructor(\n    private http: Http,\n    @Inject(SERVICE_CONFIG) private config: IServiceConfig\n  ) {\n    super();\n  }\n\n  private extractData(res: Response) {\n    if (res.text() === \"\") {\n      return [];\n    }\n    return res.json() || [];\n  }\n\n  private handleErrorObservable(error: HttpErrorResponse) {\n    return observableThrowError(error.message || error);\n  }\n\n  public getHelmCharts(\n    projectName: string,\n  ): Observable<HelmChartItem[]> {\n    if (!projectName) {\n      return observableThrowError(\"Bad argument, No project id to get helm charts\");\n    }\n\n    return this.http\n      .get(`${this.config.helmChartEndpoint}/${projectName}/charts`, HTTP_GET_OPTIONS)\n      .pipe(\n        map(response => this.extractData(response),\n        catchError(error => this.handleErrorObservable(error))\n      ));\n  }\n\n  public deleteHelmChart(projectId: number | string, chartName: string): Observable<any> {\n    if (!chartName) {\n      observableThrowError(\"Bad argument\");\n    }\n\n    return this.http\n      .delete(`${this.config.helmChartEndpoint}/${projectId}/charts/${chartName}`)\n      .pipe(map(response => {\n        return this.extractData(response);\n      }))\n      .pipe(catchError(this.handleErrorObservable));\n  }\n\n  public getChartVersions(\n    projectName: string,\n    chartName: string,\n  ): Observable<HelmChartVersion[]> {\n    return this.http.get(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}`, HTTP_GET_OPTIONS)\n    .pipe(\n      map(response => this.extractData(response)),\n      catchError(this.handleErrorObservable)\n    );\n  }\n\n  public deleteChartVersion(projectName: string, chartName: string, version: string): any {\n    return this.http.delete(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}/${version}`, HTTP_JSON_OPTIONS)\n    .pipe(map(response => {\n      return this.extractData(response);\n    }))\n    .pipe(catchError(this.handleErrorObservable));\n  }\n\n  public getChartDetail (\n    projectName: string,\n    chartName: string,\n    version: string,\n  ): Observable<HelmChartDetail> {\n    return this.http.get(`${this.config.helmChartEndpoint}/${projectName}/charts/${chartName}/${version}`)\n    .pipe(map(response => {\n      return this.extractData(response);\n    }))\n    .pipe(catchError(this.handleErrorObservable));\n  }\n\n  public downloadChart(\n    projectName: string,\n    filename: string,\n  ): Observable<any> {\n    return this.http.get(`${this.config.downloadChartEndpoint}/${projectName}/${filename}`, {\n      responseType: ResponseContentType.Blob,\n    })\n    .pipe(map(response => {\n      return {\n        filename: filename.split('/')[1],\n        data: response.blob()\n      };\n    }))\n    .pipe(catchError(this.handleErrorObservable));\n  }\n\n\n  public uploadChart(\n    projectName: string,\n    chart?: File,\n    prov?: File\n  ): Observable<any> {\n    let formData = new FormData();\n    let uploadURL = `${this.config.helmChartEndpoint}/${projectName}/charts`;\n    if (chart) {\n      formData.append('chart', chart);\n    }\n    if (prov) {\n      formData.append('prov', prov);\n      if (!chart) {\n        uploadURL = `${this.config.helmChartEndpoint}/${projectName}/prov`;\n      }\n    }\n    return this.http.post(uploadURL, formData, {\n      responseType: ResponseContentType.Json\n    })\n    .pipe(map(response => this.extractData(response)))\n    .pipe(catchError(this.handleErrorObservable));\n  }\n}\n"]}