1 files changed, 233 insertions, 0 deletions
diff --git a/catalog-ui/src/app/ng2/pages/workspace/disribution/distribution.service.ts b/catalog-ui/src/app/ng2/pages/workspace/disribution/distribution.service.ts
new file mode 100644
index 0000000000..ed6791c5c1
--- /dev/null
+++ b/catalog-ui/src/app/ng2/pages/workspace/disribution/distribution.service.ts
@@ -0,0 +1,233 @@
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { tap } from 'rxjs/operators';
+import { Distribution } from '../../../../models/distribution';
+import { ISdcConfig, SdcConfigToken } from '../../../config/sdc-config.config';
+
+@Injectable()
+export class DistributionService {
+    protected baseUrl;
+    private distributionList = [];
+    private distributionStatusesMap = {};
+
+    // tslint:disable:no-string-literal
+
+    constructor(protected http: HttpClient, @Inject(SdcConfigToken) sdcConfig: ISdcConfig) {
+        this.baseUrl = sdcConfig.api.root + sdcConfig.api.component_api_root;
+    }
+
+    // Once the distribution page is loaded or when the user wants to refresh the list
+     async initDistributionsList(componentUuid: string): Promise<object> {
+        const distributionsListURL = this.baseUrl + 'services/' + componentUuid + '/distribution';
+        const res = this.http.get<Distribution[]>(distributionsListURL).pipe(tap( (result) => {
+            this.distributionList = result['distributionStatusOfServiceList'];
+            this.insertDistrbutionsToMap();
+        }  ));
+        return res.toPromise();
+    }
+
+    // Once the user click on the relevant distribution ID in the distribution table (open and close)
+    async initDistributionsStatusForDistributionID(distributionID: string): Promise<object> {
+        const distributionStatus = this.baseUrl + 'services/distribution/' + distributionID;
+        const res = this.http.get<object>(distributionStatus).pipe(tap( (result) => {
+            this.insertDistributionStatusToDistributionsMap(distributionID, result['distributionStatusList']);
+        }  ));
+        return res.toPromise();
+    }
+
+    public getDistributionList(specificDistributionID?: string) {
+        if (specificDistributionID) {
+            return this.distributionList.filter((distribution) => {
+                return distribution['distributionID'] === specificDistributionID;
+            });
+        } else {
+            return this.distributionList;
+        }
+    }
+
+    public getComponentsByDistributionID(distributionID: string) {
+        const components = [];
+        const distributionStatusMap = this.getStatusMapForDistributionID(distributionID);
+        if (distributionStatusMap) {
+            distributionStatusMap.forEach((component) => components.push(component.componentID));
+        }
+        return components;
+    }
+
+    // get array of artifacts per distributionID w/o componentName, sliced by artifact status
+    public getArtifactsForDistributionIDAndComponentByStatus(distributionID: string, statusToSearch: string, componentName?: string) {
+        const filteredArtifactsByStatus = [];
+
+        if (componentName) {
+            this.getArtifactstByDistributionIDAndComponentsName(distributionID, componentName).forEach ( (artifact) => {
+                if (this.artifactStatusHasMatch(artifact, statusToSearch)) {
+                    filteredArtifactsByStatus.push(artifact);
+                }
+            } );
+        } else {
+            this.getArtifactstByDistributionIDAndComponentsName(distributionID).forEach ( (artifact) => {
+                if (this.artifactStatusHasMatch(artifact, statusToSearch)) {
+                    filteredArtifactsByStatus.push(artifact);
+                }
+            } );
+        }
+        return filteredArtifactsByStatus;
+    }
+
+    public getArtifactstByDistributionIDAndComponentsName(distributionID: string, componentName?: string): any[] {
+        const artifacts = [];
+        if (this.getStatusMapForDistributionID(distributionID)) {
+            if (componentName) {
+                if (this.getStatusMapForDistributionID(distributionID).filter((component) => component.componentID === componentName).length > 0) {
+                    const artifactsArr = this.getStatusMapForDistributionID(distributionID).filter((component) => component.componentID === componentName)[0]['artifacts']
+                    if (artifactsArr.length > 0) {
+                        artifactsArr.forEach((artifact) => {
+                            const artifactObj = {
+                                url: artifact.artifactUrl,
+                                name: artifact.artifactName,
+                                statuses: artifact.statuses
+                            };
+                            artifacts.push(artifactObj);
+                        });
+                    }
+                }
+            } else {
+                const components = this.getComponentsByDistributionID(distributionID);
+                components.forEach((componentName) => {
+                    if (this.getStatusMapForDistributionID(distributionID).filter((component) => component.componentID === componentName).length > 0) {
+                        const artifactsArr = this.getStatusMapForDistributionID(distributionID).filter((component) => component.componentID === componentName)[0]['artifacts']
+                        if (artifactsArr.length > 0) {
+                            artifactsArr.forEach((artifact) => {
+                                const artifactObj = {
+                                    url: artifact.artifactUrl,
+                                    name: artifact.artifactName,
+                                    statuses: artifact.statuses
+                                };
+                                artifacts.push(artifactObj);
+                            });
+                        }
+                    }
+                });
+            }
+        }
+        return artifacts;
+    }
+
+    public getStatusMapForDistributionID(distributionID: string) {
+        return this.distributionStatusesMap[distributionID];
+    }
+
+    public markDeploy(uniqueId: string, distributionID: string): Promise<object> {
+        const distributionStatus = this.baseUrl + 'services/' + uniqueId + '/distribution/' + distributionID + '/markDeployed';
+        const res = this.http.post<object>(distributionStatus, {}).pipe(tap( (result) => {
+            console.log(result);
+        }  ));
+        return res.toPromise();
+    }
+
+    public getMSOStatus(distributionID: string, componentName: string): string {
+        const msoStatus = this.distributionStatusesMap[distributionID].filter((component) => component.componentID === componentName)[0].msoStatus;
+        return msoStatus ? msoStatus : '';
+    }
+
+    private artifactStatusHasMatch(artifact: any, statusToSerach: string) {
+        for (let i = 0; i < artifact.statuses.length; i++) {
+            if (artifact.statuses[i].status === statusToSerach) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private insertDistributionStatusToDistributionsMap(distributionID: string, distributionStatusMapResponseFromServer: object[]) {
+
+        // // Clear the Distribution ID array - to avoid statuses duplications
+        const distribution = this.distributionStatusesMap[distributionID];
+        distribution.length = 0;
+
+        // Sort the response of statuses from Server, so it will be easy to pop the latest status when it will be required
+        const sortedResponseByTimeStamp = distributionStatusMapResponseFromServer.sort((a, b) => b['timestamp'] - a['timestamp'])
+
+        sortedResponseByTimeStamp.map((distributionStatus) => {
+            const formattedDate = this.formatDate(distributionStatus['timestamp']);
+
+            // if (distributionStatus['url'] === null) {
+            //     distributionStatus['url'] = "";
+            // }
+
+            const detailedArtifactStatus = {
+                componentID: distributionStatus['omfComponentID'],
+                artifactName: distributionStatus['url']? distributionStatus['url'].split('/').pop() : '',
+                url: distributionStatus['url'],
+                time: distributionStatus['timestamp'],
+                status: distributionStatus['status'],
+            };
+
+
+
+            // Add Component to this.distributionStatusesMap in case not exist.
+            let componentPosition = _.findIndex(distribution, {componentID: detailedArtifactStatus.componentID})
+
+            if (componentPosition === -1) {
+                this.addComponentIdToDistributionStatusMap(distributionID, detailedArtifactStatus.componentID);
+                componentPosition = distribution.length - 1;
+            }
+
+            const component = distribution[componentPosition];
+
+
+            // Add Artifact to this.distributionStatusesMap[componentID] in case not exist.
+            let artifactPosition = _.findIndex(component.artifacts, {artifactUrl: detailedArtifactStatus.url})
+
+            if (artifactPosition === -1) {
+                this.addArtifactToComponentId(distributionID, componentPosition, detailedArtifactStatus.artifactName, detailedArtifactStatus.url);
+                artifactPosition = component.artifacts.length - 1;
+            }
+
+
+            // Add status to relevat artifact in relevent componentID.
+            if (detailedArtifactStatus.url) {
+                // Case where there is a url -> should add its status
+                component.artifacts[artifactPosition].statuses.push({
+                    timeStamp: detailedArtifactStatus.time,
+                    status: detailedArtifactStatus.status
+                });
+            } else {
+                // Should update the Component -> status from MSO
+                this.distributionStatusesMap[distributionID][componentPosition].msoStatus = detailedArtifactStatus.status;
+            }
+
+
+        });
+    }
+
+    private addComponentIdToDistributionStatusMap(distributionID: string, componentIDValue: string) {
+        this.distributionStatusesMap[distributionID].push({
+            componentID: componentIDValue,
+            msoStatus: null,
+            artifacts: []
+            });
+    }
+
+    private addArtifactToComponentId(distributionID: string, componentPosition: number, artifactNameValue: string, artifactURLValue: any) {
+        if (artifactNameValue) {
+            this.distributionStatusesMap[distributionID][componentPosition].artifacts.push({
+                artifactName: artifactNameValue,
+                artifactUrl: artifactURLValue,
+                statuses: []
+            });
+        }
+    }
+
+    private insertDistrbutionsToMap() {
+        this.distributionList.map((distribution) => this.distributionStatusesMap[distribution.distributionID] = []);
+    }
+
+    private formatDate(epochTime: string) {
+        const intEpochTime = new Date(parseInt(epochTime, 10));
+        const amOrPm = (intEpochTime.getHours() + 24) % 24 > 12 ? 'PM' : 'AM';
+        const formattedDate = (intEpochTime.getMonth() + 1) + '/' + intEpochTime.getDate() + '/' +  intEpochTime.getFullYear() + ' ' + intEpochTime.getHours() + ':' +
+            intEpochTime.getMinutes() + amOrPm;
+        return formattedDate;
+    }
+}