message: 'Error: Invalid Content. %1 has invalid format.',
messageId: "SVC4723"
}
-#---------SVC4732------------------------------
+#---------SVC4734------------------------------
# %1 - list of validation errors
INVALID_PM_DICTIONARY_FILE: {
code: 400,
message: 'Error: Invalid PM Dictionary File. %1',
- messageId: "SVC4732"
+ messageId: "SVC4734"
+ }
+#-----------SVC4735---------------------------
+ #%1 - input name
+ INPUT_ALREADY_EXIST: {
+ code: 409,
+ message: "Error: Input with '%1' name already exists.",
+ messageId: "SVC4735"
+ }
+#---------SVC4736------------------------------
+ INVALID_INPUT_NAME: {
+ code: 400,
+ message: "Error: Input name contains invalid characters. It should have only letters, numbers and underscores.",
+ messageId: "SVC4736"
}
package org.openecomp.sdc.be.components.impl;
import fj.data.Either;
+import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang.BooleanUtils;
import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.property.PropertyDeclarationOrchestrator;
import org.openecomp.sdc.be.components.validation.ComponentValidations;
+import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.utils.MapUtil;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
+import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstInputsMap;
import org.openecomp.sdc.be.model.ComponentInstListInput;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
+import org.openecomp.sdc.be.resources.data.EntryData;
import org.openecomp.sdc.common.log.elements.LoggerSupportability;
import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions;
import org.openecomp.sdc.common.log.enums.StatusCode;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Optional;
import java.util.stream.Collectors;
-@Component("inputsBusinessLogic")
+@org.springframework.stereotype.Component("inputsBusinessLogic")
public class InputsBusinessLogic extends BaseBusinessLogic {
private static final String CREATE_INPUT = "CreateInput";
}
+ public Either<EntryData<String, InputDefinition>, ResponseFormat> addInputToComponent(String componentId,
+ String inputName,
+ InputDefinition newInputDefinition,
+ String userId) {
+ Either<EntryData<String, InputDefinition>, ResponseFormat> result = null;
+
+ validateUserExists(userId);
+
+ Either<Component, StorageOperationStatus> serviceElement =
+ toscaOperationFacade.getToscaElement(componentId);
+ if (serviceElement.isRight()) {
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, ""));
+ return result;
+ }
+
+ Component component = serviceElement.left().value();
+ NodeTypeEnum nodeType = component.getComponentType().getNodeType();
+
+ StorageOperationStatus lockResult = graphLockOperation.lockComponent(componentId, nodeType);
+ if (!lockResult.equals(StorageOperationStatus.OK)) {
+ BeEcompErrorManager.getInstance()
+ .logBeFailedLockObjectError(CREATE_INPUT, nodeType.name().toLowerCase(), componentId);
+ log.info("Failed to lock component {}. Error - {}", componentId, lockResult);
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+ return result;
+ }
+
+ try {
+ if (!ComponentValidationUtils.canWorkOnComponent(component, userId)) {
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
+ return result;
+ }
+
+ List<InputDefinition> inputs = component.getInputs();
+
+ if (CollectionUtils.isEmpty(inputs)) {
+ inputs = new ArrayList<>();
+ }
+
+ if (isInputExistInComponent(inputs, inputName)) {
+
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus
+ .INPUT_ALREADY_EXIST, inputName));
+ return result;
+ }
+
+ Map<String, DataTypeDefinition> allDataTypes = getAllDataTypes(applicationDataTypeCache);
+
+ // validate input default values
+ Either<Boolean, ResponseFormat> defaultValuesValidation = validatePropertyDefaultValue(
+ newInputDefinition, allDataTypes);
+ if (defaultValuesValidation.isRight()) {
+ result = Either.right(defaultValuesValidation.right().value());
+ return result;
+ }
+
+ // convert Input
+ ToscaPropertyType type = getType(newInputDefinition.getType());
+ if (type != null) {
+ PropertyValueConverter converter = type.getConverter();
+ // get inner type
+ String innerType = null;
+ SchemaDefinition schema = newInputDefinition.getSchema();
+ if (schema != null) {
+ PropertyDataDefinition prop = schema.getProperty();
+ if (prop != null) {
+ innerType = prop.getType();
+ }
+ }
+ if (newInputDefinition.getDefaultValue() != null) {
+ String convertedValue = converter
+ .convert(newInputDefinition.getDefaultValue(), innerType, allDataTypes);
+ newInputDefinition.setDefaultValue(convertedValue);
+ }
+ }
+
+ Either<InputDefinition, StorageOperationStatus> addInputEither =
+ toscaOperationFacade.addInputToComponent(inputName, newInputDefinition, component);
+
+ if (addInputEither.isRight()) {
+ log.info("Failed to add new input {}. Error - {}", componentId,
+ addInputEither.right().value());
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus
+ .GENERAL_ERROR));
+ return result;
+ }
+
+ result = Either.left(new EntryData<>(inputName, newInputDefinition));
+ return result;
+ } finally {
+ commitOrRollback(result);
+ // unlock component
+ graphLockOperation.unlockComponent(componentId, nodeType);
+ }
+ }
+
+ private boolean isInputExistInComponent(List<InputDefinition> inputs, String inputName) {
+ return CollectionUtils.isNotEmpty(inputs) &&
+ inputs.stream().anyMatch(input -> input.getName().equals(inputName));
+ }
+
}
import org.openecomp.sdc.be.model.ComponentInstInputsMap;
import org.openecomp.sdc.be.model.PropertyConstraint;
import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintJacksonDeserializer;
return Either.left(propertyDefinition);
}
+ private Either<InputDefinition, ActionStatus> getInputDefinitionFromJson(String componentId, String inputName, JSONObject value) {
+ String jsonString = value.toJSONString();
+ Either<InputDefinition, ActionStatus> convertJsonToObject = convertJsonToObject(jsonString, InputDefinition.class);
+ if (convertJsonToObject.isRight()) {
+ return Either.right(convertJsonToObject.right().value());
+ }
+ InputDefinition inputDefinition = convertJsonToObject.left().value();
+ String uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, inputName);
+ inputDefinition.setUniqueId(uniqueId);
+
+ return Either.left(inputDefinition);
+ }
+
protected Either<Map<String, PropertyDefinition>, ActionStatus> getPropertiesListForUpdate(String data) {
Map<String, PropertyDefinition> properties = new HashMap<>();
}
-
protected String propertyToJson(Map.Entry<String, PropertyDefinition> property) {
JSONObject root = new JSONObject();
String propertyName = property.getKey();
return getInputBL(context);
}
+
+ protected Either<Map<String, InputDefinition>, ActionStatus> getInputModel(String componentId, String data) {
+ JSONParser parser = new JSONParser();
+ JSONObject root;
+ try {
+ Map<String, InputDefinition> inputs = new HashMap<>();
+ root = (JSONObject) parser.parse(data);
+
+ Set entrySet = root.entrySet();
+ Iterator iterator = entrySet.iterator();
+ while (iterator.hasNext()) {
+ Entry next = (Entry) iterator.next();
+ String inputName = (String) next.getKey();
+
+ if(!isInputNameValid(inputName)) {
+ return Either.right(ActionStatus.INVALID_INPUT_NAME);
+ }
+
+ JSONObject value = (JSONObject) next.getValue();
+ Either<InputDefinition, ActionStatus> inputDefinitionEither =
+ getInputDefinitionFromJson(componentId, inputName, value);
+
+ if(inputDefinitionEither.isRight()) {
+ return Either.right(inputDefinitionEither.right().value());
+ }
+
+ inputs.put(inputName, inputDefinitionEither.left().value());
+ }
+
+ return Either.left(inputs);
+ } catch (ParseException e) {
+ log.warn("Input content is invalid - {}", data, e);
+ return Either.right(ActionStatus.INVALID_CONTENT);
+ }
+ }
+
+ protected boolean isInputNameValid(String inputName) {
+ return Objects.nonNull(inputName)
+ && inputName.matches(PROPERTY_NAME_REGEX);
+
+ }
}
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.resources.data.EntryData;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.common.api.Constants;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
+import java.util.Map;
@Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
@Tags({@Tag(name = "SDC Internal APIs")})
private static final Logger log = Logger.getLogger(InputsServlet.class);
private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(InputsServlet.class.getName());
private static final String START_HANDLE_REQUEST_OF = "(get) Start handle request of {}";
+ private static final String CREATE_INPUT = "CreateInput";
private final DataTypeBusinessLogic businessLogic;
private final InputsBusinessLogic inputsBusinessLogic;
DeclarationTypeEnum.INPUT, request);
}
+ @POST
+ @Path("/{componentType}/{componentId}/create/input")
+ @Operation(description = "Create inputs on service", method = "POST", summary = "Return inputs list", responses = {
+ @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Resource.class)))),
+ @ApiResponse(responseCode = "200", description = "Component found"),
+ @ApiResponse(responseCode = "403", description = "Restricted operation"),
+ @ApiResponse(responseCode = "404", description = "Component not found")})
+ public Response createInput(@PathParam("componentType") final String componentType,
+ @PathParam("componentId") final String componentId, @Context final HttpServletRequest request,
+ @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
+ @Parameter(description = "ComponentIns Inputs Object to be created",
+ required = true) String componentInstInputsMapObj) {
+
+ return createInput(componentId, componentInstInputsMapObj, request, userId);
+ }
/**
* Creates a "list input" and updates given list of properties to get value from the input.
return response;
}
}
+
+ private Response createInput(String componentId, String data, HttpServletRequest request,String userId) {
+ String url = request.getMethod() + " " + request.getRequestURI();
+ log.debug("Start handle request of {} modifier id is {} data is {}", url, userId, data);
+ loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS, StatusCode.STARTED,"CREATE_INPUTS by user {} ", userId);
+
+ try{
+ Either<Map<String, InputDefinition>, ActionStatus> inputDefinition =
+ getInputModel(componentId, data);
+ if (inputDefinition.isRight()) {
+ ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(inputDefinition.right().value());
+ return buildErrorResponse(responseFormat);
+ }
+
+ Map<String, InputDefinition> inputs = inputDefinition.left().value();
+ if (inputs == null || inputs.size() != 1) {
+ log.info("Input content is invalid - {}", data);
+ ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT);
+ return buildErrorResponse(responseFormat);
+ }
+
+ Map.Entry<String, InputDefinition> entry = inputs.entrySet().iterator().next();
+ InputDefinition newInputDefinition = entry.getValue();
+ newInputDefinition.setParentUniqueId(componentId);
+ String inputName = newInputDefinition.getName();
+
+ Either<EntryData<String, InputDefinition>, ResponseFormat> addInputEither =
+ inputsBusinessLogic.addInputToComponent(componentId, inputName, newInputDefinition, userId);
+
+ if(addInputEither.isRight()) {
+ return buildErrorResponse(addInputEither.right().value());
+ }
+
+ loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS, StatusCode.COMPLETE,"CREATE_INPUTS by user {} ", userId);
+ return buildOkResponse(newInputDefinition);
+
+ } catch (Exception e) {
+ BeEcompErrorManager.getInstance().logBeRestApiGeneralError(CREATE_INPUT);
+ log.debug("create input failed with exception", e);
+ ResponseFormat responseFormat =
+ getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR);
+ return buildErrorResponse(responseFormat);
+ }
+ }
}
// Inputs
INPUT_IS_NOT_CHILD_OF_COMPONENT,
CFVC_LOOP_DETECTED,
+ INPUT_ALREADY_EXIST,
+
//Forwarding Path related
FORWARDING_PATH_NAME_MAXIMUM_LENGTH, FORWARDING_PATH_NAME_ALREADY_IN_USE, FORWARDING_PATH_NAME_EMPTY,
FORWARDING_PATH_PROTOCOL_MAXIMUM_LENGTH, FORWARDING_PATH_DESTINATION_PORT_MAXIMUM_LENGTH,
INTERFACE_LIFECYCLE_TYPES_NOT_FOUND,
INVALID_PROPERTY_NAME,
+ INVALID_INPUT_NAME,
//Property Constraints
INVALID_PROPERTY_CONSTRAINTS, INVALID_PROPERTY_CONSTRAINTS_FORMAT, CANNOT_DELETE_VALID_VALUES,
return Either.left(newProperty);
}
+ public Either<InputDefinition, StorageOperationStatus> addInputToComponent(String inputName,
+ InputDefinition newInputDefinition,
+ Component component) {
+ newInputDefinition.setName(inputName);
+
+ StorageOperationStatus status = getToscaElementOperation(component)
+ .addToscaDataToToscaElement(component.getUniqueId(), EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, newInputDefinition, JsonPresentationFields.NAME);
+ if (status != StorageOperationStatus.OK) {
+ CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to add the input {} to the component {}. Status is {}. ", inputName, component.getName(), status);
+ return Either.right(status);
+ }
+
+ ComponentParametersView filter = new ComponentParametersView(true);
+ filter.setIgnoreProperties(false);
+ filter.setIgnoreInputs(false);
+ Either<Component, StorageOperationStatus> getUpdatedComponentRes = getToscaElement(component.getUniqueId(), filter);
+ if (getUpdatedComponentRes.isRight()) {
+ CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get updated component {}. Status is {}. ", component.getUniqueId(), getUpdatedComponentRes.right().value());
+ return Either.right(status);
+ }
+
+ InputDefinition newInput = null;
+ List<InputDefinition> inputs =
+ (getUpdatedComponentRes.left().value()).getInputs();
+ if (CollectionUtils.isNotEmpty(inputs)) {
+ Optional<InputDefinition> inputOptional = inputs.stream().filter(
+ inputEntry -> inputEntry.getName().equals(inputName)).findAny();
+ if (inputOptional.isPresent()) {
+ newInput = inputOptional.get();
+ }
+ }
+ if (newInput == null) {
+ CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find recently added input {} " +
+ "on the component {}. Status is {}. ", inputs, component.getUniqueId(), StorageOperationStatus.NOT_FOUND);
+ return Either.right(StorageOperationStatus.NOT_FOUND);
+ }
+
+ return Either.left(newInput);
+ }
+
public StorageOperationStatus deletePropertyOfComponent(Component component, String propertyName) {
return getToscaElementOperation(component).deleteToscaDataElement(component.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, propertyName, JsonPresentationFields.NAME);
}
return result;
}
-
- public Either<AttributeDataDefinition, StorageOperationStatus> addAttributeOfResource(Component component, AttributeDataDefinition newAttributeDef) {
+ public Either<AttributeDataDefinition, StorageOperationStatus> addAttributeOfResource(Component component, AttributeDataDefinition newAttributeDef) {
Either<Component, StorageOperationStatus> getUpdatedComponentRes = null;
Either<AttributeDataDefinition, StorageOperationStatus> result = null;
<span *ngIf="input.description"
class="property-description-icon sprite-new show-desc"
tooltip="{{input.description}}" tooltipDelay="0"></span>
+ <div class="delete-button-container">
+ <span *ngIf="showDelete" class="sprite-new delete-btn" (click)="openDeleteModal(input)" data-tests-id="delete-input-button"></span>
+ </div>
</div>
<!-- From Instance -->
<div class="table-cell col3">
[testId]="'input-' + input.name"
[constraints] = "getConstraints(input)">
</dynamic-element>
- <div class="delete-button-container">
- <span *ngIf="input.instanceUniqueId && !readonly" class="sprite-new delete-btn" (click)="openDeleteModal(input)" data-tests-id="delete-input-button"></span>
- </div>
</div>
</div>
</div>
// Column: Property Name
&.col1 {
flex: 1 0 130px;
- max-width: 250px;
+ max-width: 300px;
+ display: flex;
justify-content: space-between;
@Input() readonly: boolean;
@Input() isLoading: boolean;
@Input() componentType: string;
-
+ @Input() showDelete:boolean;
@Output() inputChanged: EventEmitter<any> = new EventEmitter<any>();
@Output() deleteInput: EventEmitter<any> = new EventEmitter<any>();
@Input() fePropertiesMap: InstanceFePropertiesMap;
@ViewChildren('metadataViewChildren') public metadataViewChildren: QueryList<DynamicElementComponent>;
-
+
sortBy: String;
reverse: boolean;
selectedInputToDelete: InputFEModel;
var mapKeyError = input.metadataMapKeyError;
if(input.metadataMapKeyError){
dynamicElementComponent.cmpRef.instance.control.setErrors({mapKeyError});
- }
+ }
};
onMetadataValueChanged = (input: InputFEModel, event, metadataEntry: MetadataEntry) => {
input.updateMetadataValue(metadataEntry, event.value);
this.inputChanged.emit(input);
};
-
-
+
+
createNewMetadataEntry = (input: InputFEModel): void => {
let metadataEntry = new MetadataEntry("", "");
input.addMetadataEntry(metadataEntry);
input.deleteMetadataEntry(metadataEntry);
this.inputChanged.emit(input);
}
-
+
onDeleteInput = () => {
this.deleteInput.emit(this.selectedInputToDelete);
this.modalService.closeCurrentModal();
<inputs-table class="properties-table"
[fePropertiesMap]="instanceFePropertiesMap"
[readonly]="isReadonly"
+ [showDelete]="!isReadOnly && isSelf()"
[inputs]="inputs | searchFilter:'name':searchQuery"
[instanceNamesMap]="componentInstanceNamesMap"
[isLoading]="loadingInputs"
</div>
</div>
<div class="right-column">
- <div *ngIf="!isReadonly" class="add-btn"
+ <div *ngIf="!isReadonly && !isInputsTabSelected" class="add-btn"
(click)="addProperty()" [ngClass]="{'disabled': !isSelf()}">Add Property</div>
+ <div *ngIf="!isReadonly && isInputsTabSelected" class="add-btn"
+ (click)="addInput()" [ngClass]="{'disabled': !isSelf()}">Add Input</div>
<tabs #hierarchyNavTabs tabStyle="simple-tabs" class="gray-border">
<tab tabTitle="Composition">
<div class="hierarchy-nav-container">
modal.instance.open();
}
+ /*** addInput ***/
+ addInput = () => {
+ let modalTitle = 'Add Input';
+ let modal = this.ModalService.createCustomModal(new ModalModel(
+ 'sm',
+ modalTitle,
+ null,
+ [
+ new ButtonModel('Save', 'blue', () => {
+ modal.instance.dynamicContent.instance.isLoading = true;
+ const newInput: InputBEModel = modal.instance.dynamicContent.instance.propertyModel;
+ this.topologyTemplateService.createServiceInput(this.component.uniqueId, newInput)
+ .subscribe((response) => {
+ modal.instance.dynamicContent.instance.isLoading = false;
+ const newInputProp: InputFEModel = this.inputsUtils.convertInputBEToInputFE(response);
+ this.inputs.push(newInputProp);
+ modal.instance.close();
+ }, (error) => {
+ modal.instance.dynamicContent.instance.isLoading = false;
+ this.Notification.error({
+ message: 'Failed to add input:' + error,
+ title: 'Failure'
+ });
+ });
+ }, () => !modal.instance.dynamicContent.instance.checkFormValidForSubmit()),
+ new ButtonModel('Cancel', 'outline grey', () => {
+ modal.instance.close();
+ }),
+ ],
+ null
+ ));
+ this.ModalService.addDynamicContentToModal(modal, PropertyCreatorComponent, {});
+ modal.instance.open();
+ }
+
/*** SEARCH RELATED FUNCTIONS ***/
searchPropertiesInstances = (filterData:FilterPropertiesAssignmentData) => {
let instanceBePropertiesMap:InstanceBePropertiesMap;
*/
import { Injectable } from '@angular/core';
-import { InputFEModel} from "app/models";
+import { InputBEModel, InputFEModel } from "app/models";
+import { DataTypeService } from "app/ng2/services/data-type.service";
@Injectable()
export class InputsUtils {
- constructor() {}
+ constructor(private dataTypeService:DataTypeService) {}
public initDefaultValueObject = (input: InputFEModel): void => {
input.resetDefaultValueObjValidation();
this.initDefaultValueObject(input);
}
+ public convertInputBEToInputFE = (input: InputBEModel): InputFEModel => {
+ const newFEInput: InputFEModel = new InputFEModel(input); //Convert input to FE
+ this.initDefaultValueObject(newFEInput);
+ return newFEInput;
+ }
+
}
});
}
+ createServiceInput(componentId: string, inputModel: InputBEModel): Observable<InputBEModel> {
+ const serverObject = {};
+ serverObject[inputModel.name] = inputModel;
+ return this.http.post<InputBEModel>(this.baseUrl + 'services/' + componentId + '/create/input', serverObject)
+ .map((res) => {
+ const input: InputBEModel = new InputBEModel(res);
+ return input;
+ });
+ }
+
getDependencies(componentType: string, componentId: string): Observable<IDependenciesServerResponse[]> {
return this.http.get<IDependenciesServerResponse[]>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/dependencies');
}
Code Review / sdc.git / commitdiff