new ArtifactOperationInfo(false, false, ArtifactOperationEnum.DOWNLOAD), artifactId, null, null, null, null, null, parentId,
containerComponentType);
ArtifactDefinition artifactDefinition;
- Either<ArtifactDefinition, Operation> insideValue = result;
- if (insideValue.isLeft()) {
- artifactDefinition = insideValue.left().value();
+ if (result.isLeft()) {
+ artifactDefinition = result.left().value();
} else {
- artifactDefinition = insideValue.right().value().getImplementationArtifact();
+ artifactDefinition = result.right().value().getImplementationArtifact();
}
// for tosca artifacts and heat env on VF level generated on download without saving
if (artifactDefinition.getPayloadData() != null) {
*/
package org.openecomp.sdc.be.tosca;
+import static org.openecomp.sdc.be.dao.api.ActionStatus.ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION;
+import static org.openecomp.sdc.be.dao.api.ActionStatus.ERROR_DURING_CSAR_CREATION;
import static org.openecomp.sdc.be.tosca.ComponentCache.MergeStrategy.overwriteIfSameVersions;
import static org.openecomp.sdc.be.tosca.FJToVavrHelper.Try0.fromEither;
import org.springframework.beans.factory.annotation.Autowired;
import org.yaml.snakeyaml.Yaml;
-/**
- * @author tg851x
- */
@org.springframework.stereotype.Component("csar-utils")
public class CsarUtils {
return matcher.group(0);
}
-
private static <L, R> F<L, Either<L, R>> iff(Predicate<L> p, Function<L, Either<L, R>> ifTrue) {
return l -> p.test(l) ? ifTrue.apply(l) : Either.left(l);
}
String cassandraId = d.getMiddle();
Component childComponent = d.getRight();
Either<byte[], ResponseFormat> entryData = getEntryData(cassandraId, childComponent).right()
- .map(x -> componentsUtils.getResponseFormat(x));
+ .map(componentsUtils::getResponseFormat);
if (entryData.isRight()) {
return Either.right(entryData.right().value());
}
}
private Either<byte[], ResponseFormat> getLatestSchemaFilesFromCassandra() {
- String fto = getVersionFirstThreeOctets();
+ String fto = versionFirstThreeOctets;
return sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(fto, CONFORMANCE_LEVEL).right().map(schemaFilesFetchDBError(fto)).left()
.bind(iff(List::isEmpty, () -> schemaFileFetchError(fto), s -> Either.left(s.iterator().next().getPayloadAsArray())));
}
return Either.right(componentsUtils.getResponseFormat(ActionStatus.TOSCA_SCHEMA_FILES_NOT_FOUND, firstThreeOctets, CONFORMANCE_LEVEL));
}
- private Either<byte[], ActionStatus> getFromCassandra(String cassandraId) {
+ private Either<byte[], ActionStatus> getFromCassandra(String cassandraId) {
return artifactCassandraDao.getArtifact(cassandraId).right().map(operationstatus -> {
- log.info("Failed to fetch artifact from Cassandra by id {} error {}.", cassandraId, operationstatus);
+ log.info("Failed to fetch artifact from Cassandra by id {} error {}.", cassandraId, operationstatus);
StorageOperationStatus storageStatus = DaoStatusConverter.convertCassandraStatusToStorageStatus(operationstatus);
return componentsUtils.convertFromStorageResponse(storageStatus);
}).left().map(DAOArtifactData::getDataAsArray);
private String createNsMfBlock0(String serviceName, String createdBy, String serviceVersion, String releaseTime, String serviceType,
String description, String serviceTemplate, String hash) {
final String block0template = "metadata??\n" + "ns_product_name: %s\n" + "ns_provider_id: %s\n" + "ns_package_version: %s\n" +
- //"ns_create_date_time: %s\n" +
"ns_release_data_time: %s\n" + "ns_type: %s\n" + "ns_package_description: %s\n\n" + "Source: %s\n" + "Algorithm: MD5\n" + "Hash: %s\n\n";
return String.format(block0template, serviceName, createdBy, serviceVersion, releaseTime, serviceType, description, serviceTemplate, hash);
}
return Either.right(writeComponentArtifactsToSpecifiedPath.right().value());
}
Map<String, ArtifactsInfo> componentInstancesArtifacts = mainTypeAndCIArtifacts.getComponentInstancesArtifacts();
- Set<String> keySet = componentInstancesArtifacts.keySet();
String currentPath = ARTIFACTS_PATH + RESOURCES_PATH;
- for (String keyAssetName : keySet) {
+ for (String keyAssetName : componentInstancesArtifacts.keySet()) {
ArtifactsInfo artifactsInfo = componentInstancesArtifacts.get(keyAssetName);
String pathWithAssetName = currentPath + keyAssetName + PATH_DELIMITER;
writeComponentArtifactsToSpecifiedPath = writeArtifactsInfoToSpecifiedPath(mainComponent, artifactsInfo, zipstream, pathWithAssetName,
if (checkComponentBeforeOperation(component)) {
return Either.left(zipstream);
}
- final Map<String, InterfaceDefinition> interfaces = ((Resource) component).getInterfaces();
- for (Map.Entry<String, InterfaceDefinition> interfaceEntry : interfaces.entrySet()) {
+ for (Map.Entry<String, InterfaceDefinition> interfaceEntry : ((Resource) component).getInterfaces().entrySet()) {
for (OperationDataDefinition operation : interfaceEntry.getValue().getOperations().values()) {
try {
if (checkComponentBeforeWrite(component, interfaceEntry, operation)) {
if (artifactFromCassandra.isRight()) {
log.error(ARTIFACT_NAME_UNIQUE_ID, artifactName, artifactUUID);
log.error("Failed to get {} payload from DB reason: {}", artifactName, artifactFromCassandra.right().value());
- return Either.right(componentsUtils
- .getResponseFormat(ActionStatus.ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, "Resource", component.getUniqueId(),
- artifactName, artifactUUID));
+ return Either.right(componentsUtils.getResponseFormat(
+ ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, "Resource", component.getUniqueId(), artifactName, artifactUUID));
}
- final byte[] payloadData = artifactFromCassandra.left().value();
zipstream.putNextEntry(new ZipEntry(OperationArtifactUtil.createOperationArtifactPath(component, null, operation, true)));
- zipstream.write(payloadData);
+ zipstream.write(artifactFromCassandra.left().value());
} catch (IOException e) {
log.error("Component Name {}, Interface Name {}, Operation Name {}", component.getNormalizedName(), interfaceEntry.getKey(),
operation.getName());
- log.error("Error while writing the operation's artifacts to the CSAR " + "{}", e);
- return Either
- .right(componentsUtils.getResponseFormat(ActionStatus.ERROR_DURING_CSAR_CREATION, "Resource", component.getUniqueId()));
+ log.error("Error while writing the operation's artifacts to the CSAR", e);
+ return Either.right(componentsUtils.getResponseFormat(ERROR_DURING_CSAR_CREATION, "Resource", component.getUniqueId()));
}
}
}
return result.toString();
}
- private ComponentTypeArtifacts collectComponentTypeArtifacts(
- Component fetchedComponent
- ) {
+ private ComponentTypeArtifacts collectComponentTypeArtifacts(Component fetchedComponent) {
ArtifactsInfo componentArtifacts = collectComponentArtifacts(fetchedComponent);
ComponentTypeArtifacts componentArtifactsInfo = new ComponentTypeArtifacts();
if (componentArtifacts.isNotEmpty()) {
return Either.left(true);
}
- public String getVersionFirstThreeOctets() {
- return versionFirstThreeOctets;
- }
-
private Map<String, List<ArtifactDefinition>> getComponentInstanceSpecificArtifacts(Map<String, ArtifactDefinition> componentArtifacts,
Map<ArtifactGroupTypeEnum, Map<String, List<ArtifactDefinition>>> componentTypeArtifacts,
ArtifactGroupTypeEnum artifactGroupTypeEnum) {
Map<String, List<ArtifactDefinition>> informationalArtifactsByType = collectGroupArtifacts(informationalArtifacts);
Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
Map<String, List<ArtifactDefinition>> deploymentArtifactsByType = collectGroupArtifacts(deploymentArtifacts);
- Map<String, ArtifactDefinition> interfaceOperationArtifacts =
- OperationArtifactUtil.getDistinctInterfaceOperationArtifactsByName(component);
- Map<String, List<ArtifactDefinition>> interfaceOperationArtifactsByType = collectGroupArtifacts(
- interfaceOperationArtifacts);
ArtifactsInfo artifactsInfo = new ArtifactsInfo();
if (!informationalArtifactsByType.isEmpty()) {
artifactsInfo.addArtifactsToGroup(ArtifactGroupTypeEnum.INFORMATIONAL, informationalArtifactsByType);
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
return toscaResourceName.substring(toscaResourceName.lastIndexOf(DOT) + 1);
}
- private static boolean isArtifactPresent(final OperationDataDefinition operationDataDefinition) {
- return operationDataDefinition.getImplementation() != null && operationDataDefinition.getImplementation().getArtifactName() != null;
+ private boolean isArtifactPresent(final OperationDataDefinition operationDataDefinition) {
+ return operationDataDefinition.getImplementation() != null
+ && StringUtils.isNotEmpty(operationDataDefinition.getImplementation().getArtifactName());
}
private static String getInputValue(final OperationInputDefinition input) {
- String inputValue = input.getValue() == null ? input.getToscaDefaultValue(): input.getValue();
+ String inputValue = input.getValue() == null ? input.getToscaDefaultValue() : input.getValue();
if (inputValue != null && inputValue.contains(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) {
Gson gson = new Gson();
Map<String, List<String>> consumptionValue = gson.fromJson(inputValue, Map.class);
}
private Map<String, Object> getInterfacesMap(Component component, Map<String, DataTypeDefinition> dataTypes, boolean isAssociatedComponent) {
- return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent, false);
+ return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent);
}
public Map<String, Object> getInterfacesMap(final Component component, final ComponentInstance componentInstance,
final Map<String, InterfaceDefinition> interfaces, final Map<String, DataTypeDefinition> dataTypes,
- final boolean isAssociatedComponent, final boolean isServiceProxyInterface) {
+ final boolean isAssociatedComponent) {
if (MapUtils.isEmpty(interfaces)) {
return null;
}
final Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
- handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent, isServiceProxyInterface,
+ handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent,
toscaInterfaceDefinitions, interfaceDefinition);
}
return toscaInterfaceDefinitions;
public Map<String, Object> getInterfacesMapFromComponentInstance(final Component component, final ComponentInstance componentInstance,
final Map<String, DataTypeDefinition> dataTypes,
- final boolean isAssociatedComponent, final boolean isServiceProxyInterface) {
+ final boolean isAssociatedComponent) {
final Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
for (final Map.Entry<String, Object> interfaceEntry : componentInstance.getInterfaces().entrySet()) {
final InterfaceDefinition interfaceDefinition = objectMapper.convertValue(interfaceEntry.getValue(), InterfaceDefinition.class);
- handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent, isServiceProxyInterface,
+ handleInterfaceOperations(component, componentInstance, dataTypes, isAssociatedComponent,
toscaInterfaceDefinitions, interfaceDefinition);
}
return toscaInterfaceDefinitions;
private void handleInterfaceOperations(final Component component, final ComponentInstance componentInstance,
final Map<String, DataTypeDefinition> dataTypes, final boolean isAssociatedComponent,
- final boolean isServiceProxyInterface, final Map<String, Object> toscaInterfaceDefinitions,
+ final Map<String, Object> toscaInterfaceDefinitions,
final InterfaceDefinition interfaceDefinition) {
final String interfaceType;
if (componentInstance != null && LOCAL_INTERFACE_TYPE.equals(interfaceDefinition.getType())) {
}
toscaInterfaceDefinition.setOperations(toscaOperationMap);
final Map<String, Object> interfaceInputMap = createInterfaceInputMap(interfaceDefinition, dataTypes);
- if (!interfaceInputMap.isEmpty()) {
+ if (MapUtils.isNotEmpty(interfaceInputMap)) {
toscaInterfaceDefinition.setInputs(interfaceInputMap);
}
final Map<String, Object> interfaceDefinitionAsMap = getObjectAsMap(toscaInterfaceDefinition);
final OperationDataDefinition operationDataDefinition,
final ToscaLifecycleOperationDefinition toscaOperation,
final Map<String, DataTypeDefinition> dataTypes) {
- if (operationDataDefinition.getImplementation() == null) {
+ final ArtifactDataDefinition implementation = operationDataDefinition.getImplementation();
+ if (implementation == null) {
return;
}
- final String operationArtifactPath;
- final ToscaInterfaceOperationImplementation toscaInterfaceOperationImplementation = new ToscaInterfaceOperationImplementation();
- toscaInterfaceOperationImplementation.setPrimary(new ToscaArtifactDefinition());
- final ToscaArtifactDefinition toscaArtifactDefinition = toscaInterfaceOperationImplementation.getPrimary();
- if (isArtifactPresent(operationDataDefinition) && StringUtils.isNotEmpty(operationDataDefinition.getImplementation().getArtifactName())) {
- operationArtifactPath = OperationArtifactUtil
- .createOperationArtifactPath(component, componentInstance, operationDataDefinition, isAssociatedComponent);
- toscaArtifactDefinition.setFile(operationArtifactPath);
- toscaArtifactDefinition.setArtifact_version(!operationDataDefinition.getImplementation().getArtifactVersion()
- .equals(NumberUtils.INTEGER_ZERO.toString()) ? operationDataDefinition.getImplementation().getArtifactVersion() : null);
- toscaArtifactDefinition.setType(operationDataDefinition.getImplementation().getArtifactType());
- final Map<String, ToscaPropertyAssignment> propertiesMap = handleImplementationProperties(operationDataDefinition, dataTypes);
- if (!propertiesMap.isEmpty()) {
- toscaArtifactDefinition.setProperties(propertiesMap);
+
+ if (isArtifactPresent(operationDataDefinition)) {
+ final String operationArtifactPath =
+ OperationArtifactUtil.createOperationArtifactPath(component, componentInstance, operationDataDefinition, isAssociatedComponent);
+ if (implementation.getArtifactType() != null) {
+ final ToscaArtifactDefinition toscaArtifactDefinition = new ToscaArtifactDefinition();
+ toscaArtifactDefinition.setFile(operationArtifactPath);
+ final String artifactVersion = implementation.getArtifactVersion();
+ toscaArtifactDefinition.setArtifact_version(!artifactVersion.equals(NumberUtils.INTEGER_ZERO.toString()) ? artifactVersion : null);
+ toscaArtifactDefinition.setType(implementation.getArtifactType());
+ final Map<String, ToscaPropertyAssignment> propertiesMap = handleImplementationProperties(operationDataDefinition, dataTypes);
+ if (MapUtils.isNotEmpty(propertiesMap)) {
+ toscaArtifactDefinition.setProperties(propertiesMap);
+ }
+ final ToscaInterfaceOperationImplementation toscaInterfaceOperationImplementation = new ToscaInterfaceOperationImplementation();
+ toscaInterfaceOperationImplementation.setPrimary(toscaArtifactDefinition);
+ toscaOperation.setImplementation(toscaInterfaceOperationImplementation);
+ } else {
+ toscaOperation.setImplementation(
+ StringUtils.isBlank(operationArtifactPath) || "null".equals(operationArtifactPath) ? null : operationArtifactPath);
}
- toscaOperation.setImplementation(
- toscaArtifactDefinition.getType() != null ? toscaInterfaceOperationImplementation : operationArtifactPath);
- } else {
- toscaArtifactDefinition.setFile(operationDataDefinition.getImplementation().getArtifactName());
- toscaOperation.setImplementation(toscaInterfaceOperationImplementation);
}
}
return intValue == null ? value : intValue;
}
- private void handleInstanceInterfaces(
- Map<String, List<ComponentInstanceInterface>> componentInstanceInterfaces,
- ComponentInstance componentInstance, Map<String, DataTypeDefinition> dataTypes, ToscaNodeTemplate nodeTemplate,
- String instanceUniqueId,
- Component parentComponent) {
-
- if (MapUtils.isEmpty(componentInstanceInterfaces)
- || !componentInstanceInterfaces.containsKey(instanceUniqueId)) {
+ private void handleInstanceInterfaces(Map<String, List<ComponentInstanceInterface>> componentInstanceInterfaces,
+ ComponentInstance componentInstance, Map<String, DataTypeDefinition> dataTypes,
+ ToscaNodeTemplate nodeTemplate, String instanceUniqueId, Component parentComponent) {
+
+ if (MapUtils.isEmpty(componentInstanceInterfaces) || !componentInstanceInterfaces.containsKey(instanceUniqueId)) {
nodeTemplate.setInterfaces(null);
return;
}
- final List<ComponentInstanceInterface> currServiceInterfaces =
- componentInstanceInterfaces.get(instanceUniqueId);
+ final List<ComponentInstanceInterface> currServiceInterfaces = componentInstanceInterfaces.get(instanceUniqueId);
final Map<String, InterfaceDefinition> tmpInterfaces = new HashMap<>();
- currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface
- .getUniqueId(), instInterface));
+ currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface.getUniqueId(), instInterface));
final Map<String, Object> interfaceMap = interfacesOperationsConverter
- .getInterfacesMap(parentComponent, componentInstance, tmpInterfaces, dataTypes, isComponentOfTypeServiceProxy(componentInstance),
- isComponentOfTypeServiceProxy(componentInstance));
+ .getInterfacesMap(parentComponent, componentInstance, tmpInterfaces, dataTypes, isComponentOfTypeServiceProxy(componentInstance));
interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
nodeTemplate.setInterfaces(MapUtils.isEmpty(interfaceMap) ? null : interfaceMap);
interfaceMap = proxyInterfaces.get();
}
} else {
- interfaceMap = interfacesOperationsConverter
- .getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false, false);
+ interfaceMap = interfacesOperationsConverter.getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false);
}
interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
// always available in the proxy node template
removeOperationImplementationForProxyNodeType(proxyComponentInterfaces);
- return Optional
- .ofNullable(interfacesOperationsConverter.getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes, false, false));
+ return Optional.ofNullable(interfacesOperationsConverter.getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes, false));
}
private static class CustomRepresenter extends Representer {
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
- final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false, true);
+ final var interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false);
assertNotNull(interfacesMap);
assertEquals(1, interfacesMap.size());
assertTrue(interfacesMap.containsKey("resourceName"));
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceName, interfaceDefinition);
//when
- Map<String, Object> interfacesMap = interfacesOperationsConverter
- .getInterfacesMap(component, null, component.getInterfaces(), null, false, true);
+ Map<String, Object> interfacesMap = interfacesOperationsConverter.getInterfacesMap(component, null, component.getInterfaces(), null, false);
//then
assertTrue(interfacesMap.containsKey(interfaceName));
final Map<String, Object> actualInterfaceMap = (Map<String, Object>) interfacesMap.get(interfaceName);
service.setInterfaces(Collections.singletonMap("NotLocal", new InterfaceDefinition("NotLocal", null,
new HashMap<>())));
- Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null,
- service.getInterfaces(), null, false, false);
+ Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null, service.getInterfaces(), null, false);
assertTrue(MapUtils.isNotEmpty(resultMap)
&& resultMap.containsKey("NotLocal"));
void setUpMock() {
MockitoAnnotations.openMocks(this);
doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
- doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter)
- .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean());
+ doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter).getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean());
}
private Resource getNewResource() {
* <p>
* Jackson DeSerialization workaround constructor to create an operation with no arguments.
* </p>
- *
- * @param emptyString The empty string provided by jackson.
*/
public Operation() {
super();
+++ /dev/null
-/*
- * Copyright © 2016-2018 European Support Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.openecomp.sdc.be.model;
-
-import java.util.Map;
-import java.util.Objects;
-import org.openecomp.sdc.be.datatypes.elements.OperationImplementation;
-
-public class OperationInstance/* extends Operation*/ {
-
- private OperationImplementation implementation;
- private Map<String, Object> inputs;
-
-
- public OperationImplementation getImplementation() {
- return implementation;
- }
-
- public void setImplementation(OperationImplementation implementation) {
- this.implementation = implementation;
- }
-
- public Map<String, Object> getInputs() {
- return inputs;
- }
-
- public void setInputs(Map<String, Object> inputs) {
- this.inputs = inputs;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (!(o instanceof OperationInstance)) {
- return false;
- }
- OperationInstance that = (OperationInstance) o;
- return Objects.equals(implementation, that.implementation) &&
- Objects.equals(inputs, that.inputs);
- }
-
- @Override
- public int hashCode() {
-
- return Objects.hash(implementation, inputs);
- }
-}
-
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2019 Nokia. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-package org.openecomp.sdc.be.model;
-
-import static com.google.code.beanmatchers.BeanMatchers.hasValidBeanEquals;
-import static com.google.code.beanmatchers.BeanMatchers.hasValidGettersAndSetters;
-import static org.junit.Assert.assertThat;
-
-import org.junit.Test;
-
-public class OperationInstanceTest {
- @Test
- public void shouldHaveValidGettersAndSetters() {
- assertThat(OperationInstance.class, hasValidGettersAndSetters());
- assertThat(OperationInstance.class, hasValidBeanEquals());
- }
-}
\ No newline at end of file
package org.openecomp.sdc.be.datatypes.elements;
-import java.util.HashSet;
import java.util.List;
-import java.util.Objects;
+import lombok.Data;
+@Data
public class OperationImplementation {
private String primary;
private List<String> dependencies;
- public String getPrimary() {
- return primary;
- }
-
- public void setPrimary(String primary) {
- this.primary = primary;
- }
-
- public List<String> getDependencies() {
- return dependencies;
- }
-
- public void setDependencies(List<String> dependencies) {
- this.dependencies = dependencies;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (!(o instanceof OperationImplementation)) {
- return false;
- }
- OperationImplementation that = (OperationImplementation) o;
- return Objects.equals(primary, that.primary)
- && Objects.equals(new HashSet<>(dependencies), new HashSet<>(that.dependencies));
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(primary, dependencies);
- }
}
package org.openecomp.sdc.be.datatypes.elements;
import java.util.Map;
-import java.util.Objects;
+import lombok.Data;
+
+@Data
+public class OperationInstance {
-public class OperationInstance/* extends Operation*/ {
private OperationImplementation implementation;
private Map<String, Object> inputs;
-
- public OperationImplementation getImplementation() {
- return implementation;
- }
-
- public void setImplementation(OperationImplementation implementation) {
- this.implementation = implementation;
- }
-
- public Map<String, Object> getInputs() {
- return inputs;
- }
-
- public void setInputs(Map<String, Object> inputs) {
- this.inputs = inputs;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (!(o instanceof OperationInstance)) {
- return false;
- }
- OperationInstance that = (OperationInstance) o;
- return Objects.equals(implementation, that.implementation)
- && Objects.equals(inputs, that.inputs);
- }
-
- @Override
- public int hashCode() {
-
- return Objects.hash(implementation, inputs);
- }
}
Code Review / sdc.git / commitdiff