예제 #1
0
  private boolean patch(Data<Resource> data, RequestScope requestScope) {
    boolean isUpdated;

    if (relationshipType.isToMany()) {
      Collection<Resource> resources = data.get();
      if (resources == null) {
        return false;
      }
      if (!resources.isEmpty()) {
        isUpdated =
            record.updateRelation(
                relationshipName,
                new Relationship(null, new Data<>(resources)).toPersistentResources(requestScope));
      } else {
        isUpdated = record.clearRelation(relationshipName);
      }
    } else if (relationshipType.isToOne()) {
      Resource resource = data.get().iterator().next();
      if (resource != null) {
        isUpdated =
            record.updateRelation(
                relationshipName,
                new Relationship(null, new Data<>(resource)).toPersistentResources(requestScope));
      } else {
        isUpdated = record.clearRelation(relationshipName);
      }
    } else {
      throw new IllegalStateException("Bad relationship type");
    }

    return isUpdated;
  }
예제 #2
0
 @Override
 public void handle(StateContext state, SubCollectionReadCollectionContext ctx) {
   String subCollection = ctx.term().getText();
   EntityDictionary dictionary = state.getRequestScope().getDictionary();
   try {
     Set<PersistentResource> collection = resource.getRelation(subCollection); // Check if exists.
     String entityName =
         dictionary.getBinding(
             dictionary.getParameterizedType(resource.getObject(), subCollection));
     Class<?> entityClass = dictionary.getBinding(entityName);
     if (entityClass == null) {
       throw new IllegalArgumentException("Unknown type " + entityName);
     }
     final BaseState nextState;
     if (collection instanceof SingleElementSet) {
       PersistentResource record = collection.iterator().next();
       nextState = new RecordTerminalState(subCollection, record);
     } else {
       nextState =
           new CollectionTerminalState(
               entityClass, Optional.of(resource), Optional.of(subCollection));
     }
     state.setState(nextState);
   } catch (InvalidAttributeException e) {
     throw new InvalidCollectionException(subCollection);
   }
 }
예제 #3
0
파일: Parent.java 프로젝트: leixu/elide
 @Override
 public boolean ok(PersistentResource<Parent> record) {
   Parent parent = record.getObject();
   if (parent.getChildren() != null && parent.getSpouses() != null) {
     return true;
   }
   throw new IllegalStateException("Uninitialized " + parent);
 }
예제 #4
0
  @Test
  public void testExecuteMultipleRelations() throws Exception {
    JsonApiDocument jsonApiDocument = new JsonApiDocument();

    MultivaluedMap<String, String> queryParams = new MultivaluedHashMap<>();
    queryParams.put("include", Arrays.asList("children", "spouses"));
    includedProcessor.execute(jsonApiDocument, parentRecord1, Optional.of(queryParams));

    List<Resource> expectedIncluded =
        Arrays.asList(childRecord1.toResource(), parentRecord2.toResource());
    List<Resource> actualIncluded = jsonApiDocument.getIncluded();

    Assert.assertEquals(
        actualIncluded,
        expectedIncluded,
        "Included Processor added single requested resource from 'include' query param");
  }
예제 #5
0
 @Override
 public void handle(StateContext state, SubCollectionSubCollectionContext ctx) {
   String id = ctx.entity().id().getText();
   String subCollection = ctx.entity().term().getText();
   try {
     state.setState(new RecordState(resource.getRelation(subCollection, id)));
   } catch (InvalidAttributeException e) {
     throw new InvalidCollectionException(subCollection);
   }
 }
예제 #6
0
 @Override
 public void handle(StateContext state, SubCollectionToOneContext ctx) {
   String subCollection = ctx.term().getText();
   Set<PersistentResource> single = resource.getRelation(subCollection);
   if (single instanceof SingleElementSet) {
     state.setState(new RecordState(single.iterator().next()));
   } else {
     throw new InvalidCollectionException(
         "Expected single element but found list for '%s'", subCollection);
   }
 }
예제 #7
0
 private boolean post(Data<Resource> data, RequestScope requestScope) {
   Collection<Resource> resources = data.get();
   if (resources == null) {
     return false;
   }
   resources
       .stream()
       .forEachOrdered(
           resource ->
               record.addRelation(relationshipName, resource.toPersistentResource(requestScope)));
   return true;
 }
예제 #8
0
  @Test
  public void testExecuteMultipleNestedRelations() throws Exception {
    JsonApiDocument jsonApiDocument = new JsonApiDocument();

    MultivaluedMap<String, String> queryParams = new MultivaluedHashMap<>();
    queryParams.put("include", Collections.singletonList("children.friends"));
    includedProcessor.execute(jsonApiDocument, parentRecord3, Optional.of(queryParams));

    Set<Resource> expectedIncluded =
        Sets.newHashSet(
            childRecord1.toResource(),
            childRecord2.toResource(),
            childRecord3.toResource(),
            childRecord4.toResource());
    Set<Resource> actualIncluded = new HashSet<>(jsonApiDocument.getIncluded());

    Assert.assertEquals(
        actualIncluded,
        expectedIncluded,
        "Included Processor added multiple nested requested resource collections from 'include' query param");
  }
예제 #9
0
  @Test
  public void testExecuteSingleRelationOnCollection() throws Exception {
    JsonApiDocument jsonApiDocument = new JsonApiDocument();

    Set<PersistentResource> parents = new HashSet<>();
    parents.add(parentRecord1);
    parents.add(parentRecord2);

    MultivaluedMap<String, String> queryParams = new MultivaluedHashMap<>();
    queryParams.put("include", Collections.singletonList("children"));
    includedProcessor.execute(jsonApiDocument, parents, Optional.of(queryParams));

    List<Resource> expectedIncluded =
        Arrays.asList(childRecord1.toResource(), childRecord2.toResource());
    List<Resource> actualIncluded = jsonApiDocument.getIncluded();

    Assert.assertEquals(
        actualIncluded,
        expectedIncluded,
        "Included Processor added requested resource from all records");
  }
예제 #10
0
  @Override
  public void handle(StateContext state, SubCollectionReadEntityContext ctx) {
    String id = ctx.entity().id().getText();
    String subCollection = ctx.entity().term().getText();

    try {
      PersistentResource nextRecord = resource.getRelation(subCollection, id);
      state.setState(new RecordTerminalState(subCollection, nextRecord));
    } catch (InvalidAttributeException e) {
      throw new InvalidCollectionException(subCollection);
    }
  }
예제 #11
0
  @Override
  public void handle(StateContext state, SubCollectionRelationshipContext ctx) {
    String id = ctx.entity().id().getText();
    String subCollection = ctx.entity().term().getText();
    User user = state.getRequestScope().getUser();

    PersistentResource childRecord;
    try {
      childRecord = resource.getRelation(subCollection, id);
    } catch (InvalidAttributeException e) {
      throw new InvalidCollectionException(subCollection);
    }

    String relationName = ctx.relationship().term().getText();
    try {
      childRecord.getRelation(relationName);
    } catch (InvalidAttributeException e) {
      throw new InvalidCollectionException(relationName);
    }

    state.setState(new RelationshipTerminalState(childRecord, relationName));
  }
예제 #12
0
  @Override
  public Supplier<Pair<Integer, JsonNode>> handleGet(StateContext state) {
    JsonApiDocument doc = new JsonApiDocument();
    RequestScope requestScope = state.getRequestScope();
    ObjectMapper mapper = requestScope.getMapper().getObjectMapper();
    Optional<MultivaluedMap<String, String>> queryParams = requestScope.getQueryParams();

    Map<String, Relationship> relationships = record.toResource().getRelationships();
    Relationship relationship = null;
    if (relationships != null) {
      relationship = relationships.get(relationshipName);
    }

    // Handle valid relationship
    if (relationship != null) {

      // Set data
      Data<Resource> data = relationship.getData();
      doc.setData(data);

      // Run include processor
      DocumentProcessor includedProcessor = new IncludedProcessor();
      includedProcessor.execute(doc, record, queryParams);

      return () -> Pair.of(HttpStatus.SC_OK, mapper.convertValue(doc, JsonNode.class));
    }

    // Handle no data for relationship
    if (relationshipType.isToMany()) {
      doc.setData(new Data<>(new ArrayList<>()));
    } else if (relationshipType.isToOne()) {
      doc.setData(new Data<>((Resource) null));
    } else {
      throw new IllegalStateException("Failed to PATCH a relationship");
    }
    return () -> Pair.of(HttpStatus.SC_OK, mapper.convertValue(doc, JsonNode.class));
  }
예제 #13
0
  public RelationshipTerminalState(PersistentResource record, String relationshipName) {
    this.record = record;

    this.relationshipType = record.getRelationshipType(relationshipName);
    this.relationshipName = relationshipName;
  }