@lowcodeunit/applications-flow-common 1.33.151-angular-13 → 1.33.152-social-ish-angular-13-test

package/esm2015/lib/services/applications-flow.service.js

@@ -0,0 +1,146 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { LCUServiceSettings } from '@lcu/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@lcu/common";
+export class ApplicationsFlowService {
+    //  Properties
+    // Constructors
+    constructor(http, settings) {
+        this.http = http;
+        this.settings = settings;
+        this.apiRoot = settings.APIRoot;
+    }
+    // API Methods
+    ConfigureDevOpsAction(actionLookup) {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/devops/actions/${actionLookup}/configure`, {}, {
+            headers: this.loadHeaders(),
+        });
+    }
+    CreateRepository(organization, repoName) {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories`, {
+            Name: repoName,
+        }, {
+            headers: this.loadHeaders(),
+        });
+    }
+    DeleteApplication(appLookup) {
+        return this.http.delete(`${this.apiRoot}/api/lowcodeunit/manage/applications/${appLookup}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    DeleteDevOpsAction(doaLookup) {
+        return this.http.delete(`${this.apiRoot}/api/lowcodeunit/manage/devops-actions/${doaLookup}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    DeleteProject(projectLookup) {
+        return this.http.delete(`${this.apiRoot}/api/lowcodeunit/manage/projects/${projectLookup}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    DeleteSourceControl(scLookup) {
+        return this.http.delete(`${this.apiRoot}/api/lowcodeunit/manage/source-controls/${scLookup}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    EnsureUserEnterprise() {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/enterprise/ensure`, {}, {
+            headers: this.loadHeaders(),
+        });
+    }
+    GetActiveEnterprise() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/enterprises/active`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    HasValidConnection() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/github/connection/valid`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListProjects() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/projects`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListBranches(organization, repository) {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories/${repository}/branches`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListBuildPaths(organization, repository, branch = '') {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories/${repository}/build-paths?branch=${branch}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListEnterprises() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/enterprises/list`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListOrganizations() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/github/organizations`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    ListRepositories(organization) {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    LoadEnterpriseAsCode() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/eac`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    LoadProjectHostingDetails(organization, repository, branch) {
+        branch = encodeURIComponent(branch);
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/projects/organizations/${organization}/repositories/${repository}/branches/${branch}/hosting/details`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    NewLoadProjectHostingDetails() {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/projects/hosting/details`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    SaveEnterpriseAsCode(eac) {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/eac`, eac, {
+            headers: this.loadHeaders(),
+        });
+    }
+    SetActiveEnterprise(activeEntLookup) {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/enterprises/active`, {
+            ActiveEnterpriseLookup: activeEntLookup,
+        }, {
+            headers: this.loadHeaders(),
+        });
+    }
+    UnpackLowCodeUnit(req) {
+        return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/projects/unpack`, req, {
+            headers: this.loadHeaders(),
+        });
+    }
+    UserFeed(page, pageSize) {
+        return this.http.get(`${this.apiRoot}/api/lowcodeunit/userfeed?page=${page}&pageSize=${pageSize}`, {
+            headers: this.loadHeaders(),
+        });
+    }
+    //  Helpers
+    loadHeaders() {
+        return {};
+    }
+}
+ApplicationsFlowService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ApplicationsFlowService_Factory() { return new ApplicationsFlowService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.LCUServiceSettings)); }, token: ApplicationsFlowService, providedIn: "root" });
+ApplicationsFlowService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ApplicationsFlowService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: LCUServiceSettings }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"applications-flow.service.js","sourceRoot":"/home/runner/work/applications-flow/applications-flow/projects/common/src/","sources":["lib/services/applications-flow.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { LCUServiceSettings } from '@lcu/common';\r\nimport { Observable } from 'rxjs';\r\nimport { EnterpriseAsCode } from '@semanticjs/common';\r\nimport { UnpackLowCodeUnitRequest } from '../state/applications-flow.state';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ApplicationsFlowService {\r\n  //  Fields\r\n  protected apiRoot: string;\r\n\r\n  //  Properties\r\n\r\n  // Constructors\r\n  constructor(\r\n    protected http: HttpClient,\r\n    protected settings: LCUServiceSettings\r\n  ) {\r\n    this.apiRoot = settings.APIRoot;\r\n  }\r\n\r\n  // API Methods\r\n  public ConfigureDevOpsAction(actionLookup: string): Observable<object> {\r\n    return this.http.post(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/devops/actions/${actionLookup}/configure`,\r\n      {},\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public CreateRepository(\r\n    organization: string,\r\n    repoName: string\r\n  ): Observable<object> {\r\n    return this.http.post(\r\n      `${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories`,\r\n      {\r\n        Name: repoName,\r\n      },\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public DeleteApplication(appLookup: string): Observable<object> {\r\n    return this.http.delete(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/applications/${appLookup}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public DeleteDevOpsAction(doaLookup: string): Observable<object> {\r\n    return this.http.delete(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/devops-actions/${doaLookup}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public DeleteProject(projectLookup: string): Observable<object> {\r\n    return this.http.delete(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/projects/${projectLookup}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public DeleteSourceControl(scLookup: string): Observable<object> {\r\n    return this.http.delete(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/source-controls/${scLookup}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public EnsureUserEnterprise(): Observable<object> {\r\n    return this.http.post(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/enterprise/ensure`,\r\n      {},\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public GetActiveEnterprise(): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/enterprises/active`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public HasValidConnection(): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/github/connection/valid`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public ListProjects(): Observable<object> {\r\n    return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/projects`, {\r\n      headers: this.loadHeaders(),\r\n    });\r\n  }\r\n\r\n  public ListBranches(\r\n    organization: string,\r\n    repository: string\r\n  ): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories/${repository}/branches`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public ListBuildPaths(\r\n    organization: string,\r\n    repository: string,\r\n    branch: string = ''\r\n  ): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories/${repository}/build-paths?branch=${branch}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public ListEnterprises(): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/enterprises/list`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public ListOrganizations(): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/github/organizations`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public ListRepositories(organization: string): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/github/organizations/${organization}/repositories`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public LoadEnterpriseAsCode(): Observable<object> {\r\n    return this.http.get(`${this.apiRoot}/api/lowcodeunit/manage/eac`, {\r\n      headers: this.loadHeaders(),\r\n    });\r\n  }\r\n\r\n  public LoadProjectHostingDetails(\r\n    organization: string,\r\n    repository: string,\r\n    branch: string\r\n  ): Observable<object> {\r\n    branch = encodeURIComponent(branch);\r\n\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/projects/organizations/${organization}/repositories/${repository}/branches/${branch}/hosting/details`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public NewLoadProjectHostingDetails(): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/projects/hosting/details`,\r\n\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public SaveEnterpriseAsCode(eac: EnterpriseAsCode): Observable<object> {\r\n    return this.http.post(`${this.apiRoot}/api/lowcodeunit/manage/eac`, eac, {\r\n      headers: this.loadHeaders(),\r\n    });\r\n  }\r\n\r\n  public SetActiveEnterprise(activeEntLookup: string): Observable<object> {\r\n    return this.http.post(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/enterprises/active`,\r\n      {\r\n        ActiveEnterpriseLookup: activeEntLookup,\r\n      },\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public UnpackLowCodeUnit(req: UnpackLowCodeUnitRequest): Observable<object> {\r\n    return this.http.post(\r\n      `${this.apiRoot}/api/lowcodeunit/manage/projects/unpack`,\r\n      req,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  public UserFeed(page: number, pageSize: number): Observable<object> {\r\n    return this.http.get(\r\n      `${this.apiRoot}/api/lowcodeunit/userfeed?page=${page}&pageSize=${pageSize}`,\r\n      {\r\n        headers: this.loadHeaders(),\r\n      }\r\n    );\r\n  }\r\n\r\n  //  Helpers\r\n  protected loadHeaders(): { [header: string]: string | string[] } {\r\n    return {};\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/eac.service.js

@@ -0,0 +1,218 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { ProjectService } from './project.service';
+import { ApplicationsFlowState, } from '../state/applications-flow.state';
+import * as i0 from "@angular/core";
+import * as i1 from "./project.service";
+export class SaveApplicationAsCodeEventRequest {
+}
+export class SaveDFSModifierEventRequest {
+}
+export class SaveEnvironmentAsCodeEventRequest {
+}
+export class SaveProjectAsCodeEventRequest {
+}
+export class EaCService {
+    //  Constructors
+    constructor(projectService) {
+        this.projectService = projectService;
+        this.State = new ApplicationsFlowState();
+    }
+    //  API Methods
+    get CreatingProject() {
+        return this.projectService.CreatingProject;
+    }
+    DeleteApplication(appLookup, appName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (confirm(`Are you sure you want to delete application '${appName}'?`)) {
+                yield this.projectService.DeleteApplication(this.State, appLookup);
+            }
+        });
+    }
+    DeleteDevOpsAction(doaLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (confirm(`Are you sure you want to delete DevOps action '${doaLookup}'?`)) {
+                yield this.projectService.DeleteDevOpsAction(this.State, doaLookup);
+            }
+        });
+    }
+    DeleteProject(projectLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (confirm(`Are you sure you want to delete Project '${projectLookup}'?`)) {
+                yield this.projectService.DeleteProject(this.State, projectLookup);
+            }
+        });
+    }
+    DeleteSourceControl(scLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (confirm(`Are you sure you want to delete Source Control '${scLookup}'?`)) {
+                yield this.projectService.DeleteSourceControl(this.State, scLookup);
+            }
+        });
+    }
+    // this.appsFlowEventsSvc.EnsureUserEnterpriseEvent.subscribe(async () => {
+    //   await this.projectService.EnsureUserEnterprise(this.State);
+    // });
+    EnsureUserEnterprise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.EnsureUserEnterprise(this.State);
+        });
+    }
+    GetActiveEnterprise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.GetActiveEnterprise(this.State);
+        });
+    }
+    get EditingProjectLookup() {
+        return this.projectService.EditingProjectLookup;
+    }
+    HasValidConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.HasValidConnection(this.State);
+        });
+    }
+    ListEnterprises() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.ListEnterprises(this.State);
+        });
+    }
+    LoadEnterpriseAsCode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.LoadEnterpriseAsCode(this.State);
+        });
+    }
+    SaveApplicationAsCode(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handleSaveApplication(req);
+        });
+    }
+    SaveDFSModifier(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handleSaveDFSModifier(req);
+        });
+    }
+    SaveEnterpriseAsCode(eac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.SaveEnterpriseAsCode(this.State, eac);
+        });
+    }
+    SaveEnvironmentAsCode(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handleSaveEnvironment(req);
+        });
+    }
+    SaveProjectAsCode(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.handleSaveProject(req.ProjectLookup, req.Project);
+        });
+    }
+    SetActiveEnterprise(eventValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.projectService.SetActiveEnterprise(this.State, eventValue);
+        });
+    }
+    SetCreatingProject(creatingProject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.projectService.SetCreatingProject(creatingProject);
+        });
+    }
+    SetEditProjectSettings(projectLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.projectService.SetEditProjectSettings(this.State, projectLookup);
+        });
+    }
+    UnpackLowCodeUnit(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (confirm(`Are you sure you want to unpack application '${req.ApplicationName}' with version '${req.Version}'?`)) {
+                yield this.projectService.UnpackLowCodeUnit(this.State, req);
+            }
+        });
+    }
+    //  Helpers
+    handleSaveApplication(req) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const saveEaC = {
+                EnterpriseLookup: this.State.EaC.EnterpriseLookup,
+                Applications: {},
+                Projects: {},
+            };
+            const existingProj = Object.assign({}, this.State.EaC.Projects[req.ProjectLookup]);
+            if (((_a = existingProj.ApplicationLookups) === null || _a === void 0 ? void 0 : _a.indexOf(req.ApplicationLookup)) < 0) {
+                if (!existingProj.ApplicationLookups) {
+                    existingProj.ApplicationLookups = [];
+                }
+                existingProj.ApplicationLookups.push(req.ApplicationLookup);
+                saveEaC.Projects[req.ProjectLookup] = existingProj;
+            }
+            if (req.Application) {
+                saveEaC.Applications[req.ApplicationLookup] = req.Application;
+            }
+            yield this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);
+        });
+    }
+    handleSaveDFSModifier(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const saveEaC = {
+                EnterpriseLookup: this.State.EaC.EnterpriseLookup,
+                Modifiers: {},
+                Projects: {},
+            };
+            if (req.Modifier) {
+                saveEaC.Modifiers[req.ModifierLookup] = req.Modifier;
+            }
+            if (req.ProjectLookup) {
+                saveEaC.Projects[req.ProjectLookup] = {
+                    ModifierLookups: [req.ModifierLookup],
+                };
+            }
+            yield this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);
+        });
+    }
+    handleSaveEnvironment(req) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const saveEaC = {
+                EnterpriseLookup: (_b = (_a = this.State) === null || _a === void 0 ? void 0 : _a.EaC) === null || _b === void 0 ? void 0 : _b.EnterpriseLookup,
+                DataTokens: {},
+                Environments: {},
+            };
+            if (req.Environment) {
+                saveEaC.Environments[req.EnvironmentLookup] = req.Environment;
+            }
+            if (req.EnterpriseDataTokens) {
+                saveEaC.DataTokens = req.EnterpriseDataTokens;
+            }
+            yield this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);
+        });
+    }
+    handleSaveProject(projectLookup, project) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const projHosts = {};
+            (_a = project === null || project === void 0 ? void 0 : project.Hosts) === null || _a === void 0 ? void 0 : _a.forEach((host) => {
+                projHosts[host] = this.State.EaC.Hosts[host];
+            });
+            const saveEaC = {
+                EnterpriseLookup: this.State.EaC.EnterpriseLookup,
+                Enterprise: Object.assign(Object.assign({}, this.State.EaC.Enterprise), { PrimaryHost: project.Hosts[0] }),
+                Hosts: projHosts,
+                // Providers: this.State.EaC.Providers,  //  TODO:  Remove after all providers ADB2C's have been upgraded
+                Projects: {},
+            };
+            saveEaC.Projects[projectLookup] = project;
+            yield this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);
+            this.SetEditProjectSettings(projectLookup);
+        });
+    }
+}
+EaCService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EaCService_Factory() { return new EaCService(i0.ɵɵinject(i1.ProjectService)); }, token: EaCService, providedIn: "root" });
+EaCService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+EaCService.ctorParameters = () => [
+    { type: ProjectService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eac.service.js","sourceRoot":"/home/runner/work/applications-flow/applications-flow/projects/common/src/","sources":["lib/services/eac.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Injectable } from '@angular/core';\nimport { ProjectService } from './project.service';\nimport {\n  ApplicationsFlowState,\n  UnpackLowCodeUnitRequest,\n} from '../state/applications-flow.state';\nimport {\n  EaCApplicationAsCode,\n  EaCDataToken,\n  EaCDFSModifier,\n  EaCEnvironmentAsCode,\n  EaCHost,\n  EaCProjectAsCode,\n  EnterpriseAsCode,\n} from '@semanticjs/common';\n\nexport class SaveApplicationAsCodeEventRequest {\n  public Application?: EaCApplicationAsCode;\n\n  public ApplicationLookup?: string;\n\n  public ProjectLookup?: string;\n}\n\nexport class SaveDFSModifierEventRequest {\n  public Modifier: EaCDFSModifier;\n\n  public ModifierLookup: string;\n\n  public ProjectLookup?: string;\n}\n\nexport class SaveEnvironmentAsCodeEventRequest {\n  public EnterpriseDataTokens?: { [lookup: string]: EaCDataToken };\n\n  public Environment?: EaCEnvironmentAsCode;\n\n  public EnvironmentLookup?: string;\n}\n\nexport class SaveProjectAsCodeEventRequest {\n  public Project?: EaCProjectAsCode;\n\n  public ProjectLookup?: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EaCService {\n  //  Properties\n  public State: ApplicationsFlowState;\n\n  //  Constructors\n  constructor(\n    protected projectService: ProjectService\n  ) {\n    this.State = new ApplicationsFlowState();\n  }\n\n  //  API Methods\n\n  public get CreatingProject(): boolean {\n    return this.projectService.CreatingProject;\n  }\n\n  public async DeleteApplication(\n    appLookup: string,\n    appName: string\n  ): Promise<void> {\n    if (confirm(`Are you sure you want to delete application '${appName}'?`)) {\n      await this.projectService.DeleteApplication(this.State, appLookup);\n    }\n  }\n\n  public async DeleteDevOpsAction(doaLookup: string): Promise<void> {\n    if (confirm(`Are you sure you want to delete DevOps action '${doaLookup}'?`)) {\n\n      await this.projectService.DeleteDevOpsAction(this.State, doaLookup);\n    }\n  }\n\n  public async DeleteProject(projectLookup: string): Promise<void> {\n    if (confirm(`Are you sure you want to delete Project '${projectLookup}'?`)) {\n\n      await this.projectService.DeleteProject(this.State, projectLookup);\n    }\n  }\n\n  public async DeleteSourceControl(scLookup: string): Promise<void> {\n    if (confirm(`Are you sure you want to delete Source Control '${scLookup}'?`)) {\n\n      await this.projectService.DeleteSourceControl(this.State, scLookup);\n    }\n  }\n\n  // this.appsFlowEventsSvc.EnsureUserEnterpriseEvent.subscribe(async () => {\n  //   await this.projectService.EnsureUserEnterprise(this.State);\n  // });\n  \n\n  public async EnsureUserEnterprise(): Promise<void> {\n    await this.projectService.EnsureUserEnterprise(this.State);\n  }\n\n  public async GetActiveEnterprise(): Promise<void> {\n    await this.projectService.GetActiveEnterprise(this.State);\n  }\n\n  public get EditingProjectLookup(): string {\n    return this.projectService.EditingProjectLookup;\n  }\n\n  public async HasValidConnection(): Promise<void>{\n    await this.projectService.HasValidConnection(this.State);\n  }\n\n  public async ListEnterprises(): Promise<void> {\n    await this.projectService.ListEnterprises(this.State);\n  }\n\n  public async LoadEnterpriseAsCode(): Promise<void>{\n    await this.projectService.LoadEnterpriseAsCode(this.State);\n  }\n\n  public async SaveApplicationAsCode(\n    req: SaveApplicationAsCodeEventRequest\n  ): Promise<void> {\n    await this.handleSaveApplication(req);\n  }\n\n  public async SaveDFSModifier(req: SaveDFSModifierEventRequest): Promise<void> {\n    await this.handleSaveDFSModifier(req);\n  }\n\n  public async SaveEnterpriseAsCode(eac: EnterpriseAsCode): Promise<void>  {\n    await this.projectService.SaveEnterpriseAsCode(this.State, eac);\n  }\n\n  public async SaveEnvironmentAsCode(req: SaveEnvironmentAsCodeEventRequest): Promise<void>{\n    await this.handleSaveEnvironment(req);\n  }\n\n  public async SaveProjectAsCode(req: SaveProjectAsCodeEventRequest): Promise<void>{\n    await this.handleSaveProject(req.ProjectLookup, req.Project);\n  }\n\n  public async SetActiveEnterprise(eventValue: any): Promise<void>{\n    this.projectService.SetActiveEnterprise(this.State, eventValue);\n  }\n\n  public async SetCreatingProject(creatingProject: boolean): Promise<void>{\n      this.projectService.SetCreatingProject(creatingProject);\n  }\n\n  public async SetEditProjectSettings(projectLookup: string): Promise<void>{\n      await this.projectService.SetEditProjectSettings(\n        this.State,\n        projectLookup\n      );\n  }\n\n  public async UnpackLowCodeUnit(req: UnpackLowCodeUnitRequest): Promise<void> {\n    if (\n      confirm(\n        `Are you sure you want to unpack application '${req.ApplicationName}' with version '${req.Version}'?`\n      )\n    ) {\n      await this.projectService.UnpackLowCodeUnit(this.State, req);\n    }\n  }\n\n\n  //  Helpers\n  protected async handleSaveApplication(\n    req: SaveApplicationAsCodeEventRequest\n  ): Promise<void> {\n    const saveEaC: EnterpriseAsCode = {\n      EnterpriseLookup: this.State.EaC.EnterpriseLookup,\n      Applications: {},\n      Projects: {},\n    };\n\n    const existingProj = {\n      ...this.State.EaC.Projects[req.ProjectLookup],\n    };\n\n    if (existingProj.ApplicationLookups?.indexOf(req.ApplicationLookup) < 0) {\n      if (!existingProj.ApplicationLookups) {\n        existingProj.ApplicationLookups = [];\n      }\n\n      existingProj.ApplicationLookups.push(req.ApplicationLookup);\n\n      saveEaC.Projects[req.ProjectLookup] = existingProj;\n    }\n\n    if (req.Application) {\n      saveEaC.Applications[req.ApplicationLookup] = req.Application;\n    }\n\n    await this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);\n  }\n\n  protected async handleSaveDFSModifier(\n    req: SaveDFSModifierEventRequest\n  ): Promise<void> {\n    const saveEaC: EnterpriseAsCode = {\n      EnterpriseLookup: this.State.EaC.EnterpriseLookup,\n      Modifiers: {},\n      Projects: {},\n    };\n\n    if (req.Modifier) {\n      saveEaC.Modifiers[req.ModifierLookup] = req.Modifier;\n    }\n\n    if (req.ProjectLookup) {\n      saveEaC.Projects[req.ProjectLookup] = {\n        ModifierLookups: [req.ModifierLookup],\n      };\n    }\n\n    await this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);\n  }\n\n  protected async handleSaveEnvironment(\n    req: SaveEnvironmentAsCodeEventRequest\n  ): Promise<void> {\n    const saveEaC: EnterpriseAsCode = {\n      EnterpriseLookup: this.State?.EaC?.EnterpriseLookup,\n      DataTokens: {},\n      Environments: {},\n    };\n\n    if (req.Environment) {\n      saveEaC.Environments[req.EnvironmentLookup] = req.Environment;\n    }\n\n    if (req.EnterpriseDataTokens) {\n      saveEaC.DataTokens = req.EnterpriseDataTokens;\n    }\n\n    await this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);\n  }\n\n  protected async handleSaveProject(\n    projectLookup: string,\n    project: EaCProjectAsCode\n  ): Promise<void> {\n    const projHosts: { [lookup: string]: EaCHost } = {};\n\n    project?.Hosts?.forEach((host) => {\n      projHosts[host] = this.State.EaC.Hosts[host];\n    });\n\n    const saveEaC: EnterpriseAsCode = {\n      EnterpriseLookup: this.State.EaC.EnterpriseLookup,\n      Enterprise: {\n        ...this.State.EaC.Enterprise,\n        PrimaryHost: project.Hosts[0],\n      },\n      Hosts: projHosts,\n      // Providers: this.State.EaC.Providers,  //  TODO:  Remove after all providers ADB2C's have been upgraded\n      Projects: {},\n    };\n\n    saveEaC.Projects[projectLookup] = project;\n\n    await this.projectService.SaveEnterpriseAsCode(this.State, saveEaC);\n\n    this.SetEditProjectSettings(projectLookup);\n  }\n}\n"]}

package/esm2015/lib/services/forms.service.js

@@ -0,0 +1,131 @@
+import { FormValuesModel } from './../models/form.values.model';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class FormsService {
+    constructor() {
+        this.forms = [];
+        this.previousFormValues = [];
+        this.FormIsDirty = new Subject();
+    }
+    set Form(val) {
+        if (!val) {
+            return;
+        }
+        this._form = val;
+        this.forms.push(val);
+        this.createValuesReference(val);
+    }
+    get Form() {
+        return this._form;
+    }
+    /**
+     *
+     * @param val as string - enabled form name
+     * @param val as boolen - enable/disable all forms
+     *
+     * Enable / disable forms, use this when a form is being edited and
+     * all other forms need to be disabled
+     */
+    DisableForms(val) {
+        const preventEvent = { onlySelf: true, emitEvent: false };
+        this.forms.forEach((form) => {
+            if (typeof val === 'boolean') {
+                val ? form.Form.disable(preventEvent) : form.Form.enable(preventEvent);
+            }
+            else {
+                if (form.Id === val) {
+                    form.Form.enable(preventEvent);
+                }
+                else {
+                    form.Form.disable(preventEvent);
+                }
+            }
+        });
+    }
+    /**
+     * Create a reference of initial form data
+     * Use this to compare if values really changed, because
+     * the user could change values back to the original
+     *
+     * @param obj form data
+     */
+    createValuesReference(val) {
+        // const values: Array<{key: string, value: string}> = [];
+        const keyValues = {};
+        for (const [key, value] of Object.entries(val.Form.controls)) {
+            // values.push({key, value: value.value});
+            keyValues[key] = value.value;
+        }
+        // this.formsValues.push(new FormValuesModel(val.Id, val.Form.value));
+        this.previousFormValues.push(new FormValuesModel(val.Id, keyValues));
+    }
+    /**
+     * Update value reference after saves
+     *
+     * @param val form model with values
+     */
+    UpdateValuesReference(val) {
+        const index = this.previousFormValues.findIndex((x) => {
+            return x.Id === val.Id;
+        });
+        this.previousFormValues[index].Values = val.Form.value;
+        // TODO: look at consolidating updating this.forms and this.previousFormValues - shannon (7-14-21)
+        const formIndex = this.forms.findIndex((x) => {
+            return x.Id === val.Id;
+        });
+        this.forms[formIndex] = val;
+    }
+    /**
+     * Reset form values back to previous
+     *
+     * @param id form id
+     */
+    ResetFormValues(id) {
+        this.forms.find((form) => {
+            if (form.Id === id) {
+                form.Form.patchValue(this.GetPreviousFormValues(id).Values);
+            }
+        });
+    }
+    /**
+     *
+     * @param id form id to search for
+     *
+     * @returns previous form values
+     */
+    GetPreviousFormValues(id) {
+        return this.previousFormValues.find((x) => {
+            return x.Id === id;
+        });
+    }
+    /**
+     * Check for actual form changes, because the user
+     * could have canceled or changed the value back to the
+     * original
+     *
+     * @param id form id
+     * @param formToCheck form to be tested
+     */
+    ForRealThough(id, formToCheck) {
+        const formVals = this.previousFormValues.find((x) => {
+            return x.Id === id;
+        });
+        for (const key in formToCheck.controls) {
+            if (formToCheck.controls[key].value !== formVals.Values[key]) {
+                this.FormIsDirty.next(true);
+                return true;
+            }
+        }
+        this.FormIsDirty.next(false);
+        return false;
+    }
+}
+FormsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FormsService_Factory() { return new FormsService(); }, token: FormsService, providedIn: "root" });
+FormsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+FormsService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms.service.js","sourceRoot":"/home/runner/work/applications-flow/applications-flow/projects/common/src/","sources":["lib/services/forms.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormValuesModel } from './../models/form.values.model';\nimport { FormModel } from './../models/form.model';\nimport { Injectable } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { Subject } from 'rxjs';\n\n@Injectable({\n    providedIn: 'root',\n  })\n\nexport class FormsService {\n\n    /**\n     * List of forms\n     */\n    private _form: FormModel;\n    public set Form(val: FormModel) {\n\n        if (!val) { return; }\n\n        this._form = val;\n        this.forms.push(val);\n        this.createValuesReference(val);\n    }\n\n    public get Form(): FormModel {\n        return this._form;\n    }\n\n    /**\n     * When any form is being edited\n     */\n    public FormIsDirty: Subject<boolean>;\n\n    protected forms: Array<FormModel>;\n\n    /**\n     * Storage reference for intial form values\n     */\n    // public formsInitialValues: Array<FormModel>;\n    protected previousFormValues: Array<FormValuesModel>;\n\n    /**\n     * \n     * @param val as string - enabled form name\n     * @param val as boolen - enable/disable all forms\n     * \n     * Enable / disable forms, use this when a form is being edited and \n     * all other forms need to be disabled\n     */\n    public DisableForms(val: string | boolean): void {\n\n        const preventEvent: {onlySelf: boolean, emitEvent: boolean} = { onlySelf: true, emitEvent: false };\n\n        this.forms.forEach((form: FormModel) => {\n\n            if (typeof val === 'boolean') {\n                val ? form.Form.disable(preventEvent) : form.Form.enable(preventEvent);\n            } else {\n                if (form.Id === val) {\n                    form.Form.enable(preventEvent);\n                } else {\n                    form.Form.disable(preventEvent);\n                }\n            }\n        });\n    }\n\n\n    /**\n     * Create a reference of initial form data\n     * Use this to compare if values really changed, because\n     * the user could change values back to the original\n     *\n     * @param obj form data\n     */\n    protected createValuesReference(val: FormModel): void {\n\n        // const values: Array<{key: string, value: string}> = [];\n        const keyValues: object = {};\n\n        for (const [key, value] of Object.entries(val.Form.controls)) {\n\n            // values.push({key, value: value.value});\n            keyValues[key] = value.value;\n        }\n\n        // this.formsValues.push(new FormValuesModel(val.Id, val.Form.value));\n        this.previousFormValues.push(new FormValuesModel(val.Id, keyValues));\n    }\n\n    /**\n     * Update value reference after saves\n     * \n     * @param val form model with values\n     */\n    public UpdateValuesReference(val: FormModel): void {\n\n        const index: number = this.previousFormValues.findIndex((x: FormValuesModel) => {\n            return x.Id === val.Id;\n        });\n\n        this.previousFormValues[index].Values = val.Form.value;\n\n        // TODO: look at consolidating updating this.forms and this.previousFormValues - shannon (7-14-21)\n        const formIndex: number = this.forms.findIndex((x: FormModel) => {\n            return x.Id === val.Id;\n        });\n\n        this.forms[formIndex] = val;\n    }\n\n    /**\n     * Reset form values back to previous \n     * \n     * @param id form id\n     */\n    public ResetFormValues(id: string): void {\n        this.forms.find((form: FormModel) => {\n            if (form.Id === id) {\n                form.Form.patchValue(this.GetPreviousFormValues(id).Values);\n            }\n        });\n    }\n\n    /**\n     * \n     * @param id form id to search for\n     *\n     * @returns previous form values\n     */\n    public GetPreviousFormValues(id: string): FormValuesModel {\n        return this.previousFormValues.find((x: FormValuesModel) => {\n            return x.Id === id;\n        });\n    }\n\n    /**\n     * Check for actual form changes, because the user\n     * could have canceled or changed the value back to the\n     * original\n     *\n     * @param id form id\n     * @param formToCheck form to be tested\n     */\n    public ForRealThough(id: string, formToCheck: FormGroup): boolean {\n\n        const formVals: FormValuesModel = this.previousFormValues.find((x: FormValuesModel) => {\n            return x.Id === id;\n        });\n\n        for (const key in formToCheck.controls) {\n            if (formToCheck.controls[key].value !== formVals.Values[key]) {\n                this.FormIsDirty.next(true);\n                return true;\n            }\n        }\n\n        this.FormIsDirty.next(false);\n        return false;\n    }\n\n    constructor() {\n        this.forms = [];\n        this.previousFormValues = [];\n        this.FormIsDirty = new Subject();\n    }\n}\n"]}