NodesFactory,
Point
} from "app/models";
-import { ComponentInstanceFactory, ComponentFactory, GRAPH_EVENTS, GraphColors } from "app/utils";
+import { ComponentInstanceFactory, ComponentFactory, GRAPH_EVENTS, GraphColors, GraphUIObjects, ModalsHandler } from "app/utils";
import { EventListenerService, LoaderService } from "app/services";
import { CompositionGraphLinkUtils } from "./utils/composition-graph-links-utils";
import { CompositionGraphGeneralUtils } from "./utils/composition-graph-general-utils";
deletePathsOnCy(): void;
drawPathOnCy(data: ForwardingPath): void;
selectedPathId: string;
+
+ copyComponentInstance(): void;
+ pasteComponentInstance(event: IDragDropEvent): void;
+
+ origComponentId: string;
}
export class CompositionGraph implements ng.IDirective {
private _currentlyCLickedNodePosition: Cy.Position;
private dragElement: JQuery;
private dragComponent: ComponentInstance;
+ private cyBackgroundClickEvent: any;
constructor(private $q: ng.IQService,
private $log: ng.ILogService,
private ModalServiceNg2: ModalService,
private ConnectionWizardServiceNg2: ConnectionWizardService,
private ComponentInstanceServiceNg2: ComponentInstanceServiceNg2,
- private servicePathGraphUtils: ServicePathGraphUtils) {
+ private servicePathGraphUtils: ServicePathGraphUtils,
+ private ModalsHandler: ModalsHandler) {
}
this.CompositionGraphLinkUtils.deleteLink(this._cy, scope.component, true, link);
}
};
+
+
+ document.onkeydown = (event) => {
+ let isModalExist = document.getElementsByTagName('body')[0].classList.contains('modal-open');
+
+ if (!scope.isViewOnly && !isModalExist) {
+
+ switch (event.keyCode) {
+
+ case 46: //delete
+ scope.deleteSelectedElements();
+ break;
+
+ case 67: //ctrl+c : copy componentInstance
+ if (event.ctrlKey && scope.component.isService()) {
+ scope.copyComponentInstance();
+ }
+ break;
+ case 86: // ctrl+v: paste componentInstance
+ if (event.ctrlKey && scope.component.isService()) {
+ let hidePasteObj = $(".w-canvas-content-paste");
+ hidePasteObj.click();
+ }
+ break;
+
+ }
+ }
+ };
+
+ scope.deleteSelectedElements = (): void => {
+ if (this._cy) {
+ let nodesToDelete = this._cy.$('node:selected');
+ let edgesSelected = this._cy.$('edge:selected');
+ if (nodesToDelete.length + edgesSelected.length <= 0) {
+ return;
+ }
+ let componentInstancetobeDele;
+ let title: string = "Delete Confirmation";
+ let message: string = "Are you sure you would like to delete selected elements?";
+ if (nodesToDelete.size() == 1 && edgesSelected.size() == 0) {
+
+ componentInstancetobeDele = nodesToDelete[0].data().componentInstance;
+ let showName = nodesToDelete[0].data().componentInstance.name;
+ message = "Are you sure you would like to delete" + " " + showName + "?";
+ }
+
+ let onOk = (): void => {
+ if (nodesToDelete.size() == 1 && edgesSelected.size() == 0) {
+ this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_DELETE_COMPONENT_INSTANCE, componentInstancetobeDele);
+ }
+ else {
+ this.NodesGraphUtils.batchDeleteNodes(this._cy, scope.component, nodesToDelete);
+ }
+
+ };
+
+ this.ModalsHandler.openConfirmationModal(title, message, false).then(onOk);
+ }
+
+ };
+
+ scope.copyComponentInstance = (): void => {
+ scope.origComponentId = scope.component.uniqueId;
+ if (scope.component.selectedInstance) {
+ scope.origSelectedInstance = scope.component.selectedInstance;
+ }
+ };
+
+
+ scope.pasteComponentInstance = (event: IDragDropEvent): void => {
+ event.clientX = event.clientX ? event.clientX : this.cyBackgroundClickEvent ? this.cyBackgroundClickEvent.originalEvent.clientX : null;
+ event.clientY = event.clientY ? event.clientY : this.cyBackgroundClickEvent ? this.cyBackgroundClickEvent.originalEvent.clientY : null;
+
+ if (event.clientX == null || event.clientY == null) {
+ return;
+ }
+ let offsetPosition = {
+ x: event.clientX - GraphUIObjects.DIAGRAM_PALETTE_WIDTH_OFFSET,
+ y: event.clientY - GraphUIObjects.DIAGRAM_HEADER_OFFSET
+ };
+
+ let mousePosition = this.commonGraphUtils.HTMLCoordsToCytoscapeCoords(this._cy.extent(), offsetPosition);
+ let newPositionX = mousePosition.x;
+ let newPositionY = mousePosition.y;
+ let origSelectedInstance = scope.origSelectedInstance;
+
+ let copyComponentInstance = `{
+ "posX":"${newPositionX}",
+ "posY":"${newPositionY}",
+ "name":"${origSelectedInstance.componentName}",
+ "componentVersion":"${origSelectedInstance.componentVersion}",
+ "originType":"${origSelectedInstance.originType}",
+ "icon":"${origSelectedInstance.icon}",
+ "componentUid":"${origSelectedInstance.componentUid}"
+ }`;
+
+ this.isComponentPasteValid(scope, this._cy, event, offsetPosition, origSelectedInstance);
+
+
+ let onSuccess = (response): void => {
+ let success = (component: Component) => {
+ scope.component.componentInstances = component.componentInstances;
+ if (component.isService() && component.componentInstances.length > 0) {
+ _.each(component.componentInstances, (instance) => {
+ if (instance.uniqueId == response.componentInstance.uniqueId) {
+ let compositionGraphNode: CompositionCiNodeBase = this.NodesFactory.createNode(instance);
+ this.commonGraphUtils.addComponentInstanceNodeToGraph(this._cy, compositionGraphNode);
+ }
+ });
+ }
+ scope.isLoading = false;
+ };
+ scope.component.getComponent().then(success);
+ };
+ let onFailed = (error: any): void => {
+ console.log(error);
+ scope.isLoading = false;
+ };
+
+ if (scope.pasteValid) {
+ scope.isLoading = true;
+ scope.component.pasteMenuComponentInstance(origSelectedInstance.uniqueId, copyComponentInstance).then(onSuccess, onFailed);
+ }
+ };
+
}
+
+
private registerCytoscapeGraphEvents(scope: ICompositionGraphScope) {
this._cy.on('addedgemouseup', (event, data) => {
}
this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_GRAPH_BACKGROUND_CLICKED);
}
+ this.cyBackgroundClickEvent = event;
scope.hideRelationMenu();
}
});
}
-
private initDropZone(scope: ICompositionGraphScope) {
if (scope.isViewOnly) {
}
};
};
+ private isComponentPasteValid(scope: ICompositionGraphScope, cy: Cy.Instance, event: IDragDropEvent, offsetPosition: Cy.Position, origSelectedInstance: ComponentInstance) {
+ let bbox = this._getNodeBBox(cy, event, origSelectedInstance, offsetPosition);
+ if (this.GeneralGraphUtils.isPaletteDropValid(cy, bbox, origSelectedInstance)) {
+ scope.pasteValid = true;
+ } else {
+ scope.pasteValid = false;
+ }
+ }
+
+ private _getNodeBBox(cy: Cy.Instance, event: IDragDropEvent, origSelectedInstance: ComponentInstance, position?: Cy.Position) {
+ let bbox = <Cy.BoundingBox>{};
+ if (!position) {
+ position = this.commonGraphUtils.getCytoscapeNodePosition(cy, event);
+ }
+ let cushionWidth: number = 40;
+ let cushionHeight: number = 40;
+
+ bbox.x1 = position.x - cushionWidth / 2;
+ bbox.y1 = position.y - cushionHeight / 2;
+ bbox.x2 = position.x + cushionWidth / 2;
+ bbox.y2 = position.y + cushionHeight / 2;
+ return bbox;
+ }
public static factory = ($q,
$log,
ModalService,
ConnectionWizardService,
ComponentInstanceServiceNg2,
- ServicePathGraphUtils) => {
+ ServicePathGraphUtils,
+ ModalsHandler) => {
return new CompositionGraph(
$q,
$log,
ModalService,
ConnectionWizardService,
ComponentInstanceServiceNg2,
- ServicePathGraphUtils);
+ ServicePathGraphUtils,
+ ModalsHandler);
}
}
'ModalServiceNg2',
'ConnectionWizardServiceNg2',
'ComponentInstanceServiceNg2',
- 'ServicePathGraphUtils'
+ 'ServicePathGraphUtils',
+ 'ModalsHandler'
];
create-relation="createLinkFromMenu" cancel="cancelRelationMenu()"></relation-menu> -->
<menu-list-ng2 [props]="canvasMenuProps"></menu-list-ng2>
+<div id="cyMenu" class="hidePaste">
+ <div class="w-canvas-content-paste" data-ng-click="pasteComponentInstance($event)">paste</div>
+</div>
<div class="w-sdc-search-menu" data-ng-class="{'with-sidebar': withSidebar}">
background-color:rgb(248, 248, 248);
}
+ .hidePaste {
+ display:none;
+ }
+
.sdc-canvas-zones__wrapper {
position: absolute;
bottom: 10px;
this.createLink(linkObg, cy, component);
};
+ public batchDeleteEdges(cy: Cy.Instance, component: Component, edgesToDelete: Cy.CollectionEdges, alreadyDeleteNodeIds?: Array<string>): void {
+ let toDeleteLinks: Array<RelationshipModel> = new Array<RelationshipModel>();
+ if (alreadyDeleteNodeIds && alreadyDeleteNodeIds.length > 0) {
+ edgesToDelete.each((i: number, link: Cy.CollectionEdges) => {
+ if (alreadyDeleteNodeIds.indexOf(link.data().source) < 0 && alreadyDeleteNodeIds.indexOf(link.data().target) < 0) {
+ toDeleteLinks.push(link.data().relation);
+ }
+ });
+ }
+ else {
+ edgesToDelete.each((i: number, link: Cy.CollectionEdges) => {
+ toDeleteLinks.push(link.data().relation);
+ });
+ }
+ this.loaderService.showLoader('composition-graph');
+ let onSuccessDeleteRelations = (response: Array<RelationshipModel>) => {
+ console.info('onSuccessDeleteRelations response is ', response);
+ //remove tempSimplePortNodes
+ if (alreadyDeleteNodeIds && alreadyDeleteNodeIds.length > 0) {
+ edgesToDelete.each((i: number, link: Cy.CollectionEdges) => {
+ if (alreadyDeleteNodeIds.indexOf(link.data().source) < 0 && alreadyDeleteNodeIds.indexOf(link.data().target) < 0) {
+ cy.remove(edgesToDelete);
+ }
+ });
+ }
+ else {
+ edgesToDelete.each((i: number, link: Cy.CollectionEdges) => {
+ cy.remove(edgesToDelete);
+ });
+ }
+ };
+
+ if (toDeleteLinks.length > 0) {
+ this.generalGraphUtils.getGraphUtilsServerUpdateQueue().addBlockingUIActionWithReleaseCallback(
+ () => component.batchDeleteRelation(toDeleteLinks).then(onSuccessDeleteRelations),
+ () => this.loaderService.hideLoader('composition-graph'));
+
+ }
+ };
+
public createLinkFromMenu = (cy:Cy.Instance, chosenMatch:Match, component:Component):void => {
if (chosenMatch) {
};
+ /**
+ * Batch delete component instances on server and then removes them from the graph as well
+ * @param cy
+ * @param component
+ * @param nodesToDelete
+ */
+ public batchDeleteNodes(cy:Cy.Instance, component:Component, nodesToDelete:Cy.CollectionNodes):Array<string> {
+ let nodesToDeleteIds:Array<string> = new Array<string>();
+ if(nodesToDelete && nodesToDelete.size() > 0){
+ nodesToDelete.each((i:number, node:Cy.CollectionNodes) => {
+ nodesToDeleteIds.push(node.data('id'));
+ });
+ this.loaderService.showLoader('composition-graph');
+ let componentInstances:Array<ComponentInstance> = component.componentInstances;
+ let onSuccess:(response:any) => void = (deleteFailedIds:any) => {
+ this.removeDeletedNodesOnGraph(cy, nodesToDelete, deleteFailedIds, componentInstances);
+ };
+
+ let onFailed:(response:any) => void = (response:any) => {
+ console.error('batchDeleteNodes failed error is', response);
+ };
+
+ this.GeneralGraphUtils.getGraphUtilsServerUpdateQueue().addBlockingUIActionWithReleaseCallback(
+ () => component.batchDeleteComponentInstance(nodesToDeleteIds).then(onSuccess, onFailed),
+ () => this.loaderService.hideLoader('composition-graph')
+ );
+ }
+
+ return nodesToDeleteIds;
+ };
+
+ private deleteNodeSuccess(cy:Cy.Instance, component:Component, nodeToDelete:Cy.CollectionNodes):void{
+ //if node to delete is a UCPE, remove all children (except UCPE-CPs) and remove their "hostedOn" links
+ if (nodeToDelete.data().isUcpe) {
+ _.each(cy.nodes('[?isInsideGroup]'), (node)=> {
+ this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_REMOVE_NODE_FROM_UCPE, node, nodeToDelete);
+ });
+ }
+
+ //check whether the node is connected to any VLs that only have one other connection. If so, delete that VL as well
+ if (!(nodeToDelete.data() instanceof CompositionCiNodeVl)) {
+ let connectedVls:Array<Cy.CollectionFirstNode> = this.getConnectedVlToNode(nodeToDelete);
+ this.handleConnectedVlsToDelete(connectedVls);
+ }
+
+ // check whether there is a service path going through this node, and if so clean it from the graph.
+ let nodeId = nodeToDelete.data().id;
+ let connectedPathLinks = cy.collection(`[type="${CompositionCiServicePathLink.LINK_TYPE}"][source="${nodeId}"], [type="${CompositionCiServicePathLink.LINK_TYPE}"][target="${nodeId}"]`);
+ _.forEach(connectedPathLinks, (link, key) => {
+ cy.remove(`[pathId="${link.data().pathId}"]`);
+ });
+
+ // update service path list
+ this.serviceService.getComponentCompositionData(component).subscribe((response:ServiceGenericResponse) => {
+ (<Service>component).forwardingPaths = response.forwardingPaths;
+ });
+
+ this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_DELETE_COMPONENT_INSTANCE_SUCCESS, nodeId);
+
+ //update UI
+ cy.remove(nodeToDelete);
+ }
+
+ private removeDeletedNodesOnGraph(cy:Cy.Instance, nodesToDelete:Cy.CollectionNodes, deleteFailedIds:Array<string>, componentInstances:Array<ComponentInstance>):void {
+ nodesToDelete.each((j:number, nodeToDelete:Cy.CollectionNodes) => {
+ if(deleteFailedIds.indexOf(nodeToDelete.data('id')) < 0) {
+ //if node to delete is a UCPE, remove all children (except UCPE-CPs) and remove their "hostedOn" links
+ if (nodeToDelete.data().isUcpe) {
+ _.each(cy.nodes('[?isInsideGroup]'), (node)=> {
+ this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_REMOVE_NODE_FROM_UCPE, node , nodeToDelete);
+ });
+ }
+
+ //check whether the node is connected to any VLs that only have one other connection. If so, delete that VL as well
+ if(!(nodeToDelete.data() instanceof CompositionCiNodeVl)) {
+ let connectedVls:Array<Cy.CollectionFirstNode> = this.getConnectedVlToNode(nodeToDelete);
+ this.handleConnectedVlsToDelete(connectedVls);
+ }
+
+
+ cy.remove(nodeToDelete);
+ }
+ });
+ }
+
/**
* Finds all VLs connected to a single node
* @param node
'use strict';
import * as _ from "lodash";
-import {AsdcComment, ArtifactModel, ArtifactGroupModel, IFileDownload, PropertyModel, PropertiesGroup, AttributeModel, AttributesGroup, ComponentInstance,
+import {
+ AsdcComment, ArtifactModel, ArtifactGroupModel, IFileDownload, PropertyModel, PropertiesGroup, AttributeModel, AttributesGroup, ComponentInstance,
InputModel, DisplayModule, Module, IValidate, RelationshipModel, IMainCategory, RequirementsGroup, CapabilitiesGroup, AdditionalInformationModel,
- Resource, IAppMenu, OperationModel, Service} from "../../models";
-
-import {IComponentService} from "../../services/components/component-service";
-import {CommonUtils} from "../../utils/common-utils";
-import {QueueUtils} from "../../utils/functions";
-import {ArtifactGroupType} from "../../utils/constants";
-import {ComponentMetadata} from "../component-metadata";
-import {Capability} from "../capability";
-import {Requirement} from "../requirement";
-import {Relationship} from "../graph/relationship";
+ Resource, IAppMenu, OperationModel, Service
+} from "../../models";
+
+import { IComponentService } from "../../services/components/component-service";
+import { CommonUtils } from "../../utils/common-utils";
+import { QueueUtils } from "../../utils/functions";
+import { ArtifactGroupType } from "../../utils/constants";
+import { ComponentMetadata } from "../component-metadata";
+import { Capability } from "../capability";
+import { Requirement } from "../requirement";
+import { Relationship } from "../graph/relationship";
import { PolicyInstance } from "app/models/graph/zones/policy-instance";
import { GroupInstance } from "../graph/zones/group-instance";
//---------------------------------------------- API CALLS ----------------------------------------------------//
//Component API
- getComponent():ng.IPromise<Component>;
- updateComponent():ng.IPromise<Component>;
- createComponentOnServer():ng.IPromise<Component>;
- changeLifecycleState(state:string, commentObj:AsdcComment):ng.IPromise<Component>;
- validateName(newName:string):ng.IPromise<IValidate>;
- updateRequirementsCapabilities():ng.IPromise<any>;
+ getComponent(): ng.IPromise<Component>;
+ updateComponent(): ng.IPromise<Component>;
+ createComponentOnServer(): ng.IPromise<Component>;
+ changeLifecycleState(state: string, commentObj: AsdcComment): ng.IPromise<Component>;
+ validateName(newName: string): ng.IPromise<IValidate>;
+ updateRequirementsCapabilities():
ng.IPromise<any>;
//Artifacts API
- addOrUpdateArtifact(artifact:
ArtifactModel):ng.IPromise<ArtifactModel>;
- updateMultipleArtifacts(artifacts:
Array<ArtifactModel>):ng.IPromise<any>;
- deleteArtifact(artifactId:
string, artifactLabel:string):ng.IPromise<ArtifactModel>;
- downloadInstanceArtifact(artifactId:string):ng.IPromise<IFileDownload>;
- downloadArtifact(artifactId:string):ng.IPromise<IFileDownload>;
- getArtifactByGroupType(artifactGroupType:
string):ng.IPromise<ArtifactGroupModel>;
+ addOrUpdateArtifact(artifact:
ArtifactModel): ng.IPromise<ArtifactModel>;
+ updateMultipleArtifacts(artifacts:
Array<ArtifactModel>): ng.IPromise<any>;
+ deleteArtifact(artifactId:
string, artifactLabel: string): ng.IPromise<ArtifactModel>;
+ downloadInstanceArtifact(artifactId: string): ng.IPromise<IFileDownload>;
+ downloadArtifact(artifactId: string): ng.IPromise<IFileDownload>;
+ getArtifactByGroupType(artifactGroupType:
string): ng.IPromise<ArtifactGroupModel>;
//Property API
- addOrUpdateProperty(property:
PropertyModel):ng.IPromise<PropertyModel>;
- deleteProperty(propertyId:
string):ng.IPromise<PropertyModel>;
- updateInstanceProperties(componentInstanceId:
string, properties:PropertyModel[]):ng.IPromise<PropertyModel[]>;
+ addOrUpdateProperty(property:
PropertyModel): ng.IPromise<PropertyModel>;
+ deleteProperty(propertyId:
string): ng.IPromise<PropertyModel>;
+ updateInstanceProperties(componentInstanceId:
string, properties: PropertyModel[]): ng.IPromise<PropertyModel[]>;
//Attribute API
- deleteAttribute(attributeId:
string):ng.IPromise<AttributeModel>;
- addOrUpdateAttribute(attribute:
AttributeModel):ng.IPromise<AttributeModel>;
- updateInstanceAttribute(attribute:
AttributeModel):ng.IPromise<AttributeModel>;
+ deleteAttribute(attributeId:
string): ng.IPromise<AttributeModel>;
+ addOrUpdateAttribute(attribute:
AttributeModel): ng.IPromise<AttributeModel>;
+ updateInstanceAttribute(attribute:
AttributeModel): ng.IPromise<AttributeModel>;
//Component Instance API
- createComponentInstance(componentInstance:ComponentInstance):ng.IPromise<ComponentInstance>;
- deleteComponentInstance(componentInstanceId:string):ng.IPromise<ComponentInstance>;
- addOrUpdateInstanceArtifact(artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- deleteInstanceArtifact(artifactId:string, artifactLabel:string):ng.IPromise<ArtifactModel>;
- uploadInstanceEnvFile(artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- checkComponentInstanceVersionChange(componentUid:string):ng.IPromise<any>;
- changeComponentInstanceVersion(componentUid:string):ng.IPromise<Component>;
- updateComponentInstance(componentInstance:ComponentInstance):ng.IPromise<ComponentInstance>;
- updateMultipleComponentInstances(instances:Array<ComponentInstance>):ng.IPromise<Array<ComponentInstance>>;
+ createComponentInstance(componentInstance: ComponentInstance): ng.IPromise<ComponentInstance>;
+ deleteComponentInstance(componentInstanceId: string): ng.IPromise<ComponentInstance>;
+ batchDeleteComponentInstance(componentInstanceIds: Array<string>): ng.IPromise<ComponentInstance>;
+ addOrUpdateInstanceArtifact(artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ deleteInstanceArtifact(artifactId: string, artifactLabel: string): ng.IPromise<ArtifactModel>;
+ uploadInstanceEnvFile(artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ checkComponentInstanceVersionChange(componentUid: string): ng.IPromise<any>;
+ changeComponentInstanceVersion(componentUid: string): ng.IPromise<Component>;
+ updateComponentInstance(componentInstance: ComponentInstance): ng.IPromise<ComponentInstance>;
+ updateMultipleComponentInstances(instances: Array<ComponentInstance>): ng.IPromise<Array<ComponentInstance>>;
//Inputs API
- getComponentInstanceInputProperties(componentInstanceId:
string, inputId:string):ng.IPromise<Array<PropertyModel>>
- getComponentInstanceProperties(componentInstanceId:
string):ng.IPromise<Array<PropertyModel>>
- getComponentInputs(componentId:
string):ng.IPromise<Array<InputModel>>;
+ getComponentInstanceInputProperties(componentInstanceId:
string, inputId: string): ng.IPromise<Array<PropertyModel>>
+ getComponentInstanceProperties(componentInstanceId:
string): ng.IPromise<Array<PropertyModel>>
+ getComponentInputs(componentId:
string): ng.IPromise<Array<InputModel>>;
- createRelation(link:RelationshipModel):ng.IPromise<RelationshipModel>;
- deleteRelation(link:RelationshipModel):ng.IPromise<RelationshipModel>;
- fetchRelation(linkId:string):ng.IPromise<RelationshipModel>;
+ createRelation(link: RelationshipModel): ng.IPromise<RelationshipModel>;
+ deleteRelation(link: RelationshipModel): ng.IPromise<RelationshipModel>;
+ batchDeleteRelation(relations: Array<RelationshipModel>): ng.IPromise<Array<RelationshipModel>>
+
+ fetchRelation(linkId: string): ng.IPromise<RelationshipModel>;
//Modules
- getModuleForDisplay(moduleId:string):ng.IPromise<DisplayModule>;
- getModuleInstanceForDisplay(componentInstanceId:string, moduleId:string):ng.IPromise<DisplayModule>;
- updateGroupMetadata(group:Module):ng.IPromise<Module>;
-
+ getModuleForDisplay(moduleId: string): ng.IPromise<DisplayModule>;
+ getModuleInstanceForDisplay(componentInstanceId: string, moduleId: string): ng.IPromise<DisplayModule>;
+ updateGroupMetadata(group: Module): ng.IPromise<Module>;
+
//---------------------------------------------- HELP FUNCTIONS ----------------------------------------------------//
- getComponentSubType():string;
- isAlreadyCertified():boolean;
- isService():boolean;
- isResource():boolean;
- isComplex():boolean;
- getAdditionalInformation():Array<AdditionalInformationModel>;
- getAllVersionsAsSortedArray():Array<any>;
- getStatus(sdcMenu:IAppMenu):string;
+ getComponentSubType(): string;
+ isAlreadyCertified(): boolean;
+ isService(): boolean;
+ isResource(): boolean;
+ isComplex(): boolean;
+ getAdditionalInformation():
Array<AdditionalInformationModel>;
+ getAllVersionsAsSortedArray():
Array<any>;
+ getStatus(sdcMenu: IAppMenu): string;
}
export abstract class Component implements IComponent {
//server data
- public abstract:string;
- public uniqueId:string;
- public uuid:string;
- public invariantUUID:string;
- public name:string;
- public version:string;
- public creationDate:number;
- public lastUpdateDate:number;
- public description:string;
- public lifecycleState:string;
- public tags:Array<string>;
- public icon:string;
- public contactId:string;
- public allVersions:any;
- public creatorUserId:string;
- public creatorFullName:string;
- public lastUpdaterUserId:string;
- public lastUpdaterFullName:string;
- public componentType:string;
- public deploymentArtifacts:ArtifactGroupModel;
- public artifacts:ArtifactGroupModel;
- public toscaArtifacts:ArtifactGroupModel;
- public interfaceOperations:Array<OperationModel>;
- public distributionStatus:string;
- public categories:Array<IMainCategory>;
+ public abstract: string;
+ public uniqueId: string;
+ public uuid: string;
+ public invariantUUID: string;
+ public name: string;
+ public version: string;
+ public creationDate: number;
+ public lastUpdateDate: number;
+ public description: string;
+ public lifecycleState: string;
+ public tags: Array<string>;
+ public icon: string;
+ public contactId: string;
+ public allVersions: any;
+ public creatorUserId: string;
+ public creatorFullName: string;
+ public lastUpdaterUserId: string;
+ public lastUpdaterFullName: string;
+ public componentType: string;
+ public deploymentArtifacts: ArtifactGroupModel;
+ public artifacts: ArtifactGroupModel;
+ public toscaArtifacts: ArtifactGroupModel;
+ public interfaceOperations: Array<OperationModel>;
+ public distributionStatus: string;
+ public categories: Array<IMainCategory>;
public categoryNormalizedName: string;
public subCategoryNormalizedName: string;
- public componentInstancesProperties:PropertiesGroup;
- public componentInstancesAttributes:AttributesGroup;
- public componentInstancesRelations:Array<RelationshipModel>;
- public componentInstances:Array<ComponentInstance>;
- public inputs:Array<InputModel>;
- public capabilities:CapabilitiesGroup;
- public requirements:RequirementsGroup;
- public additionalInformation:any;
- public properties:Array<PropertyModel>;
- public attributes:Array<AttributeModel>;
- public highestVersion:boolean;
- public vendorName:string;
- public vendorRelease:string;
- public derivedList:Array<any>;
- public interfaces:any;
- public normalizedName:string;
- public systemName:string;
- public projectCode:string;
- public policies:Array<PolicyInstance>;
- public groupInstances:Array<GroupInstance>
- public modules:Array<Module>;
+ public componentInstancesProperties: PropertiesGroup;
+ public componentInstancesAttributes: AttributesGroup;
+ public componentInstancesRelations: Array<RelationshipModel>;
+ public componentInstances: Array<ComponentInstance>;
+ public inputs: Array<InputModel>;
+ public capabilities: CapabilitiesGroup;
+ public requirements: RequirementsGroup;
+ public additionalInformation: any;
+ public properties:
Array<PropertyModel>;
+ public attributes:
Array<AttributeModel>;
+ public highestVersion: boolean;
+ public vendorName: string;
+ public vendorRelease: string;
+ public derivedList:
Array<any>;
+ public interfaces: any;
+ public normalizedName: string;
+ public systemName: string;
+ public projectCode: string;
+ public policies:
Array<PolicyInstance>;
+ public groupInstances: Array<GroupInstance>
+ public modules: Array<Module>;
//custom properties
- public componentService:IComponentService;
- public filterTerm:string;
- public iconSprite:string;
- public selectedInstance:ComponentInstance;
- public mainCategory:string;
- public subCategory:string;
- public selectedCategory:string;
- public showMenu:boolean;
- public archived:boolean;
+ public componentService: IComponentService;
+ public filterTerm: string;
+ public iconSprite: string;
+ public selectedInstance: ComponentInstance;
+ public mainCategory: string;
+ public subCategory: string;
+ public selectedCategory: string;
+ public showMenu: boolean;
+ public archived: boolean;
public vspArchived: boolean;
- constructor(componentService:IComponentService, protected $q:ng.IQService, component?:Component) {
+ constructor(componentService: IComponentService, protected $q: ng.IQService, component?: Component) {
if (component) {
this.abstract = component.abstract;
this.uniqueId = component.uniqueId;
this.componentService = componentService;
}
- public setUniqueId = (uniqueId:string):void => {
+ public setUniqueId = (uniqueId: string): void => {
this.uniqueId = uniqueId;
};
- public setSelectedInstance = (componentInstance:ComponentInstance):void => {
+ public setSelectedInstance = (componentInstance: ComponentInstance): void => {
this.selectedInstance = componentInstance;
};
//------------------------------------------ API Calls ----------------------------------------------------------------//
- public changeLifecycleState = (state:string, commentObj:AsdcComment):ng.IPromise<Component> => {
+ public changeLifecycleState = (state: string, commentObj: AsdcComment): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- let onSuccess = (componentMetadata:ComponentMetadata):void => {
+ let onSuccess = (componentMetadata: ComponentMetadata): void => {
this.setComponentMetadata(componentMetadata);
// this.version = componentMetadata.version;
this.lifecycleState = componentMetadata.lifecycleState;
deferred.resolve(this);
};
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
this.componentService.changeLifecycleState(this, state, JSON.stringify(commentObj)).then(onSuccess, onError);
return deferred.promise;
};
- public getComponent = ():ng.IPromise<Component> => {
+ public getComponent = (): ng.IPromise<Component> => {
return this.componentService.getComponent(this.uniqueId);
};
- public createComponentOnServer = ():ng.IPromise<Component> => {
+ public createComponentOnServer = (): ng.IPromise<Component> => {
this.handleTags();
return this.componentService.createComponent(this);
};
- public updateComponent = ():ng.IPromise<Component> => {
+ public updateComponent = (): ng.IPromise<Component> => {
this.handleTags();
return this.componentService.updateComponent(this);
};
- public validateName = (newName:string, subtype?:string):ng.IPromise<IValidate> => {
+ public validateName = (newName: string, subtype?: string): ng.IPromise<IValidate> => {
return this.componentService.validateName(newName, subtype);
};
- public downloadArtifact = (artifactId:string):ng.IPromise<IFileDownload> => {
+ public downloadArtifact = (artifactId: string): ng.IPromise<IFileDownload> => {
return this.componentService.downloadArtifact(this.uniqueId, artifactId);
};
- public addOrUpdateArtifact = (artifact:
ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public addOrUpdateArtifact = (artifact:
ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- let onSuccess = (artifactObj:ArtifactModel):void => {
+ let onSuccess = (artifactObj: ArtifactModel): void => {
let newArtifact = new ArtifactModel(artifactObj);
let artifacts = this.getArtifactsByType(artifactObj.artifactGroupType);
artifacts[artifactObj.artifactLabel] = newArtifact;
deferred.resolve(newArtifact);
};
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
this.componentService.addOrUpdateArtifact(this.uniqueId, artifact).then(onSuccess, onError);
return deferred.promise;
};
- public updateMultipleArtifacts = (artifacts:Array<ArtifactModel>):ng.IPromise<any>=> {
+ public updateMultipleArtifacts = (artifacts: Array<ArtifactModel>): ng.IPromise<any> => {
let deferred = this.$q.defer();
- let onSuccess = (response:any):void => {
+ let onSuccess = (response: any): void => {
deferred.resolve(response);
};
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
let q = new QueueUtils(this.$q);
- _.forEach(artifacts, (artifact)=> {
- q.addBlockingUIAction(()=> this.addOrUpdateArtifact(artifact).then(onSuccess, onError));
+ _.forEach(artifacts, (artifact) => {
+ q.addBlockingUIAction(() => this.addOrUpdateArtifact(artifact).then(onSuccess, onError));
});
return deferred.promise;
};
- public deleteArtifact = (artifactId:
string, artifactLabel:string):ng.IPromise<ArtifactModel> => {
+ public deleteArtifact = (artifactId:
string, artifactLabel: string): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- let onSuccess = (artifactObj:ArtifactModel):void => {
+ let onSuccess = (artifactObj: ArtifactModel): void => {
let newArtifact = new ArtifactModel(artifactObj);
let artifacts = this.getArtifactsByType(artifactObj.artifactGroupType);
if (newArtifact.mandatory || newArtifact.serviceApi) {
return deferred.promise;
};
- public getArtifactByGroupType = (artifactGroupType:
string):ng.IPromise<ArtifactGroupModel> => {
+ public getArtifactByGroupType = (artifactGroupType:
string): ng.IPromise<ArtifactGroupModel> => {
let deferred = this.$q.defer<ArtifactGroupModel>();
- let onSuccess = (response:ArtifactGroupModel):void => {
+ let onSuccess = (response: ArtifactGroupModel): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getArtifactByGroupType(this.uniqueId, artifactGroupType).then(onSuccess, onFailed);
return deferred.promise;
};
- public getComponentInstanceArtifactsByGroupType = (componentInstanceId:
string, artifactGroupType:string):ng.IPromise<ArtifactGroupModel> => {
+ public getComponentInstanceArtifactsByGroupType = (componentInstanceId:
string, artifactGroupType: string): ng.IPromise<ArtifactGroupModel> => {
let deferred = this.$q.defer<ArtifactGroupModel>();
- let onSuccess = (response:ArtifactGroupModel):void => {
+ let onSuccess = (response: ArtifactGroupModel): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstanceArtifactsByGroupType(this.uniqueId, componentInstanceId, artifactGroupType).then(onSuccess, onFailed);
return deferred.promise;
};
- public addOrUpdateProperty = (property:
PropertyModel):ng.IPromise<PropertyModel> => {
+ public addOrUpdateProperty = (property:
PropertyModel): ng.IPromise<PropertyModel> => {
let deferred = this.$q.defer<PropertyModel>();
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
if (!property.uniqueId) {
- let onSuccess = (property:PropertyModel):void => {
+ let onSuccess = (property: PropertyModel): void => {
let newProperty = new PropertyModel(property);
this.properties.push(newProperty);
deferred.resolve(newProperty);
this.componentService.addProperty(this.uniqueId, property).then(onSuccess, onError);
}
else {
- let onSuccess = (newProperty:PropertyModel):void => {
+ let onSuccess = (newProperty: PropertyModel): void => {
// find exist instance property in parent component for update the new value ( find bu uniqueId )
- let existProperty:PropertyModel = <PropertyModel>_.find(this.properties, {uniqueId: newProperty.uniqueId});
+ let existProperty: PropertyModel = <PropertyModel>_.find(this.properties, { uniqueId: newProperty.uniqueId });
let propertyIndex = this.properties.indexOf(existProperty);
this.properties[propertyIndex] = newProperty;
deferred.resolve(newProperty);
return deferred.promise;
};
- public addOrUpdateAttribute = (attribute:
AttributeModel):ng.IPromise<AttributeModel> => {
+ public addOrUpdateAttribute = (attribute:
AttributeModel): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
if (!attribute.uniqueId) {
- let onSuccess = (attribute:AttributeModel):void => {
+ let onSuccess = (attribute: AttributeModel): void => {
let newAttribute = new AttributeModel(attribute);
this.attributes.push(newAttribute);
deferred.resolve(newAttribute);
this.componentService.addAttribute(this.uniqueId, attribute).then(onSuccess, onError);
}
else {
- let onSuccess = (newAttribute:AttributeModel):void => {
- let existAttribute:AttributeModel = <AttributeModel>_.find(this.attributes, {uniqueId: newAttribute.uniqueId});
+ let onSuccess = (newAttribute: AttributeModel): void => {
+ let existAttribute: AttributeModel = <AttributeModel>_.find(this.attributes, { uniqueId: newAttribute.uniqueId });
let attributeIndex = this.attributes.indexOf(existAttribute);
newAttribute.readonly = this.uniqueId != newAttribute.parentUniqueId;
this.attributes[attributeIndex] = newAttribute;
return deferred.promise;
};
- public deleteProperty = (propertyId:
string):ng.IPromise<PropertyModel> => {
+ public deleteProperty = (propertyId:
string): ng.IPromise<PropertyModel> => {
let deferred = this.$q.defer<PropertyModel>();
- let onSuccess = ():void => {
+ let onSuccess = (): void => {
console.log("Property deleted");
- delete _.remove(this.properties, {uniqueId: propertyId})[0];
+ delete _.remove(this.properties, { uniqueId: propertyId })[0];
deferred.resolve();
};
- let onFailed = ():void => {
+ let onFailed = (): void => {
console.log("Failed to delete property");
deferred.reject();
};
return deferred.promise;
};
- public deleteAttribute = (attributeId:
string):ng.IPromise<AttributeModel> => {
+ public deleteAttribute = (attributeId:
string): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- let onSuccess = ():void => {
+ let onSuccess = (): void => {
console.log("Attribute deleted");
- delete _.remove(this.attributes, {uniqueId: attributeId})[0];
+ delete _.remove(this.attributes, { uniqueId: attributeId })[0];
};
- let onFailed = ():void => {
+ let onFailed = (): void => {
console.log("Failed to delete attribute");
};
this.componentService.deleteAttribute(this.uniqueId, attributeId).then(onSuccess, onFailed);
};
- public updateInstancePropertiesSuccess = (newProperties:PropertyModel[]):void => {
+ public updateInstancePropertiesSuccess = (newProperties: PropertyModel[]): void => {
newProperties.forEach((newProperty) => {
// find exist instance property in parent component for update the new value ( find bu uniqueId & path)
let existProperty: PropertyModel = <PropertyModel>_.find(this.componentInstancesProperties[newProperty.resourceInstanceUniqueId], {
});
}
- public updateInstanceProperties = (componentInstanceId:
string, properties:PropertyModel[]):ng.IPromise<PropertyModel[]> => {
+ public updateInstanceProperties = (componentInstanceId:
string, properties: PropertyModel[]): ng.IPromise<PropertyModel[]> => {
let deferred = this.$q.defer<PropertyModel[]>();
- let onSuccess = (newProperties:PropertyModel[]):void => {
+ let onSuccess = (newProperties: PropertyModel[]): void => {
this.updateInstancePropertiesSuccess(newProperties);
deferred.resolve(newProperties);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
console.log('Failed to update property value');
deferred.reject(error);
};
return deferred.promise;
};
- public updateInstanceAttribute = (attribute:
AttributeModel):ng.IPromise<AttributeModel> => {
+ public updateInstanceAttribute = (attribute:
AttributeModel): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- let onSuccess = (newAttribute:AttributeModel):void => {
- let existAttribute:AttributeModel = <AttributeModel>_.find(this.componentInstancesAttributes[newAttribute.resourceInstanceUniqueId], {uniqueId: newAttribute.uniqueId});
+ let onSuccess = (newAttribute: AttributeModel): void => {
+ let existAttribute: AttributeModel = <AttributeModel>_.find(this.componentInstancesAttributes[newAttribute.resourceInstanceUniqueId], { uniqueId: newAttribute.uniqueId });
let index = this.componentInstancesAttributes[newAttribute.resourceInstanceUniqueId].indexOf(existAttribute);
this.componentInstancesAttributes[newAttribute.resourceInstanceUniqueId][index] = newAttribute;
deferred.resolve(newAttribute);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
console.log('Failed to update attribute value');
deferred.reject(error);
};
return deferred.promise;
};
- public downloadInstanceArtifact = (artifactId:string):ng.IPromise<IFileDownload> => {
+ public downloadInstanceArtifact = (artifactId: string): ng.IPromise<IFileDownload> => {
return this.componentService.downloadInstanceArtifact(this.uniqueId, this.selectedInstance.uniqueId, artifactId);
};
- public deleteInstanceArtifact = (artifactId:
string, artifactLabel:string):ng.IPromise<ArtifactModel> => {
+ public deleteInstanceArtifact = (artifactId:
string, artifactLabel: string): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- let onSuccess = (artifactObj:ArtifactModel):void => {
+ let onSuccess = (artifactObj: ArtifactModel): void => {
let newArtifact = new ArtifactModel(artifactObj);
let artifacts = this.selectedInstance.deploymentArtifacts;
if (newArtifact.mandatory || newArtifact.serviceApi) {//?????????
return deferred.promise;
};
- public addOrUpdateInstanceArtifact = (artifact:
ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public addOrUpdateInstanceArtifact = (artifact:
ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- let onSuccess = (artifactObj:ArtifactModel):void => {
+ let onSuccess = (artifactObj: ArtifactModel): void => {
switch (artifactObj.artifactGroupType) {
case ArtifactGroupType.DEPLOYMENT:
this.selectedInstance.deploymentArtifacts[artifactObj.artifactLabel] = artifactObj;
}
deferred.resolve(artifactObj);
};
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
if (artifact.uniqueId) {
return deferred.promise;
};
- public uploadInstanceEnvFile = (artifact:
ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public uploadInstanceEnvFile = (artifact:
ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- let onSuccess = (artifactObj:ArtifactModel):void => {
+ let onSuccess = (artifactObj: ArtifactModel): void => {
this.selectedInstance.deploymentArtifacts[artifactObj.artifactLabel] = artifactObj;
deferred.resolve(artifactObj);
};
- let onError = (error:any):void => {
+ let onError = (error: any): void => {
deferred.reject(error);
};
this.componentService.uploadInstanceEnvFile(this.uniqueId, this.selectedInstance.uniqueId, artifact).then(onSuccess, onError);
};
//this function will update the instance version than the function call getComponent to update the current component and return the new instance version
- public changeComponentInstanceVersion = (componentUid:string):ng.IPromise<Component> => {
+ public changeComponentInstanceVersion = (componentUid: string): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
- let onSuccess = (componentInstance:ComponentInstance):void => {
- let onSuccess = (component:Component):void => {
+ let onSuccess = (componentInstance: ComponentInstance): void => {
+ let onSuccess = (component: Component): void => {
component.setSelectedInstance(componentInstance);
deferred.resolve(component);
};
return deferred.promise;
};
- public checkComponentInstanceVersionChange = (componentUid:
string):ng.IPromise<any> => {
+ public checkComponentInstanceVersionChange = (componentUid:
string): ng.IPromise<any> => {
return this.componentService.checkResourceInstanceVersionChange(this.uniqueId, this.selectedInstance.uniqueId, componentUid);
};
- public createComponentInstance = (componentInstance:ComponentInstance):ng.IPromise<ComponentInstance> => {
+ public createComponentInstance = (componentInstance: ComponentInstance): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- let onSuccess = (instance:ComponentInstance):void => {
+ let onSuccess = (instance: ComponentInstance): void => {
this.componentInstances.push(instance);
deferred.resolve(instance);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.createComponentInstance(this.uniqueId, componentInstance).then(onSuccess, onFailed);
return deferred.promise;
};
- public updateComponentInstance = (componentInstance:ComponentInstance):ng.IPromise<ComponentInstance> => {
+ public updateComponentInstance = (componentInstance: ComponentInstance): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- let onSuccess = (updatedInstance:ComponentInstance):void => {
- let componentInstance:ComponentInstance = _.find(this.componentInstances, (instance:ComponentInstance) => {
+ let onSuccess = (updatedInstance: ComponentInstance): void => {
+ let componentInstance: ComponentInstance = _.find(this.componentInstances, (instance: ComponentInstance) => {
return instance.uniqueId === updatedInstance.uniqueId;
});
deferred.resolve(updatedInstance);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.updateComponentInstance(this.uniqueId, componentInstance).then(onSuccess, onFailed);
return deferred.promise;
};
- public updateMultipleComponentInstances = (instances:
Array<ComponentInstance>):ng.IPromise<Array<ComponentInstance>> => {
+ public updateMultipleComponentInstances = (instances:
Array<ComponentInstance>): ng.IPromise<Array<ComponentInstance>> => {
let deferred = this.$q.defer<Array<ComponentInstance>>();
- let onSuccess = (updatedInstances:Array<ComponentInstance>):void => {
+ let onSuccess = (updatedInstances: Array<ComponentInstance>): void => {
_.forEach(updatedInstances, (updatedComponentInstance) => {
- let componentInstance:ComponentInstance = _.find(this.componentInstances, (instance:ComponentInstance) => {
+ let componentInstance: ComponentInstance = _.find(this.componentInstances, (instance: ComponentInstance) => {
return instance.uniqueId === updatedComponentInstance.uniqueId;
});
deferred.resolve(updatedInstances);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.updateMultipleComponentInstances(this.uniqueId, instances).then(onSuccess, onFailed);
return deferred.promise;
};
- public deleteComponentInstance = (componentInstanceId:string):ng.IPromise<ComponentInstance> => {
+ public deleteComponentInstance = (componentInstanceId: string): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- let onSuccess = ():void => {
- let onSuccess = (component:Component):void => {
+ let onSuccess = (): void => {
+ let onSuccess = (component: Component): void => {
this.componentInstances = CommonUtils.initComponentInstances(component.componentInstances);
this.componentInstancesProperties = new PropertiesGroup(component.componentInstancesProperties);
this.componentInstancesAttributes = new AttributesGroup(component.componentInstancesAttributes);
};
this.getComponent().then(onSuccess);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.deleteComponentInstance(this.uniqueId, componentInstanceId).then(onSuccess, onFailed);
return deferred.promise;
};
+ public batchDeleteComponentInstance = (componentInstanceIds: Array<string>): ng.IPromise<any> => {
+ let deferred = this.$q.defer();
+ let onSuccess = (res: any): void => {
+ let onSuccess = (component: Component): void => {
+ this.componentInstances = CommonUtils.initComponentInstances(component.componentInstances);
+ this.componentInstancesProperties = new PropertiesGroup(component.componentInstancesProperties);
+ this.componentInstancesAttributes = new AttributesGroup(component.componentInstancesAttributes);
+ this.modules = component.modules;
+ this.componentInstancesRelations = CommonUtils.initComponentInstanceRelations(component.componentInstancesRelations);
+ deferred.resolve();
+
+ };
+ this.getComponent().then(onSuccess);
+ deferred.resolve(res);
+ };
+ let onFailed = (error: any): void => {
+ deferred.reject(error);
+ };
+
+ this.componentService.batchDeleteComponentInstance(this.uniqueId, componentInstanceIds).then(onSuccess, onFailed);
+ return deferred.promise;
+
+ };
+
- public syncComponentByRelation(relation:RelationshipModel) {
+ public syncComponentByRelation(relation: RelationshipModel) {
relation.relationships.forEach((rel) => {
if (rel.capability) {
- const toComponentInstance:ComponentInstance = this.componentInstances.find((inst) => inst.uniqueId === relation.toNode);
- const toComponentInstanceCapability:Capability = toComponentInstance.findCapability(
+ const toComponentInstance: ComponentInstance = this.componentInstances.find((inst) => inst.uniqueId === relation.toNode);
+ const toComponentInstanceCapability: Capability = toComponentInstance.findCapability(
rel.capability.type, rel.capability.uniqueId, rel.capability.ownerId, rel.capability.name);
- const isCapabilityFulfilled:boolean = rel.capability.isFulfilled();
+ const isCapabilityFulfilled: boolean = rel.capability.isFulfilled();
if (isCapabilityFulfilled && toComponentInstanceCapability) {
// if capability is fulfilled and in component, then remove it
console.log('Capability is fulfilled', rel.capability.getFullTitle(), rel.capability.leftOccurrences);
}
}
if (rel.requirement) {
- const fromComponentInstance:ComponentInstance = this.componentInstances.find((inst) => inst.uniqueId === relation.fromNode);
- const fromComponentInstanceRequirement:Requirement = fromComponentInstance.findRequirement(
+ const fromComponentInstance: ComponentInstance = this.componentInstances.find((inst) => inst.uniqueId === relation.fromNode);
+ const fromComponentInstanceRequirement: Requirement = fromComponentInstance.findRequirement(
rel.requirement.capability, rel.requirement.uniqueId, rel.requirement.ownerId, rel.requirement.name);
- const isRequirementFulfilled:boolean = rel.requirement.isFulfilled();
+ const isRequirementFulfilled: boolean = rel.requirement.isFulfilled();
if (isRequirementFulfilled && fromComponentInstanceRequirement) {
// if requirement is fulfilled and in component, then remove it
console.log('Requirement is fulfilled', rel.requirement.getFullTitle(), rel.requirement.leftOccurrences);
});
}
- public fetchRelation = (linkId:string):ng.IPromise<RelationshipModel> => {
+ public fetchRelation = (linkId: string): ng.IPromise<RelationshipModel> => {
let deferred = this.$q.defer<RelationshipModel>();
- let onSuccess = (relation:RelationshipModel):void => {
+ let onSuccess = (relation: RelationshipModel): void => {
this.syncComponentByRelation(relation);
deferred.resolve(relation);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.fetchRelation(this.uniqueId, linkId).then(onSuccess, onFailed);
return deferred.promise;
};
- public createRelation = (relation:RelationshipModel):ng.IPromise<RelationshipModel> => {
+ public createRelation = (relation: RelationshipModel): ng.IPromise<RelationshipModel> => {
let deferred = this.$q.defer<RelationshipModel>();
- let onSuccess = (relation:RelationshipModel):void => {
+ let onSuccess = (relation: RelationshipModel): void => {
console.info('Link created successfully', relation);
if (!this.componentInstancesRelations) {
this.componentInstancesRelations = [];
this.syncComponentByRelation(relation);
deferred.resolve(relation);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
console.info('Failed to create relation', error);
deferred.reject(error);
};
return deferred.promise;
};
- public deleteRelation = (relation:RelationshipModel):ng.IPromise<RelationshipModel> => {
- let deferred = this.$q.defer<RelationshipModel>();
- let onSuccess = (relation:RelationshipModel):void => {
- console.log("Link Deleted In Server");
- let relationToDelete = _.find(this.componentInstancesRelations, (item) => {
- return item.fromNode === relation.fromNode && item.toNode === relation.toNode && _.some(item.relationships, (relationship)=> {
- return angular.equals(relation.relationships[0].relation, relationship.relation);
- });
+ private deleteRelationOnSuccess(relation: RelationshipModel) {
+ let relationToDelete = _.find(this.componentInstancesRelations, (item) => {
+ return item.fromNode === relation.fromNode && item.toNode === relation.toNode && _.some(item.relationships, (relationship) => {
+ return angular.equals(relation.relationships[0].relation, relationship.relation);
});
- let index = this.componentInstancesRelations.indexOf(relationToDelete);
- if (relationToDelete != undefined && index > -1) {
- if (relationToDelete.relationships.length == 1) {
- this.componentInstancesRelations.splice(index, 1);
- } else {
- this.componentInstancesRelations[index].relationships =
- _.reject(this.componentInstancesRelations[index].relationships, (relationship) => {
- return angular.equals(relation.relationships[0].relation, relationship.relation);
- });
- }
+ });
+ let index = this.componentInstancesRelations.indexOf(relationToDelete);
+ if (relationToDelete != undefined && index > -1) {
+ if (relationToDelete.relationships.length == 1) {
+ this.componentInstancesRelations.splice(index, 1);
} else {
- console.error("Error while deleting relation - the return delete relation from server was not found in UI")
+ this.componentInstancesRelations[index].relationships =
+ _.reject(this.componentInstancesRelations[index].relationships, (relationship) => {
+ return angular.equals(relation.relationships[0].relation, relationship.relation);
+ });
}
- this.syncComponentByRelation(relation);
+ } else {
+ console.error("Error while deleting relation - the return delete relation from server was not found in UI")
+ }
+ this.syncComponentByRelation(relation);
+ }
+
+ public deleteRelation = (relation: RelationshipModel): ng.IPromise<RelationshipModel> => {
+ let deferred = this.$q.defer<RelationshipModel>();
+ let onSuccess = (relation: RelationshipModel): void => {
+ this.deleteRelationOnSuccess(relation);
deferred.resolve(relation);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
console.error("Failed To Delete Link");
deferred.reject(error);
};
return deferred.promise;
};
- public getRelationRequirementCapability(relationship: Relationship, sourceNode:ComponentInstance, targetNode:ComponentInstance): Promise<{requirement:Requirement, capability:Capability}> {
+ public batchDeleteRelation = (relations: Array<RelationshipModel>): ng.IPromise<Array<RelationshipModel>> => {
+ let deferred = this.$q.defer<Array<RelationshipModel>>();
+ let onSuccess = (responseRelations: Array<RelationshipModel>): void => {
+ console.log("Link Batch Deleted In Server");
+ let len = responseRelations.length;
+ for (let i = 0; i < len; i++) {
+ this.deleteRelationOnSuccess(responseRelations[i]);
+ }
+ deferred.resolve(responseRelations);
+ };
+ let onFailed = (error: any): void => {
+ console.error("Failed to batch Delete Link");
+ deferred.reject(error);
+ };
+ this.componentService.batchDeleteRelation(this.uniqueId, relations).then(onSuccess, onFailed);
+ return deferred.promise;
+ };
+
+ public getRelationRequirementCapability(relationship: Relationship, sourceNode: ComponentInstance, targetNode: ComponentInstance): Promise<{ requirement: Requirement, capability: Capability }> {
// try find the requirement and capability in the source and target component instances:
- let capability:Capability = targetNode.findCapability(undefined,
+ let capability: Capability = targetNode.findCapability(undefined,
relationship.relation.capabilityUid,
relationship.relation.capabilityOwnerId,
relationship.relation.capability);
- let requirement:Requirement = sourceNode.findRequirement(undefined,
+ let requirement: Requirement = sourceNode.findRequirement(undefined,
relationship.relation.requirementUid,
relationship.relation.requirementOwnerId,
relationship.relation.requirement);
- return new Promise<{requirement:Requirement, capability:Capability}>((resolve, reject) => {
+ return new Promise<{ requirement: Requirement, capability: Capability }>((resolve, reject) => {
if (capability && requirement) {
- resolve({capability, requirement});
+ resolve({ capability, requirement });
}
else {
// if requirement and/or capability is missing, then fetch the full relation with its requirement and capability:
});
}
- public updateRequirementsCapabilities = ():ng.IPromise<any> => {
+ public updateRequirementsCapabilities = ():
ng.IPromise<any> => {
let deferred = this.$q.defer();
- let onSuccess = (response:any):void => {
+ let onSuccess = (response: any): void => {
this.capabilities = new CapabilitiesGroup(response.capabilities);
this.requirements = new RequirementsGroup(response.requirements);
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getRequirementsCapabilities(this.uniqueId).then(onSuccess, onFailed);
return deferred.promise;
};
- public getModuleForDisplay = (moduleId:string):ng.IPromise<DisplayModule> => {
+ public getModuleForDisplay = (moduleId: string): ng.IPromise<DisplayModule> => {
let deferred = this.$q.defer<DisplayModule>();
- let onSuccess = (response:DisplayModule):void => {
+ let onSuccess = (response: DisplayModule): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getModuleForDisplay(this.uniqueId, moduleId).then(onSuccess, onFailed);
return deferred.promise;
};
- public getModuleInstanceForDisplay = (componentInstanceId:string, moduleId:string):ng.IPromise<DisplayModule> => {
+ public getModuleInstanceForDisplay = (componentInstanceId: string, moduleId: string): ng.IPromise<DisplayModule> => {
let deferred = this.$q.defer<DisplayModule>();
- let onSuccess = (response:DisplayModule):void => {
+ let onSuccess = (response: DisplayModule): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstanceModule(this.uniqueId, componentInstanceId, moduleId).then(onSuccess, onFailed);
// this function get all instances filtered by inputs and properties (optional) - if no search string insert - this function will
// get all the instances of the component (in service only VF instances)
- public getComponentInstancesFilteredByInputsAndProperties = (searchText?:
string):ng.IPromise<Array<ComponentInstance>> => {
+ public getComponentInstancesFilteredByInputsAndProperties = (searchText?:
string): ng.IPromise<Array<ComponentInstance>> => {
let deferred = this.$q.defer<Array<ComponentInstance>>();
- let onSuccess = (response:Array<ComponentInstance>):void => {
+ let onSuccess = (response: Array<ComponentInstance>): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstancesFilteredByInputsAndProperties(this.uniqueId, searchText).then(onSuccess, onFailed);
// get inputs for instance - Pagination function
- public getComponentInputs = ():ng.IPromise<Array<InputModel>> => {
+ public getComponentInputs = ():
ng.IPromise<Array<InputModel>> => {
let deferred = this.$q.defer<Array<InputModel>>();
- let onSuccess = (inputsRes:Array<InputModel>):void => {
+ let onSuccess = (inputsRes: Array<InputModel>): void => {
this.inputs = inputsRes;
deferred.resolve(inputsRes);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInputs(this.uniqueId).then(onSuccess, onFailed);
// get inputs instance - Pagination function
- public getComponentInstanceInputs = (componentInstanceId:
string, originComponentUid:string):ng.IPromise<Array<InputModel>> => {
+ public getComponentInstanceInputs = (componentInstanceId:
string, originComponentUid: string): ng.IPromise<Array<InputModel>> => {
let deferred = this.$q.defer<Array<InputModel>>();
- let onSuccess = (response:Array<InputModel>):void => {
+ let onSuccess = (response: Array<InputModel>): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstanceInputs(this.uniqueId, componentInstanceId, originComponentUid).then(onSuccess, onFailed);
};
// get inputs inatnce - Pagination function
- public getComponentInstanceInputProperties = (componentInstanceId:
string, inputId:string):ng.IPromise<Array<PropertyModel>> => {
+ public getComponentInstanceInputProperties = (componentInstanceId:
string, inputId: string): ng.IPromise<Array<PropertyModel>> => {
let deferred = this.$q.defer<Array<PropertyModel>>();
- let onSuccess = (response:Array<PropertyModel>):void => {
+ let onSuccess = (response: Array<PropertyModel>): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstanceInputProperties(this.uniqueId, componentInstanceId, inputId).then(onSuccess, onFailed);
};
// get inputs inatnce - Pagination function
- public getComponentInstanceProperties = (componentInstanceId:
string):ng.IPromise<Array<PropertyModel>> => {
+ public getComponentInstanceProperties = (componentInstanceId:
string): ng.IPromise<Array<PropertyModel>> => {
let deferred = this.$q.defer<Array<PropertyModel>>();
- let onSuccess = (response:Array<PropertyModel>):void => {
+ let onSuccess = (response: Array<PropertyModel>): void => {
deferred.resolve(response);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
this.componentService.getComponentInstanceProperties(this.uniqueId, componentInstanceId).then(onSuccess, onFailed);
};
- public updateGroupMetadata = (module:Module):ng.IPromise<Module> => {
+ public updateGroupMetadata = (module: Module): ng.IPromise<Module> => {
let deferred = this.$q.defer<Module>();
- let onSuccess = (updatedModule:Module):void => {
- let groupIndex:number = _.indexOf(this.modules, _.find(this.modules, (module:Module) => {
+ let onSuccess = (updatedModule: Module): void => {
+ let groupIndex: number = _.indexOf(this.modules, _.find(this.modules, (module: Module) => {
return module.uniqueId === updatedModule.uniqueId;
}));
}
deferred.resolve(updatedModule);
};
- let onFailed = (error:any):void => {
+ let onFailed = (error: any): void => {
deferred.reject(error);
};
//------------------------------------------ Help Functions ----------------------------------------------------------------//
- public isService = ():boolean => {
+ public isService = (): boolean => {
return this instanceof Service;
};
- public isResource = ():boolean => {
+ public isResource = (): boolean => {
return this instanceof Resource;
};
- public getComponentSubType = ():string => {
+ public getComponentSubType = (): string => {
return this.componentType;
};
- public isAlreadyCertified = ():boolean => {
+ public isAlreadyCertified = (): boolean => {
return parseInt(this.version) >= 1;
};
- public isComplex = ():boolean => {
+ public isComplex = (): boolean => {
return true;
};
//sort string version value from hash to sorted version (i.e 1.9 before 1.11)
- private sortVersions = (v1:string, v2:string):number => {
+ private sortVersions = (v1: string, v2: string): number => {
let ver1 = v1.split('.');
let ver2 = v2.split('.');
let diff = parseInt(_.first(ver1)) - parseInt(_.first(ver2));
return diff;
};
- public getAllVersionsAsSortedArray = ():Array<any> => {
+ public getAllVersionsAsSortedArray = ():
Array<any> => {
let res = [];
if (this.allVersions) {
let keys = Object.keys(this.allVersions).sort(this.sortVersions);
- _.forEach(keys, (key)=> {
+ _.forEach(keys, (key) => {
res.push({
versionNumber: key,
versionId: this.allVersions[key]
return res;
};
- public isLatestVersion = ():boolean => {
+ public isLatestVersion = (): boolean => {
if (this.allVersions) {
return this.version === _.last(Object.keys(this.allVersions).sort(this.sortVersions));
} else {
};
- public getAdditionalInformation = ():Array<AdditionalInformationModel> => {
- let additionalInformationObject:any = _.find(this.additionalInformation, (obj:any):boolean => {
+ public getAdditionalInformation = ():
Array<AdditionalInformationModel> => {
+ let additionalInformationObject: any = _.find(this.additionalInformation, (obj: any): boolean => {
return obj.parentUniqueId == this.uniqueId;
});
if (additionalInformationObject) {
return [];
};
- public handleTags = ():void => {
- let isContainTag = _.find(this.tags, (tag)=> {
+ public handleTags = (): void => {
+ let isContainTag = _.find(this.tags, (tag) => {
return tag === this.name;
});
if (!isContainTag) {
}
};
- public getArtifactsByType = (artifactGroupType:string):ArtifactGroupModel => {
+ public getArtifactsByType = (artifactGroupType: string): ArtifactGroupModel => {
switch (artifactGroupType) {
case ArtifactGroupType.DEPLOYMENT:
return this.deploymentArtifacts;
}
};
- public getStatus = (sdcMenu:IAppMenu):string => {
- let status:string = sdcMenu.LifeCycleStatuses[this.lifecycleState].text;
+ public getStatus = (sdcMenu: IAppMenu): string => {
+ let status: string = sdcMenu.LifeCycleStatuses[this.lifecycleState].text;
if (this.lifecycleState == "CERTIFIED" && sdcMenu.DistributionStatuses[this.distributionStatus]) {
status = sdcMenu.DistributionStatuses[this.distributionStatus].text;
}
return status;
};
- public abstract setComponentDisplayData():void;
- public abstract getTypeUrl():string;
+ public pasteMenuComponentInstance = (srcComponentId: string, msg: string): ng.IPromise<string> => {
+ let deferred = this.$q.defer<string>();
+ let onSuccess = (response): void => {
+ deferred.resolve(response);
+ };
+ let onFailed = (error: any): void => {
+ deferred.reject(error);
+ };
+ this.componentService.pasteMenuComponentInstance(this.uniqueId, srcComponentId, msg).then(onSuccess, onFailed);
+ return deferred.promise;
+
+ };
+ public abstract setComponentDisplayData(): void;
+ public abstract getTypeUrl(): string;
public setComponentMetadata(componentMetadata: ComponentMetadata) {
this.abstract = componentMetadata.abstract;
this.vspArchived = componentMetadata.vspArchived;
}
- public toJSON = ():any => {
+ public toJSON = (): any => {
let temp = angular.copy(this);
temp.componentService = undefined;
temp.filterTerm = undefined;
*/
'use strict';
import * as _ from "lodash";
-import {ArtifactModel, IFileDownload, InstancesInputsPropertiesMap, InputModel, IValidate, RelationshipModel, PropertyModel, Component, ComponentInstance,
- AttributeModel, IAppConfigurtaion, Resource, Module, DisplayModule, ArtifactGroupModel, InputsAndProperties} from "app/models";
-import {ComponentInstanceFactory, CommonUtils} from "app/utils";
-import {SharingService} from "../sharing-service";
-import {ComponentMetadata} from "../../models/component-metadata";
+import {
+ ArtifactModel, IFileDownload, InstancesInputsPropertiesMap, InputModel, IValidate, RelationshipModel, PropertyModel, Component, ComponentInstance,
+ AttributeModel, IAppConfigurtaion, Resource, Module, DisplayModule, ArtifactGroupModel, InputsAndProperties
+} from "app/models";
+import { ComponentInstanceFactory, CommonUtils } from "app/utils";
+import { SharingService } from "../sharing-service";
+import { ComponentMetadata } from "../../models/component-metadata";
export interface IComponentService {
- getComponent(id:string);
- updateComponent(component:Component):ng.IPromise<Component>;
- changeLifecycleState(component:Component, state:string, userRemarks:any):ng.IPromise<ComponentMetadata> ;
- validateName(newName:string, subtype?:string):ng.IPromise<IValidate>;
- createComponent(component:Component):ng.IPromise<Component>;
- addOrUpdateArtifact(componentId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- deleteArtifact(componentId:string, artifact:string, artifactLabel):ng.IPromise<ArtifactModel>;
- addProperty(componentId:string, property:PropertyModel):ng.IPromise<PropertyModel>;
- updateProperty(componentId:string, property:PropertyModel):ng.IPromise<PropertyModel>;
- addAttribute(componentId:string, attribute:AttributeModel):ng.IPromise<AttributeModel>;
- updateAttribute(componentId:string, attribute:AttributeModel):ng.IPromise<AttributeModel>;
- deleteProperty(componentId:string, propertyId:string):ng.IPromise<PropertyModel>;
- deleteAttribute(componentId:string, attributeId:string):ng.IPromise<AttributeModel>;
- checkResourceInstanceVersionChange(componentId:string, componentInstanceId:string, componentUid:string):ng.IPromise<any>;
- changeResourceInstanceVersion(componentId:string, componentInstanceId:string, componentUid:string):ng.IPromise<ComponentInstance>;
- updateInstanceArtifact(componentId:string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- addInstanceArtifact(componentId:string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- deleteInstanceArtifact(componentId:string, instanceId:string, artifact:string, artifactLabel):ng.IPromise<ArtifactModel>;
- createComponentInstance(componentId:string, componentInstance:ComponentInstance):ng.IPromise<ComponentInstance>;
- updateComponentInstance(componentId:string, componentInstance:ComponentInstance):ng.IPromise<ComponentInstance>;
- updateMultipleComponentInstances(componentId:string, instances:Array<ComponentInstance>):ng.IPromise< Array<ComponentInstance>>;
- downloadArtifact(componentId:string, artifactId:string):ng.IPromise<IFileDownload>;
- uploadInstanceEnvFile(componentId:string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel>;
- downloadInstanceArtifact(componentId:string, instanceId:string, artifactId:string):ng.IPromise<IFileDownload>;
- deleteComponentInstance(componentId:string, componentInstanceId:string):ng.IPromise<ComponentInstance>;
- createRelation(componentId:string, link:RelationshipModel):ng.IPromise<RelationshipModel>;
- deleteRelation(componentId:string, link:RelationshipModel):ng.IPromise<RelationshipModel>;
- fetchRelation(componentId:string, linkId:string):ng.IPromise<RelationshipModel>;
- getRequirementsCapabilities(componentId:string):ng.IPromise<any>;
- updateInstanceProperties(componentId:string, componentInstanceId:string, properties:PropertyModel[]):ng.IPromise<PropertyModel[]>;
- updateInstanceAttribute(componentId:string, attribute:AttributeModel):ng.IPromise<AttributeModel>;
- getComponentInstancesFilteredByInputsAndProperties(componentId:string, searchText:string):ng.IPromise<Array<ComponentInstance>>
- getComponentInstanceInputs(componentId:string, instanceId:string, originComponentUid):ng.IPromise<Array<InputModel>>;
- getComponentInputs(componentId:string):ng.IPromise<Array<InputModel>>;
- getComponentInstanceInputProperties(componentId:string, instanceId:string, inputId:string):ng.IPromise<Array<PropertyModel>>;
- getComponentInstanceProperties(componentId:string, instanceId:string):ng.IPromise<Array<PropertyModel>>;
- getModuleForDisplay(componentId:string, moduleId:string):ng.IPromise<DisplayModule>;
- getComponentInstanceModule(componentId:string, componentInstanceId:string, moduleId:string):ng.IPromise<DisplayModule>;
- updateGroupMetadata(componentId:string, group:Module):ng.IPromise<Module>;
- getComponentInputInputsAndProperties(serviceId:string, input:string):ng.IPromise<InputsAndProperties>;
- createInputsFromInstancesInputs(serviceId:string, instancesInputsMap:InstancesInputsPropertiesMap):ng.IPromise<Array<InputModel>>;
- createInputsFromInstancesInputsProperties(resourceId:string, instanceInputsPropertiesMap:InstancesInputsPropertiesMap):ng.IPromise<Array<PropertyModel>>;
- deleteComponentInput(serviceId:string, inputId:string):ng.IPromise<InputModel>;
- getArtifactByGroupType(componentId:string, artifactGroupType:string):ng.IPromise<ArtifactGroupModel>;
- getComponentInstanceArtifactsByGroupType(componentId:string, componentInstanceId:string, artifactGroupType:string):ng.IPromise<ArtifactGroupModel>;
+ getComponent(id: string);
+ updateComponent(component: Component): ng.IPromise<Component>;
+ changeLifecycleState(component: Component, state: string, userRemarks: any): ng.IPromise<ComponentMetadata>;
+ validateName(newName: string, subtype?: string): ng.IPromise<IValidate>;
+ createComponent(component: Component): ng.IPromise<Component>;
+ addOrUpdateArtifact(componentId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ deleteArtifact(componentId: string, artifact: string, artifactLabel): ng.IPromise<ArtifactModel>;
+ addProperty(componentId: string, property: PropertyModel): ng.IPromise<PropertyModel>;
+ updateProperty(componentId: string, property: PropertyModel): ng.IPromise<PropertyModel>;
+ addAttribute(componentId: string, attribute: AttributeModel): ng.IPromise<AttributeModel>;
+ updateAttribute(componentId: string, attribute: AttributeModel): ng.IPromise<AttributeModel>;
+ deleteProperty(componentId: string, propertyId: string): ng.IPromise<PropertyModel>;
+ deleteAttribute(componentId: string, attributeId: string): ng.IPromise<AttributeModel>;
+ checkResourceInstanceVersionChange(componentId: string, componentInstanceId: string, componentUid: string): ng.IPromise<any>;
+ changeResourceInstanceVersion(componentId: string, componentInstanceId: string, componentUid: string): ng.IPromise<ComponentInstance>;
+ updateInstanceArtifact(componentId: string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ addInstanceArtifact(componentId: string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ deleteInstanceArtifact(componentId: string, instanceId: string, artifact: string, artifactLabel): ng.IPromise<ArtifactModel>;
+ createComponentInstance(componentId: string, componentInstance: ComponentInstance): ng.IPromise<ComponentInstance>;
+ updateComponentInstance(componentId: string, componentInstance: ComponentInstance): ng.IPromise<ComponentInstance>;
+ updateMultipleComponentInstances(componentId: string, instances: Array<ComponentInstance>): ng.IPromise<Array<ComponentInstance>>;
+ downloadArtifact(componentId: string, artifactId: string): ng.IPromise<IFileDownload>;
+ uploadInstanceEnvFile(componentId: string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel>;
+ downloadInstanceArtifact(componentId: string, instanceId: string, artifactId: string): ng.IPromise<IFileDownload>;
+ deleteComponentInstance(componentId: string, componentInstanceId: string): ng.IPromise<ComponentInstance>;
+ createRelation(componentId: string, link: RelationshipModel): ng.IPromise<RelationshipModel>;
+ deleteRelation(componentId: string, link: RelationshipModel): ng.IPromise<RelationshipModel>;
+ fetchRelation(componentId: string, linkId: string): ng.IPromise<RelationshipModel>;
+ getRequirementsCapabilities(componentId: string): ng.IPromise<any>;
+ updateInstanceProperties(componentId: string, componentInstanceId: string, properties: PropertyModel[]): ng.IPromise<PropertyModel[]>;
+ updateInstanceAttribute(componentId: string, attribute: AttributeModel): ng.IPromise<AttributeModel>;
+ getComponentInstancesFilteredByInputsAndProperties(componentId: string, searchText: string): ng.IPromise<Array<ComponentInstance>>
+ getComponentInstanceInputs(componentId: string, instanceId: string, originComponentUid): ng.IPromise<Array<InputModel>>;
+ getComponentInputs(componentId: string): ng.IPromise<Array<InputModel>>;
+ getComponentInstanceInputProperties(componentId: string, instanceId: string, inputId: string): ng.IPromise<Array<PropertyModel>>;
+ getComponentInstanceProperties(componentId: string, instanceId: string): ng.IPromise<Array<PropertyModel>>;
+ getModuleForDisplay(componentId: string, moduleId: string): ng.IPromise<DisplayModule>;
+ getComponentInstanceModule(componentId: string, componentInstanceId: string, moduleId: string): ng.IPromise<DisplayModule>;
+ updateGroupMetadata(componentId: string, group: Module): ng.IPromise<Module>;
+ getComponentInputInputsAndProperties(serviceId: string, input: string): ng.IPromise<InputsAndProperties>;
+ createInputsFromInstancesInputs(serviceId: string, instancesInputsMap: InstancesInputsPropertiesMap): ng.IPromise<Array<InputModel>>;
+ createInputsFromInstancesInputsProperties(resourceId: string, instanceInputsPropertiesMap: InstancesInputsPropertiesMap): ng.IPromise<Array<PropertyModel>>;
+ deleteComponentInput(serviceId: string, inputId: string): ng.IPromise<InputModel>;
+ getArtifactByGroupType(componentId: string, artifactGroupType: string): ng.IPromise<ArtifactGroupModel>;
+ getComponentInstanceArtifactsByGroupType(componentId: string, componentInstanceId: string, artifactGroupType: string): ng.IPromise<ArtifactGroupModel>;
+ batchDeleteComponentInstance(componentId: string, componentInstanceIdList: Array<string>): ng.IPromise<any>;
+ pasteMenuComponentInstance(componentId: string, srcComponentId: string, msg: string): ng.IPromise<string>;
+ batchDeleteRelation(componentId: string, links: Array<RelationshipModel>): ng.IPromise<Array<RelationshipModel>>
+
}
export class ComponentService implements IComponentService {
'$base64'
];
- constructor(protected restangular:restangular.IElement,
- protected sdcConfig:IAppConfigurtaion,
- protected sharingService:SharingService,
- protected $q:ng.IQService,
- protected $base64:any
- ) {
+ constructor(protected restangular: restangular.IElement,
+ protected sdcConfig: IAppConfigurtaion,
+ protected sharingService: SharingService,
+ protected $q: ng.IQService,
+ protected $base64: any
+ ) {
this.restangular.setBaseUrl(sdcConfig.api.root + sdcConfig.api.component_api_root);
this.restangular.setRequestInterceptor(function (elem, operation) {
}
//this function is override by each service, we need to change this method to abstract when updtaing typescript version
- protected createComponentObject = (component:Component):Component => {
+ protected createComponentObject = (component: Component): Component => {
return component;
};
- public getComponent = (id:string):ng.IPromise<Component> => {
+ public getComponent = (id: string): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- this.restangular.one(id).get().then((response:Component) => {
- let component:Component = this.createComponentObject(response);
+ this.restangular.one(id).get().then((response: Component) => {
+ let component: Component = this.createComponentObject(response);
//console.log("Component Loaded successfully : ", component);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to load component with ID: " + id);
deferred.reject(err);
});
return deferred.promise;
};
- public updateComponent = (component:Component):ng.IPromise<Component> => {
+ public updateComponent = (component: Component): ng.IPromise<Component> => {
// If this is resource
if (component instanceof Resource) {
- let resource:Resource = <Resource>component;
+ let resource: Resource = <Resource>component;
if (resource.importedFile) {
// Update resource with payload data.
return this.updateResourceWithPayload(resource);
}
};
- private updateService = (component:Component):ng.IPromise<Component> => {
+ private updateService = (component: Component): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- this.restangular.one(component.uniqueId).one("metadata").customPUT(JSON.stringify(component)).then((response:Component) => {
- let component:Component = this.createComponentObject(response);
+ this.restangular.one(component.uniqueId).one("metadata").customPUT(JSON.stringify(component)).then((response: Component) => {
+ let component: Component = this.createComponentObject(response);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- private updateResource = (component:Component):ng.IPromise<Component> => {
+ private updateResource = (component: Component): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- this.restangular.one(component.uniqueId).customPUT(JSON.stringify(component)).then((response:Component) => {
- let component:Component = this.createComponentObject(response);
+ this.restangular.one(component.uniqueId).customPUT(JSON.stringify(component)).then((response: Component) => {
+ let component: Component = this.createComponentObject(response);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- private updateResourceMetadata = (component:Component):ng.IPromise<Component> => {
+ private updateResourceMetadata = (component: Component): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
- this.restangular.one(component.uniqueId).one('metadata').customPUT(JSON.stringify(component)).then((response:Component) => {
- let component:Component = this.createComponentObject(response);
+ this.restangular.one(component.uniqueId).one('metadata').customPUT(JSON.stringify(component)).then((response: Component) => {
+ let component: Component = this.createComponentObject(response);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
* @param component
* @returns {IPromise<T>}
*/
- private updateResourceWithPayload = (resource:Resource):ng.IPromise<Component> => {
+ private updateResourceWithPayload = (resource: Resource): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
resource.payloadData = resource.importedFile.base64;
resource.payloadName = resource.importedFile.filename;
let headerObj = this.getHeaderMd5(resource);
- this.restangular.one(resource.uniqueId).customPUT(JSON.stringify(resource), '', {}, headerObj).then((response:Component) => {
- let componentResult:Component = this.createComponentObject(response);
+ this.restangular.one(resource.uniqueId).customPUT(JSON.stringify(resource), '', {}, headerObj).then((response: Component) => {
+ let componentResult: Component = this.createComponentObject(response);
deferred.resolve(componentResult);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public createComponent = (component:Component):ng.IPromise<Component> => {
+ public createComponent = (component: Component): ng.IPromise<Component> => {
let deferred = this.$q.defer<Component>();
let headerObj = this.getHeaderMd5(component);
- this.restangular.customPOST(JSON.stringify(component), '', {}, headerObj).then((response:Component) => {
- let component:Component = this.createComponentObject(response);
+ this.restangular.customPOST(JSON.stringify(component), '', {}, headerObj).then((response: Component) => {
+ let component: Component = this.createComponentObject(response);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public validateName = (newName:string, subtype?:string):ng.IPromise<IValidate> => {
+ public validateName = (newName: string, subtype?: string): ng.IPromise<IValidate> => {
let deferred = this.$q.defer<IValidate>();
- this.restangular.one("validate-name").one(newName).get({'subtype': subtype}).then((response:any) => {
+ this.restangular.one("validate-name").one(newName).get({ 'subtype': subtype }).then((response: any) => {
deferred.resolve(response.plain());
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public changeLifecycleState = (component:Component, state:string, userRemarks:any):ng.IPromise<ComponentMetadata> => {
+ public changeLifecycleState = (component: Component, state: string, userRemarks: any): ng.IPromise<ComponentMetadata> => {
let deferred = this.$q.defer<ComponentMetadata>();
- this.restangular.one(component.uniqueId).one(state).customPOST(userRemarks).then((response:ComponentMetadata) => {
+ this.restangular.one(component.uniqueId).one(state).customPOST(userRemarks).then((response: ComponentMetadata) => {
this.sharingService.addUuidValue(response.uniqueId, response.uuid);
- let component:ComponentMetadata = new ComponentMetadata().deserialize(response);
+ let component: ComponentMetadata = new ComponentMetadata().deserialize(response);
deferred.resolve(component);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
// ------------------------------------------------ Artifacts API --------------------------------------------------//
- public addOrUpdateArtifact = (componentId:
string, artifact:ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public addOrUpdateArtifact = (componentId:
string, artifact: ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
let headerObj = {};
if (artifact.payloadData) {
headerObj = this.getHeaderMd5(artifact);
}
- this.restangular.one(componentId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response:any) => {
+ this.restangular.one(componentId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response: any) => {
deferred.resolve(response.plain());
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public downloadArtifact = (componentId:string, artifactId:string):ng.IPromise<IFileDownload> => {
+ public downloadArtifact = (componentId: string, artifactId: string): ng.IPromise<IFileDownload> => {
let deferred = this.$q.defer<IFileDownload>();
- this.restangular.one(componentId).one("artifacts").one(artifactId).get().then((response:any) => {
+ this.restangular.one(componentId).one("artifacts").one(artifactId).get().then((response: any) => {
deferred.resolve(response.plain());
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public deleteArtifact = (componentId:
string, artifactId:string, artifactLabel:string):ng.IPromise<ArtifactModel> => {
+ public deleteArtifact = (componentId:
string, artifactId: string, artifactLabel: string): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- this.restangular.one(componentId).one("artifacts").one(artifactId).remove({'operation': artifactLabel}).then((response:ArtifactModel) => {
+ this.restangular.one(componentId).one("artifacts").one(artifactId).remove({ 'operation': artifactLabel }).then((response: ArtifactModel) => {
deferred.resolve(response);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public getArtifactByGroupType = (componentId:
string, artifactGroupType:string):ng.IPromise<ArtifactGroupModel> => {
+ public getArtifactByGroupType = (componentId:
string, artifactGroupType: string): ng.IPromise<ArtifactGroupModel> => {
let deferred = this.$q.defer<ArtifactGroupModel>();
- this.restangular.one(componentId).one("artifactsByType").one(artifactGroupType).get().then((response:any) => {
- var artifacts:ArtifactGroupModel = new ArtifactGroupModel(response.plain());
+ this.restangular.one(componentId).one("artifactsByType").one(artifactGroupType).get().then((response: any) => {
+ var artifacts: ArtifactGroupModel = new ArtifactGroupModel(response.plain());
deferred.resolve(artifacts);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public getComponentInstanceArtifactsByGroupType = (componentId:
string, componentInstanceId:string, artifactGroupType:string):ng.IPromise<ArtifactGroupModel> => {
+ public getComponentInstanceArtifactsByGroupType = (componentId:
string, componentInstanceId: string, artifactGroupType: string): ng.IPromise<ArtifactGroupModel> => {
let deferred = this.$q.defer<ArtifactGroupModel>();
- this.restangular.one(componentId).one("resourceInstances").one(componentInstanceId).one("artifactsByType").one(artifactGroupType).get().then((response:any) => {
- var artifacts:ArtifactGroupModel = new ArtifactGroupModel(response.plain());
+ this.restangular.one(componentId).one("resourceInstances").one(componentInstanceId).one("artifactsByType").one(artifactGroupType).get().then((response: any) => {
+ var artifacts: ArtifactGroupModel = new ArtifactGroupModel(response.plain());
deferred.resolve(artifacts);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
// ------------------------------------------------ Properties API --------------------------------------------------//
- public addProperty = (componentId:
string, property:PropertyModel):ng.IPromise<PropertyModel> => {
+ public addProperty = (componentId:
string, property: PropertyModel): ng.IPromise<PropertyModel> => {
let deferred = this.$q.defer<PropertyModel>();
- this.restangular.one(componentId).one("properties").customPOST(property.convertToServerObject()).then((response:any) => {
- let property:PropertyModel = new PropertyModel(response[Object.keys(response)[0]]);
+ this.restangular.one(componentId).one("properties").customPOST(property.convertToServerObject()).then((response: any) => {
+ let property: PropertyModel = new PropertyModel(response[Object.keys(response)[0]]);
deferred.resolve(property);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public updateProperty = (componentId:
string, property:PropertyModel):ng.IPromise<PropertyModel> => {
+ public updateProperty = (componentId:
string, property: PropertyModel): ng.IPromise<PropertyModel> => {
let deferred = this.$q.defer<PropertyModel>();
- this.restangular.one(componentId).one("properties").one(property.uniqueId).customPUT(property.convertToServerObject()).then((response:any) => {
- let property:PropertyModel = new PropertyModel(response[Object.keys(response)[0]]);
+ this.restangular.one(componentId).one("properties").one(property.uniqueId).customPUT(property.convertToServerObject()).then((response: any) => {
+ let property: PropertyModel = new PropertyModel(response[Object.keys(response)[0]]);
deferred.resolve(property);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public deleteProperty = (componentId:
string, propertyId:string):ng.IPromise<PropertyModel> => {
+ public deleteProperty = (componentId:
string, propertyId: string): ng.IPromise<PropertyModel> => {
let deferred = this.$q.defer<PropertyModel>();
- this.restangular.one(componentId).one("properties").one(propertyId).remove().then((response:any) => {
+ this.restangular.one(componentId).one("properties").one(propertyId).remove().then((response: any) => {
deferred.resolve(response);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
// ------------------------------------------------ Attributes API --------------------------------------------------//
- public addAttribute = (componentId:
string, attribute:AttributeModel):ng.IPromise<AttributeModel> => {
+ public addAttribute = (componentId:
string, attribute: AttributeModel): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- this.restangular.one(componentId).one("attributes").customPOST(attribute.convertToServerObject()).then((response:any) => {
- let attribute:AttributeModel = new AttributeModel(response);
+ this.restangular.one(componentId).one("attributes").customPOST(attribute.convertToServerObject()).then((response: any) => {
+ let attribute: AttributeModel = new AttributeModel(response);
deferred.resolve(attribute);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public updateAttribute = (componentId:
string, attribute:AttributeModel):ng.IPromise<AttributeModel> => {
+ public updateAttribute = (componentId:
string, attribute: AttributeModel): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- this.restangular.one(componentId).one("attributes").one(attribute.uniqueId).customPUT(attribute.convertToServerObject()).then((response:any) => {
- let attribute:AttributeModel = new AttributeModel(response);
+ this.restangular.one(componentId).one("attributes").one(attribute.uniqueId).customPUT(attribute.convertToServerObject()).then((response: any) => {
+ let attribute: AttributeModel = new AttributeModel(response);
deferred.resolve(attribute);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public deleteAttribute = (componentId:
string, attributeId:string):ng.IPromise<AttributeModel> => {
+ public deleteAttribute = (componentId:
string, attributeId: string): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
- this.restangular.one(componentId).one("attributes").one(attributeId).remove().then((response:any) => {
+ this.restangular.one(componentId).one("attributes").one(attributeId).remove().then((response: any) => {
deferred.resolve(response);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
// ------------------------------------------------ Component Instances API --------------------------------------------------//
- public createComponentInstance = (componentId:string, componentInstance:ComponentInstance):ng.IPromise<ComponentInstance> => {
+ public createComponentInstance = (componentId: string, componentInstance: ComponentInstance): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- this.restangular.one(componentId).one("resourceInstance").customPOST(JSON.stringify(componentInstance)).then((response:any) => {
- let componentInstance:ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
+ this.restangular.one(componentId).one("resourceInstance").customPOST(JSON.stringify(componentInstance)).then((response: any) => {
+ let componentInstance: ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
console.log("Component Instance created", componentInstance);
deferred.resolve(componentInstance);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to create componentInstance. With Name: " + componentInstance.name);
deferred.reject(err);
});
return deferred.promise;
};
- public updateComponentInstance = (componentId:string, componentInstance:ComponentInstance):ng.IPromise<ComponentInstance> => {
+ public updateComponentInstance = (componentId: string, componentInstance: ComponentInstance): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- this.restangular.one(componentId).one("resourceInstance").one(componentInstance.uniqueId).customPOST(JSON.stringify(componentInstance)).then((response:any) => {
- let componentInstance:ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
+ this.restangular.one(componentId).one("resourceInstance").one(componentInstance.uniqueId).customPOST(JSON.stringify(componentInstance)).then((response: any) => {
+ let componentInstance: ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
console.log("Component Instance was updated", componentInstance);
deferred.resolve(componentInstance);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to update componentInstance. With ID: " + componentInstance.uniqueId + "Name: " + componentInstance.name);
deferred.reject(err);
});
return deferred.promise;
};
- public updateMultipleComponentInstances = (componentId:
string, instances:Array<ComponentInstance>):ng.IPromise<Array<ComponentInstance>> => {
+ public updateMultipleComponentInstances = (componentId:
string, instances: Array<ComponentInstance>): ng.IPromise<Array<ComponentInstance>> => {
let deferred = this.$q.defer<Array<ComponentInstance>>();
- this.restangular.one(componentId).one("resourceInstance/multipleComponentInstance").customPOST(JSON.stringify(instances)).then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance/multipleComponentInstance").customPOST(JSON.stringify(instances)).then((response: any) => {
console.log("Multiple Component Instances was updated", response);
- let updateInstances:Array<ComponentInstance> = new Array<ComponentInstance>();
- _.forEach(response, (componentInstance:ComponentInstance) => {
- let updatedComponentInstance:ComponentInstance = ComponentInstanceFactory.createComponentInstance(componentInstance);
+ let updateInstances: Array<ComponentInstance> = new Array<ComponentInstance>();
+ _.forEach(response, (componentInstance: ComponentInstance) => {
+ let updatedComponentInstance: ComponentInstance = ComponentInstanceFactory.createComponentInstance(componentInstance);
updateInstances.push(updatedComponentInstance);
});
deferred.resolve(updateInstances);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to update Multiple componentInstance.");
deferred.reject(err);
});
return deferred.promise;
};
- public deleteComponentInstance = (componentId:string, componentInstanceId:string):ng.IPromise<ComponentInstance> => {
+ public deleteComponentInstance = (componentId: string, componentInstanceId: string): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).remove().then(() => {
console.log("Component Instance was deleted");
deferred.resolve();
- }, (err)=> {
+ }, (err) => {
console.log("Failed to delete componentInstance. With ID: " + componentInstanceId);
deferred.reject(err);
});
return deferred.promise;
};
- public checkResourceInstanceVersionChange = (componentId:string, componentInstanceId:string, componentUid:string):ng.IPromise<ComponentInstance> => {
+ public checkResourceInstanceVersionChange = (componentId: string, componentInstanceId: string, componentUid: string): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one(componentUid).one("checkForwardingPathOnVersionChange").get().then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one(componentUid).one("checkForwardingPathOnVersionChange").get().then((response: any) => {
deferred.resolve(response);
}, err => {
deferred.reject(err);
return deferred.promise;
};
- public changeResourceInstanceVersion = (componentId:string, componentInstanceId:string, componentUid:string):ng.IPromise<ComponentInstance> => {
+ public changeResourceInstanceVersion = (componentId: string, componentInstanceId: string, componentUid: string): ng.IPromise<ComponentInstance> => {
let deferred = this.$q.defer<ComponentInstance>();
- this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("changeVersion").customPOST({'componentUid': componentUid}).then((response:any) => {
- let componentInstance:ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
+ this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("changeVersion").customPOST({ 'componentUid': componentUid }).then((response: any) => {
+ let componentInstance: ComponentInstance = ComponentInstanceFactory.createComponentInstance(response);
deferred.resolve(componentInstance);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public downloadInstanceArtifact = (componentId:string, instanceId:string, artifactId:string):ng.IPromise<IFileDownload> => {
+ public downloadInstanceArtifact = (componentId: string, instanceId: string, artifactId: string): ng.IPromise<IFileDownload> => {
let deferred = this.$q.defer<IFileDownload>();
- this.restangular.one(componentId).one("resourceInstances").one(instanceId).one("artifacts").one(artifactId).get().then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstances").one(instanceId).one("artifacts").one(artifactId).get().then((response: any) => {
deferred.resolve(response.plain());
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public updateInstanceArtifact = (componentId:
string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public updateInstanceArtifact = (componentId:
string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
let headerObj = {};
if (artifact.payloadData) {
headerObj = this.getHeaderMd5(artifact);
}
- this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response: any) => {
let newArtifact = new ArtifactModel(response);
deferred.resolve(newArtifact);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public addInstanceArtifact = (componentId:
string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public addInstanceArtifact = (componentId:
string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
let headerObj = {};
if (artifact.payloadData) {
headerObj = this.getHeaderMd5(artifact);
}
- this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response:any) => {
- let artifact:ArtifactModel = new ArtifactModel(response.plain());
+ this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response: any) => {
+ let artifact: ArtifactModel = new ArtifactModel(response.plain());
deferred.resolve(artifact);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public deleteInstanceArtifact = (componentId:
string, instanceId:string, artifactId:string, artifactLabel:string):ng.IPromise<ArtifactModel> => {
+ public deleteInstanceArtifact = (componentId:
string, instanceId: string, artifactId: string, artifactLabel: string): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
- this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").one(artifactId).remove({'operation': artifactLabel}).then((response:ArtifactModel) => {
+ this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").one(artifactId).remove({ 'operation': artifactLabel }).then((response: ArtifactModel) => {
deferred.resolve(response);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public uploadInstanceEnvFile = (componentId:
string, instanceId:string, artifact:ArtifactModel):ng.IPromise<ArtifactModel> => {
+ public uploadInstanceEnvFile = (componentId:
string, instanceId: string, artifact: ArtifactModel): ng.IPromise<ArtifactModel> => {
let deferred = this.$q.defer<ArtifactModel>();
let headerObj = {};
if (artifact.payloadData) {
headerObj = this.getHeaderMd5(artifact);
}
- this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("artifacts").customPOST(JSON.stringify(artifact), artifact.uniqueId, {}, headerObj).then((response: any) => {
let newArtifact = new ArtifactModel(response);
deferred.resolve(newArtifact);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public updateInstanceProperties = (componentId:
string, componentInstanceId:string, properties:PropertyModel[]):ng.IPromise<PropertyModel[]> => {
+ public updateInstanceProperties = (componentId:
string, componentInstanceId: string, properties: PropertyModel[]): ng.IPromise<PropertyModel[]> => {
let deferred = this.$q.defer<PropertyModel[]>();
- this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("properties").customPOST(JSON.stringify(properties)).then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("properties").customPOST(JSON.stringify(properties)).then((response: any) => {
const newProperties = response.map((res) => {
const newProperty = new PropertyModel(res);
newProperty.readonly = true;
return newProperty;
});
deferred.resolve(newProperties);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public updateInstanceAttribute = (componentId:
string, attribute:AttributeModel):ng.IPromise<AttributeModel> => {
+ public updateInstanceAttribute = (componentId:
string, attribute: AttributeModel): ng.IPromise<AttributeModel> => {
let deferred = this.$q.defer<AttributeModel>();
let instanceId = attribute.resourceInstanceUniqueId;
- this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("attribute").customPOST(JSON.stringify(attribute)).then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(instanceId).one("attribute").customPOST(JSON.stringify(attribute)).then((response: any) => {
let newAttribute = new AttributeModel(response);
newAttribute.readonly = true;
newAttribute.resourceInstanceUniqueId = instanceId;
deferred.resolve(newAttribute);
- }, (err)=> {
+ }, (err) => {
deferred.reject(err);
});
return deferred.promise;
};
- public createRelation = (componentId:string, link:RelationshipModel):ng.IPromise<RelationshipModel> => {
+ public createRelation = (componentId: string, link: RelationshipModel): ng.IPromise<RelationshipModel> => {
let deferred = this.$q.defer<RelationshipModel>();
- const linkPayload:RelationshipModel = new RelationshipModel(link);
+ const linkPayload: RelationshipModel = new RelationshipModel(link);
linkPayload.relationships.forEach((rel) => {
delete rel.capability;
delete rel.requirement;
});
- this.restangular.one(componentId).one("resourceInstance").one("associate").customPOST(JSON.stringify(linkPayload)).then((response:any) => {
- let relation:RelationshipModel = new RelationshipModel(response.plain());
+ this.restangular.one(componentId).one("resourceInstance").one("associate").customPOST(JSON.stringify(linkPayload)).then((response: any) => {
+ let relation: RelationshipModel = new RelationshipModel(response.plain());
console.log("Link created successfully ", relation);
deferred.resolve(relation);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to create Link From: " + link.fromNode + "To: " + link.toNode);
deferred.reject(err);
});
return deferred.promise;
};
- public deleteRelation = (componentId:string, link:RelationshipModel):ng.IPromise<RelationshipModel> => {
+ public deleteRelation = (componentId: string, link: RelationshipModel): ng.IPromise<RelationshipModel> => {
let deferred = this.$q.defer<RelationshipModel>();
- const linkPayload:RelationshipModel = new RelationshipModel(link);
+ const linkPayload: RelationshipModel = new RelationshipModel(link);
linkPayload.relationships.forEach((rel) => {
delete rel.capability;
delete rel.requirement;
});
- this.restangular.one(componentId).one("resourceInstance").one("dissociate").customPUT(JSON.stringify(linkPayload)).then((response:any) => {
- let relation:RelationshipModel = new RelationshipModel(response);
+ this.restangular.one(componentId).one("resourceInstance").one("dissociate").customPUT(JSON.stringify(linkPayload)).then((response: any) => {
+ let relation: RelationshipModel = new RelationshipModel(response);
console.log("Link deleted successfully ", relation);
deferred.resolve(relation);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to delete Link From: " + link.fromNode + "To: " + link.toNode);
deferred.reject(err);
});
return deferred.promise;
};
- public fetchRelation = (componentId:string, linkId:string):ng.IPromise<RelationshipModel> => {
+ public fetchRelation = (componentId: string, linkId: string): ng.IPromise<RelationshipModel> => {
let deferred = this.$q.defer<RelationshipModel>();
- this.restangular.one(componentId).one("relationId").one(linkId).get().then((response:any) => {
- let relation:RelationshipModel = new RelationshipModel(response);
+ this.restangular.one(componentId).one("relationId").one(linkId).get().then((response: any) => {
+ let relation: RelationshipModel = new RelationshipModel(response);
console.log("Link fetched successfully ", relation);
deferred.resolve(relation);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to fetch Link Id: " + linkId);
deferred.reject(err);
});
return deferred.promise;
};
- public getRequirementsCapabilities = (componentId:
string):ng.IPromise<any> => {
+ public getRequirementsCapabilities = (componentId:
string): ng.IPromise<any> => {
let deferred = this.$q.defer();
- this.restangular.one(componentId).one("requirmentsCapabilities").get().then((response:any) => {
+ this.restangular.one(componentId).one("requirmentsCapabilities").get().then((response: any) => {
console.log("Component requirement capabilities recived: ", response);
deferred.resolve(response);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to get requirements & capabilities");
deferred.reject(err);
});
return deferred.promise;
};
- public getModuleForDisplay = (componentId:string, moduleId:string):ng.IPromise<DisplayModule> => {
+ public getModuleForDisplay = (componentId: string, moduleId: string): ng.IPromise<DisplayModule> => {
let deferred = this.$q.defer<DisplayModule>();
- this.restangular.one(componentId).one("groups").one(moduleId).get().then((response:any) => {
+ this.restangular.one(componentId).one("groups").one(moduleId).get().then((response: any) => {
console.log("module loaded successfully: ", response);
- let module:DisplayModule = new DisplayModule(response);
+ let module: DisplayModule = new DisplayModule(response);
deferred.resolve(module);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to get module with id: ", moduleId);
deferred.reject(err);
});
return deferred.promise;
};
- public getComponentInstanceModule = (componentId:string, componentInstanceId:string, moduleId:string):ng.IPromise<DisplayModule> => {
+ public getComponentInstanceModule = (componentId: string, componentInstanceId: string, moduleId: string): ng.IPromise<DisplayModule> => {
let deferred = this.$q.defer<DisplayModule>();
- this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("groupInstance").one(moduleId).get().then((response:any) => {
+ this.restangular.one(componentId).one("resourceInstance").one(componentInstanceId).one("groupInstance").one(moduleId).get().then((response: any) => {
console.log("module loaded successfully: ", response);
- let module:DisplayModule = new DisplayModule(response);
+ let module: DisplayModule = new DisplayModule(response);
deferred.resolve(module);
- }, (err)=> {
+ }, (err) => {
console.log("Failed to get module with id: ", moduleId);
deferred.reject(err);
});
return deferred.promise;
};
- public getComponentInstancesFilteredByInputsAndProperties = (componentId:
string, searchText?:string):ng.IPromise<Array<ComponentInstance>> => {
+ public getComponentInstancesFilteredByInputsAndProperties = (componentId:
string, searchText?: string): ng.IPromise<Array<ComponentInstance>> => {
let deferred = this.$q.defer<Array<ComponentInstance>>();
- this.restangular.one(componentId).one("componentInstances").get({'searchText': searchText}).then((response:any) => {
+ this.restangular.one(componentId).one("componentInstances").get({ 'searchText': searchText }).then((response: any) => {
console.log("component instances return successfully: ", response);
- let componentInstances:Array<ComponentInstance> = CommonUtils.initComponentInstances(response);
+ let componentInstances: Array<ComponentInstance> = CommonUtils.initComponentInstances(response);
deferred.resolve(componentInstances);
}, (err) => {
console.log("Failed to get component instances of component with id: " + componentId);
return deferred.promise;
};
- public getComponentInstanceInputs = (componentId:
string, instanceId:string, originComponentUid):ng.IPromise<Array<InputModel>> => {
+ public getComponentInstanceInputs = (componentId:
string, instanceId: string, originComponentUid): ng.IPromise<Array<InputModel>> => {
let deferred = this.$q.defer<Array<InputModel>>();
- this.restangular.one(componentId).one("componentInstances").one(instanceId).one(originComponentUid).one("inputs").get().then((response:any) => {
+ this.restangular.one(componentId).one("componentInstances").one(instanceId).one(originComponentUid).one("inputs").get().then((response: any) => {
console.log("component instance input return successfully: ", response);
- let inputsArray:Array<InputModel> = new Array<InputModel>();
- _.forEach(response, (inputObj:InputModel) => {
+ let inputsArray: Array<InputModel> = new Array<InputModel>();
+ _.forEach(response, (inputObj: InputModel) => {
inputsArray.push(new InputModel(inputObj));
});
deferred.resolve(inputsArray);
return deferred.promise;
};
- public getComponentInputs = (componentId:
string):ng.IPromise<Array<InputModel>> => {
+ public getComponentInputs = (componentId:
string): ng.IPromise<Array<InputModel>> => {
let deferred = this.$q.defer<Array<InputModel>>();
- this.restangular.one(componentId).one("inputs").get().then((response:any) => {
+ this.restangular.one(componentId).one("inputs").get().then((response: any) => {
console.log("component inputs return successfully: ", response);
- let inputsArray:Array<InputModel> = new Array<InputModel>();
- _.forEach(response, (inputObj:InputModel) => {
+ let inputsArray: Array<InputModel> = new Array<InputModel>();
+ _.forEach(response, (inputObj: InputModel) => {
inputsArray.push(new InputModel(inputObj));
});
deferred.resolve(inputsArray);
return deferred.promise;
};
- public getComponentInstanceInputProperties = (componentId:
string, instanceId:string, inputId:string):ng.IPromise<Array<PropertyModel>> => {
+ public getComponentInstanceInputProperties = (componentId:
string, instanceId: string, inputId: string): ng.IPromise<Array<PropertyModel>> => {
let deferred = this.$q.defer<Array<PropertyModel>>();
- this.restangular.one(componentId).one("componentInstances").one(instanceId).one(inputId).one("properties").get().then((response:any) => {
+ this.restangular.one(componentId).one("componentInstances").one(instanceId).one(inputId).one("properties").get().then((response: any) => {
console.log("component instance input properties return successfully: ", response);
- let propertiesArray:Array<PropertyModel> = new Array<PropertyModel>();
- _.forEach(response, (propertyObj:PropertyModel) => {
+ let propertiesArray:
Array<PropertyModel> = new Array<PropertyModel>();
+ _.forEach(response, (propertyObj: PropertyModel) => {
propertiesArray.push(new PropertyModel(propertyObj));
});
deferred.resolve(propertiesArray);
};
- public getComponentInstanceProperties = (componentId:
string, instanceId:string):ng.IPromise<Array<PropertyModel>> => {
+ public getComponentInstanceProperties = (componentId:
string, instanceId: string): ng.IPromise<Array<PropertyModel>> => {
let deferred = this.$q.defer<Array<PropertyModel>>();
- this.restangular.one(componentId).one("componentInstances").one(instanceId).one("properties").get().then((response:any) => {
+ this.restangular.one(componentId).one("componentInstances").one(instanceId).one("properties").get().then((response: any) => {
console.log("component instance properties return successfully: ", response);
- let propertiesArray:Array<PropertyModel> = new Array<PropertyModel>();
- _.forEach(response, (propertyObj:PropertyModel) => {
+ let propertiesArray:
Array<PropertyModel> = new Array<PropertyModel>();
+ _.forEach(response, (propertyObj: PropertyModel) => {
propertiesArray.push(new PropertyModel(propertyObj));
});
deferred.resolve(propertiesArray);
return deferred.promise;
};
- public updateGroupMetadata = (componentId:string, group:Module):ng.IPromise<Module> => {
+ public updateGroupMetadata = (componentId: string, group: Module): ng.IPromise<Module> => {
let deferred = this.$q.defer<Module>();
- this.restangular.one(componentId).one("groups").one(group.uniqueId).one("metadata").customPUT(JSON.stringify(group)).then((response:Module) => {
+ this.restangular.one(componentId).one("groups").one(group.uniqueId).one("metadata").customPUT(JSON.stringify(group)).then((response: Module) => {
console.log("group metadata updated successfully: ", response);
- let updatedGroup:Module = new Module(response);
+ let updatedGroup: Module = new Module(response);
deferred.resolve(updatedGroup);
}, (err) => {
return deferred.promise;
};
- public getComponentInputInputsAndProperties = (serviceId:string, inputId:string):ng.IPromise<InputsAndProperties> => {
+ public getComponentInputInputsAndProperties = (serviceId: string, inputId: string): ng.IPromise<InputsAndProperties> => {
let defer = this.$q.defer<InputsAndProperties>();
- this.restangular.one(serviceId).one("inputs").one(inputId).get().then((response:InputsAndProperties) => {
+ this.restangular.one(serviceId).one("inputs").one(inputId).get().then((response: InputsAndProperties) => {
- let inputsArray:Array<InputModel> = new Array<InputModel>();
- _.forEach(response.inputs, (inputObj:InputModel) => {
+ let inputsArray: Array<InputModel> = new Array<InputModel>();
+ _.forEach(response.inputs, (inputObj: InputModel) => {
inputsArray.push(new InputModel(inputObj));
});
- let propertiesArray:Array<PropertyModel> = new Array<PropertyModel>();
- _.forEach(response.properties, (property:PropertyModel) => {
+ let propertiesArray:
Array<PropertyModel> = new Array<PropertyModel>();
+ _.forEach(response.properties, (property: PropertyModel) => {
propertiesArray.push(new PropertyModel(property));
});
defer.resolve(new InputsAndProperties(inputsArray, propertiesArray));
- }, (err)=> {
+ }, (err) => {
console.log("failed to get inputs of input : ", err);
defer.reject(err);
});
return defer.promise;
};
- createInputsFromInstancesInputsProperties = (resourceId:string, instancePropertyMap:InstancesInputsPropertiesMap):ng.IPromise<Array<PropertyModel>> => {
+ public batchDeleteComponentInstance = (componentId: string, componentInstanceIdList: Array<string>): ng.IPromise<any> => {
+ let deferred = this.$q.defer();
+ this.restangular.one(componentId).one("batchDeleteResourceInstances").customPOST(JSON.stringify(componentInstanceIdList)).then((response: any) => {
+ deferred.resolve(response.deleteFailedIds);
+ }, (err) => {
+ console.log("Failed to delete componentInstanceIdList. With IDs: " + componentInstanceIdList);
+ deferred.reject(err);
+ });
+ return deferred.promise;
+ };
+
+ public batchDeleteRelation = (componentId: string, links: Array<RelationshipModel>): ng.IPromise<Array<RelationshipModel>> => {
+ let deferred = this.$q.defer<Array<RelationshipModel>>();
+
+ _.forEach(links, (link: RelationshipModel) => {
+ let linkPayload: RelationshipModel = new RelationshipModel(link);
+ linkPayload.relationships.forEach((rel) => {
+ delete rel.capability;
+ delete rel.requirement;
+ });
+ });
+
+ this.restangular.one(componentId).one("resourceInstance").one("batchDissociate").customPUT(JSON.stringify(links)).then((response: any) => {
+ console.log("Link batch deleted successfully result is ", response);
+ let relationshipModelArray: Array<RelationshipModel> = new Array<RelationshipModel>();
+ _.forEach(response, (relationshipModelObj: RelationshipModel) => {
+ relationshipModelArray.push(new RelationshipModel(relationshipModelObj));
+ });
+ deferred.resolve(relationshipModelArray);
+ //deferred.resolve(response);
+ }, (err) => {
+ console.log("Failed to batch delete links", links);
+ deferred.reject(err);
+ });
+ return deferred.promise;
+ }
+
+ public pasteMenuComponentInstance = (componentId: string, srcComponentId: string, msg: string): ng.IPromise<string> => {
+ let deferred = this.$q.defer<string>();
+ this.restangular.one(componentId).one("copyComponentInstance").one(srcComponentId).customPOST(msg).then((response: any) => {
+ deferred.resolve(response);
+ }, (err) => {
+ deferred.reject(err);
+ });
+ return deferred.promise;
+
+ };
+
+
+
+ createInputsFromInstancesInputsProperties = (resourceId: string, instancePropertyMap: InstancesInputsPropertiesMap): ng.IPromise<Array<PropertyModel>> => {
let defer = this.$q.defer<Array<PropertyModel>>();
- this.restangular.one(resourceId).one("create/properties").customPOST(instancePropertyMap).then((response:any) => {
- let inputsArray:Array<PropertyModel> = new Array<PropertyModel>();
- _.forEach(response, (inputObj:PropertyModel) => {
+ this.restangular.one(resourceId).one("create/properties").customPOST(instancePropertyMap).then((response: any) => {
+ let inputsArray:
Array<PropertyModel> = new Array<PropertyModel>();
+ _.forEach(response, (inputObj: PropertyModel) => {
inputsArray.push(new PropertyModel(inputObj));
});
defer.resolve(inputsArray);
- }, (err)=> {
+ }, (err) => {
console.log("failed to create service inputs from VF instances inputs : ", err);
defer.reject(err);
});
return defer.promise;
};
- createInputsFromInstancesInputs = (serviceId:
string, instancesMap:InstancesInputsPropertiesMap):ng.IPromise<Array<InputModel>> => {
+ createInputsFromInstancesInputs = (serviceId:
string, instancesMap: InstancesInputsPropertiesMap): ng.IPromise<Array<InputModel>> => {
let defer = this.$q.defer<Array<InputModel>>();
- this.restangular.one(serviceId).one("create/inputs").customPOST(instancesMap).then((response:any) => {
- let inputsArray:Array<InputModel> = new Array<InputModel>();
- _.forEach(response, (inputObj:InputModel) => {
+ this.restangular.one(serviceId).one("create/inputs").customPOST(instancesMap).then((response: any) => {
+ let inputsArray: Array<InputModel> = new Array<InputModel>();
+ _.forEach(response, (inputObj: InputModel) => {
inputsArray.push(new InputModel(inputObj));
});
defer.resolve(inputsArray);
- }, (err)=> {
+ }, (err) => {
console.log("failed to create service inputs from VF instances inputs : ", err);
defer.reject(err);
});
return defer.promise;
};
- deleteComponentInput = (serviceId:string, inputId:string):ng.IPromise<InputModel> => {
+ deleteComponentInput = (serviceId: string, inputId: string): ng.IPromise<InputModel> => {
let defer = this.$q.defer<InputModel>();
- this.restangular.one(serviceId).one("delete").one(inputId).one("input").remove().then((response:any) => {
+ this.restangular.one(serviceId).one("delete").one(inputId).one("input").remove().then((response: any) => {
let inputToDelete = new InputModel(response);
defer.resolve(inputToDelete);
- }, (err)=> {
+ }, (err) => {
console.log("failed to delete input from service: ", err);
defer.reject(err);
});
return defer.promise;
};
- private getHeaderMd5 = (object:any):any => {
+ private getHeaderMd5 = (object: any): any => {
let headerObj = {};
// This is ugly workaround!!!
// The md5 result is not correct if we do not add the line JSON.stringify(resource); twice.
JSON.stringify(object);
- let componentString:string = JSON.stringify(object);
+ let componentString: string = JSON.stringify(object);
let md5Result = md5(componentString).toLowerCase();
- headerObj = {'Content-MD5': this.$base64.encode(md5Result)};
+ headerObj = { 'Content-MD5': this.$base64.encode(md5Result) };
return headerObj;
};
Code Review / sdc.git / commitdiff