/** * Set the {@link QueryParamsBuilder} to use to parse and handle query parameters. * When invoked, overwrites previous QueryParamsBuilders and {@link QuerySpecDeserializer}s. * * @param queryParamsBuilder */ public void setQueryParamsBuilds(QueryParamsBuilder queryParamsBuilder) { PreconditionUtil.assertNotNull("A query params builder must be provided, but is null", queryParamsBuilder); this.queryParamsBuilder = queryParamsBuilder; this.querySpecDeserializer = null; }
/** * Returns a {@link SecurityProvider} instance that combines all instances * registered by modules. * * @return resource lookup */ public ServiceDiscovery getServiceDiscovery() { PreconditionUtil.assertNotNull("serviceDiscovery not yet available", serviceDiscovery); return serviceDiscovery; }
/** * Set the {@link QuerySpecDeserializer} to use to parse and handle query parameters. * When invoked, overwrites previous {@link QueryParamsBuilder}s and QuerySpecDeserializers. * * @param querySpecDeserializer */ public void setQuerySpecDeserializer(QuerySpecDeserializer querySpecDeserializer) { PreconditionUtil.assertNotNull("A query spec deserializer must be provided, but is null", querySpecDeserializer); this.querySpecDeserializer = querySpecDeserializer; this.queryParamsBuilder = null; }
public RequestDispatcher getRequestDispatcher() { PreconditionUtil.assertNotNull("expected requestDispatcher", requestDispatcher); return requestDispatcher; }
public List<V> getList(K key) { List<V> list = map.get(key); PreconditionUtil.assertNotNull("key not available", list); return list; }
public static RepositoryRequestSpec forFindTarget(ModuleRegistry moduleRegistry, QueryAdapter queryAdapter, List<?> ids, ResourceField relationshipField) { RepositoryRequestSpecImpl spec = new RepositoryRequestSpecImpl(moduleRegistry); spec.queryAdapter = queryAdapter; spec.ids = ids; spec.relationshipField = relationshipField; spec.method = HttpMethod.GET; PreconditionUtil.assertNotNull("relationshipField is null", relationshipField); return spec; }
public static RepositoryRequestSpecImpl forRelation(ModuleRegistry moduleRegistry, HttpMethod method, Object entity, QueryAdapter queryAdapter, Iterable<?> ids, ResourceField relationshipField) { RepositoryRequestSpecImpl spec = new RepositoryRequestSpecImpl(moduleRegistry); spec.entity = entity; spec.queryAdapter = queryAdapter; spec.ids = ids; spec.relationshipField = relationshipField; spec.method = method; PreconditionUtil.assertNotNull("relationshipField is null", relationshipField); return spec; }
public String getOppositeResourceType() { PreconditionUtil.assertEquals("not an association", ResourceFieldType.RELATIONSHIP, resourceFieldType); PreconditionUtil.assertNotNull("resourceType must not be null", oppositeResourceType); return oppositeResourceType; }
/** * Sets the maximum page limit allowed for paginated requests. * <p> * This is important to prevent denial of service attacks on the server. * <p> * NOTE: This using this feature requires a {@link QuerySpecDeserializer} and it does not work with the * deprecated {@link QueryParamsBuilder}. * * @param maxPageLimit */ public void setMaxPageLimit(Long maxPageLimit) { PreconditionUtil.assertNotNull("Setting the max page limit requires using the QuerySpecDeserializer, but " + "it is null. Are you using QueryParams instead?", this.querySpecDeserializer); ((DefaultQuerySpecDeserializer) this.querySpecDeserializer).setMaxPageLimit(maxPageLimit); }
/** * Sets the default page limit for requests that return a collection of elements. If the api user does not * specify the page limit, then this default value will be used. * <p> * This is important to prevent denial of service attacks on the server. * <p> * NOTE: This using this feature requires a {@link QuerySpecDeserializer} and it does not work with the * deprecated {@link QueryParamsBuilder}. * * @param defaultPageLimit */ public void setDefaultPageLimit(Long defaultPageLimit) { PreconditionUtil.assertNotNull("Setting the default page limit requires using the QuerySpecDeserializer, but " + "it is null. Are you using QueryParams instead?", this.querySpecDeserializer); ((DefaultQuerySpecDeserializer) this.querySpecDeserializer).setDefaultLimit(defaultPageLimit); }
public MetaAttribute getAttribute(String name) { setupCache(); MetaAttribute attr = attrMap.get(name); PreconditionUtil.assertNotNull(getName() + "." + name, attr); return attr; }
/** * @param meta * of the entity * @return Gets the primary key attribute of the given entity. Assumes a * primary key is available and no compound primary keys are * supported. */ public static MetaAttribute getPrimaryKeyAttr(MetaDataObject meta) { MetaKey primaryKey = meta.getPrimaryKey(); PreconditionUtil.assertNotNull("no primary key", primaryKey); PreconditionUtil.assertEquals("non-compound primary key expected", 1, primaryKey.getElements().size()); return primaryKey.getElements().get(0); }
public void setIncludedElements(Document document, Object entity, QueryAdapter queryAdapter, RepositoryMethodParameterProvider parameterProvider, Set<String> additionalEagerLoadedRelations) { List<Object> entityList = DocumentMapperUtil.toList(entity); List<Resource> dataList = DocumentMapperUtil.toList(document.getData().get()); Map<ResourceIdentifier, Resource> dataMap = new HashMap<>(); Map<ResourceIdentifier, Object> entityMap = new HashMap<>(); for (int i = 0; i < dataList.size(); i++) { Resource dataElement = dataList.get(i); ResourceIdentifier id = dataElement.toIdentifier(); entityMap.put(id, entityList.get(i)); dataMap.put(id, dataElement); } Map<ResourceIdentifier, Resource> resourceMap = new HashMap<>(); resourceMap.putAll(dataMap); Set<ResourceIdentifier> inclusions = new HashSet<>(); PopulatedCache populatedCache = new PopulatedCache(); ArrayList<ResourceField> stack = new ArrayList<>(); populate(dataList, inclusions, resourceMap, entityMap, stack, queryAdapter, parameterProvider, additionalEagerLoadedRelations, populatedCache); // no need to include resources included in the data section inclusions.removeAll(dataMap.keySet()); // setup included section ArrayList<Resource> included = new ArrayList<>(); for (ResourceIdentifier inclusionId : inclusions) { Resource includedResource = resourceMap.get(inclusionId); PreconditionUtil.assertNotNull("resource not found", includedResource); included.add(includedResource); } Collections.sort(included); LOGGER.debug("Extracted included resources {}", included.toString()); document.setIncluded(included); }
private void setupServiceUrlProvider() { if (serviceUrlProvider == null) { String resourceDefaultDomain = getProperty(KatharsisProperties.RESOURCE_DEFAULT_DOMAIN); String webPathPrefix = getWebPathPrefix(); if (resourceDefaultDomain != null) { String serviceUrl = buildServiceUrl(resourceDefaultDomain, webPathPrefix); serviceUrlProvider = new ConstantServiceUrlProvider(serviceUrl); } else { // serviceUrl is obtained from incoming request context serviceUrlProvider = defaultServiceUrlProvider; } } PreconditionUtil.assertNotNull("expected serviceUrlProvider", serviceUrlProvider); }
public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) { this.locator = locator; ConfigurationBuilder builder = new ConfigurationBuilder(); PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages); FilterBuilder filter = new FilterBuilder(); for (String resourceSearchPackage : resourceSearchPackages.split(",")) { builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage)); filter.includePackage(resourceSearchPackage); } filter.includePackage(Repository.class.getPackage().getName()); filter.includePackage(ResourceRepository.class.getPackage().getName()); builder = builder.filterInputsBy(filter); builder = builder.addUrls(ClasspathHelper.forClass(Repository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class)); builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()); reflections = new Reflections(builder); }
private RepositoryInformation buildInformation(Object repository, Class<? extends Object> repositoryClass, RepositoryInformationBuilderContext context) { Class<?> sourceResourceClass = getSourceResourceClass(repository, repositoryClass); Class<?> targetResourceClass = getTargetResourceClass(repository, repositoryClass); PreconditionUtil.assertNotNull("no sourceResourceClass", sourceResourceClass); PreconditionUtil.assertNotNull("no targetResourceClass", targetResourceClass); ResourceInformationBuilder resourceInformationBuilder = context.getResourceInformationBuilder(); PreconditionUtil.assertTrue("cannot get ResourceInformation for " + sourceResourceClass, resourceInformationBuilder.accept(sourceResourceClass)); ResourceInformation sourceResourceInformation = resourceInformationBuilder.build(sourceResourceClass); ResourceInformation targetResourceInformation; if (resourceInformationBuilder.accept(targetResourceClass)) { targetResourceInformation = resourceInformationBuilder.build(targetResourceClass); } else { // support for polymorphism like relations to java.lang.Object targetResourceInformation = new ResourceInformation(context.getTypeParser(), targetResourceClass, null, null, null); } return new RelationshipRepositoryInformationImpl(repositoryClass, sourceResourceInformation, targetResourceInformation); }
private ResourceInformation getResourceInformation(Class<?> resourceClass) { if (resourceRegistry != null) { RegistryEntry entry = resourceRegistry.getEntryForClass(resourceClass); PreconditionUtil.assertNotNull(resourceClass.getName(), entry); return entry.getResourceInformation(); } else { AnnotationResourceInformationBuilder infoBuilder = new AnnotationResourceInformationBuilder( new ResourceFieldNameTransformer()); infoBuilder.init(new DefaultResourceInformationBuilderContext(infoBuilder, new TypeParser())); return infoBuilder.build(resourceClass); } }
private MetaElement getMetaInternal(Type type, Class<? extends MetaElement> elementMetaClass, boolean nullable) { PreconditionUtil.assertNotNull("type must not be null", type); checkInitialized(); MetaElement meta = getUniqueElementByType(type, elementMetaClass); if (meta == null) { synchronized (this) { meta = getUniqueElementByType(type, elementMetaClass); if (meta == null) { boolean wasInitializing = adding; if (!wasInitializing) { adding = true; } meta = allocateMeta(type, elementMetaClass, nullable); if (meta != null) { add(meta); } if (!wasInitializing) { initialize(); } } } } return meta; }
public void add(MetaElement element) { PreconditionUtil.assertNotNull("no name provided", element.getName()); if (element instanceof MetaType) { MetaType typeElement = element.asType();
PreconditionUtil.assertNotNull(information.getResourceType(), metaResource); for (ResourceField field : information.getRelationshipFields()) { if (field.getOppositeName() != null) { MetaAttribute attr = metaResource.getAttribute(field.getUnderlyingName()); MetaAttribute oppositeAttr = oppositeMeta.getAttribute(field.getOppositeName()); PreconditionUtil.assertNotNull(attr.getId() + " opposite not found", oppositeAttr); attr.setOppositeAttribute(oppositeAttr);