Java Code Examples for org.springframework.data.repository.core.RepositoryInformation#getDomainType()

@Override
protected Object getTargetRepository(RepositoryInformation repositoryInformation) {

    JdbcAggregateTemplate template = new JdbcAggregateTemplate(publisher, context, converter, accessStrategy);

    Class<?> type = repositoryInformation.getDomainType();
    RelationalPath<?> relationalPathBase = getRelationalPathBase(repositoryInformation);
    ConstructorExpression<?> constructor = getConstructorExpression(type, relationalPathBase);
    SimpleQuerydslJdbcRepository<?, ?> repository = new SimpleQuerydslJdbcRepository(template,
                                                                                        context.getRequiredPersistentEntity(
                                                                                                type),
                                                                                        sqlQueryFactory,
                                                                                        constructor,
                                                                                        relationalPathBase);

    if (entityCallbacks != null) {
        template.setEntityCallbacks(entityCallbacks);
    }

    return repository;
}
 

public static Object findOne(Repositories repositories, Class<?> domainObjClass,
		String id) throws HttpRequestMethodNotSupportedException {

	Optional<Object> domainObj = null;

	RepositoryInformation ri = RepositoryUtils.findRepositoryInformation(repositories,
			domainObjClass);

	if (ri == null) {
		throw new ResourceNotFoundException();
	}

	Class<?> domainObjClazz = ri.getDomainType();
	Class<?> idClazz = ri.getIdType();

	Optional<Method> findOneMethod = ri.getCrudMethods().getFindOneMethod();
	if (!findOneMethod.isPresent()) {
		throw new HttpRequestMethodNotSupportedException("fineOne");
	}

	Object oid = new DefaultConversionService().convert(id, idClazz);
	domainObj = (Optional<Object>) ReflectionUtils.invokeMethod(findOneMethod.get(),
			repositories.getRepositoryFor(domainObjClazz).get(), oid);

	return domainObj.orElseThrow(ResourceNotFoundException::new);
}
 

public static Object save(Repositories repositories, Object domainObj)
		throws HttpRequestMethodNotSupportedException {

	RepositoryInformation ri = RepositoryUtils.findRepositoryInformation(repositories,
			domainObj.getClass());

	if (ri == null) {
		throw new ResourceNotFoundException();
	}

	Class<?> domainObjClazz = ri.getDomainType();

	if (domainObjClazz != null) {
		Optional<Method> saveMethod = ri.getCrudMethods().getSaveMethod();
		if (!saveMethod.isPresent()) {
			throw new HttpRequestMethodNotSupportedException("save");
		}
		domainObj = ReflectionUtils.invokeMethod(saveMethod.get(),
				repositories.getRepositoryFor(domainObjClazz).get(), domainObj);
	}

	return domainObj;
}
 

@Override
protected Object getTargetRepository(RepositoryInformation metadata) {
  Class<?> domainType = metadata.getDomainType();
  ElasticsearchEntityInformation<?, Serializable> entityInformation =
      getEntityInformation(domainType);
  if (!hasAclStrategyAnnotation(domainType)) {
    return getTargetRepositoryViaReflection(metadata, entityInformation,
        elasticsearchOperations);
  }

  // invokes
  // com.github.lothar.security.acl.elasticsearch.repository.AclElasticsearchRepository.AclNumberKeyedRepository(ElasticsearchEntityInformation<T,
  // ID>, ElasticsearchOperations, AclFilterProvider)
  ElasticsearchRepository<?, ?> repository = getTargetRepositoryViaReflection(metadata,
      entityInformation, elasticsearchOperations, filterProvider);
  logger.debug("Created {}", repository);

  return repository;
}
 

@ResponseBody
@RequestMapping(value = ENTITY_FINDALLLATESTVERSION_MAPPING, method = RequestMethod.GET)
public ResponseEntity<?> findAllLatestVersion(RootResourceInformation repoInfo,
											  PersistentEntityResourceAssembler assembler,
											  @PathVariable String repository)
		throws ResourceNotFoundException, HttpRequestMethodNotSupportedException {

	RepositoryInformation repositoryInfo = RepositoryUtils.findRepositoryInformation(repositories, repository);
	Class<?> domainType = repositoryInfo.getDomainType();

	List result = (List)ReflectionUtils.invokeMethod(FINDALLLATESTVERSION_METHOD, repositories.getRepositoryFor(domainType).get());

	return ResponseEntity.ok(toResources(result, assembler, this.pagedResourcesAssembler, domainType, null));
}
 

public static Object findOne(Repositories repositories, String repository, String id)
		throws HttpRequestMethodNotSupportedException {

	Optional<Object> domainObj = null;

	RepositoryInformation ri = RepositoryUtils.findRepositoryInformation(repositories, repository);

	if (ri == null) {
		throw new ResourceNotFoundException();
	}

	Class<?> domainObjClazz = ri.getDomainType();
	Class<?> idClazz = ri.getIdType();

	Optional<Method> findOneMethod = ri.getCrudMethods().getFindOneMethod();
	if (!findOneMethod.isPresent()) {
		throw new HttpRequestMethodNotSupportedException("fineOne");
	}

	Object oid = new DefaultConversionService().convert(id, idClazz);
	domainObj = (Optional<Object>) ReflectionUtils.invokeMethod(findOneMethod.get(),
			repositories.getRepositoryFor(domainObjClazz).get(), oid);

	if (null == domainObj) {
		throw new ResourceNotFoundException();
	}

	return domainObj.orElseThrow(ResourceNotFoundException::new);
}
 

public static Iterable findAll(Repositories repositories, String repository)
		throws HttpRequestMethodNotSupportedException {

	Iterable entities = null;

	RepositoryInformation ri = RepositoryUtils.findRepositoryInformation(repositories, repository);

	if (ri == null) {
		throw new ResourceNotFoundException();
	}

	Class<?> domainObjClazz = ri.getDomainType();
	Class<?> idClazz = ri.getIdType();

	Optional<Method> findAllMethod = ri.getCrudMethods().getFindAllMethod();
	if (!findAllMethod.isPresent()) {
		throw new HttpRequestMethodNotSupportedException("fineAll");
	}

	entities = (Iterable) ReflectionUtils.invokeMethod(findAllMethod.get(),
			repositories.getRepositoryFor(domainObjClazz));

	if (null == entities) {
		throw new ResourceNotFoundException();
	}

	return entities;
}
 

protected SimpleJpaRepository<?, ?> getTargetRepository(RepositoryInformation information,
    EntityManager entityManager) {
  Class<?> domainType = information.getDomainType();
  if (!hasAclStrategyAnnotation(domainType)) {
    return super.getTargetRepository(information, entityManager);
  }

  JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(domainType);

  // invokes
  // com.github.lothar.security.acl.jpa.repository.AclJpaRepository.AclJpaRepository(JpaEntityInformation<T,
  // ?>, EntityManager, JpaSpecProvider<T>)
  SimpleJpaRepository<?, ?> repository = getTargetRepositoryViaReflection(information,
      entityInformation, entityManager, jpaSpecProvider);
  logger.debug("Created {}", repository);

  return repository;
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
protected Object getTargetRepository(final RepositoryInformation metadata) {
	return new SimpleArangoRepository(arangoOperations, metadata.getDomainType());
}
 

@Override
protected Object getTargetRepository(RepositoryInformation information) {
    return new BaseRepositoryImpl<T, I>((Class<T>) information.getDomainType(), em);
}
 

@Override
@SuppressWarnings("unchecked")
protected Object getTargetRepository(RepositoryInformation information) {
	return new SoftDeletesRepositoryImpl<T, ID>((Class<T>) information.getDomainType(), entityManager);
}