All the code I have is divided into different layers:

Controller:

package com.ex.admin.controllers; import com.ex.admin.dto.EmployeeDTO; import com.ex.admin.services.impl.EmployeeServiceImpl; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.rest.webmvc.BasePathAwareController; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @BasePathAwareController @RequestMapping("api/admin/employee") public class EmployeeController { @Autowired EmployeeServiceImpl employeeServiceImpl; @GetMapping(value = "/employees") public ResponseEntity<List<EmployeeDTO>> finAllEmployees() { return employeeServiceImpl.findAllEmployees(); } @DeleteMapping(value = "/delete") public ResponseEntity<EmployeeDTO> deleteManyEmployees(@RequestBody List<String> codeList) { return employeeServiceImpl.deleteManyEmployees(codeList); } @DeleteMapping(value = "/delete/{code}") public ResponseEntity<EmployeeDTO> deleteEmployee(@PathVariable("code") String employeeCode) { return employeeServiceImpl.deleteEmployee(employeeCode); } @PostMapping(value = "/create") public ResponseEntity<EmployeeDTO> createEmployee(@RequestBody EmployeeDTO employeeDTO) { return employeeServiceImpl.createNewEmployee(employeeDTO); } @PutMapping(value = "/edit") public ResponseEntity<EmployeeDTO> editEmployee(@RequestBody EmployeeDTO employeeDTO) { return employeeServiceImpl.editEmployee(employeeDTO); } }

Mapper :

 package com.ex.admin.dto.mappers; import com.ex.admin.dto.EmployeeDTO; import com.ex.admin.entity.Employee; import org.mapstruct.Mapper; import org.mapstruct.Mapping; import org.mapstruct.Mappings; @Mapper(componentModel = "spring") public interface EmployeeMapper { @Mappings({ @Mapping(target="id", source="entity.id"), @Mapping(target="employeeName", source="entity.codeOfEmployee"), @Mapping(target="ruName", source="entity.nameRu"), @Mapping(target="kzName", source="entity.nameKk"), @Mapping(target="enName", source="entity.nameEn") }) EmployeeDTO employeeToEmployeeDTO(Employee entity); @Mappings({ @Mapping(target="id", source="dto.id"), @Mapping(target="codeOfEmployee", source="dto.employeeName"), @Mapping(target="nameRu", source="dto.ruName"), @Mapping(target="nameKk", source="dto.kzName"), @Mapping(target="nameEn", source="dto.enName") }) Employee employeeDTOtoEmployee(EmployeeDTO dto); }

Dto :

 package com.ex.admin.dto; import lombok.Data; @Data public class EmployeeDTO { private Long id; private String employeeName; private String ruName; private String kzName; private String enName; }

Entity:

 package com.ex.admin.entity; import lombok.Data; import javax.persistence.*; import java.util.Date; @Entity @Table(name = "employees") @Data public class Employee { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "code") private String codeOfEmployee; @Column(name = "name_ru") private String nameRu; @Column(name = "name_kk") private String nameKk; @Column(name = "name_en") private String nameEn; @Column(name = "is_removed") private boolean isRemoved; @Column(name = "create_time") private Date createTime; @Column(name = "edit_time") private Date editTime; }

Repository :

 package com.ex.admin.repository; import com.ex.admin.entity.Employee; import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import java.util.List; import java.util.Optional; @Repository public interface EmployeeRepository extends CrudRepository<Employee,Long > { @Query(nativeQuery = true,value = "SELECT * FROM employees where is_removed=false") Iterable<Employee> findAllExistingEmployees(); @Transactional @Modifying @Query("UPDATE Employee em SET em.isRemoved=:bool WHERE em.codeOfEmployee IN (:listOfCode)") Integer delManyEmployeesInRepo(@Param("bool") boolean bool, @Param("listOfCode") List<String> listOfCode); @Override Employee save(Employee entity); @Override Optional<Employee> findById(Long aLong); Employee findByCodeOfEmployee(String codeOfEmployee); }

Service:

 package com.ex.admin.services.impl; import com.ex.admin.dto.EmployeeDTO; import com.ex.admin.dto.mappers.EmployeeMapper; import com.ex.admin.entity.Employee; import com.ex.admin.repository.EmployeeRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import java.util.*; @Service public class EmployeeServiceImpl { @Autowired private EmployeeMapper employeeMapper; @Autowired private EmployeeRepository employeeRepository; public ResponseEntity<List<EmployeeDTO>> findAllEmployees() { Iterator<Employee> employeeIterator = employeeRepository.findAllExistingEmployees().iterator(); List<EmployeeDTO> listEmployeeDTO = new ArrayList<>(); while (employeeIterator.hasNext()) { listEmployeeDTO.add(employeeMapper.employeeToEmployeeDTO(employeeIterator.next())); } return new ResponseEntity(listEmployeeDTO, HttpStatus.OK); } public ResponseEntity<EmployeeDTO> deleteManyEmployees(List<String> stringList) { //Реализация удаления всех сотрудников } public ResponseEntity<EmployeeDTO> deleteEmployee(String employeeCode) { Employee employee = employeeRepository.findByCodeOfEmployee(employeeCode); employee.setRemoved(true); return ResponseEntity.ok(employeeMapper.employeeToEmployeeDTO(employeeRepository.save(employee))); } public ResponseEntity<EmployeeDTO> createNewEmployee(EmployeeDTO employeeDTO) { //реализация Создания сотрудника } public ResponseEntity<EmployeeDTO> editEmployee(EmployeeDTO employeeDTO) { employeeMapper.employeeDTOtoEmployee(employeeDTO); Optional<Employee> employeeOptional = employeeRepository.findById(employeeMapper.employeeDTOtoEmployee(employeeDTO).getId()); Employee employee = employeeOptional.get(); employee.setNameEn(employeeDTO.getEnName()); employee.setCodeOfEmployee(employeeDTO.getEmployeeName()); employee.setNameRu(employeeDTO.getRuName()); employee.setNameKk(employeeDTO.getKzName()); employeeDTO = employeeMapper.employeeToEmployeeDTO(employeeRepository.save(employee)); return new ResponseEntity(employeeDTO, HttpStatus.OK); } }

Do not ask about architecture, I don’t know why, we don’t have a lead or an architect, so how it’s done, it’s done so. My backend is connected to the front end (Vue.js).
In the Service there are methods for deleting an employee and employees. For an employee I managed to implement.

I still do not really understand how it happened.

 public ResponseEntity<EmployeeDTO> deleteEmployee(String employeeCode) { Employee employee = employeeRepository.findByCodeOfEmployee(employeeCode); employee.setRemoved(true); return ResponseEntity.ok(employeeMapper.employeeToEmployeeDTO(employeeRepository.save(employee))); }

enter image description here

When you click on a small basket designed to remove 1 item works. But if I select the 3 items by the checkbox, I can’t click on the big basket to delete several items:
enter image description here

Please tell me how you can write a method for deleting several employees, I don’t really understand (I marked the places where I can’t do it, specially erased the code because I got confused there and it didn’t work.

    1 answer 1

    • In the loop, loop through all the incoming codes.

    • for each code, go to the database and see if there are such records. If there is a delete. If not then either ignore or throw an error to the client.

       public ResponseEntity<EmployeeDTO> deleteManyEmployees(List<String> codesList){ codesList.forEach(code-> { Optional< Employee > employee = employeeRepository.findByCode(code); if(employee.isPresent()) { employee.get().setRemoved(true); } }); }

    Repository:

     @Repository public interface EmployeeRepository extends CrudRepository<Employee,Long > { ... Optional<Employee> findByCode(String code); ... }

    I do not know who did it, but I see the use of the @Transactional annotation in the repository at first, and I think it is not correct.

    I would recommend reading something about spring, etc.

    • findByCode underlines in red and yet the same method should return something, I tried something like, but did not understand until the end - Ivan Petrovchenko
    • I read the documentation and try to do the task - Petrovchenko Ivan
    • @PetrovchenkoIvan for it needs to be written in your repository. - Tsyklop
    • @PetrovchenkoIvan updated the answer. - Tsyklop pm
    • And what should it return? In the same place, the type of the return value means there should be a return and something - Petrovchenko Ivan