@seniorsistemas/exclusion-process-component 0.0.1-c049d10c-e93a-4d63-9c2a-b17bca40c324 → 0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805

package/lib/src/services/logical-delete.service.spec.ts

@@ -0,0 +1,322 @@
+import { HttpClient } from "@angular/common/http";
+import { TestBed } from "@angular/core/testing";
+import { HttpTestingController, HttpClientTestingModule } from "@angular/common/http/testing";
+import { TranslateModule, TranslateService } from "@ngx-translate/core";
+import { MessageService } from "primeng/api";
+import { LogicalDeleteConfigService } from "./logical-delete-config.service";
+import { LogicalDeleteService } from "./logical-delete.service";
+import { ProjectConfigs, ProjectConfigsInjectionToken } from "../models/project-config";
+
+describe("LogicalDeleteService", () => {
+    let service: LogicalDeleteService;
+    let httpMock: HttpTestingController;
+    let httpClient: HttpClient;
+    let messageService: MessageService;
+    let translateService: TranslateService;
+    let logicalDeleteConfigService: LogicalDeleteConfigService;
+
+    const defaultProjectConfigs: ProjectConfigs = {
+        domain: "domain",
+        service: "service"
+    };
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [HttpClientTestingModule, TranslateModule.forRoot()],
+            providers: [
+                HttpClient,
+                MessageService,
+                TranslateService,
+                LogicalDeleteConfigService,
+                {
+                    provide: ProjectConfigsInjectionToken,
+                    useValue: defaultProjectConfigs
+                }
+            ]
+        });
+        httpMock = TestBed.inject(HttpTestingController);
+        httpClient = TestBed.inject(HttpClient);
+        messageService = TestBed.inject(MessageService);
+        translateService = TestBed.inject(TranslateService);
+        logicalDeleteConfigService = TestBed.inject(LogicalDeleteConfigService);
+        service = new LogicalDeleteService(httpClient, messageService, translateService, logicalDeleteConfigService);
+    });
+
+    afterEach(() => {
+        httpMock.verify();
+    });
+
+    it("should be created", () => {
+        expect(service).toBeTruthy();
+    });
+
+    describe("defaultCatch", () => {
+        it("should call messageService.add if there was an error", done => {
+            const mockErrorResponse = { status: 400, statusText: "Bad request" };
+            const addSpy = spyOn(messageService, "add");
+            service.listExclusions("entity name", {}).subscribe(
+                () => {},
+                () => {
+                    expect(addSpy).toHaveBeenCalledWith({
+                        severity: "error",
+                        summary: "400",
+                        detail: "Bad request"
+                    });
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('entity%20name')");
+            req.flush(null, mockErrorResponse);
+        });
+
+        it("should call messageService.add setting the summary as Error if no status is provided", done => {
+            const mockErrorResponse = { status: 0, statusText: "Bad request" };
+            const addSpy = spyOn(messageService, "add");
+            service.listExclusions("entity name", {}).subscribe(
+                () => {},
+                () => {
+                    expect(addSpy).toHaveBeenCalledWith({
+                        severity: "error",
+                        summary: "Error",
+                        detail: "Bad request"
+                    });
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('entity%20name')");
+            req.flush(null, mockErrorResponse);
+        });
+
+        it("should call messageService.add setting the detail as the error message", done => {
+            const mockErrorResponse = {
+                status: 400,
+                statusText: "Bad request"
+            };
+            const addSpy = spyOn(messageService, "add");
+            service.listExclusions("entity name", {}).subscribe(
+                () => {},
+                () => {
+                    expect(addSpy).toHaveBeenCalledWith({
+                        severity: "error",
+                        summary: "400",
+                        detail: "Some error"
+                    });
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('entity%20name')");
+            req.flush(
+                {
+                    message: "Some error"
+                },
+                mockErrorResponse
+            );
+        });
+
+        it("should call messageService.add setting the default message for unauthorized", done => {
+            spyOn(translateService, "instant").and
+                .callFake((val: any) => `translated_${val}`);
+
+            const mockErrorResponse = {
+                status: 401,
+                statusText: "Unauthorized"
+            };
+            const addSpy = spyOn(messageService, "add");
+            service.listExclusions("entity name", {}).subscribe(
+                () => {},
+                () => {
+                    expect(addSpy).toHaveBeenCalledWith({
+                        severity: "error",
+                        summary: "translated_domain.service.error_unauthorized_title",
+                        detail: "translated_domain.service.error_unauthorized_description"
+                    });
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('entity%20name')");
+            req.flush(null, mockErrorResponse);
+        });
+    });
+
+    describe("getListQueryParams", () => {
+        it("should set default page and size", () => {
+            const result = service.getListQueryParams({});
+            expect(result.get("offset")).toBe("0");
+            expect(result.get("size")).toBe("10");
+        });
+
+        it("should set page and size as string parameters", () => {
+            const result = service.getListQueryParams({ page: 1, size: 25 });
+            expect(result.get("offset")).toBe("1");
+            expect(result.get("size")).toBe("25");
+        });
+
+        it("should set the filterQuery as filter if the param is set", () => {
+            const result = service.getListQueryParams({ filterQuery: "valid filter info" });
+            expect(result.get("filter")).toBe("valid filter info");
+        });
+
+        it("should set the display fields separated by comma if the param is set", () => {
+            const result = service.getListQueryParams({ displayFields: ["field1", "field2"] });
+            expect(result.get("displayfields")).toBe("field1,field2");
+        });
+
+        it("should set the orderBy param when sort is set", () => {
+            const result = service.getListQueryParams({ sort: [{ field: "field1", order: 1 }, { field: "field2", order: -1 }] });
+            expect(result.get("orderby")).toBe("field1 asc, field2 desc");
+        });
+    });
+
+    describe("getProcessDetails", () => {
+        it("should filter by recordId", done => {
+            const httpGetSpy = spyOn(httpClient, "get").and.callThrough();
+
+            service.getProcessDetails("valid recordId").subscribe(
+                () => {
+                    expect(httpGetSpy).toHaveBeenCalledWith("domain/service/entities/exclusionProcess", { params: { filter: "recordId eq 'valid recordId'" } });
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?filter=recordId%20eq%20'valid%20recordId'");
+            req.flush({ contents: [] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should return null if record not found", done => {
+            service.getProcessDetails("valid recordId").subscribe(
+                value => {
+                    expect(value).toBeNull();
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?filter=recordId%20eq%20'valid%20recordId'");
+            req.flush({ contents: [] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should return the record if it was found", done => {
+            service.getProcessDetails("valid recordId").subscribe(
+                value => {
+                    expect(value.id).toBe("valid id");
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?filter=recordId%20eq%20'valid%20recordId'");
+            req.flush({ contents: [{id: 'valid id'}] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should call defaultCatch in case of an error", done => {
+            spyOn(service, "defaultCatch").and.callThrough();
+
+            service.getProcessDetails("valid recordId").subscribe(
+                () => {},
+                () => {
+                    done();
+                }
+            );
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?filter=recordId%20eq%20'valid%20recordId'");
+            req.flush(null, { status: 400, statusText: "Some error message" });
+
+            expect(service.defaultCatch).toHaveBeenCalled();
+        });
+    });
+
+    describe("listExclusions", () => {
+        it("should filter by entityName", done => {
+            service.listExclusions("valid entityName").subscribe(
+                () => {
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('valid%20entityName')");
+            req.flush({ contents: [] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should add filter by entityName with other filter already exists", done => {
+            const params = { filterQuery: 'status eq test' };
+            service.listExclusions("valid entityName", params).subscribe(
+                () => {
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne(
+                "domain/service/entities/exclusionProcess?size=10&offset=0&filter=status%20eq%20test%20and%20lower(entityName)%20eq%20lower('valid%20entityName')");
+            req.flush({ contents: [] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should call getListQueryParams to create the http filters", done => {
+            const getListQueryParamsSpy = spyOn(service, 'getListQueryParams').and.callThrough();
+            const params = { filterQuery: 'status eq test', page: 1, orderBy: 'id asc' };
+
+            service.listExclusions("valid entityName", params).subscribe(
+                () => {
+                    expect(getListQueryParamsSpy).toHaveBeenCalledWith(params);
+                    done();
+                }
+            );
+
+            const req = httpMock.match(() => true)[0];
+            req.flush({ contents: [] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should call defaultCatch in case of an error", done => {
+            spyOn(service, "defaultCatch").and.callThrough();
+
+            service.listExclusions("valid entityName").subscribe(
+                () => {},
+                () => {
+                    done();
+                }
+            );
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('valid%20entityName')");
+            req.flush(null, { status: 400, statusText: "Some error message" });
+
+            expect(service.defaultCatch).toHaveBeenCalled();
+        });
+
+        it("should return the list on data", done => {
+            service.listExclusions("valid entityName").subscribe(
+                value => {
+                    expect(value.contents.length).toBe(2);
+                    expect(value.contents[0].id).toBe("1");
+                    expect(value.contents[0].startDate).toBeFalsy();
+                    expect(value.contents[0].finishDate).toBeFalsy();
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('valid%20entityName')");
+            req.flush({ contents: [{id: "1"}, {id: "2"}] }, { status: 200, statusText: "Ok" });
+        });
+
+        it("should return the starDate and finishDate converted to date when present", done => {
+            service.listExclusions("valid entityName").subscribe(
+                value => {
+                    const startDate = value.contents[0].startDate;
+                    expect(startDate.toISOString()).toContain("2023-02-10");
+                    const finishDate = value.contents[0].finishDate;
+                    expect(finishDate.toISOString()).toContain("2023-05-05");
+                    done();
+                }
+            );
+
+            const req = httpMock.expectOne("domain/service/entities/exclusionProcess?size=10&offset=0&filter=lower(entityName)%20eq%20lower('valid%20entityName')");
+            const reqResponse = {
+                contents: [
+                    {
+                        startDate: "2023-02-10",
+                        finishDate: "2023-05-05"
+                    }
+                ]
+            };
+            req.flush(reqResponse, { status: 200, statusText: "Ok" });
+        });
+    });
+});

package/lib/src/services/logical-delete.service.ts

@@ -0,0 +1,122 @@
+import * as moment from "moment";
+import { HttpClient, HttpParams } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { TranslateService } from "@ngx-translate/core";
+import { MessageService } from "primeng/api";
+import { Observable, throwError } from "rxjs";
+import { catchError, map } from "rxjs/operators";
+import { ListResult, ExclusionProcess } from "../models/index";
+import { LogicalDeleteConfigService } from "./logical-delete-config.service";
+import { ListParams } from "../models/list-params";
+
+@Injectable()
+export class LogicalDeleteService {
+    private exclusionProcessUrl: string;
+    private listExclusionsUrl: string;
+
+    constructor(
+        private readonly http: HttpClient,
+        private readonly messageService: MessageService,
+        private readonly translate: TranslateService,
+        private readonly projectConfigs: LogicalDeleteConfigService) {
+
+        const entityUrl = `${projectConfigs.getDomain()}/${projectConfigs.getService()}`;
+        this.exclusionProcessUrl = `${entityUrl}/entities/exclusionProcess`;
+        this.listExclusionsUrl = `${entityUrl}/entities/exclusionProcess`;
+        this.defaultCatch = this.defaultCatch.bind(this);
+    }
+
+    public defaultCatch() {
+        return catchError<any, any>((err: any) => {
+            if (err) {
+                let summary = err.status ? String(err.status) : "Error";
+                let detail = (err.error && err.error.message) || err.statusText || err.message || "Error";
+
+                if (err.status === 401) {
+                    const prefix = this.projectConfigs.getTranslationPrefix();
+                    summary = this.translate.instant(`${prefix}.error_unauthorized_title`);
+                    detail = this.translate.instant(`${prefix}.error_unauthorized_description`);
+                }
+
+                this.messageService.add({
+                    severity: "error",
+                    summary,
+                    detail
+                });
+            }
+
+            return throwError(err);
+        });
+    }
+
+    public getListQueryParams(listParams: ListParams) {
+        const { page = 0, size = 10, sort = [], filterQuery = "", displayFields = [] } = listParams;
+
+        let params = new HttpParams();
+        params = params.append("size", String(size));
+        params = params.append("offset", String(page));
+
+        if (sort && sort.length) {
+            params = params.append(
+                "orderby",
+                sort
+                    .map(s => {
+                        if (s.order === -1) {
+                            return `${s.field} desc`;
+                        }
+
+                        return `${s.field} asc`;
+                    })
+                    .join(", ")
+            );
+        }
+
+        if (filterQuery) {
+            params = params.append("filter", filterQuery);
+        }
+
+        if (displayFields && displayFields.length) {
+            params = params.append("displayfields", displayFields.join());
+        }
+
+        return params;
+    }
+
+    public getProcessDetails(recordId: string): Observable<ExclusionProcess> {
+        const filterParams = {
+            filter: `recordId eq '${recordId}'`
+        };
+
+        return this.http.get<ListResult<ExclusionProcess>>(this.exclusionProcessUrl, { params: filterParams })
+            .pipe<ListResult<ExclusionProcess>>(this.defaultCatch())
+            .pipe(map(value => {
+                if (!value.contents?.length) {
+                    return null;
+                }
+                return value.contents[0];
+            }));
+    }
+
+    public listExclusions(entityName: string, params: ListParams = {}): Observable<ListResult<ExclusionProcess>> {
+        if (params.filterQuery) {
+            params.filterQuery += ` and lower(entityName) eq lower('${entityName}')`;
+        } else {
+            params.filterQuery = `lower(entityName) eq lower('${entityName}')`;
+        }
+
+        return this.http.get<ListResult<ExclusionProcess>>(this.exclusionProcessUrl, { params: this.getListQueryParams(params) })
+            .pipe<ListResult<ExclusionProcess>>(this.defaultCatch())
+            .pipe<ListResult<ExclusionProcess>>(map(value => {
+                value.contents.forEach(p => {
+                    if (p.startDate) {
+                        p.startDate = moment(p.startDate).toDate();
+                    }
+
+                    if (p.finishDate) {
+                        p.finishDate = moment(p.finishDate).toDate();
+                    }
+                });
+                return value;
+            }));
+    }
+}

package/lib/test.ts

@@ -0,0 +1,14 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import "zone.js/dist/zone-testing";
+import { getTestBed } from "@angular/core/testing";
+import { BrowserDynamicTestingModule, platformBrowserDynamicTesting } from "@angular/platform-browser-dynamic/testing";
+
+declare const require: any;
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting());
+// Then we find all the tests.
+const context = require.context("./", true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/lib/tsconfig.lib.json

@@ -0,0 +1,19 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "../../out-tsc/lib",
+        "target": "es2015",
+        "declaration": true,
+        "inlineSources": true,
+        "types": [],
+        "lib": [
+            "dom",
+            "es2017"
+        ]
+    },
+    "angularCompilerOptions": {
+        "skipTemplateCodegen": true,
+        "strictMetadataEmit": true,
+        "enableResourceInlining": true
+    }
+}

package/lib/tsconfig.lib.prod.json

@@ -0,0 +1,6 @@
+{
+    "extends": "./tsconfig.lib.json",
+    "angularCompilerOptions": {
+        "enableIvy": false
+    }
+}

package/lib/tsconfig.spec.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "../out-tsc/spec",
+        "baseUrl": "./",
+        "types": ["jasmine", "node"]
+    },
+    "files": ["./test.ts", "../src/polyfills.ts"],
+    "include": ["../**/*.spec.ts", "../**/*.d.ts"]
+}
+
+

package/lib/tslint.json

@@ -0,0 +1,19 @@
+{
+    "extends": "../tslint.json",
+    "rules": {
+        "directive-selector": [
+            true,
+            "attribute",
+            "erp",
+            "s",
+            "camelCase"
+        ],
+        "component-selector": [
+            true,
+            "element",
+            "erp",
+            "s",
+            "kebab-case"
+        ]
+    }
+}

package/package.json

@@ -1,12 +1,27 @@
 {
-  "$schema": "../node_modules/ng-packagr/package.schema.json",
   "name": "@seniorsistemas/exclusion-process-component",
-  "version": "0.0.1-c049d10c-e93a-4d63-9c2a-b17bca40c324",
-  "repository": {
-    "type": "git",
-    "url": "https://git.senior.com.br/one-senior/exclusion-process-component"
+  "version": "0.6.0-44030ff3-2eeb-49f7-8927-0920cc01a805",
+  "engines": {
+    "node": ">=10.14.0",
+    "npm": ">=6.4.1"
   },
-  "peerDependencies": {
+  "scripts": {
+    "ng": "ng",
+    "start": "node server.js --project=exclusion-process-component-app",
+    "build": "ng-packagr -p lib/package.json",
+    "test": "ng test --watch=false",
+    "test:dev": "ng test",
+    "test:coverage": "ng test --watch=false --code-coverage && npx http-server coverage -o",
+    "lint": "ng lint",
+    "e2e": "ng e2e"
+  },
+  "project": {
+    "app": "exclusion-process-component",
+    "domain": "platform",
+    "service": "exclusion-process-component"
+  },
+  "private": false,
+  "dependencies": {
     "@angular/animations": "~9.1.13",
     "@angular/cdk": "~9.2.4",
     "@angular/common": "~9.1.13",
@@ -44,20 +59,46 @@
     "quill": "^1.3.7",
     "rxjs": "~6.6.3",
     "rxjs-compat": "^6.6.7",
+    "tslib": "^1.10.0",
     "web-animations-js": "^2.3.2",
     "zone.js": "~0.10.2"
   },
-  "main": "bundles/seniorsistemas-exclusion-process-component.umd.js",
-  "module": "fesm5/seniorsistemas-exclusion-process-component.js",
-  "es2015": "fesm2015/seniorsistemas-exclusion-process-component.js",
-  "esm5": "esm5/seniorsistemas-exclusion-process-component.js",
-  "esm2015": "esm2015/seniorsistemas-exclusion-process-component.js",
-  "fesm5": "fesm5/seniorsistemas-exclusion-process-component.js",
-  "fesm2015": "fesm2015/seniorsistemas-exclusion-process-component.js",
-  "typings": "seniorsistemas-exclusion-process-component.d.ts",
-  "metadata": "seniorsistemas-exclusion-process-component.metadata.json",
-  "sideEffects": false,
-  "dependencies": {
-    "tslib": "^1.10.0"
+  "devDependencies": {
+    "@angular-devkit/build-angular": "~0.901.15",
+    "@angular/cli": "~9.1.15",
+    "@angular/compiler-cli": "~9.1.13",
+    "@angular/language-service": "~9.1.13",
+    "@babel/core": "^7.12.3",
+    "@compodoc/compodoc": "^1.1.11",
+    "@storybook/addon-actions": "^6.0.27",
+    "@storybook/addon-essentials": "^6.0.27",
+    "@storybook/addon-links": "^6.0.27",
+    "@storybook/angular": "^6.0.27",
+    "@types/cropperjs": "~1.1.3",
+    "@types/element-resize-detector": "~1.1.2",
+    "@types/jasmine": "~3.3.8",
+    "@types/jasminewd2": "~2.0.3",
+    "@types/node": "^12.11.1",
+    "babel-loader": "^8.1.0",
+    "codelyzer": "^5.1.2",
+    "core-js": "^3.0.1",
+    "jasmine-core": "~3.4.0",
+    "jasmine-spec-reporter": "~4.2.1",
+    "karma": "~4.1.0",
+    "karma-chrome-launcher": "~2.2.0",
+    "karma-coverage-istanbul-reporter": "~2.0.1",
+    "karma-jasmine": "~2.0.1",
+    "karma-jasmine-html-reporter": "^1.4.0",
+    "karma-parallel": "~0.3.1",
+    "karma-spec-reporter": "~0.0.32",
+    "ng-packagr": "^9.0.0",
+    "ngx-cookie-service": "^10.1.1",
+    "prettier": "~1.14.0",
+    "protractor": "~5.4.0",
+    "react-is": "^17.0.1",
+    "ts-node": "~7.0.0",
+    "tslint": "~5.11.0",
+    "tslint-config-prettier": "~1.14.0",
+    "typescript": "~3.8.3"
   }
 }

package/protractor.conf.js

@@ -0,0 +1,28 @@
+// Protractor configuration file, see link for more information
+// https://github.com/angular/protractor/blob/master/lib/config.ts
+
+const { SpecReporter } = require('jasmine-spec-reporter');
+
+exports.config = {
+  allScriptsTimeout: 11000,
+  specs: [
+    './e2e/**/*.e2e-spec.ts'
+  ],
+  capabilities: {
+    'browserName': 'chrome'
+  },
+  directConnect: true,
+  baseUrl: 'http://localhost:4200/',
+  framework: 'jasmine',
+  jasmineNodeOpts: {
+    showColors: true,
+    defaultTimeoutInterval: 30000,
+    print: function() {}
+  },
+  onPrepare() {
+    require('ts-node').register({
+      project: 'e2e/tsconfig.e2e.json'
+    });
+    jasmine.getEnv().addReporter(new SpecReporter({ spec: { displayStacktrace: true } }));
+  }
+};

package/senior-ci/.devcontainer/Dockerfile

@@ -0,0 +1,27 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.194.3/containers/python-3/.devcontainer/base.Dockerfile
+
+# [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
+ARG VARIANT="3.9"
+FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+
+# [Choice] Node.js version: none, lts/*, 16, 14, 12, 10
+ARG NODE_VERSION="lts/*"
+RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
+
+# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
+COPY requirements.txt /tmp/pip-tmp/
+COPY requirements-dev.txt /tmp/pip-tmp/
+RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements-dev.txt \
+    && rm -rf /tmp/pip-tmp
+
+# Install Helm
+RUN curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash
+
+# [Optional] Uncomment this section to install additional OS packages.
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get -y install --no-install-recommends default-jdk
+
+# [Optional] Uncomment this line to install global node packages.
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
+
+ENV JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64/bin/java