Examples with MongoPersistentEntity org.springframework.data.mongodb.core.mapping.MongoPersistentEntity used on opensource projects

Example 1 with MongoPersistentEntity

use of org.springframework.data.mongodb.core.mapping.MongoPersistentEntity in project spring-data-mongodb by spring-projects.

the class MongoOperationsUnitTests method operationsSetUp.

@Before
public final void operationsSetUp() {
    person = new Person("Oliver");
    persons = Arrays.asList(person);
    converter = new AbstractMongoConverter(null) {

        public void write(Object t, Bson bson) {
            ((Document) bson).put("firstName", person.getFirstName());
        }

        @SuppressWarnings("unchecked")
        public <S extends Object> S read(Class<S> clazz, Bson bson) {
            return (S) person;
        }

        public MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> getMappingContext() {
            return null;
        }

        public Object convertToMongoType(Object obj, TypeInformation<?> typeInformation) {
            return null;
        }

        public DBRef toDBRef(Object object, MongoPersistentProperty referingProperty) {
            return null;
        }

        @Override
        public MongoTypeMapper getTypeMapper() {
            return null;
        }
    };
}

Example 2 with MongoPersistentEntity

use of org.springframework.data.mongodb.core.mapping.MongoPersistentEntity in project spring-data-mongodb by spring-projects.

the class ReactiveMongoTemplate method findDistinct.

/*
	 * (non-Javadoc)
	 * @see org.springframework.data.mongodb.core.ReactiveMongoOperations#findDistinct(org.springframework.data.mongodb.core.query.Query, java.lang.String, java.lang.String, java.lang.Class, java.lang.Class)
	 */
@SuppressWarnings("unchecked")
public <T> Flux<T> findDistinct(Query query, String field, String collectionName, Class<?> entityClass, Class<T> resultClass) {
    Assert.notNull(query, "Query must not be null!");
    Assert.notNull(field, "Field must not be null!");
    Assert.notNull(collectionName, "CollectionName must not be null!");
    Assert.notNull(entityClass, "EntityClass must not be null!");
    Assert.notNull(resultClass, "ResultClass must not be null!");
    MongoPersistentEntity<?> entity = getPersistentEntity(entityClass);
    Document mappedQuery = queryMapper.getMappedObject(query.getQueryObject(), entity);
    String mappedFieldName = queryMapper.getMappedFields(new Document(field, 1), entity).keySet().iterator().next();
    Class<T> mongoDriverCompatibleType = mongoDatabaseFactory.getCodecFor(resultClass).map(Codec::getEncoderClass).orElse((Class) BsonValue.class);
    Flux<?> result = execute(collectionName, collection -> {
        DistinctPublisher<T> publisher = collection.distinct(mappedFieldName, mappedQuery, mongoDriverCompatibleType);
        return query.getCollation().map(Collation::toMongoCollation).map(publisher::collation).orElse(publisher);
    });
    if (resultClass == Object.class || mongoDriverCompatibleType != resultClass) {
        Class<?> targetType = getMostSpecificConversionTargetType(resultClass, entityClass, field);
        MongoConverter converter = getConverter();
        result = result.map(it -> converter.mapValueToTargetType(it, targetType, NO_OP_REF_RESOLVER));
    }
    return (Flux<T>) result;
}

Example 3 with MongoPersistentEntity

use of org.springframework.data.mongodb.core.mapping.MongoPersistentEntity in project spring-data-mongodb by spring-projects.

the class MongoExampleMapper method getMappedPropertyPath.

private String getMappedPropertyPath(String path, Class<?> probeType) {
    MongoPersistentEntity<?> entity = mappingContext.getRequiredPersistentEntity(probeType);
    Iterator<String> parts = Arrays.asList(path.split("\\.")).iterator();
    final Stack<MongoPersistentProperty> stack = new Stack<>();
    List<String> resultParts = new ArrayList<>();
    while (parts.hasNext()) {
        String part = parts.next();
        MongoPersistentProperty prop = entity.getPersistentProperty(part);
        if (prop == null) {
            entity.doWithProperties((PropertyHandler<MongoPersistentProperty>) property -> {
                if (property.getFieldName().equals(part)) {
                    stack.push(property);
                }
            });
            if (stack.isEmpty()) {
                return "";
            }
            prop = stack.pop();
        }
        resultParts.add(prop.getName());
        if (prop.isEntity() && mappingContext.hasPersistentEntityFor(prop.getActualType())) {
            entity = mappingContext.getRequiredPersistentEntity(prop.getActualType());
        } else {
            break;
        }
    }
    return StringUtils.collectionToDelimitedString(resultParts, ".");
}

Example 4 with MongoPersistentEntity

use of org.springframework.data.mongodb.core.mapping.MongoPersistentEntity in project spring-data-mongodb by spring-projects.

the class MongoPersistentEntityIndexCreatorUnitTests method doesNotCreateIndexForEntityComingFromDifferentMappingContext.

@Test
public void doesNotCreateIndexForEntityComingFromDifferentMappingContext() {
    MongoMappingContext mappingContext = new MongoMappingContext();
    MongoMappingContext personMappingContext = prepareMappingContext(Person.class);
    MongoPersistentEntityIndexCreator creator = new MongoPersistentEntityIndexCreator(mappingContext, mongoTemplate);
    MongoPersistentEntity<?> entity = personMappingContext.getRequiredPersistentEntity(Person.class);
    MappingContextEvent<MongoPersistentEntity<?>, MongoPersistentProperty> event = new MappingContextEvent<MongoPersistentEntity<?>, MongoPersistentProperty>(personMappingContext, entity);
    creator.onApplicationEvent(event);
    verifyZeroInteractions(collection);
}

Example 5 with MongoPersistentEntity

use of org.springframework.data.mongodb.core.mapping.MongoPersistentEntity in project spring-data-mongodb by spring-projects.

the class MongoTemplate method findDistinct.

/*
	 * (non-Javadoc)
	 * @see org.springframework.data.mongodb.core.MongoOperations#findDistinct(org.springframework.data.mongodb.core.query.Query, java.lang.String, java.lang.String, java.lang.Class, java.lang.Class)
	 */
@Override
@SuppressWarnings("unchecked")
public <T> List<T> findDistinct(Query query, String field, String collectionName, Class<?> entityClass, Class<T> resultClass) {
    Assert.notNull(query, "Query must not be null!");
    Assert.notNull(field, "Field must not be null!");
    Assert.notNull(collectionName, "CollectionName must not be null!");
    Assert.notNull(entityClass, "EntityClass must not be null!");
    Assert.notNull(resultClass, "ResultClass must not be null!");
    MongoPersistentEntity<?> entity = entityClass != Object.class ? getPersistentEntity(entityClass) : null;
    Document mappedQuery = queryMapper.getMappedObject(query.getQueryObject(), entity);
    String mappedFieldName = queryMapper.getMappedFields(new Document(field, 1), entity).keySet().iterator().next();
    Class<T> mongoDriverCompatibleType = getMongoDbFactory().getCodecFor(resultClass).map(Codec::getEncoderClass).orElse((Class) BsonValue.class);
    MongoIterable<?> result = execute(collectionName, (collection) -> {
        DistinctIterable<T> iterable = collection.distinct(mappedFieldName, mappedQuery, mongoDriverCompatibleType);
        return query.getCollation().map(Collation::toMongoCollation).map(iterable::collation).orElse(iterable);
    });
    if (resultClass == Object.class || mongoDriverCompatibleType != resultClass) {
        MongoConverter converter = getConverter();
        DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory);
        result = result.map((source) -> converter.mapValueToTargetType(source, getMostSpecificConversionTargetType(resultClass, entityClass, field), dbRefResolver));
    }
    try {
        return (List<T>) result.into(new ArrayList<>());
    } catch (RuntimeException e) {
        throw potentiallyConvertRuntimeException(e, exceptionTranslator);
    }
}