target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test(expected = MethodNotAllowedException.class) public void addRelations() { repo.addRelations(null, null, null); }
|
@Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }
|
@Test(expected = MethodNotAllowedException.class) public void removeRelations() { repo.removeRelations(null, null, null); }
|
@Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }
|
ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }
|
@Test public void checkEmpty() { Assert.assertFalse(new RelationshipMatcher().matches(field)); }
|
public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); }
|
RelationshipMatcher { public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); } }
|
RelationshipMatcher { public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); } }
|
RelationshipMatcher { public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); } RelationshipMatcherRule rule(); boolean matches(ResourceField field); }
|
RelationshipMatcher { public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); } RelationshipMatcherRule rule(); boolean matches(ResourceField field); }
|
@Test public void serializeArray() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.of(Arrays.asList(new ResourceIdentifier("a", "b")))); checkSerialize(relationship); }
|
public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void serializeSingleData() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.of(new ResourceIdentifier("a", "b"))); checkSerialize(relationship); }
|
public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void serializeNull() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.nullValue()); checkSerialize(relationship); }
|
public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test(expected = IllegalStateException.class) public void setInvalidDataThrowsException() { Relationship relationship = new Relationship(); relationship.setData(Nullable.of("not a ResourceIdentifier")); }
|
public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null || value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void getCollectionData() { Document doc = new Document(); Assert.assertFalse(doc.getCollectionData().isPresent()); doc.setData(Nullable.nullValue()); Assert.assertTrue(doc.getCollectionData().get().isEmpty()); Resource resource1 = Mockito.mock(Resource.class); doc.setData(Nullable.of(resource1)); Assert.assertEquals(1, doc.getCollectionData().get().size()); Resource resource2 = Mockito.mock(Resource.class); doc.setData(Nullable.of(Arrays.asList(resource1, resource2))); Assert.assertEquals(2, doc.getCollectionData().get().size()); }
|
@JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); }
|
Document implements MetaContainer, LinksContainer { @JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); } }
|
Document implements MetaContainer, LinksContainer { @JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); } }
|
Document implements MetaContainer, LinksContainer { @JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); } Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); List<Resource> getIncluded(); void setIncluded(List<Resource> includes); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); List<ErrorData> getErrors(); void setErrors(List<ErrorData> errors); @JsonIgnore boolean isMultiple(); @JsonIgnore Nullable<Resource> getSingleData(); @Override int hashCode(); @Override boolean equals(Object obj); @JsonIgnore Nullable<List<Resource>> getCollectionData(); ObjectNode getJsonapi(); void setJsonapi(ObjectNode jsonapi); }
|
Document implements MetaContainer, LinksContainer { @JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); } Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); List<Resource> getIncluded(); void setIncluded(List<Resource> includes); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); List<ErrorData> getErrors(); void setErrors(List<ErrorData> errors); @JsonIgnore boolean isMultiple(); @JsonIgnore Nullable<Resource> getSingleData(); @Override int hashCode(); @Override boolean equals(Object obj); @JsonIgnore Nullable<List<Resource>> getCollectionData(); ObjectNode getJsonapi(); void setJsonapi(ObjectNode jsonapi); }
|
@Test public void checkContextAccess() throws ExecutionException, InterruptedException { Object context = new Object(); Assert.assertFalse(resultFactory.hasThreadContext()); resultFactory.setThreadContext(context); Assert.assertSame(context, resultFactory.getThreadContext()); Assert.assertTrue(resultFactory.hasThreadContext()); ExecutorService executorService = Executors.newSingleThreadExecutor(); try { Future<?> future = executorService.submit(new Runnable() { @Override public void run() { Assert.assertFalse(resultFactory.hasThreadContext()); } }); future.get(); Assert.assertFalse(resultFactory.isAsync()); } finally { executorService.shutdownNow(); } }
|
@Override public T get() { return object; }
|
ImmediateResult implements Result<T> { @Override public T get() { return object; } }
|
ImmediateResult implements Result<T> { @Override public T get() { return object; } ImmediateResult(T object); }
|
ImmediateResult implements Result<T> { @Override public T get() { return object; } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
ImmediateResult implements Result<T> { @Override public T get() { return object; } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
@Test(expected = UnsupportedOperationException.class) public void subscribeNotSupported() { Result<Object> result = resultFactory.just(new Object()); result.subscribe(null, null); }
|
@Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); }
|
ImmediateResult implements Result<T> { @Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); } }
|
ImmediateResult implements Result<T> { @Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); }
|
ImmediateResult implements Result<T> { @Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
ImmediateResult implements Result<T> { @Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
@Test public void getMessage() { violation.getMessage(); Mockito.verify(errorData, Mockito.times(1)).getDetail(); }
|
@Override public String getMessage() { return errorData.getDetail(); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }
|
@Test(expected = UnsupportedOperationException.class) public void onErrorResumeNotSupported() { Result<Object> result = resultFactory.just(new Object()); result.onErrorResume(null); }
|
@Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); }
|
ImmediateResult implements Result<T> { @Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); } }
|
ImmediateResult implements Result<T> { @Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); }
|
ImmediateResult implements Result<T> { @Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
ImmediateResult implements Result<T> { @Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }
|
@Test public void test() { DocumentFilterContext context = Mockito.mock(DocumentFilterContext.class); DocumentFilterChain chain = Mockito.mock(DocumentFilterChain.class); AbstractDocumentFilter filter = new AbstractDocumentFilter(); filter.filter(context, chain); Mockito.verify(chain, Mockito.times(1)).doFilter(Mockito.eq(context)); }
|
@Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); }
|
AbstractDocumentFilter implements DocumentFilter { @Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); } }
|
AbstractDocumentFilter implements DocumentFilter { @Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); } }
|
AbstractDocumentFilter implements DocumentFilter { @Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); } @Override Response filter(DocumentFilterContext context, DocumentFilterChain chain); }
|
AbstractDocumentFilter implements DocumentFilter { @Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); } @Override Response filter(DocumentFilterContext context, DocumentFilterChain chain); }
|
@Test public void checkListenerEvent() { ResourceRegistryPartListener listener = Mockito.mock(ResourceRegistryPartListener.class); part.addListener(listener); part.addEntry(entry); ArgumentCaptor<ResourceRegistryPartEvent> eventCaptor = ArgumentCaptor.forClass(ResourceRegistryPartEvent.class); Mockito.verify(listener, Mockito.times(1)).onChanged(eventCaptor.capture()); }
|
@Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); Set<RegistryEntry> getEntries(); RegistryEntry getEntry(String resourceType); RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); Set<RegistryEntry> getEntries(); RegistryEntry getEntry(String resourceType); RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); }
|
@Test public void checkAddRemoveListeners() { ResourceRegistryPartListener listener = Mockito.mock(ResourceRegistryPartListener.class); part.addListener(listener); part.addEntry(entry); part.removeListener(listener); part.addEntry(entry2); Mockito.verify(listener, Mockito.times(1)).onChanged(Mockito.any(ResourceRegistryPartEvent.class)); part.addListener(listener); part.addEntry(entry3); Mockito.verify(listener, Mockito.times(2)).onChanged(Mockito.any(ResourceRegistryPartEvent.class)); }
|
@Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); Set<RegistryEntry> getEntries(); RegistryEntry getEntry(String resourceType); RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); }
|
DefaultResourceRegistryPart extends ResourceRegistryPartBase { @Override public RegistryEntry addEntry(RegistryEntry entry) { ResourceInformation resourceInformation = entry.getResourceInformation(); Type implementationType = resourceInformation.getImplementationType(); String resourceType = resourceInformation.getResourceType(); String resourcePath = resourceInformation.getResourcePath(); PreconditionUtil.verify(resourceType != null, "no resourceType set for entry %s", entry); PreconditionUtil .verify(!resourcesByType.containsKey(resourceType), "resourceType '%s' already exists, cannot add entry %s", resourceType, entry); if (entry.hasResourceRepository()) { PreconditionUtil .verify(!resourcesByPath.containsKey(resourcePath), "resourceType '%s' already exists, cannot add entry %s", resourcePath, entry); resourcesByPath.put(resourcePath != null ? resourcePath : resourceType, entry); } resourcesByImplementationType.put(implementationType, entry); resourcesByType.put(resourceType, entry); latestVersion = Math.max(latestVersion, ignoreUnbounded(resourceInformation.getVersionRange().getMax())); for (ResourceField field : resourceInformation.getFields()) { latestVersion = Math.max(latestVersion, ignoreUnbounded(field.getVersionRange().getMax())); } logger.debug("Added resource '{}' to ResourceRegistry", resourceType); notifyChange(); return entry; } DefaultResourceRegistryPart(); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); Set<RegistryEntry> getEntries(); RegistryEntry getEntry(String resourceType); RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); }
|
@Test(expected = IllegalStateException.class) public void testDuplicatePartThrowsException() { HierarchicalResourceRegistryPart part = new HierarchicalResourceRegistryPart(); part.putPart("", new DefaultResourceRegistryPart()); part.putPart("", new DefaultResourceRegistryPart()); }
|
public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); }
|
HierarchicalResourceRegistryPart extends ResourceRegistryPartBase { public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); } }
|
HierarchicalResourceRegistryPart extends ResourceRegistryPartBase { public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); } }
|
HierarchicalResourceRegistryPart extends ResourceRegistryPartBase { public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); } void putPart(String prefix, ResourceRegistryPart part); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(String resourceType); @Override RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); @Override Collection<RegistryEntry> getEntries(); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); }
|
HierarchicalResourceRegistryPart extends ResourceRegistryPartBase { public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); } void putPart(String prefix, ResourceRegistryPart part); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(String resourceType); @Override RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); @Override Collection<RegistryEntry> getEntries(); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); }
|
@Test public void shouldReturnIntegerMAXForNotRelatedClassesFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(Exception.class, SomeException.class); assertThat(distance).isEqualTo(Integer.MAX_VALUE); }
|
int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldReturn0DistanceBetweenSameClassFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(Exception.class, Exception.class); assertThat(distance).isEqualTo(0); }
|
int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldReturn1AsADistanceBetweenSameClassFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(SomeException.class, Exception.class); assertThat(distance).isEqualTo(1); }
|
int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldNotFindMapperIfSuperClassIsNotMappedFromException() { Optional<ExceptionMapper> mapper = exceptionMapperRegistry.findMapperFor(RuntimeException.class); assertThat(mapper.isPresent()).isFalse(); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldFindDirectExceptionMapperFromException() { Optional<ExceptionMapper> mapper = exceptionMapperRegistry.findMapperFor(IllegalStateException.class); assertThat(mapper.isPresent()).isTrue(); assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test(expected = UnsupportedOperationException.class) public void getConstraintDescriptor() { violation.getConstraintDescriptor(); }
|
@Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); } }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }
|
ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }
|
@Test public void shouldFindDescendantExceptionMapperFromException() { Optional<ExceptionMapper> mapper = exceptionMapperRegistry.findMapperFor(ClosedFileSystemException.class); assertThat(mapper.isPresent()).isTrue(); assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldFindDirectExceptionMapperFromError() { ErrorResponse response = ErrorResponse.builder().setStatus(HttpStatus.BAD_REQUEST_400).build(); Optional<ExceptionMapper<?>> mapper = (Optional) exceptionMapperRegistry.findMapperFor(response); assertThat(mapper.isPresent()).isTrue(); assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class); Throwable throwable = mapper.get().fromErrorResponse(response); assertThat(throwable).isExactlyInstanceOf(IllegalStateException.class); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldFindDescendantExceptionMapperFromError() { ErrorData errorData = ErrorData.builder().setId("someId").build(); ErrorResponse response = ErrorResponse.builder().setStatus(HttpStatus.BAD_REQUEST_400).setSingleErrorData(errorData).build(); Optional<ExceptionMapper<?>> mapper = (Optional) exceptionMapperRegistry.findMapperFor(response); assertThat(mapper.isPresent()).isTrue(); assertThat(mapper.get()).isExactlyInstanceOf(SomeIllegalStateExceptionMapper.class); Throwable throwable = mapper.get().fromErrorResponse(response); assertThat(throwable).isExactlyInstanceOf(SomeIllegalStateException.class); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void shouldNotFindDescendantExceptionMapperFromError() { ErrorData errorData = ErrorData.builder().setId("someOtherId").build(); ErrorResponse response = ErrorResponse.builder().setStatus(HttpStatus.BAD_REQUEST_400).setSingleErrorData(errorData).build(); Optional<ExceptionMapper<?>> mapper = (Optional) exceptionMapperRegistry.findMapperFor(response); assertThat(mapper.isPresent()).isTrue(); assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class); }
|
public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
ExceptionMapperRegistry { public Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass) { int currentDistance = Integer.MAX_VALUE; ExceptionMapper closestExceptionMapper = null; for (ExceptionMapperType mapperType : exceptionMappers) { int tempDistance = getDistanceBetweenExceptions(exceptionClass, mapperType.getExceptionClass()); if (tempDistance < currentDistance) { currentDistance = tempDistance; closestExceptionMapper = mapperType.getExceptionMapper(); if (currentDistance == 0) { break; } } } return Optional.ofNullable(closestExceptionMapper); } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }
|
@Test public void checkToString() { ExceptionMapper mapper = Mockito.mock(ExceptionMapper.class); Mockito.when(mapper.toString()).thenReturn("customMapper"); ExceptionMapperType type = new ExceptionMapperType(IllegalStateException.class, mapper); Assert.assertEquals("ExceptionMapperType[exceptionClass=java.lang.IllegalStateException, exceptionMapper=customMapper]", type.toString()); }
|
@Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; }
|
ExceptionMapperType implements Prioritizable { @Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; } }
|
ExceptionMapperType implements Prioritizable { @Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; } ExceptionMapperType(Class<? extends Throwable> exceptionClass, ExceptionMapper exceptionMapper); }
|
ExceptionMapperType implements Prioritizable { @Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; } ExceptionMapperType(Class<? extends Throwable> exceptionClass, ExceptionMapper exceptionMapper); Class<? extends Throwable> getExceptionClass(); ExceptionMapper getExceptionMapper(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int getPriority(); }
|
ExceptionMapperType implements Prioritizable { @Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; } ExceptionMapperType(Class<? extends Throwable> exceptionClass, ExceptionMapper exceptionMapper); Class<? extends Throwable> getExceptionClass(); ExceptionMapper getExceptionMapper(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int getPriority(); }
|
@Test public void testAttributesBasic() { Task task = createTask(2, "sample task"); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertEquals("sample task", resource.getAttributes().get("name").asText()); Assert.assertThat(resource.getAttributes().get("writeOnlyValue"), CoreMatchers.nullValue()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testSerializeWithoutLinks() { Task task = createTask(2, "sample task"); mappingConfig.getResourceMapping().setSerializeLinks(false); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertNull(resource.getLinks()); Relationship relationship = resource.getRelationships().get("project"); Assert.assertNull(relationship.getLinks()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testSerializeRootSelfLink() { Task task = createTask(2, "sample task"); QueryAdapter adapter = createAdapter(Task.class); Mockito.when(container.getRequestContextBase().getRequestUri()).thenReturn(URI.create("http: Document document = mapper.toDocument(toResponse(task), adapter, mappingConfig).get(); Assert.assertEquals("http: }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testCompactMode() { LinksInformation links = new TaskLinks(); Task task = createTask(2, "sample task"); task.setLinksInformation(links); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(new QuerySpec(Task.class)); queryAdapter.setCompactMode(true); Document document = mapper.toDocument(toResponse(task), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertNull(resource.getLinks().get("self")); Assert.assertNotNull(resource.getLinks().get("someLink")); Relationship project = resource.getRelationships().get("project"); Assert.assertNull(project.getLinks()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testCompactModeWithInclusion() { Project project = new Project(); project.setName("someProject"); project.setId(3L); Task task = createTask(2, "sample task"); task.setProject(project); QuerySpec querySpec = new QuerySpec(Task.class); querySpec.includeRelation(Arrays.asList("project")); QueryAdapter queryAdapter = toAdapter(querySpec); DocumentMappingConfig config = mappingConfig.clone(); config.getResourceMapping().setSerializeSelfRelationshipLinks(false); Document document = mapper.toDocument(toResponse(task), queryAdapter, config).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship projectRel = resource.getRelationships().get("project"); ObjectNode links = projectRel.getLinks(); Assert.assertFalse(links.has("self")); Assert.assertTrue(links.has("related")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void test() { ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class); Iterator<ClientModuleFactory> iterator = loader.iterator(); Set<Class> moduleClasses = new HashSet<>(); while (iterator.hasNext()) { ClientModuleFactory moduleFactory = iterator.next(); Module module = moduleFactory.create(); moduleClasses.add(module.getClass()); } Assert.assertEquals(2, moduleClasses.size()); Assert.assertTrue(moduleClasses.contains(ValidationModule.class)); Assert.assertTrue(moduleClasses.contains(MetaModule.class)); }
|
@Override public ValidationModule create() { return ValidationModule.create(); }
|
ValidationClientModuleFactory implements ClientModuleFactory { @Override public ValidationModule create() { return ValidationModule.create(); } }
|
ValidationClientModuleFactory implements ClientModuleFactory { @Override public ValidationModule create() { return ValidationModule.create(); } }
|
ValidationClientModuleFactory implements ClientModuleFactory { @Override public ValidationModule create() { return ValidationModule.create(); } @Override ValidationModule create(); }
|
ValidationClientModuleFactory implements ClientModuleFactory { @Override public ValidationModule create() { return ValidationModule.create(); } @Override ValidationModule create(); }
|
@Test public void testOmitSelfRelatedLinks() { Project project = new Project(); project.setName("someProject"); project.setId(3L); LinksInformation links = new TaskLinks(); Task task = createTask(2, "sample task"); task.setLinksInformation(links); task.setProject(project); QuerySpec querySpec = new QuerySpec(Task.class); querySpec.includeRelation(Arrays.asList("project")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); queryAdapter.setCompactMode(true); Document document = mapper.toDocument(toResponse(task), queryAdapter, mappingConfig.clone()).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertNull(resource.getLinks().get("self")); Assert.assertNotNull(resource.getLinks().get("someLink")); Relationship projectRel = resource.getRelationships().get("project"); Assert.assertNull(projectRel.getLinks()); Assert.assertEquals(1, document.getIncluded().size()); Resource projectResource = document.getIncluded().get(0); Assert.assertNull(projectResource.getRelationships().get("tasks")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testCustomSelfLinks() { TaskLinks links = new TaskLinks(); links.self = new DefaultLink("http: Task task = createTask(2, "sample task"); task.setLinksInformation(links); QuerySpec querySpec = new QuerySpec(Task.class); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(task), queryAdapter, mappingConfig.clone()).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertEquals("http: Relationship projectRel = resource.getRelationships().get("project"); Assert.assertEquals("http: }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testJsonIncludeNonEmptyIgnoresNull() throws JsonProcessingException { Schedule schedule = new Schedule(); schedule.setDesc(null); schedule.setFollowupProject(null); QuerySpec querySpec = new QuerySpec(Project.class); querySpec.includeRelation(PathSpec.of("followupProject")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(schedule), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertFalse(resource.getAttributes().containsKey("description")); Assert.assertFalse(resource.getRelationships().containsKey("followup")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testJsonIncludeNonEmptyIgnoresEmptyList() throws JsonProcessingException { Schedule schedule = new Schedule(); schedule.setKeywords(Collections.emptyList()); schedule.setTasks(new ArrayList<>()); QuerySpec querySpec = new QuerySpec(Project.class); querySpec.includeRelation(PathSpec.of("tasks")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(schedule), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertFalse(resource.getAttributes().containsKey("keywords")); Assert.assertFalse(resource.getRelationships().containsKey("tasks")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testJsonIncludeNonEmptyWritesNonEmpty() throws JsonProcessingException { Project project = new Project(); project.setId(12L); Schedule schedule = new Schedule(); schedule.setDesc("Hello"); schedule.setFollowupProject(project); QuerySpec querySpec = new QuerySpec(Project.class); querySpec.includeRelation(PathSpec.of("followupProject")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(schedule), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertTrue(resource.getAttributes().containsKey("description")); Assert.assertTrue(resource.getRelationships().containsKey("followup")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testOptionalNotSerializedIfEmpty() { Schedule schedule = new Schedule(); schedule.setDueDate(Optional.empty()); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(new QuerySpec(Project.class)); Document document = mapper.toDocument(toResponse(schedule), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertFalse(resource.getAttributes().containsKey("dueDate")); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testOptionalSerializedIfSet() { Schedule schedule = new Schedule(); schedule.setDueDate(Optional.of(OffsetDateTime.now())); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(new QuerySpec(Project.class)); Document document = mapper.toDocument(toResponse(schedule), queryAdapter, mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertTrue(resource.getAttributes().containsKey("dueDate")); JsonNode node = resource.getAttributes().get("dueDate"); Assert.assertTrue(node.asText().length() > 0); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testCompactModeWithNullData() { QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(new QuerySpec(Task.class)); queryAdapter.setCompactMode(true); Document compactDocument = mapper.toDocument(new JsonApiResponse(), queryAdapter, mappingConfig).get(); queryAdapter.setCompactMode(false); Document standardDocument = mapper.toDocument(new JsonApiResponse(), queryAdapter, mappingConfig).get(); Assert.assertEquals(standardDocument, compactDocument); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testDocumentInformation() { Task task = createTask(2, "sample task"); TestLinksInformation links = new TestLinksInformation(); links.value = new DefaultLink("linksValue"); TestMetaInformation meta = new TestMetaInformation(); meta.value = "metaValue"; JsonApiResponse response = toResponse(task); response.setMetaInformation(meta); response.setLinksInformation(links); Document document = mapper.toDocument(response, createAdapter(Task.class), mappingConfig).get(); Assert.assertEquals("linksValue", getLinkText(document.getLinks().get("value"))); Assert.assertEquals("metaValue", document.getMeta().get("value").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testResourceInformation() { TestLinksInformation links = new TestLinksInformation(); links.value = new DefaultLink("linksValue"); TestMetaInformation meta = new TestMetaInformation(); meta.value = "metaValue"; Task task = createTask(2, "sample task"); task.setMetaInformation(meta); task.setLinksInformation(links); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("linksValue", getLinkText(resource.getLinks().get("value"))); Assert.assertEquals("metaValue", resource.getMeta().get("value").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void test() { HomeModuleExtension extension = new HomeModuleExtension(); extension.addPath("/test/directory/"); extension.addPath("/test/something"); SimpleModule extensionModule = new SimpleModule("extension"); extensionModule.addExtension(extension); HomeModule module = Mockito.spy(HomeModule.create(HomeFormat.JSON_HOME)); CrnkBoot boot = new CrnkBoot(); boot.addModule(module); boot.addModule(extensionModule); boot.setServiceUrlProvider(new ConstantServiceUrlProvider("http: boot.boot(); List<String> list = module.list("/", new QueryContext()); Assert.assertTrue(list.toString(), list.contains("test/")); list = module.list("/test/", new QueryContext()); Assert.assertTrue(list.toString(), list.contains("directory/")); Assert.assertTrue(list.toString(), list.contains("something")); }
|
public void addPath(String path) { paths.add(path); }
|
HomeModuleExtension implements ModuleExtension { public void addPath(String path) { paths.add(path); } }
|
HomeModuleExtension implements ModuleExtension { public void addPath(String path) { paths.add(path); } }
|
HomeModuleExtension implements ModuleExtension { public void addPath(String path) { paths.add(path); } @Override Class<? extends Module> getTargetModule(); @Override boolean isOptional(); void addPath(String path); }
|
HomeModuleExtension implements ModuleExtension { public void addPath(String path) { paths.add(path); } @Override Class<? extends Module> getTargetModule(); @Override boolean isOptional(); void addPath(String path); }
|
@Test public void testErrors() { JsonApiResponse response = new JsonApiResponse(); ErrorData error = Mockito.mock(ErrorData.class); response.setErrors(Arrays.asList(error)); Document document = mapper.toDocument(response, createAdapter(Task.class), mappingConfig).get(); List<ErrorData> errors = document.getErrors(); Assert.assertEquals(1, errors.size()); Assert.assertSame(error, errors.get(0)); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipSingleValuedEager() { LazyTask task = createLazyTask(2); Project project = createProject(3, "sample project"); task.setProject(project); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship relationship = resource.getRelationships().get("project"); Assert.assertNotNull(relationship); ResourceIdentifier relationshipData = relationship.getSingleData().get(); Assert.assertNotNull(relationshipData); Assert.assertEquals("3", relationshipData.getId()); Assert.assertEquals("projects", relationshipData.getType()); Assert.assertTrue(document.getIncluded().isEmpty()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipLazyMultiValued() { LazyTask task = createLazyTask(2); Project project1 = createProject(3, "sample project"); Project project2 = createProject(4, "sample project"); task.setProjects(Arrays.asList(project1, project2)); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship relationship = resource.getRelationships().get("projects"); Assert.assertNotNull(relationship); Nullable<List<ResourceIdentifier>> relationshipData = relationship.getCollectionData(); Assert.assertFalse(relationshipData.isPresent()); Assert.assertTrue(document.getIncluded().isEmpty()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipIncludeMultiValued() { LazyTask task = createLazyTask(2); Project project1 = createProject(3, "sample project3"); Project project2 = createProject(4, "sample project4"); task.setProjects(Arrays.asList(project1, project2)); QuerySpec querySpec = new QuerySpec(LazyTask.class); querySpec.includeRelation(Arrays.asList("projects")); Document document = mapper.toDocument(toResponse(task), toAdapter(querySpec), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship relationship = resource.getRelationships().get("projects"); Assert.assertNotNull(relationship); List<ResourceIdentifier> relationshipData = relationship.getCollectionData().get(); Assert.assertNotNull(relationshipData); Assert.assertEquals(2, relationshipData.size()); Assert.assertEquals("3", relationshipData.get(0).getId()); Assert.assertEquals("projects", relationshipData.get(0).getType()); Assert.assertEquals("4", relationshipData.get(1).getId()); Assert.assertEquals("projects", relationshipData.get(1).getType()); Assert.assertFalse(document.getIncluded().isEmpty()); List<Resource> included = document.getIncluded(); Assert.assertEquals(2, included.size()); Assert.assertEquals("3", included.get(0).getId()); Assert.assertEquals("projects", included.get(0).getType()); Assert.assertEquals("sample project3", included.get(0).getAttributes().get("name").asText()); Assert.assertEquals("4", included.get(1).getId()); Assert.assertEquals("projects", included.get(1).getType()); Assert.assertEquals("sample project4", included.get(1).getAttributes().get("name").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipIncludeRelation() { LazyTask task = createLazyTask(2); Project project = createProject(3, "sample project"); task.setProject(project); QuerySpec querySpec = new QuerySpec(LazyTask.class); querySpec.includeRelation(Arrays.asList("project")); Document document = mapper.toDocument(toResponse(task), toAdapter(querySpec), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship relationship = resource.getRelationships().get("project"); Assert.assertNotNull(relationship); ResourceIdentifier relationshipData = relationship.getSingleData().get(); Assert.assertNotNull(relationshipData); Assert.assertEquals("3", relationshipData.getId()); Assert.assertEquals("projects", relationshipData.getType()); List<Resource> included = document.getIncluded(); Assert.assertEquals(1, included.size()); Assert.assertEquals("3", included.get(0).getId()); Assert.assertEquals("projects", included.get(0).getType()); Assert.assertEquals("sample project", included.get(0).getAttributes().get("name").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipCyclicInclusion() { Task task = createTask(2, "sample task"); Project project = createProject(3, "sample project"); task.setProject(project); project.setTask(task); QuerySpec querySpec = new QuerySpec(Task.class); querySpec.includeRelation(Arrays.asList("project")); querySpec.getOrCreateQuerySpec(Project.class).includeRelation(Arrays.asList("task")); Document document = mapper.toDocument(toResponse(task), toAdapter(querySpec), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Relationship relationship = resource.getRelationships().get("project"); Assert.assertNotNull(relationship); ResourceIdentifier relationshipData = relationship.getSingleData().get(); Assert.assertNotNull(relationshipData); Assert.assertEquals("3", relationshipData.getId()); Assert.assertEquals("projects", relationshipData.getType()); List<Resource> included = document.getIncluded(); Assert.assertEquals(1, included.size()); Assert.assertEquals("3", included.get(0).getId()); Assert.assertEquals("projects", included.get(0).getType()); Assert.assertEquals("sample project", included.get(0).getAttributes().get("name").asText()); Assert.assertEquals("2", included.get(0).getRelationships().get("task").getSingleData().get().getId()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipSingleValuedIncludeByDefault() { Task task = createTask(2, "sample task"); Project project = createProject(3, "sample project"); task.setProject(project); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertEquals("sample task", resource.getAttributes().get("name").asText()); Relationship relationship = resource.getRelationships().get("project"); Assert.assertNotNull(relationship); Assert.assertEquals("http: getLinkText(relationship.getLinks().get("self"))); Assert.assertEquals("http: ResourceIdentifier relationshipData = relationship.getSingleData().get(); Assert.assertNotNull(relationshipData); Assert.assertEquals("3", relationshipData.getId()); Assert.assertEquals("projects", relationshipData.getType()); List<Resource> included = document.getIncluded(); Assert.assertEquals(1, included.size()); Assert.assertEquals("3", included.get(0).getId()); Assert.assertEquals("projects", included.get(0).getType()); Assert.assertEquals("sample project", included.get(0).getAttributes().get("name").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testMultipleInclusions() { Task task1 = createTask(1, "other task"); Task task2 = createTask(2, "other task"); Task task3 = createTask(3, "sample task"); Project project = new Project(); project.setName("someProject"); project.setId(3L); project.setTask(task1); project.setTasks(Arrays.asList(task2, task3)); QuerySpec querySpec = new QuerySpec(Project.class); querySpec.includeRelation(Arrays.asList("tasks")); querySpec.includeRelation(Arrays.asList("task")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(project), queryAdapter, new DocumentMappingConfig()).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("3", resource.getId()); Assert.assertEquals("projects", resource.getType()); Relationship taskRel = resource.getRelationships().get("task"); Assert.assertNotNull(taskRel.getLinks()); Assert.assertTrue(taskRel.getData().isPresent()); Assert.assertNotNull(taskRel.getData().get()); Relationship tasksRel = resource.getRelationships().get("tasks"); Assert.assertNotNull(tasksRel.getLinks()); Assert.assertTrue(tasksRel.getData().isPresent()); Assert.assertNotNull(tasksRel.getData().get()); Assert.assertEquals(2, tasksRel.getCollectionData().get().size()); Assert.assertEquals(3, document.getIncluded().size()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testConvergingInclusionPaths() { Task task1 = createTask(1, "other task"); Task task2 = createTask(2, "other task"); Project project1 = new Project(); project1.setName("someProject"); project1.setId(3L); project1.setTasks(Arrays.asList(task1, task2)); Project project2 = new Project(); project2.setName("someProject"); project2.setId(2L); task1.setProject(project1); task1.setProjectsInit(Arrays.asList(project2)); task1.setLinksInformation(new DefaultSelfLinksInformation()); project1.setTask(task2); project2.setTask(task2); QuerySpec querySpec = new QuerySpec(Task.class); querySpec.includeRelation(Arrays.asList("project", "task")); querySpec.includeRelation(Arrays.asList("projectsInit", "task")); QuerySpecAdapter queryAdapter = (QuerySpecAdapter) toAdapter(querySpec); Document document = mapper.toDocument(toResponse(task1), queryAdapter, new DocumentMappingConfig()).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("1", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Relationship projectRel = resource.getRelationships().get("project"); Assert.assertNotNull(projectRel.getLinks()); Assert.assertTrue(projectRel.getData().isPresent()); Assert.assertNotNull(projectRel.getData().get()); Relationship projectsRel = resource.getRelationships().get("projectsInit"); Assert.assertNotNull(projectsRel.getLinks()); Assert.assertTrue(projectsRel.getData().isPresent()); Assert.assertNotNull(projectsRel.getData().get()); Assert.assertEquals(1, projectsRel.getCollectionData().get().size()); Assert.assertEquals(3, document.getIncluded().size()); List<Resource> included = document.getIncluded(); Resource projectResource2 = included.get(0); Resource projectResource3 = included.get(1); Assert.assertTrue(projectResource2.getRelationships().get("task").getData().isPresent()); Assert.assertTrue(projectResource3.getRelationships().get("task").getData().isPresent()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testRelationshipSingleValuedLazy() { LazyTask task = createLazyTask(2); Project project = createProject(3, "sample project"); task.setLazyProject(project); Document document = mapper.toDocument(toResponse(task), createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("lazy_tasks", resource.getType()); Relationship relationship = resource.getRelationships().get("lazyProject"); Assert.assertNotNull(relationship); Assert.assertEquals("http: getLinkText(relationship.getLinks().get("self"))); Assert.assertEquals("http: getLinkText(relationship.getLinks().get("related"))); Nullable<ResourceIdentifier> relationshipData = relationship.getSingleData(); Assert.assertFalse(relationshipData.isPresent()); Assert.assertTrue(document.getIncluded().isEmpty()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void checkAccepts() { HttpRequestContextBase context = Mockito.mock(HttpRequestContextBase.class); Mockito.when(context.getMethod()).thenReturn("GET"); Mockito.when(context.getRequestHeader(Mockito.eq(HttpHeaders.HTTP_HEADER_ACCEPT))).thenReturn(HttpHeaders.JSON_CONTENT_TYPE); HttpRequestProcessor requestProcessor = module.getRequestProcessor(); HttpRequestContextBaseAdapter contextAdapter = new HttpRequestContextBaseAdapter(context); Mockito.when(context.getPath()).thenReturn("/"); Assert.assertTrue(requestProcessor.accepts(contextAdapter)); Mockito.when(context.getPath()).thenReturn("/doesNotExists"); Assert.assertFalse(requestProcessor.accepts(contextAdapter)); Mockito.when(context.getPath()).thenReturn("/tasks"); Assert.assertFalse(requestProcessor.accepts(contextAdapter)); }
|
protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; } }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; } protected HomeModule(); }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { protected HttpRequestProcessor getRequestProcessor() { return requestProcessor; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); static final String JSON_HOME_CONTENT_TYPE; static final String JSON_CONTENT_TYPE; }
|
@Test public void testAttributesSelection() { Task task = createTask(2, "sample task"); task.setCategory("sample category"); task.setProject(new Project()); JsonApiResponse response = new JsonApiResponse(); response.setEntity(task); QuerySpec querySpec = new QuerySpec(Task.class); querySpec.includeField(Arrays.asList("category")); Document document = mapper.toDocument(response, toAdapter(querySpec), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("2", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertNull(resource.getAttributes().get("name")); Assert.assertNull(resource.getRelationships().get("project")); Assert.assertEquals("sample category", resource.getAttributes().get("category").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void testAttributesOrdering() { Task task = createTask(3, "sample task"); task.setCategory("sample category"); task.setName("sample name"); JsonApiResponse response = new JsonApiResponse(); response.setEntity(task); Document document = mapper.toDocument(response, createAdapter(Task.class), mappingConfig).get(); Resource resource = document.getSingleData().get(); Assert.assertEquals("3", resource.getId()); Assert.assertEquals("tasks", resource.getType()); Assert.assertTrue(resource.getAttributes() instanceof LinkedHashMap); Assert.assertEquals(resource.getAttributes().keySet(), Stream.of("category", "completed", "deleted", "name", "otherTasks", "readOnlyValue", "status") .collect(Collectors.toCollection(LinkedHashSet::new))); Assert.assertEquals("sample name", resource.getAttributes().get("name").asText()); Assert.assertEquals("sample category", resource.getAttributes().get("category").asText()); }
|
public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
DocumentMapper { public Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig mappingConfig) { if (response == null) { LOGGER.debug("null response returned"); return null; } int requestVersion = queryAdapter.getQueryContext().getRequestVersion(); ResourceMappingConfig resourceMapping = mappingConfig.getResourceMapping(); Document doc = new Document(); doc.setJsonapi(jsonapi); addErrors(doc, response.getErrors()); util.setMeta(doc, response.getMetaInformation()); if (mappingConfig.getResourceMapping().getSerializeLinks()) { LinksInformation linksInformation = enrichSelfLink(response.getLinksInformation(), queryAdapter); util.setLinks(doc, linksInformation, queryAdapter); } addData(doc, response.getEntity(), queryAdapter, resourceMapping); Result<Document> result = addRelationDataAndInclusions(doc, response.getEntity(), queryAdapter, mappingConfig); result.doWork(it -> applyIgnoreEmpty(doc, queryAdapter, requestVersion)); result.doWork(it -> compact(doc, queryAdapter)); return result; } DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo, UrlBuilder urlBuilder); DocumentMapper(ResourceRegistry resourceRegistry, ObjectMapper objectMapper, PropertiesProvider propertiesProvider,
ResourceFilterDirectory resourceFilterDirectory, ResultFactory resultFactory, Map<String, String> serverInfo,
boolean client, UrlBuilder urlBuilder); ResourceMapper getResourceMapper(); void setClient(boolean client); Result<Document> toDocument(JsonApiResponse response, QueryAdapter queryAdapter, DocumentMappingConfig
mappingConfig); }
|
@Test public void toResourceId() { Task task = new Task(); task.setId(12L); ResourceIdentifier id = util.toResourceId(task); Assert.assertEquals("tasks", id.getType()); Assert.assertEquals("12", id.getId()); }
|
public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
@Test public void nullRoResourceId() { Assert.assertNull(util.toResourceId(null)); }
|
public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
DocumentMapperUtil { public ResourceIdentifier toResourceId(Object entity) { if (entity == null) { return null; } RegistryEntry entry = resourceRegistry.findEntry(entity); ResourceInformation resourceInformation = entry.getResourceInformation(); return resourceInformation.toResourceIdentifier(entity); } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
@Test public void toResourceIds() { Task task = new Task(); task.setId(12L); List<ResourceIdentifier> ids = util.toResourceIds(Arrays.asList(task)); ResourceIdentifier id = ids.get(0); Assert.assertEquals("tasks", id.getType()); Assert.assertEquals("12", id.getId()); }
|
public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; }
|
DocumentMapperUtil { public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; } }
|
DocumentMapperUtil { public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); }
|
DocumentMapperUtil { public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
DocumentMapperUtil { public List<ResourceIdentifier> toResourceIds(Collection<?> entities) { List<ResourceIdentifier> results = new ArrayList<>(); for (Object entity : entities) { results.add(toResourceId(entity)); } return results; } DocumentMapperUtil(ResourceRegistry resourceRegistry, ObjectMapper objectMapper,
PropertiesProvider propertiesProvider, UrlBuilder urlBuilder); @SuppressWarnings({ "unchecked", "rawtypes" }) static List<T> toList(Object entity); Link getRelationshipLink(Resource resource, ResourceField field, boolean related); List<ResourceIdentifier> toResourceIds(Collection<?> entities); ResourceIdentifier toResourceId(Object entity); void setLinks(LinksContainer container, LinksInformation linksInformation, QueryAdapter queryAdapter); void setMeta(MetaContainer container, MetaInformation metaInformation); ResourceInformation getResourceInformation(Object resource); ResourceInformation getResourceInformation(String resourceType); boolean hasResourceInformation(String resourceType); String getSelfUrl(QueryContext queryContext, ResourceInformation resourceInformation, Object entity); static SerializerUtil getSerializerUtil(); }
|
@Test public void resourceWithNoResourcePath() { InformationBuilder.ResourceInformationBuilder resource = builder.createResource(Task.class, "tasks"); ResourceInformation info = resource.build(); resource.superResourceType("superTask"); resource.implementationType(Project.class); Assert.assertEquals("tasks", info.getResourceType()); Assert.assertEquals("tasks", info.getResourcePath()); }
|
@Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
@Test public void resource() { InformationBuilder.ResourceInformationBuilder resource = builder.createResource(Task.class, "tasks", null); resource.superResourceType("superTask"); resource.resourceType("changedTasks"); resource.implementationType(Project.class); InformationBuilder.FieldInformationBuilder idField = resource.addField("id", ResourceFieldType.ID, String.class); idField.serializeType(SerializeType.EAGER); idField.access(new ResourceFieldAccess(true, true, true, false, false)); ResourceFieldAccessor accessor = Mockito.mock(ResourceFieldAccessor.class); InformationBuilder.FieldInformationBuilder projectField = resource.addField("project", ResourceFieldType.RELATIONSHIP, Project.class); projectField.serializeType(SerializeType.EAGER); projectField.access(new ResourceFieldAccess(true, false, true, false, false)); projectField.oppositeName("tasks"); projectField.relationshipRepositoryBehavior(RelationshipRepositoryBehavior.FORWARD_OWNER); projectField.lookupIncludeBehavior(LookupIncludeBehavior.AUTOMATICALLY_ALWAYS); projectField.accessor(accessor); ResourceInformation info = resource.build(); Assert.assertEquals("changedTasks", info.getResourceType()); Assert.assertEquals(Project.class, info.getResourceClass()); Assert.assertEquals("superTask", info.getSuperResourceType()); ResourceField idInfo = info.findFieldByName("id"); Assert.assertEquals("id", idInfo.getUnderlyingName()); Assert.assertEquals(String.class, idInfo.getType()); Assert.assertFalse(idInfo.getAccess().isFilterable()); Assert.assertFalse(idInfo.getAccess().isSortable()); Assert.assertTrue(idInfo.getAccess().isPostable()); Assert.assertTrue(idInfo.getAccess().isPatchable()); Assert.assertEquals(SerializeType.EAGER, idInfo.getSerializeType()); Assert.assertFalse(idInfo.isCollection()); ResourceField projectInfo = info.findFieldByName("project"); Assert.assertEquals("project", projectInfo.getUnderlyingName()); Assert.assertEquals("tasks", projectInfo.getOppositeName()); Assert.assertEquals(LookupIncludeBehavior.AUTOMATICALLY_ALWAYS, projectInfo.getLookupIncludeBehavior()); Assert.assertEquals(Project.class, projectInfo.getType()); Assert.assertSame(accessor, projectInfo.getAccessor()); Assert.assertFalse(projectInfo.getAccess().isFilterable()); Assert.assertFalse(projectInfo.getAccess().isSortable()); Assert.assertFalse(projectInfo.getAccess().isPostable()); Assert.assertTrue(projectInfo.getAccess().isPatchable()); Assert.assertEquals(SerializeType.EAGER, projectInfo.getSerializeType()); Assert.assertEquals(RelationshipRepositoryBehavior.FORWARD_OWNER, projectInfo.getRelationshipRepositoryBehavior()); Assert.assertFalse(projectInfo.isCollection()); }
|
@Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
@Test public void checkRelationIdFieldCreation() { InformationBuilder.ResourceInformationBuilder resource = builder.createResource(Task.class, "tasks", null); resource.superResourceType("superTask"); resource.resourceType("changedTasks"); resource.implementationType(Project.class); InformationBuilder.FieldInformationBuilder idField = resource.addField("id", ResourceFieldType.ID, String.class); idField.serializeType(SerializeType.EAGER); idField.access(new ResourceFieldAccess(true, true, true, false, false)); ResourceFieldAccessor idAccessor = Mockito.mock(ResourceFieldAccessor.class); ResourceFieldAccessor accessor = Mockito.mock(ResourceFieldAccessor.class); InformationBuilder.FieldInformationBuilder projectField = resource.addField("project", ResourceFieldType.RELATIONSHIP, Project.class); projectField.idName("taskId"); projectField.idAccessor(idAccessor); projectField.idType(Long.class); projectField.serializeType(SerializeType.EAGER); projectField.access(new ResourceFieldAccess(true, false, true, false, false)); projectField.oppositeName("tasks"); projectField.lookupIncludeBehavior(LookupIncludeBehavior.AUTOMATICALLY_ALWAYS); projectField.accessor(accessor); ResourceInformation info = resource.build(); Assert.assertEquals("changedTasks", info.getResourceType()); Assert.assertEquals(Project.class, info.getResourceClass()); Assert.assertEquals("superTask", info.getSuperResourceType()); ResourceField projectInfo = info.findFieldByName("project"); Assert.assertEquals("project", projectInfo.getUnderlyingName()); Assert.assertEquals("tasks", projectInfo.getOppositeName()); Assert.assertEquals(LookupIncludeBehavior.AUTOMATICALLY_ALWAYS, projectInfo.getLookupIncludeBehavior()); Assert.assertEquals(Project.class, projectInfo.getType()); Assert.assertSame(accessor, projectInfo.getAccessor()); Assert.assertFalse(projectInfo.getAccess().isFilterable()); Assert.assertFalse(projectInfo.getAccess().isSortable()); Assert.assertFalse(projectInfo.getAccess().isPostable()); Assert.assertTrue(projectInfo.getAccess().isPatchable()); Assert.assertEquals(SerializeType.EAGER, projectInfo.getSerializeType()); Assert.assertTrue(projectInfo.hasIdField()); Assert.assertEquals("taskId", projectInfo.getIdName()); Assert.assertEquals(Long.class, projectInfo.getIdType()); Assert.assertSame(idAccessor, projectInfo.getIdAccessor()); Assert.assertFalse(projectInfo.isCollection()); }
|
@Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
@Test public void checkResourceTypeHolderIngored() { ResourceInformation resourceInformation = builder.createResource(Task.class, "tasks", null).build(); Assert.assertTrue(ResourceTypeHolder.class.isAssignableFrom(ResourceTypeHolder.class)); Assert.assertNull(resourceInformation.findFieldByName("type")); }
|
@Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType) { return createResource(resourceClass, resourceType, null); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
@Test public void checkRelationshipRepository() { InformationBuilder.RelationshipRepositoryInformationBuilder repositoryBuilder = builder.createRelationshipRepository("projects", "tasks"); RepositoryMethodAccess expectedAccess = new RepositoryMethodAccess(true, false, true, false); repositoryBuilder.setAccess(expectedAccess); RelationshipRepositoryInformation repositoryInformation = repositoryBuilder.build(); RepositoryMethodAccess actualAccess = repositoryInformation.getAccess(); Assert.assertEquals(expectedAccess, actualAccess); }
|
@Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); } }
|
DefaultInformationBuilder implements InformationBuilder { @Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); } DefaultInformationBuilder(TypeParser typeParser); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
DefaultInformationBuilder implements InformationBuilder { @Override public RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType) { RelationshipMatcher matcher = new RelationshipMatcher(); matcher.rule().target(targetResourceType).source(sourceResourceType).add(); return createRelationshipRepository(matcher); } DefaultInformationBuilder(TypeParser typeParser); @Override FieldInformationBuilder createResourceField(); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(String sourceResourceType, String targetResourceType); @Override RelationshipRepositoryInformationBuilder createRelationshipRepository(RelationshipMatcher matcher); @Override ResourceRepositoryInformationBuilder createResourceRepository(); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType); @Override ResourceInformationBuilder createResource(Class<?> resourceClass, String resourceType, String resourcePath); }
|
@Test public void moduleName() { HomeModule module = boot.getModuleRegistry().getModule(HomeModule.class).get(); Assert.assertEquals("home", module.getModuleName()); }
|
@Override public String getModuleName() { return "home"; }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { @Override public String getModuleName() { return "home"; } }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { @Override public String getModuleName() { return "home"; } protected HomeModule(); }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { @Override public String getModuleName() { return "home"; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); }
|
HomeModule implements Module, ModuleExtensionAware<HomeModuleExtension> { @Override public String getModuleName() { return "home"; } protected HomeModule(); static HomeModule create(); static HomeModule create(HomeFormat defaultFormat); void addPathFilter(Predicate<HttpRequestContext> pathFilter); @Override String getModuleName(); @Override void setupModule(final ModuleContext context); List<String> list(String requestPath, QueryContext queryContext); boolean hasPotentialFilterIssues(); @Override void setExtensions(List<HomeModuleExtension> extensions); @Override void init(); static final String JSON_HOME_CONTENT_TYPE; static final String JSON_CONTENT_TYPE; }
|
@Test public void enrichSelfLinksInformationNoQuerySpec() { ResourceList resources = new DefaultResourceList(); when(requestSpec.getQueryAdapter()).thenReturn(mock(QueryAdapter.class)); LinksInformation result = RepositoryAdapterUtils.enrichLinksInformation(moduleRegistry, null, resources, requestSpec); assertThat(result, is(nullValue())); }
|
public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; }
|
RepositoryAdapterUtils { public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; } }
|
RepositoryAdapterUtils { public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; } }
|
RepositoryAdapterUtils { public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; } static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry,
LinksInformation linksInformation, Object resource,
RepositoryRequestSpec requestSpec); }
|
RepositoryAdapterUtils { public static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry, LinksInformation linksInformation, Object resource, RepositoryRequestSpec requestSpec) { if (requestSpec.getQueryAdapter() instanceof QuerySpecAdapter && resource instanceof ResourceList) { ResourceList<?> resources = (ResourceList<?>) resource; linksInformation = enrichPageLinksInformation(moduleRegistry, linksInformation, resources, requestSpec); } return linksInformation; } static LinksInformation enrichLinksInformation(ModuleRegistry moduleRegistry,
LinksInformation linksInformation, Object resource,
RepositoryRequestSpec requestSpec); }
|
@Test public void onSingleElementShouldReturnTheSameValue() { String string = "hello world"; List<String> values = Collections.singletonList(string); String result = StringUtils.join(",", values); assertThat(result).isEqualTo(string); }
|
public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }
|
@Test public void onTwoElementsShouldReturnJoinedValues() { List<String> values = Arrays.asList("hello", "world"); String result = StringUtils.join(" ", values); assertThat(result).isEqualTo("hello world"); }
|
public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }
|
@Test public void onIsBlankValues() { assertTrue(StringUtils.isBlank(null)); assertTrue(StringUtils.isBlank("")); assertTrue(StringUtils.isBlank(" ")); assertFalse(StringUtils.isBlank("crnk")); assertFalse(StringUtils.isBlank(" crnk ")); }
|
public static boolean isBlank(String value) { int strLen; if (value == null || (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; }
|
StringUtils { public static boolean isBlank(String value) { int strLen; if (value == null || (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; } }
|
StringUtils { public static boolean isBlank(String value) { int strLen; if (value == null || (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; } private StringUtils(); }
|
StringUtils { public static boolean isBlank(String value) { int strLen; if (value == null || (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); }
|
StringUtils { public static boolean isBlank(String value) { int strLen; if (value == null || (strLen = value.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((!Character.isWhitespace(value.charAt(i)))) { return false; } } return true; } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }
|
@Test public void onJoinOfNulls() { Assert.assertEquals("null,null", StringUtils.join(",", Arrays.asList(null, null))); }
|
public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); }
|
StringUtils { public static String join(String delimiter, Iterable<?> stringsIterable) { List<String> strings = new LinkedList<>(); Iterator<?> iterator = stringsIterable.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); if (obj == null) { strings.add(null); } else { strings.add(obj.toString()); } } StringBuilder ab = new StringBuilder(); for (int i = 0; i < strings.size(); i++) { ab.append(strings.get(i)); if (i != strings.size() - 1) { ab.append(delimiter); } } return ab.toString(); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }
|
@Test public void checkDecapitalize() { Assert.assertEquals("", StringUtils.decapitalize("")); Assert.assertEquals("test", StringUtils.decapitalize("Test")); Assert.assertEquals("someTest", StringUtils.decapitalize("SomeTest")); }
|
public static String decapitalize(String name) { if (name == null || name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); }
|
StringUtils { public static String decapitalize(String name) { if (name == null || name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); } }
|
StringUtils { public static String decapitalize(String name) { if (name == null || name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); } private StringUtils(); }
|
StringUtils { public static String decapitalize(String name) { if (name == null || name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); }
|
StringUtils { public static String decapitalize(String name) { if (name == null || name.length() == 0) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); } private StringUtils(); static String join(String delimiter, Iterable<?> stringsIterable); static boolean isBlank(String value); static String emptyToNull(String value); static String decapitalize(String name); static String firstToUpper(String name); static String nullToEmpty(String value); static final String EMPTY; }
|
@Test public void onNullBeanGetShouldThrowException() { expectedException.expect(IllegalArgumentException.class); PropertyUtils.getProperty(null, "privatePropertyWithMutators"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onBooleanWithGetPrefix() { Bean bean = new Bean(); bean.setBooleanWithGetPrefix(true); Object result = PropertyUtils.getProperty(bean, "booleanWithGetPrefix"); assertThat(result).isEqualTo(true); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onNullFieldGetShouldThrowException() { Bean bean = new Bean(); expectedException.expect(IllegalArgumentException.class); PropertyUtils.getProperty(bean, (String) null); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onBooleanPrimitiveWithMutatorsShouldReturnValue() { Bean bean = new Bean(); bean.setBooleanPrimitivePropertyWithMutators(true); Object result = PropertyUtils .getProperty(bean, "booleanPrimitivePropertyWithMutators"); assertThat(result).isEqualTo(true); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void testSetObjectMapper() { ObjectMapper myObjectMapper = new ObjectMapper(); client = new CrnkClient(getBaseUri().toString()) { protected ObjectMapper createDefaultObjectMapper() { throw new IllegalStateException("this should not happer"); } }; client.setObjectMapper(myObjectMapper); Assert.assertSame(myObjectMapper, client.getObjectMapper()); ResourceRepository<Schedule, Object> repository = client.getRepositoryForType(Schedule.class); repository.findAll(new QuerySpec(Schedule.class)); }
|
public void setObjectMapper(ObjectMapper objectMapper) { PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already configured, consider calling SetObjectMapper earlier or and avoid multiple calls"); this.objectMapper = objectMapper; this.configureObjectMapper(); }
|
CrnkClient { public void setObjectMapper(ObjectMapper objectMapper) { PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already configured, consider calling SetObjectMapper earlier or and avoid multiple calls"); this.objectMapper = objectMapper; this.configureObjectMapper(); } }
|
CrnkClient { public void setObjectMapper(ObjectMapper objectMapper) { PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already configured, consider calling SetObjectMapper earlier or and avoid multiple calls"); this.objectMapper = objectMapper; this.configureObjectMapper(); } CrnkClient(String serviceUrl); CrnkClient(String serviceUrl, ClientType clientType); CrnkClient(ServiceUrlProvider serviceUrlProvider, ClientType clientType); }
|
CrnkClient { public void setObjectMapper(ObjectMapper objectMapper) { PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already configured, consider calling SetObjectMapper earlier or and avoid multiple calls"); this.objectMapper = objectMapper; this.configureObjectMapper(); } CrnkClient(String serviceUrl); CrnkClient(String serviceUrl, ClientType clientType); CrnkClient(ServiceUrlProvider serviceUrlProvider, ClientType clientType); int getVersion(); void setVersion(int version); ClientFormat getFormat(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); QueryContext getQueryContext(); void findModules(); void setProxyFactory(ClientProxyFactory proxyFactory); void registerHttpAdapterProvider(HttpAdapterProvider httpAdapterProvider); List<HttpAdapterProvider> getHttpAdapterProviders(); @SuppressWarnings("unchecked") R getRepositoryForInterface(Class<R> repositoryInterfaceClass); @SuppressWarnings({ "unchecked", "rawtypes" }) ResourceRepository<T, I> getRepositoryForType(Class<T> resourceClass); ResourceRepository<Resource, String> getRepositoryForPath(String resourceType); RelationshipRepository<Resource, String, Resource, String> getRepositoryForPath(String sourceResourceType,
String targetResourceType); @SuppressWarnings({ "unchecked", "rawtypes" }) RelationshipRepository<T, I, D, J> getRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); ManyRelationshipRepository<T, I, D, J> getManyRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); OneRelationshipRepository<T, I, D, J> getOneRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); ResourceRegistry getRegistry(); void addModule(Module module); HttpAdapter getHttpAdapter(); void setHttpAdapter(HttpAdapter httpAdapter); ExceptionMapperRegistry getExceptionMapperRegistry(); ActionStubFactory getActionStubFactory(); void setActionStubFactory(ActionStubFactory actionStubFactory); QuerySpecUrlMapper getUrlMapper(); void setUrlMapper(QuerySpecUrlMapper urlMapper); ModuleRegistry getModuleRegistry(); ClientDocumentMapper getDocumentMapper(); ServiceUrlProvider getServiceUrlProvider(); }
|
CrnkClient { public void setObjectMapper(ObjectMapper objectMapper) { PreconditionUtil.verify(this.objectMapper == null, "ObjectMapper already configured, consider calling SetObjectMapper earlier or and avoid multiple calls"); this.objectMapper = objectMapper; this.configureObjectMapper(); } CrnkClient(String serviceUrl); CrnkClient(String serviceUrl, ClientType clientType); CrnkClient(ServiceUrlProvider serviceUrlProvider, ClientType clientType); int getVersion(); void setVersion(int version); ClientFormat getFormat(); ServiceDiscovery getServiceDiscovery(); void setServiceDiscovery(ServiceDiscovery serviceDiscovery); QueryContext getQueryContext(); void findModules(); void setProxyFactory(ClientProxyFactory proxyFactory); void registerHttpAdapterProvider(HttpAdapterProvider httpAdapterProvider); List<HttpAdapterProvider> getHttpAdapterProviders(); @SuppressWarnings("unchecked") R getRepositoryForInterface(Class<R> repositoryInterfaceClass); @SuppressWarnings({ "unchecked", "rawtypes" }) ResourceRepository<T, I> getRepositoryForType(Class<T> resourceClass); ResourceRepository<Resource, String> getRepositoryForPath(String resourceType); RelationshipRepository<Resource, String, Resource, String> getRepositoryForPath(String sourceResourceType,
String targetResourceType); @SuppressWarnings({ "unchecked", "rawtypes" }) RelationshipRepository<T, I, D, J> getRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); ManyRelationshipRepository<T, I, D, J> getManyRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); OneRelationshipRepository<T, I, D, J> getOneRepositoryForType(
Class<T> sourceClass, Class<D> targetClass); ObjectMapper getObjectMapper(); void setObjectMapper(ObjectMapper objectMapper); ResourceRegistry getRegistry(); void addModule(Module module); HttpAdapter getHttpAdapter(); void setHttpAdapter(HttpAdapter httpAdapter); ExceptionMapperRegistry getExceptionMapperRegistry(); ActionStubFactory getActionStubFactory(); void setActionStubFactory(ActionStubFactory actionStubFactory); QuerySpecUrlMapper getUrlMapper(); void setUrlMapper(QuerySpecUrlMapper urlMapper); ModuleRegistry getModuleRegistry(); ClientDocumentMapper getDocumentMapper(); ServiceUrlProvider getServiceUrlProvider(); }
|
@Test public void methodPropertyShouldReturnValue() { Bean bean = new Bean(); Object result = PropertyUtils .getProperty(bean, "methodProperty"); assertThat(result).isEqualTo("noFieldsHere"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void getPropertyClassForMethodPropertyShouldReturnClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "methodProperty"); assertThat(result).isEqualTo(String.class); }
|
public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void getPropertyTypeForMethodPropertyShouldReturnType() { Object result = PropertyUtils.getPropertyType(Bean.class, "methodProperty"); assertThat(result).isEqualTo(String.class); }
|
public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void getPropertyTypeForSetShouldReturnGenericType() { Object result = PropertyUtils.getPropertyType(Bean.class, "setProperty"); assertThat(ParameterizedType.class).isAssignableFrom(result.getClass()); }
|
public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onBooleanWithMutatorsShouldReturnValue() { Bean bean = new Bean(); bean.setBooleanPropertyWithMutators(true); Object result = PropertyUtils.getProperty(bean, "booleanPropertyWithMutators"); assertThat(result).isEqualTo(true); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onStringPublicWithMutatorsShouldReturnValue() { Bean bean = new Bean(); bean.publicProperty = "value"; Object result = PropertyUtils.getProperty(bean, "publicProperty"); assertThat(result).isEqualTo("value"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onStringPublicReturnStringClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "publicProperty"); assertThat(result).isEqualTo(String.class); }
|
public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void getPropertyClassShouldThrowExceptionForInvalidField() { try { PropertyUtils.getPropertyClass(Bean.class, "doesNotExist"); Assert.fail(); } catch (PropertyException e) { Assert.assertEquals("doesNotExist", e.getField()); Assert.assertEquals(Bean.class, e.getResourceClass()); } }
|
public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void getPropertyTypeShouldThrowExceptionForInvalidField() { try { PropertyUtils.getPropertyType(Bean.class, "doesNotExist"); Assert.fail(); } catch (PropertyException e) { Assert.assertEquals("doesNotExist", e.getField()); Assert.assertEquals(Bean.class, e.getResourceClass()); } }
|
public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onStringPublicReturnStringType() { Object result = PropertyUtils.getPropertyType(Bean.class, "publicProperty"); assertThat(result).isEqualTo(String.class); }
|
public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Type getPropertyType(Class<?> beanClass, String field) { return INSTANCE.findPropertyType(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void testUIDComputation() { Serializable id = "test"; RegistryEntry entry = Mockito.mock(RegistryEntry.class); ResourceInformation resourceInformation = Mockito.mock(ResourceInformation.class); Mockito.when(resourceInformation.getResourceType()).thenReturn("someType"); Mockito.when(resourceInformation.toIdString(Mockito.eq(id))).thenReturn("someId"); Mockito.when(entry.getResourceInformation()).thenReturn(resourceInformation); String uid = upsert.getUID(entry, id); Assert.assertEquals("someType#someId", uid); }
|
public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); }
|
ClientResourceUpsert extends ResourceUpsert { public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); } }
|
ClientResourceUpsert extends ResourceUpsert { public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); }
|
ClientResourceUpsert extends ResourceUpsert { public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }
|
ClientResourceUpsert extends ResourceUpsert { public String getUID(ResourceIdentifier id) { return id.getType() + "#" + id.getId(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }
|
@Test public void onBooleanPropertyWithMutatorsReturnBooleanClass() { Object result = PropertyUtils.getPropertyClass(Bean.class, "booleanPropertyWithMutators"); assertThat(result).isEqualTo(Boolean.class); }
|
public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Class<?> getPropertyClass(Class<?> beanClass, String field) { return INSTANCE.findPropertyClass(beanClass, field); } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onStringProtectedGetWithMutatorsShouldThrowException() { Bean bean = new Bean(); expectedException.expect(PropertyException.class); PropertyUtils.getProperty(bean, "protectedProperty"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onInheritedStringPrivateWithMutatorsShouldReturnValue() { Bean bean = new ChildBean(); bean.setPrivatePropertyWithMutators("value"); Object result = PropertyUtils.getProperty(bean, "privatePropertyWithMutators"); assertThat(result).isEqualTo("value"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onMethodAccessorOnlyShouldReturnValue() { GetterTest bean = new GetterTest(); Object result = PropertyUtils.getProperty(bean, "property"); assertThat(result).isEqualTo("valueProperty"); }
|
public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static Object getProperty(Object bean, String field) { INSTANCE.checkParameters(bean, field); try { return INSTANCE.getPropertyValue(bean, field); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onListValueForSetPropertyShouldGetConverted() { Bean bean = new Bean(); PropertyUtils.setProperty(bean, "setProperty", Arrays.asList("4", "1", "3", "2")); assertEquals(bean.getSetProperty(), new LinkedHashSet(Arrays.asList("4", "1", "3", "2"))); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onNullBeanSetShouldThrowException() { expectedException.expect(IllegalArgumentException.class); PropertyUtils.setProperty(null, "privatePropertyWithMutators", null); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onNullFieldSetShouldThrowException() { Bean bean = new Bean(); expectedException.expect(IllegalArgumentException.class); PropertyUtils.setProperty(bean, null, null); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onBooleanPrimitiveWithMutatorsShouldSetValue() { Bean bean = new Bean(); PropertyUtils.setProperty(bean, "booleanPrimitivePropertyWithMutators", true); assertThat(bean.isBooleanPrimitivePropertyWithMutators()).isEqualTo(true); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onBooleanWithMutatorsShouldSetValue() { Bean bean = new Bean(); PropertyUtils.setProperty(bean, "booleanPropertyWithMutators", true); assertThat(bean.getBooleanPropertyWithMutators()).isEqualTo(true); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test public void onStringPublicWithMutatorsShouldSetValue() { Bean bean = new Bean(); PropertyUtils.setProperty(bean, "publicProperty", "value"); assertThat(bean.publicProperty).isEqualTo("value"); }
|
public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
PropertyUtils { public static void setProperty(Object bean, String field, Object value) { INSTANCE.checkParameters(bean, field); try { INSTANCE.setPropertyValue(bean, field, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { throw handleReflectionException(bean.getClass(), field, e); } } private PropertyUtils(); static Object getProperty(Object bean, String field); static Class<?> getPropertyClass(Class<?> beanClass, String field); static Type getPropertyType(Class<?> beanClass, String field); static Object getProperty(Object bean, List<String> propertyPath); static Class<?> getPropertyClass(Class<?> clazz, List<String> propertyPath); static void setProperty(Object bean, String field, Object value); @SuppressWarnings("unchecked") static Object prepareValue(Object value, Class<?> fieldClass); }
|
@Test(expected = UnsupportedOperationException.class) public void testAcceptableNotSupported() { upsert.isAcceptable(null, null); }
|
@Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); }
|
ClientResourceUpsert extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); } }
|
ClientResourceUpsert extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); }
|
ClientResourceUpsert extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }
|
ClientResourceUpsert extends ResourceUpsert { @Override public boolean isAcceptable(JsonPath jsonPath, String method) { throw new UnsupportedOperationException(); } ClientResourceUpsert(ClientProxyFactory proxyFactory); String getUID(ResourceIdentifier id); String getUID(RegistryEntry entry, Serializable id); void setRelations(List<Resource> resources, QueryContext queryContext); List<Object> allocateResources(List<Resource> resources, QueryContext queryContext); @Override boolean isAcceptable(JsonPath jsonPath, String method); @Override Result<Response> handleAsync(JsonPath jsonPath, QueryAdapter queryAdapter, Document requestDocument); }
|
@Test(expected = RepositoryNotFoundException.class) public void testBlackListingOfUnknownClass() { QueryContext queryContext = Mockito.mock(QueryContext.class); securityModule.isAllowed(queryContext, UnknownResource.class, ResourcePermission.GET); }
|
public boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission) { String resourceType = toType(resourceClass); return isAllowed(queryContext, resourceType, permission); }
|
SecurityModule implements Module { public boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission) { String resourceType = toType(resourceClass); return isAllowed(queryContext, resourceType, permission); } }
|
SecurityModule implements Module { public boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission) { String resourceType = toType(resourceClass); return isAllowed(queryContext, resourceType, permission); } protected SecurityModule(); protected SecurityModule(SecurityConfig config); }
|
SecurityModule implements Module { public boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission) { String resourceType = toType(resourceClass); return isAllowed(queryContext, resourceType, permission); } protected SecurityModule(); protected SecurityModule(SecurityConfig config); DataRoomMatcher getDataRoomMatcher(); static SecurityModule newServerModule(SecurityConfig config); static SecurityModule newClientModule(); void setEnabled(final boolean enabled); boolean isEnabled(); void setEnabled(Supplier<Boolean> enabled); @Override String getModuleName(); void reconfigure(SecurityConfig config); SecurityConfig getConfig(); @Override void setupModule(ModuleContext context); boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission); boolean isAllowed(QueryContext queryContext, String resourceType, ResourcePermission permission); ResourcePermission getCallerPermissions(QueryContext queryContext, String resourceType); ResourcePermission getRolePermissions(QueryContext queryContext, String resourceType, String checkedRole); ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass); ResourcePermission getResourcePermission(QueryContext queryContext, String resourceType); boolean isUserInRole(QueryContext queryContext, String role); SecurityProvider getCallerSecurityProvider(); }
|
SecurityModule implements Module { public boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission) { String resourceType = toType(resourceClass); return isAllowed(queryContext, resourceType, permission); } protected SecurityModule(); protected SecurityModule(SecurityConfig config); DataRoomMatcher getDataRoomMatcher(); static SecurityModule newServerModule(SecurityConfig config); static SecurityModule newClientModule(); void setEnabled(final boolean enabled); boolean isEnabled(); void setEnabled(Supplier<Boolean> enabled); @Override String getModuleName(); void reconfigure(SecurityConfig config); SecurityConfig getConfig(); @Override void setupModule(ModuleContext context); boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission); boolean isAllowed(QueryContext queryContext, String resourceType, ResourcePermission permission); ResourcePermission getCallerPermissions(QueryContext queryContext, String resourceType); ResourcePermission getRolePermissions(QueryContext queryContext, String resourceType, String checkedRole); ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass); ResourcePermission getResourcePermission(QueryContext queryContext, String resourceType); boolean isUserInRole(QueryContext queryContext, String role); SecurityProvider getCallerSecurityProvider(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.