* See the License for the specific language governing permissions and
* limitations under the License.
* ============LICENSE_END=========================================================
+ * Modifications copyright (c) 2019 Nokia
+ * ================================================================================
*/
package org.openecomp.sdc.be.components.impl;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-
+import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
import org.openecomp.sdc.be.model.Resource;
-import org.openecomp.sdc.exception.ResponseFormat;
+import org.openecomp.sdc.common.log.wrappers.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
-import fj.data.Either;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
/**
* This class holds the logic of arranging resource instance on the canvas for imported VF
*/
@Component("compositionBusinessLogic")
public class CompositionBusinessLogic {
- @Autowired
- private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
-
+ private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
+ private static final Logger log = Logger.getLogger(CompositionBusinessLogic.class.getName());
private static final int VFC_CANVAS_ELEMENT_SIZE = 50;
private static final int CP_CANVAS_ELEMENT_SIZE = 21;
private static final int CANVAS_WIDTH = 1000;
private static final int SPACE_BETWEEN_ELEMENTS = VFC_CANVAS_ELEMENT_SIZE * 4;
private static final double CP_RADIUS_FACTOR = 0.4;
+ @Autowired
+ public CompositionBusinessLogic(ComponentInstanceBusinessLogic componentInstanceBusinessLogic) {
+ this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
+ }
+
enum RelativePosition {
LEFT, RIGHT, UP, DOWN
};
- protected Either<List<ComponentInstance>, ResponseFormat> setPositionsForComponentInstances(Resource resource, String userId) {
- Either<List<ComponentInstance>, ResponseFormat> result = Either.left(resource.getComponentInstances());
-
+ protected void setPositionsForComponentInstances(Resource resource, String userId) {
boolean isNotAllPositionsCalculated = resource.getComponentInstances() == null
- || resource.getComponentInstances().stream().filter(p -> (p.getPosX() == null || p.getPosX().isEmpty()) || (p.getPosY() == null || p.getPosY().isEmpty())).findAny().isPresent();
-
+ || resource.getComponentInstances().stream().anyMatch(p -> (p.getPosX() == null || p.getPosX().isEmpty()) || (p.getPosY() == null || p.getPosY().isEmpty()));
if (isNotAllPositionsCalculated && resource.getComponentInstances() != null) {
// Arrange Icons In Spiral Pattern
Map<ImmutablePair<Double, Double>, ComponentInstance> componentInstanceLocations = buildSpiralPatternPositioningForComponentInstances(resource);
-
// Set Relative Locations According to Canvas Size
- componentInstanceLocations.entrySet().stream().forEach(e -> setRelativePosition(e));
-
+ componentInstanceLocations.entrySet().forEach(this::setRelativePosition);
// Update in DB
- result = componentInstanceBusinessLogic.updateComponentInstance(ComponentTypeEnum.RESOURCE_PARAM_NAME, resource.getUniqueId(), userId, resource.getComponentInstances(), false, false);
-
+ componentInstanceBusinessLogic.updateComponentInstance(ComponentTypeEnum.RESOURCE_PARAM_NAME,resource, resource.getUniqueId(),
+ userId, resource.getComponentInstances(), false);
}
- return result;
-
}
private void setRelativePosition(Entry<ImmutablePair<Double, Double>, ComponentInstance> entry) {
double offsetedCanvasPosition;
switch (componentInstance.getOriginType()) {
case CP:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.CP_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.CP_CANVAS_ELEMENT_SIZE / 2.0;
break;
case VL:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.CP_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.CP_CANVAS_ELEMENT_SIZE / 2.0;
break;
case VF:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2.0;
break;
case VFC:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2.0;
break;
case VFCMT:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2.0;
break;
default:
- offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2;
+ offsetedCanvasPosition = topLeftCanvasPosition - CompositionBusinessLogic.VFC_CANVAS_ELEMENT_SIZE / 2.0;
break;
}
return String.valueOf(offsetedCanvasPosition);
componentInstances.addAll(resource.getComponentInstances());
Map<ComponentInstance, List<ComponentInstance>> connectededCps = getCpsConnectedToVFC(componentInstances, resource);
// Remove all cp that are connected from the list
- componentInstances.removeAll(connectededCps.values().stream().flatMap(e -> e.stream()).collect(Collectors.toList()));
+ componentInstances.removeAll(connectededCps.values().stream().flatMap(Collection::stream).collect(Collectors.toList()));
buildSpiralPatternForMajorComponents(componentInstanceLocations, componentInstances);
buildCirclePatternForCps(componentInstanceLocations, connectededCps);
for (ComponentInstance currCp : cpsGroup) {
double cpXposition = xCenter + CompositionBusinessLogic.CP_RADIUS_FACTOR * Math.cos(currentAngle);
double cpYposition = yCenter + CompositionBusinessLogic.CP_RADIUS_FACTOR * Math.sin(currentAngle);
- componentInstLocations.put(new ImmutablePair<Double, Double>(cpXposition, cpYposition), currCp);
+ componentInstLocations.put(new ImmutablePair<>(cpXposition, cpYposition), currCp);
currentAngle += angleBetweenCps;
}
for (ComponentInstance curr : componentInstances) {
elementsCounter++;
if (elementsCounter == 1) {
- currPlacement = new ImmutablePair<Double, Double>(0D, 0D);
+ currPlacement = new ImmutablePair<>(0D, 0D);
} else if (elementsCounter == 2) {
- currPlacement = new ImmutablePair<Double, Double>(-1D, 0D);
+ currPlacement = new ImmutablePair<>(-1D, 0D);
relationToPrevElement = RelativePosition.LEFT;
} else {
relationToPrevElement = getRelativePositionForCurrentElement(componentInstanceLocations, relationToPrevElement, prevPlacement);
switch (relativeLocation) {
case LEFT: {
- relativeElementPosition = new ImmutablePair<Double, Double>(currElement.getLeft() - 1, currElement.getRight());
+ relativeElementPosition = new ImmutablePair<>(currElement.getLeft() - 1, currElement.getRight());
break;
}
case RIGHT: {
- relativeElementPosition = new ImmutablePair<Double, Double>(currElement.getLeft() + 1, currElement.getRight());
+ relativeElementPosition = new ImmutablePair<>(currElement.getLeft() + 1, currElement.getRight());
break;
}
case UP: {
- relativeElementPosition = new ImmutablePair<Double, Double>(currElement.getLeft(), currElement.getRight() + 1);
+ relativeElementPosition = new ImmutablePair<>(currElement.getLeft(), currElement.getRight() + 1);
break;
}
case DOWN: {
- relativeElementPosition = new ImmutablePair<Double, Double>(currElement.getLeft(), currElement.getRight() - 1);
+ relativeElementPosition = new ImmutablePair<>(currElement.getLeft(), currElement.getRight() - 1);
break;
}
default: {
}
return relativeElementPosition;
}
+ protected void validateAndSetDefaultCoordinates(ComponentInstance resourceInstance) {
+ int xCenter = CANVAS_WIDTH / 2;
+ int yCenter = CANVAS_HEIGHT / 2;
+ double leftLimit = -10D;
+ double rightLimit = -1D;
+ double generatedDouble = leftLimit + new SecureRandom().nextDouble() * (rightLimit - leftLimit);
+
+ if (StringUtils.isEmpty(resourceInstance.getPosX())|| StringUtils.isEmpty(resourceInstance.getPosY())){
+ resourceInstance.setPosX(calculateCompositionPosition(xCenter, generatedDouble, resourceInstance));
+ resourceInstance.setPosY(calculateCompositionPosition(yCenter, generatedDouble, resourceInstance));
+ log.debug("Missing Failed PosX/PosY values. new values generated automatically. PosX = {} and PosY = {}", resourceInstance.getPosX(), resourceInstance.getPosY());
+ }
+ }
+
}
Code Review / sdc.git / blobdiff