Resolved exception caused by Handler execution: org.springframework.data.mapping.context.InvalidPersistentPropertyPath: No property userDetails found on com.samples.springdatamongodb.model.User!

{
    "token": null,
    "userDetails": {
        "email": "borgymanotoy@gmail.com",
        "lastName": "Manotoy",
        "firstName": "Borgy",
        "middleName": null
    },
    "userId": "5a86a67a5f03a313dccd2053",
    "userAuthenticationInfo": {
        "password": "freeforall",
        "username": "borgymanotoy"
    }
}

package com.samples.springdatamongodb.config;

import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.ulisesbocchio.jasyptspringboot.annotation.EncryptablePropertySource;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

import javax.annotation.Resource;

@Configuration
@EnableMongoRepositories(basePackages = "com.samples.springdatamongodb")
@EncryptablePropertySource(name = "EncryptedProperties", value = {"classpath:/profiles/${profile:dev}/db.properties", "classpath:/profiles/${profile:dev}/application.properties"})
public class MongoConfig extends AbstractMongoConfiguration {

    private static final String PROPERTY_NAME_DATABASE_NAME = "spring.data.mongodb.database";
    private static final String PROPERTY_NAME_DATABASE_HOST = "spring.data.mongodb.host";
    private static final String PROPERTY_NAME_DATABASE_PORT = "spring.data.mongodb.port";

    @Resource
    private Environment m_environment;


    @Override
    protected String getDatabaseName() {
        return m_environment.getRequiredProperty(PROPERTY_NAME_DATABASE_NAME);
    }

    @Override
    public Mongo mongo() throws Exception {
        return new MongoClient(m_environment.getRequiredProperty(PROPERTY_NAME_DATABASE_HOST),
                Integer.parseInt(m_environment.getRequiredProperty(PROPERTY_NAME_DATABASE_PORT)));
    }

}

package com.samples.springdatamongodb.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;


@Document(collection = "users")
public class User {

    @Id
    private String m_userId;

    @Field("userDetails")
    private UserDetail m_userDetails;

    @Field("userAuthenticationInfo")
    private UserAuthenticationInfo m_userAuthenticationInfo;

    @Transient
    @Field("token")
    private String m_token;


    public String getUserId() {
        return m_userId;
    }

    public void setUserId(String userId) {
        m_userId = userId;
    }

    public UserDetail getUserDetails() {
        return m_userDetails;
    }

    public void setUserDetails(UserDetail userDetails) {
        m_userDetails = userDetails;
    }

    public UserAuthenticationInfo getUserAuthenticationInfo() {
        return m_userAuthenticationInfo;
    }

    public void setUserAuthenticationInfo(UserAuthenticationInfo userAuthenticationInfo) {
        m_userAuthenticationInfo = userAuthenticationInfo;
    }

    public String getToken() {
        return m_token;
    }

    public void setToken(String token) {
        m_token = token;
    }

}

package com.samples.springdatamongodb.model;

import org.springframework.data.mongodb.core.mapping.Field;

public class UserAuthenticationInfo {

    @Field("username")
    private String m_username;

    @Field("password")
    private String m_password;


    public String getUsername() {
        return m_username;
    }

    public void setUsername(String username) {
        m_username = username;
    }

    public String getPassword() {
        return m_password;
    }

    public void setPassword(String password) {
        m_password = password;
    }

}

package com.samples.springdatamongodb.model;

import org.hibernate.validator.constraints.NotBlank;
import org.springframework.data.mongodb.core.mapping.Field;

import javax.validation.constraints.Size;

public class UserDetail {

    @Field("firstName")
    private String m_firstName;

    @Field("lastName")
    private String m_lastName;

    @Field("middleName")
    private String m_middleName;

    @Field("email")
    @NotBlank
    @Size(max = 200)
    private String m_email;


    public String getFirstName() {
        return m_firstName;
    }

    public void setFirstName(String firstName) {
        m_firstName = firstName;
    }

    public String getLastName() {
        return m_lastName;
    }

    public void setLastName(String lastName) {
        m_lastName = lastName;
    }

    public String getEmail() {
        return m_email;
    }

    public void setEmail(String email) {
        m_email = email;
    }

    public String getMiddleName() {
        return m_middleName;
    }

    public void setMiddleName(String middleName) {
        m_middleName = middleName;
    }
}

package com.samples.springdatamongodb.repository;

import com.ploverbay.ticketing.authentication.model.User;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.stereotype.Repository;


@Repository
public interface UserRepository extends MongoRepository<User, String> {

    @Query("{ '_id' : ?0 }")
    User findByUserId(String userId);

    @Query("{ 'userDetails.email' : ?0 }")
    User findByEmail(String email);

}

package com.samples.springdatamongodb.service;

import com.samples.springdatamongodb.model.User;
import com.samples.springdatamongodb.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("userService")
public class UserService {

    @Autowired
    private UserRepository m_userRepository;


    ...

    public User findByEmail(String email) {
        return m_userRepository.findByEmail(email);
    }

    public User saveUser(User user) {
        return m_userRepository.save(user);
    }
    ...

}

package com.samples.springdatamongodb.controller;

import com.samples.springdatamongodb.model.ErrorMessage;
import com.samples.springdatamongodb.model.User;
import com.samples.springdatamongodb.model.ValidationResponse;
import com.samples.springdatamongodb.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/accounts")
public class AccountsController {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private UserService m_userService;

    ...

    @GetMapping("/search")
    public User getUserByEmail(@RequestParam("email") String email) {
        logger.debug("Getting user with email: ", email);
        return m_userService.findByEmail(email);
    }

    @PostMapping
    public Object addUser(@RequestBody User user, BindingResult bindingResult) {
        logger.debug("Saving user : " + user);
        if (!bindingResult.hasErrors()) {
            return m_userService.saveUser(user);
        } else {
            return handleValidationError(bindingResult);
        }
    }

    ...

}