--- /dev/null
+package org.onap.champ.service;
+
+import org.onap.aai.champcore.ChampGraph;
+import org.onap.aai.champcore.ChampTransaction;
+import org.onap.aai.champcore.exceptions.ChampMarshallingException;
+import org.onap.aai.champcore.exceptions.ChampObjectNotExistsException;
+import org.onap.aai.champcore.exceptions.ChampRelationshipNotExistsException;
+import org.onap.aai.champcore.exceptions.ChampSchemaViolationException;
+import org.onap.aai.champcore.exceptions.ChampTransactionException;
+import org.onap.aai.champcore.exceptions.ChampUnmarshallingException;
+import org.onap.aai.champcore.model.ChampElement;
+import org.onap.aai.champcore.model.ChampObject;
+import org.onap.aai.champcore.model.ChampRelationship;
+import org.onap.aai.champcore.model.fluent.object.ObjectBuildOrPropertiesStep;
+import org.onap.aai.cl.api.Logger;
+import org.onap.aai.cl.eelf.LoggerFactory;
+import org.onap.champ.exception.ChampServiceException;
+import org.onap.champ.service.logging.ChampMsgs;
+import org.onap.champ.util.ChampProperties;
+import org.onap.champ.util.ChampServiceConstants;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.ws.rs.core.Response.Status;
+
+public class ChampDataService {
+ private ChampUUIDService champUUIDService;
+
+ private ChampGraph graphImpl;
+ private ChampTransactionCache cache;
+ private static final String KEY_NAME = ChampProperties.get(ChampServiceConstants.CHAMP_KEY_NAME);
+ private static final String SOT_NAME = ChampProperties.get(ChampServiceConstants.CHAMP_SOT_NAME);
+ private static final String CREATED_TS_NAME = ChampProperties.get(ChampServiceConstants.CHAMP_CREATED_TS_NAME);
+ private static final String LAST_MOD_TS_NAME = ChampProperties.get(ChampServiceConstants.CHAMP_LAST_MOD_TS_NAME);
+ private Logger logger = LoggerFactory.getInstance().getLogger(ChampDataService.class);
+
+
+ public ChampDataService(ChampUUIDService champUUIDService, ChampGraph graphImpl, ChampTransactionCache cache) {
+
+ this.champUUIDService = champUUIDService;
+ this.graphImpl = graphImpl;
+ this.cache = cache;
+ }
+
+ public ChampObject getObject(String id, Optional<ChampTransaction> transaction) throws ChampServiceException {
+
+ Optional<ChampObject> retrieved = Optional.empty();
+ try {
+ retrieved = champUUIDService.getObjectbyUUID(id, transaction.orElse(null));
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ throw new ChampServiceException("Error: " + e.getMessage(), Status.INTERNAL_SERVER_ERROR);
+ }
+ if (retrieved.isPresent()) {
+ return (ChampObject) champUUIDService.populateUUIDKey(retrieved.get());
+ } else {
+ return null;
+ }
+ }
+
+ public ChampObject storeObject(ChampObject object, Optional<ChampTransaction> transaction)
+ throws ChampMarshallingException, ChampSchemaViolationException, ChampObjectNotExistsException,
+ ChampTransactionException, ChampServiceException {
+
+ if (object.getProperty(KEY_NAME).isPresent() || object.getKey().isPresent()) {
+ throw new ChampServiceException(KEY_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+
+ champUUIDService.populateUUIDProperty(object, java.util.UUID.randomUUID().toString());
+ addTimestamps(object, null);
+ ChampObject created = graphImpl.storeObject(object, transaction);
+ return (ChampObject) champUUIDService.populateUUIDKey(created);
+ }
+
+ public ChampObject replaceObject(ChampObject object, String objectId, Optional<ChampTransaction> transaction)
+ throws ChampServiceException, ChampUnmarshallingException, ChampTransactionException, ChampMarshallingException,
+ ChampSchemaViolationException, ChampObjectNotExistsException {
+ if (object.getKey().isPresent() && (!object.getKeyValue().equals(objectId))) {
+ throw new ChampServiceException("Object Id in the URI doesn't match the body.", Status.BAD_REQUEST);
+ }
+
+ if (object.getProperty(KEY_NAME).isPresent() && !object.getProperty(KEY_NAME).get().toString().equals(objectId)) {
+ throw new ChampServiceException(KEY_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+
+ Optional<ChampObject> retrieved = champUUIDService.getObjectbyUUID(objectId, transaction.orElse(null));
+ if (!retrieved.isPresent()) {
+ throw new ChampServiceException(objectId + " not found", Status.NOT_FOUND);
+ }
+ ObjectBuildOrPropertiesStep payloadBuilder = ChampObject.create().from(object).withKey(retrieved.get().getKey().get())
+ .withProperty(KEY_NAME, objectId);
+ if (retrieved.get().getProperty(SOT_NAME).isPresent()){
+ payloadBuilder = payloadBuilder.withProperty(SOT_NAME, retrieved.get().getProperty(SOT_NAME).get());
+ }
+
+ if (object.getProperty(CREATED_TS_NAME).isPresent() && retrieved.get().getProperty(CREATED_TS_NAME).isPresent()) {
+ // the timestamps in object are parsed as strings regardless of how the input json is. Convert retrieved to string for easy comparison
+ if (!retrieved.get().getProperty(CREATED_TS_NAME).get().toString().equals(object.getProperty(CREATED_TS_NAME).get())) {
+ throw new ChampServiceException(CREATED_TS_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+ }
+
+ if (object.getProperty(LAST_MOD_TS_NAME).isPresent() && retrieved.get().getProperty(LAST_MOD_TS_NAME).isPresent()) {
+ if (!retrieved.get().getProperty(LAST_MOD_TS_NAME).get().toString().equals(object.getProperty(LAST_MOD_TS_NAME).get())) {
+ throw new ChampServiceException(LAST_MOD_TS_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+ }
+
+ ChampObject payload = payloadBuilder.build();
+ addTimestamps(payload, (Long)retrieved.get().getProperty(CREATED_TS_NAME).orElse(null));
+ ChampObject updated = graphImpl.replaceObject(payload, transaction);
+ return (ChampObject) champUUIDService.populateUUIDKey(updated);
+ }
+
+ public void deleteObject(String objectId, Optional<ChampTransaction> transaction) throws ChampServiceException,
+ ChampObjectNotExistsException, ChampTransactionException, ChampUnmarshallingException {
+ Optional<ChampObject> retrieved = champUUIDService.getObjectbyUUID(objectId, transaction.orElse(null));
+ if (!retrieved.isPresent()) {
+ throw new ChampServiceException(objectId + " not found", Status.NOT_FOUND);
+ }
+ Stream<ChampRelationship> relationships = graphImpl.retrieveRelationships(retrieved.get(), transaction);
+
+ if (relationships.count() > 0) {
+ throw new ChampServiceException("Attempt to delete vertex with id " + objectId + " which has incident edges.",
+ Status.BAD_REQUEST);
+ }
+ graphImpl.deleteObject(retrieved.get().getKey().get(), transaction);
+
+ }
+
+ public ChampRelationship storeRelationship(ChampRelationship r, Optional<ChampTransaction> transaction)
+ throws ChampMarshallingException, ChampObjectNotExistsException, ChampSchemaViolationException,
+ ChampRelationshipNotExistsException, ChampUnmarshallingException, ChampTransactionException,
+ ChampServiceException {
+
+ if (r.getSource() == null || !r.getSource().getKey().isPresent() || r.getTarget() == null
+ || !r.getTarget().getKey().isPresent()) {
+ logger.error(ChampMsgs.CHAMP_DATA_SERVICE_ERROR, "Source/Target Object key must be provided");
+ throw new ChampServiceException("Source/Target Object key must be provided", Status.BAD_REQUEST);
+ }
+
+ if (r.getProperty(KEY_NAME).isPresent() || r.getKey().isPresent()) {
+ logger.error(ChampMsgs.CHAMP_DATA_SERVICE_ERROR, "key or " + KEY_NAME + " not allowed while creating new Objects");
+ throw new ChampServiceException("key or " + KEY_NAME + " not allowed while creating new Objects", Status.BAD_REQUEST);
+
+ }
+
+ Optional<ChampObject> source = champUUIDService.getObjectbyUUID(r.getSource().getKey().get().toString(),
+ transaction.orElse(null));
+ Optional<ChampObject> target = champUUIDService.getObjectbyUUID(r.getTarget().getKey().get().toString(),
+ transaction.orElse(null));
+
+ if (!source.isPresent() || !target.isPresent()) {
+ logger.error(ChampMsgs.CHAMP_DATA_SERVICE_ERROR, "Source/Target object not found");
+ throw new ChampServiceException("Source/Target object not found", Status.BAD_REQUEST);
+ }
+
+ champUUIDService.populateUUIDProperty(r, java.util.UUID.randomUUID().toString());
+
+ ChampRelationship payload = new ChampRelationship.Builder(source.get(), target.get(), r.getType())
+ .properties(r.getProperties()).build();
+ addTimestamps(payload, null);
+ ChampRelationship created = graphImpl.storeRelationship(payload, transaction);
+ return (ChampRelationship) champUUIDService.populateUUIDKey(created);
+ }
+
+ public ChampRelationship updateRelationship(ChampRelationship r, String rId, Optional<ChampTransaction> transaction)
+ throws ChampServiceException, ChampUnmarshallingException, ChampTransactionException, ChampMarshallingException,
+ ChampSchemaViolationException, ChampRelationshipNotExistsException {
+ if (r.getKey().isPresent() && (!r.getKeyValue().equals(rId))) {
+
+ throw new ChampServiceException("Relationship Id in the URI \"" + rId + "\" doesn't match the URI in the body"
+ + " \"" + r.getKeyValue() + "\"", Status.BAD_REQUEST);
+
+ }
+
+ if (r.getProperty(KEY_NAME).isPresent() && !r.getProperty(KEY_NAME).get().toString().equals(rId)) {
+ throw new ChampServiceException(KEY_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+
+ Optional<ChampRelationship> retrieved = champUUIDService.getRelationshipbyUUID(rId, transaction.orElse(null));
+ if (!retrieved.isPresent()) {
+ throw new ChampServiceException(rId + " not found", Status.NOT_FOUND);
+ }
+ // check if key is present or if it equals the key that is in the URI
+ if (r.getSource() == null || !r.getSource().getKey().isPresent() || r.getTarget() == null
+ || !r.getTarget().getKey().isPresent()) {
+ throw new ChampServiceException("Source/Target Object key must be provided", Status.BAD_REQUEST);
+ }
+ ChampObject source = retrieved.get().getSource();
+ ChampObject target = retrieved.get().getTarget();
+
+ if (!source.getProperty(KEY_NAME).get().toString().equals(r.getSource().getKey().get().toString())
+ || !target.getProperty(KEY_NAME).get().toString().equals(r.getTarget().getKey().get().toString())) {
+ throw new ChampServiceException("Source/Target cannot be updated", Status.BAD_REQUEST);
+ }
+
+ if (r.getProperty(CREATED_TS_NAME).isPresent() && retrieved.get().getProperty(CREATED_TS_NAME).isPresent()) {
+ if (!retrieved.get().getProperty(CREATED_TS_NAME).get().toString().equals(r.getProperty(CREATED_TS_NAME).get())) {
+ throw new ChampServiceException(CREATED_TS_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+ }
+
+ if (r.getProperty(LAST_MOD_TS_NAME).isPresent() && retrieved.get().getProperty(LAST_MOD_TS_NAME).isPresent()) {
+ if (!retrieved.get().getProperty(LAST_MOD_TS_NAME).get().toString().equals(r.getProperty(LAST_MOD_TS_NAME).get())) {
+ throw new ChampServiceException(LAST_MOD_TS_NAME + " can't be updated", Status.BAD_REQUEST);
+ }
+ }
+
+ ChampRelationship payload = new ChampRelationship.Builder(source, target, r.getType())
+ .key(retrieved.get().getKey().get()).properties(r.getProperties()).property(KEY_NAME, rId).build();
+ addTimestamps(payload, (Long)retrieved.get().getProperty(CREATED_TS_NAME).orElse(null));
+ ChampRelationship updated = graphImpl.replaceRelationship(payload, transaction);
+ return (ChampRelationship) champUUIDService.populateUUIDKey(updated);
+ }
+
+ public void deleteRelationship(String relationshipId, Optional<ChampTransaction> transaction)
+ throws ChampServiceException, ChampRelationshipNotExistsException, ChampTransactionException,
+ ChampUnmarshallingException {
+ Optional<ChampRelationship> retrieved = champUUIDService.getRelationshipbyUUID(relationshipId,
+ transaction.orElse(null));
+ if (!retrieved.isPresent()) {
+ throw new ChampServiceException(relationshipId + " not found", Status.NOT_FOUND);
+ }
+
+ graphImpl.deleteRelationship(retrieved.get(), transaction);
+
+ }
+
+
+ public List<ChampRelationship> getRelationshipsByObject(String objectId, Optional<ChampTransaction> transaction)
+ throws ChampServiceException {
+ try {
+ Optional<ChampObject> retrievedObject = champUUIDService.getObjectbyUUID(objectId, transaction.orElse(null));
+ if (!retrievedObject.isPresent()) {
+ throw new ChampServiceException(objectId + " not found", Status.NOT_FOUND);
+ }
+ List<ChampRelationship> relations = new ArrayList<ChampRelationship>();
+
+ Stream<ChampRelationship> retrieved = graphImpl.retrieveRelationships(retrievedObject.get(), transaction);
+ relations = champUUIDService.populateUUIDKey(retrieved.collect(Collectors.toList()));
+ return relations;
+ } catch (ChampObjectNotExistsException e) {
+ throw new ChampServiceException(" obj not found", Status.NOT_FOUND);
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ throw new ChampServiceException("Internal Error", Status.INTERNAL_SERVER_ERROR);
+ }
+
+ }
+
+ /**
+ * Gets the ChampObjects that pass filter
+ * @param filter key/value pairs that must be present in the returned objects
+ * @param properties properties that will show up in the object
+ * @return
+ * @throws ChampServiceException
+ */
+ public List<ChampObject> queryObjects(Map<String, Object> filter, HashSet<String> properties) throws ChampServiceException {
+ try {
+
+ Stream<ChampObject> retrieved = graphImpl.queryObjects(filter);
+ List<ChampObject> objects = champUUIDService.populateUUIDKey(retrieved.collect(Collectors.toList()));
+
+ if (!properties.contains("all")) {
+ for (ChampObject champObject : objects) {
+ champObject.dropProperties(properties);
+ }
+ }
+
+ return objects;
+ } catch (ChampTransactionException e) {
+ throw new ChampServiceException("Internal Error", Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ public List<ChampRelationship> queryRelationships(Map<String, Object> filter) throws ChampServiceException {
+ try {
+ List<ChampRelationship> relations = new ArrayList<ChampRelationship>();
+ Stream<ChampRelationship> retrieved;
+
+ retrieved = graphImpl.queryRelationships(filter);
+
+ relations = champUUIDService.populateUUIDKey(retrieved.collect(Collectors.toList()));
+ return relations;
+ } catch (ChampTransactionException e) {
+ throw new ChampServiceException("Internal Error", Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ public ChampRelationship getRelationship(String id, Optional<ChampTransaction> transaction)
+ throws ChampServiceException {
+
+ Optional<ChampRelationship> retrieved = Optional.empty();
+ try {
+ retrieved = champUUIDService.getRelationshipbyUUID(id, transaction.orElse(null));
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ throw new ChampServiceException("Error: " + e.getMessage(), Status.INTERNAL_SERVER_ERROR);
+ }
+ if (retrieved.isPresent()) {
+ return (ChampRelationship) champUUIDService.populateUUIDKey(retrieved.get());
+ } else {
+ return null;
+ }
+ }
+
+ public String openTransaction() {
+ ChampTransaction transaction = graphImpl.openTransaction();
+ String transacId = transaction.id();
+ cache.put(transacId, transaction);
+ return transacId;
+
+ }
+
+ public void commitTransaction(String tId) throws ChampServiceException, ChampTransactionException {
+ ChampTransaction transaction = cache.get(tId);
+ if (transaction == null) {
+ throw new ChampServiceException("Transaction Not found: " + tId, Status.NOT_FOUND);
+ }
+ graphImpl.commitTransaction(transaction);
+ cache.invalidate(tId);
+ cache.invalidate(transaction.id());
+
+ }
+
+ public void rollbackTransaction(String tId) throws ChampServiceException, ChampTransactionException {
+ ChampTransaction transaction = cache.get(tId);
+ if (transaction == null) {
+ throw new ChampServiceException("Transaction Not found: " + tId, Status.NOT_FOUND);
+ }
+ graphImpl.rollbackTransaction(transaction);
+ cache.invalidate(tId);
+ cache.invalidate(transaction.id());
+
+ }
+
+ public ChampTransaction getTransaction(String id) {
+ return cache.get(id);
+ }
+
+ private void addTimestamps(ChampElement e, Long oldCreated) {
+ Long timestamp = System.currentTimeMillis();
+
+ if (oldCreated == null) {
+ e.getProperties().put(CREATED_TS_NAME, timestamp);
+ } else {
+ e.getProperties().put(CREATED_TS_NAME, oldCreated);
+ }
+
+ e.getProperties().put(LAST_MOD_TS_NAME, timestamp);
+ }
+}
Code Review / aai / champ.git / blobdiff