Java 我的方法未定义且已赢得'；Don’别让这些能手工作

我已将问题重新措辞，并将更详细地解释。我很抱歉，谢谢你。这就是SpringBootJava中的系统。我使用的java是11。至于系统，它上升了。它与数据库通信。然而，我无法使系统工作。它给了我未定义方法的答案，我不明白我错了什么。这里有许多关于未定义方法的答案，但我所寻找的没有一个与我的错误类似

我的资源：

@RestController
@RequestMapping("/api/cidade")
public class CidadeResource {

    @Autowired
    private CidadeRepository repository;
    @Autowired
    private EstadoRepository repositoryEstado;
    @Autowired
    private CidadeResourceMapper mapper;

    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<CidadeDTO>> getPageWithQuery(@QuerydslPredicate(root = Cidade.class) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }

    @PostMapping
    public ResponseEntity <CidadeDTO> add(@Valid @RequestBody CidadeWriteDTO dto) throws Exception {
        Cidade entity = this.mapper.fromDto(dto);
        entity = repository.save(entity);
        ResponseEntity <CidadeDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        return re;
    }

    @GetMapping(value = "/{id}")
    public ResponseEntity <CidadeDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity <CidadeDTO> update(@Valid @RequestBody CidadeWriteDTO dto, @PathVariable Integer id) throws AppException {
        Optional <Cidade> entity = repository.findById(id);
        if (entity.isPresent()) {
            Double qtdPopulacao = 0 D;
            if (entity.get().getEstado().getPopulacao() == null)
                qtdPopulacao = entity.get().getPopulacao();
            else {
                // Remove a população da cidade (antes da alteração)
                qtdPopulacao = entity.get().getEstado().getPopulacao() - entity.get().getPopulacao();
            }
            this.mapper.merge(entity.get(), dto);
            // Adiciona a população da cidade
            qtdPopulacao += dto.getPopulacao();
            // Atualiza os dados no estado
            entity.get().getEstado().setPopulacao(qtdPopulacao);
            // Salva a entidade no BD
            repositoryEstado.save(entity.get().getEstado());
            if (dto.getPopulacao() < 0)
                throw new AppException("Valor inválido da quantidade da população");
            Cidade mergedEntity = repository.save(entity.get());
            ResponseEntity < CidadeDTO > re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            return re;
        } else {
            throw new RuntimeException();
        }
    }

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        repository.deleteById(id);
    }

    private PageDto <CidadeDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page <Cidade> pageEntity = repository.findAll(predicate, pageble);
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false)
                            .map(this::convertToDto)
                            .collect(Collectors.toList()), pageEntity.getTotalElements());
    }

    private CidadeDTO convertToDto(Cidade entity) {
        return mapper.toDto(entity);
    }
}

在前面的部分，我使用了角度。在版本7中，“我的浏览器”的控制台和网络中出现的错误如下所示，postman中也出现了错误：

{timestamp: 1606485361742, status: 500, error: "Internal Server Error",…}
error: "Internal Server Error"
message: "Unresolved compilation problem: ↵ Cannot infer type arguments for PageDto<>↵"
path: "/api/cidade/"
status: 500
timestamp: 1606485361742

}

错误是：类型ESTADOWIRTETTO的方法getId（）未定义，并在中突出显示：

public Estado getEstado(EstadoWirteDTO estadoWirteDTO, Estado mappingTarget) {  
        return repository.findById(estadoWirteDTO.getId()).get();

现在在包中，请执行以下操作：

EstadoResource.java：

    @RestController 
    @RequestMapping("/api/estado") 
    public class EstadoResource {
    
@Autowired
private EstadoRepository repository;
@Autowired
private EstadoResourceMapper mapper;
@Autowired
private EstadoService service; 

@GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
public ResponseEntity<PageDto<EstadoDTO>> getPageWithQuery(@QuerydslPredicate(root = Estado.class ) Predicate predicate, Pageable pageble) {
    return ResponseEntity.ok(convertToPageDto(predicate, pageble));
}
    
@GetMapping(value = "/{id}")
public ResponseEntity<EstadoDTO> get(@PathVariable Integer id) {
    return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
}

@PostMapping
public ResponseEntity<EstadoDTO> add(@Valid @RequestBody EstadoDTO dto) throws Exception {
    Estado entity = this.mapper.fromDto(dto);
    
    service.validateAdd(dto, entity);

    entity = repository.save(entity);
    
    ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(entity));
    
    return re;
            
}

@PutMapping(value = "/{id}")
public ResponseEntity<EstadoDTO> update(@Valid @RequestBody EstadoDTO dto, @PathVariable Integer id) throws Exception {
    
    Optional<Estado> entity = repository.findById(id);
    if (entity.isPresent()) {
        
        this.mapper.merge(entity.get(), dto);

        service.validateUpdate(dto, entity.get());

        Estado mergedEntity = repository.save(entity.get());
        
        ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
        
        return re;
    } else {
        throw new RuntimeException();
    }
    
}   

@DeleteMapping(value = "/{id}")
public void delete(@PathVariable Integer id) throws Exception {
    
    service.validateDelete(id);
    
    repository.deleteById(id);
    
}

private PageDto<EstadoDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
    Page<Estado> pageEntity = repository.findAll(predicate, pageble);
    
    return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
            .collect(Collectors.toList()), pageEntity.getTotalElements());
}      

private EstadoDTO convertToDto(Estado entity) {
    return mapper.toDto(entity);
}
    

@RestController 
@RequestMapping("/api/estado") 
public class EstadoResource {
        
    @Autowired
    private EstadoRepository repository;
    @Autowired
    private EstadoResourceMapper mapper;
    @Autowired
    private EstadoService service; 
    
    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<EstadoDTO>> getPageWithQuery(@QuerydslPredicate(root = Estado.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
        
    @GetMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PostMapping
    public ResponseEntity<EstadoDTO> add(@Valid @RequestBody EstadoDTO dto) throws Exception {
        Estado entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> update(@Valid @RequestBody EstadoDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Estado> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Estado mergedEntity = repository.save(entity.get());
            
            ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<EstadoDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Estado> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private EstadoDTO convertToDto(Estado entity) {
        return mapper.toDto(entity);
    }
        
}

@RestController 
@RequestMapping("/api/pais") 
public class PaisResource {
        
    @Autowired
    private PaisRepository repository;
    @Autowired
    private PaisResourceMapper mapper;
    @Autowired
    private PaisService service; 

    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<PaisDTO>> getPageWithQuery(@QuerydslPredicate(root = Pais.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
    
    @PostMapping
    public ResponseEntity<PaisDTO> add(@Valid @RequestBody PaisDTO dto) throws Exception {
        Pais entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @GetMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> update(@Valid @RequestBody PaisDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Pais> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Pais mergedEntity = repository.save(entity.get());
            
            ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<PaisDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Pais> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private PaisDTO convertToDto(Pais entity) {
        return mapper.toDto(entity);
    }
        
}

@RestController
@请求映射（“/api/estado”）
公共类地产资源{
@自动连线
私人地产存储库；
@自动连线
私人地产资源映射器；
@自动连线
私人地产服务；
@GetMapping（products={MediaType.APPLICATION\u JSON\u VALUE}）
public ResponseEntity getPageWithQuery（@QuerydslPredicate（root=Estado.class）谓词谓词，可分页）{
返回ResponseEntity.ok（convertToPageDto（谓词，分页））；
}
@GetMapping（value=“/{id}”）
public ResponseEntity get（@PathVariable整数id）{
返回ResponseEntity.ok（converttoto（repository.findById（id.get（））；
}
@邮戳
公共响应属性添加（@Valid@RequestBody estadTo dto）引发异常{
Estado entity=this.mapper.fromDto（dto）；
服务。验证EADD（dto，实体）；
实体=repository.save（实体）；
ResponseEntity re=ResponseEntity.ok（this.converttoto（entity））；
返回re；
}
@PutMapping（value=“/{id}”）
公共响应属性更新（@Valid@RequestBody estadTo dto，@PathVariable Integer id）引发异常{
可选实体=repository.findById（id）；
if（entity.isPresent（））{
this.mapper.merge（entity.get（），dto）；
service.validateUpdate（dto，entity.get（））；
Estado mergedEntity=repository.save（entity.get（））；
ResponseEntity re=ResponseEntity.ok（this.converttoto（mergedEntity））；
返回re；
}否则{
抛出新的RuntimeException（）；
}
}   
@DeleteMapping（value=“/{id}”）
公共void delete（@PathVariable Integer id）引发异常{
服务。验证删除（id）；
repository.deleteById（id）；
}
private PageDto ConvertoPagedTo（谓词谓词，分页可分页）{
pageEntity=repository.findAll（谓词，pageble）；
返回新的PageDto（StreamSupport.stream（pageEntity.spliterator（），false）.map（this:：convertto）
.collect（Collectors.toList（）），pageEntity.getTotalElements（））；
}      
私人EstadoDTO转换（Estado实体）{
返回mapper.toDto（实体）；
}
}

错误是：无法推断PageDto的类型参数 并突出显示在： 返回新的PageDto（StreamSupport.stream（pageEntity.spliterator（），false）.map（this:：convertto） .collect（Collectors.toList（）），pageEntity.getTotalElements（））； }

现在在pais na classe包装中：

PaisResource.java：

    @RestController 
    @RequestMapping("/api/estado") 
    public class EstadoResource {
    
@Autowired
private EstadoRepository repository;
@Autowired
private EstadoResourceMapper mapper;
@Autowired
private EstadoService service; 

@GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
public ResponseEntity<PageDto<EstadoDTO>> getPageWithQuery(@QuerydslPredicate(root = Estado.class ) Predicate predicate, Pageable pageble) {
    return ResponseEntity.ok(convertToPageDto(predicate, pageble));
}
    
@GetMapping(value = "/{id}")
public ResponseEntity<EstadoDTO> get(@PathVariable Integer id) {
    return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
}

@PostMapping
public ResponseEntity<EstadoDTO> add(@Valid @RequestBody EstadoDTO dto) throws Exception {
    Estado entity = this.mapper.fromDto(dto);
    
    service.validateAdd(dto, entity);

    entity = repository.save(entity);
    
    ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(entity));
    
    return re;
            
}

@PutMapping(value = "/{id}")
public ResponseEntity<EstadoDTO> update(@Valid @RequestBody EstadoDTO dto, @PathVariable Integer id) throws Exception {
    
    Optional<Estado> entity = repository.findById(id);
    if (entity.isPresent()) {
        
        this.mapper.merge(entity.get(), dto);

        service.validateUpdate(dto, entity.get());

        Estado mergedEntity = repository.save(entity.get());
        
        ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
        
        return re;
    } else {
        throw new RuntimeException();
    }
    
}   

@DeleteMapping(value = "/{id}")
public void delete(@PathVariable Integer id) throws Exception {
    
    service.validateDelete(id);
    
    repository.deleteById(id);
    
}

private PageDto<EstadoDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
    Page<Estado> pageEntity = repository.findAll(predicate, pageble);
    
    return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
            .collect(Collectors.toList()), pageEntity.getTotalElements());
}      

private EstadoDTO convertToDto(Estado entity) {
    return mapper.toDto(entity);
}
    

@RestController 
@RequestMapping("/api/estado") 
public class EstadoResource {
        
    @Autowired
    private EstadoRepository repository;
    @Autowired
    private EstadoResourceMapper mapper;
    @Autowired
    private EstadoService service; 
    
    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<EstadoDTO>> getPageWithQuery(@QuerydslPredicate(root = Estado.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
        
    @GetMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PostMapping
    public ResponseEntity<EstadoDTO> add(@Valid @RequestBody EstadoDTO dto) throws Exception {
        Estado entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> update(@Valid @RequestBody EstadoDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Estado> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Estado mergedEntity = repository.save(entity.get());
            
            ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<EstadoDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Estado> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private EstadoDTO convertToDto(Estado entity) {
        return mapper.toDto(entity);
    }
        
}

@RestController 
@RequestMapping("/api/pais") 
public class PaisResource {
        
    @Autowired
    private PaisRepository repository;
    @Autowired
    private PaisResourceMapper mapper;
    @Autowired
    private PaisService service; 

    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<PaisDTO>> getPageWithQuery(@QuerydslPredicate(root = Pais.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
    
    @PostMapping
    public ResponseEntity<PaisDTO> add(@Valid @RequestBody PaisDTO dto) throws Exception {
        Pais entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @GetMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> update(@Valid @RequestBody PaisDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Pais> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Pais mergedEntity = repository.save(entity.get());
            
            ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<PaisDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Pais> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private PaisDTO convertToDto(Pais entity) {
        return mapper.toDto(entity);
    }
        
}

@RestController
@请求映射（“/api/pais”）
公共类PaisResource{
@自动连线
私人储蓄库；
@自动连线
私有PaisResourceMapper映射器；
@自动连线
私人PaisService服务；
@GetMapping（products={MediaType.APPLICATION\u JSON\u VALUE}）
public ResponseEntity getPageWithQuery（@QuerydslPredicate（root=Pais.class）谓词谓词，可分页{
返回ResponseEntity.ok（convertToPageDto（谓词，分页））；
}
@邮戳
公共响应属性添加（@Valid@RequestBody PaisDTO）引发异常{
Pais实体=this.mapper.fromDto（dto）；
服务。验证EADD（dto，实体）；
实体=repository.save（实体）；
ResponseEntity re=ResponseEntity.ok（this.converttoto（entity））；
返回re；
}
@GetMapping（value=“/{id}”）
public ResponseEntity get（@PathVariable整数id）{
返回ResponseEntity.ok（converttoto（repository.findById（id.get（））；
}
@PutMapping（value=“/{id}”）
公共响应属性更新（@Valid@RequestBody PaisDTO，@PathVariable Integer id）引发异常{
可选实体=repository.findById（id）；
if（entity.isPresent（））{
this.mapper.merge（entity.get（），dto）；
service.validateUpdate（dto，entity.get（））；
Pais mergedEntity=repository.save（entity.get（））；
ResponseEntity re=ResponseEntity.ok（this.converttoto（mergedEntity））；
返回re；
}否则{
抛出新的RuntimeException（）；
}
}   
@DeleteMapping（value=“/{id}”）
公共void delete（@PathVariable Integer id）引发异常{
服务。验证删除（id）；
repository.deleteById（id）；
}
private PageDto ConvertoPagedTo（谓词谓词，分页可分页）{
pageEntity=repository.findAll（谓词，pageble）；
返回新的PageDto（StreamSupport.stream（pageEntity.spliterator（），false）.map（this:：convertto）
.collect（Collectors.toList（）），pageEntity.getTotalElements（））；
}      
专用PaisDTO CONVERTODTO（Pais实体）{
返回mapper.toDto（实体）；
}
@RestController 
@RequestMapping("/api/estado") 
public class EstadoResource {
        
    @Autowired
    private EstadoRepository repository;
    @Autowired
    private EstadoResourceMapper mapper;
    @Autowired
    private EstadoService service; 
    
    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<EstadoDTO>> getPageWithQuery(@QuerydslPredicate(root = Estado.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
        
    @GetMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PostMapping
    public ResponseEntity<EstadoDTO> add(@Valid @RequestBody EstadoDTO dto) throws Exception {
        Estado entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<EstadoDTO> update(@Valid @RequestBody EstadoDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Estado> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Estado mergedEntity = repository.save(entity.get());
            
            ResponseEntity<EstadoDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<EstadoDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Estado> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private EstadoDTO convertToDto(Estado entity) {
        return mapper.toDto(entity);
    }
        
}

@RestController 
@RequestMapping("/api/pais") 
public class PaisResource {
        
    @Autowired
    private PaisRepository repository;
    @Autowired
    private PaisResourceMapper mapper;
    @Autowired
    private PaisService service; 

    @GetMapping(produces = { MediaType.APPLICATION_JSON_VALUE })
    public ResponseEntity<PageDto<PaisDTO>> getPageWithQuery(@QuerydslPredicate(root = Pais.class ) Predicate predicate, Pageable pageble) {
        return ResponseEntity.ok(convertToPageDto(predicate, pageble));
    }
    
    @PostMapping
    public ResponseEntity<PaisDTO> add(@Valid @RequestBody PaisDTO dto) throws Exception {
        Pais entity = this.mapper.fromDto(dto);
        
        service.validateAdd(dto, entity);

        entity = repository.save(entity);
        
        ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(entity));
        
        return re;
                
    }

    @GetMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> get(@PathVariable Integer id) {
        return ResponseEntity.ok(convertToDto(repository.findById(id).get()));
    }

    @PutMapping(value = "/{id}")
    public ResponseEntity<PaisDTO> update(@Valid @RequestBody PaisDTO dto, @PathVariable Integer id) throws Exception {
        
        Optional<Pais> entity = repository.findById(id);
        if (entity.isPresent()) {
            
            this.mapper.merge(entity.get(), dto);

            service.validateUpdate(dto, entity.get());

            Pais mergedEntity = repository.save(entity.get());
            
            ResponseEntity<PaisDTO> re = ResponseEntity.ok(this.convertToDto(mergedEntity));
            
            return re;
        } else {
            throw new RuntimeException();
        }
        
    }   

    @DeleteMapping(value = "/{id}")
    public void delete(@PathVariable Integer id) throws Exception {
        
        service.validateDelete(id);
        
        repository.deleteById(id);
        
    }
    
    private PageDto<PaisDTO> convertToPageDto(Predicate predicate, Pageable pageble) {
        Page<Pais> pageEntity = repository.findAll(predicate, pageble);
        
        return new PageDto<>(StreamSupport.stream(pageEntity.spliterator(), false).map(this::convertToDto)
                .collect(Collectors.toList()), pageEntity.getTotalElements());
    }      
    
    private PaisDTO convertToDto(Pais entity) {
        return mapper.toDto(entity);
    }
        
}

@Service
public class PaisServiceImp implements PaisService {

    @Autowired
    private PaisRepository repository;
    
    @Override
    public void validateDelete(Integer id) throws AppException {
        
        Optional<Pais> pais = repository.findById(id);
        if (!pais.isPresent())
            throw new AppException("País não encontratro");
        
        Long qtdEstados = repository.getQtdEstados(id);
        if (qtdEstados > 0)
            throw new AppException("Esse país possui um estado vinculado, favor desvincular primeiro");
    }

    @Override
    public void validateUpdate(@Valid PaisDTO dto, Pais entity) throws AppException {
        Optional<Pais> pais = repository.findByNome(dto.getNome());
        if (pais.isPresent()) {
            if (!entity.getId().equals(pais.get().getId()))
                throw new AppException("Já existe um país com esse nome");
        }
    }

    @Override
    public void validateAdd(@Valid PaisDTO dto, Pais entity) throws AppException {
        Optional<Pais> pais = repository.findByNome(dto.getNome());
        if (pais.isPresent())
            throw new AppException("Já existe um país com esse nome");
}

}