empl-mngmnt-srv

package com.leverx.employeestat.rest.configuration;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import liquibase.integration.spring.SpringLiquibase;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.security.config.oauth2.client.CommonOAuth2Provider;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.client.InMemoryOAuth2AuthorizedClientService;
import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
import org.springframework.security.oauth2.client.registration.ClientRegistration;
import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
import org.springframework.security.oauth2.client.registration.InMemoryClientRegistrationRepository;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;
import java.util.*;
import java.util.stream.Collectors;

@Configuration
@ComponentScan("com.leverx.employeestat.rest*")
@EnableWebMvc
@EnableTransactionManagement
@EnableSwagger2
@EnableJpaRepositories(basePackages = "com.leverx.employeestat.rest.repository*")
@PropertySource({
        "classpath:properties/db.properties",
        "classpath:properties/session-factory.properties",
        "classpath:security/google-security.properties",
        "classpath:application.properties"})
@EnableScheduling
@Slf4j
public class Config implements WebMvcConfigurer {

    private final static List<String> clients = Arrays.asList("google");
    private final static String CLIENT_PROPERTY_KEY = "spring.security.oauth2.client.registration.";

    @Value("${driverClass}")
    private String driverClass;

    @Value("${dbuser}")
    private String user;

    @Value("${password}")
    private String password;

    @Value("${jdbcUrl}")
    private String jdbcUrl;

    private Environment env;

    @Autowired
    public Config(Environment env) {
        this.env = env;
    }

    public Config() {

    }

    @Bean
    public ClientRegistrationRepository clientRegistrationRepository() {
        List<ClientRegistration> registrations = clients.stream()
                .map(this::getRegistration)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

        return new InMemoryClientRegistrationRepository(registrations);
    }

    @Bean
    public OAuth2AuthorizedClientService authorizedClientService() {
        return new InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SpringLiquibase liquibase() {
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setChangeLog("classpath:db/changelog/liquibase-changeLog.xml");
        liquibase.setDataSource(dataSource());
        return liquibase;
    }

    @Bean
    public DataSource dataSource() {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            log.info(String.format("Connecting to the datasource (driver=%s, url=%s, user=%s)", driverClass, jdbcUrl, user));

            dataSource.setDriverClass(driverClass);
            dataSource.setJdbcUrl(jdbcUrl);
            dataSource.setUser(user);
            dataSource.setPassword(password);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setDataSource(dataSource());
        factory.setJpaVendorAdapter(hibernateJpaVendorAdapter());
        factory.setPackagesToScan(env.getRequiredProperty("packagesToScan"));
        Properties props = new Properties();
        props.put("hibernate.dialect", env.getRequiredProperty("hibernate.dialect"));
        props.put("hibernate.show_sql", env.getRequiredProperty("hibernate.show_sql"));
        props.put("hibernate.ddl-auto", env.getRequiredProperty("hibernate.ddl-auto"));
        factory.setJpaProperties(props);
        return factory;
    }

    @Bean
    public JpaTransactionManager transactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return transactionManager;
    }

    @Bean
    public HibernateJpaVendorAdapter hibernateJpaVendorAdapter() {
        return new HibernateJpaVendorAdapter();
    }

    @Bean
    public CommonsMultipartResolver multipartResolver() {
        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
        resolver.setMaxUploadSize(10000000L);
        return resolver;
    }

    @Bean
    public Docket api() {
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build().apiInfo(apiInfo());

        return docket;
    }

    private ApiInfo apiInfo() {
        return new ApiInfo(
                "Employees Service",
                "API for keeping track of employees and their employment",
                "0.9 BETA", "",
                new Contact(
                        "Ivan Shestakov",
                        "https://github.com/VanyaShestakov",
                        "[email protected]"),
                "", "", Collections.emptyList());
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");

        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
    }

    private ClientRegistration getRegistration(String client) {
        String clientId = env.getProperty(CLIENT_PROPERTY_KEY + client + ".client-id");

        if (clientId == null) {
            return null;
        }

        String clientSecret = env.getProperty(CLIENT_PROPERTY_KEY + client + ".client-secret");

        if (client.equals("google")) {
            return CommonOAuth2Provider.GOOGLE
                    .getBuilder(client)
                    .clientId(clientId)
                    .clientSecret(clientSecret)
                    .build();
        }
        return null;
    }
}

package com.leverx.employeestat.rest.configuration;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class WebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{Config.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}
package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.controller.tool.BindingResultParser;
import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.exception.NotValidRecordException;
import com.leverx.employeestat.rest.model.RegistrationRequest;
import com.leverx.employeestat.rest.model.ResetPasswordRequest;
import com.leverx.employeestat.rest.service.AuthorizationService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@RestController
@RequestMapping("/api")
@Api(tags = {"Authorization"})
@Slf4j
public class AuthorizationController {

    private final AuthorizationService authorizationService;
    private final BindingResultParser bindingResultParser;

    @Autowired
    public AuthorizationController(AuthorizationService authorizationService, BindingResultParser bindingResultParser) {
        this.authorizationService = authorizationService;
        this.bindingResultParser = bindingResultParser;
    }

    @PostMapping("/register")
    @ResponseStatus(HttpStatus.CREATED)
    @ApiOperation(value = "Register employee", response = EmployeeDTO.class)
    public EmployeeDTO registerEmployee(@ApiParam(name = "Registration request", value = "Contains mandatory fields for registration of employee")
                                        @RequestBody
                                        @Valid RegistrationRequest request, BindingResult result) {
        log.info("executing registerEmployee() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException
                    (String.format("Fields of Employee have errors: %s", bindingResultParser.getFieldErrMismatches(result)));
        }
        return authorizationService.registerEmployee(request.toDTO());
    }

    @PostMapping("/reset-password")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @ApiOperation(value = "Reset password of employee")
    public void resetPassword(@ApiParam(name = "Reset password request", value = "Contains username, old and new password of employee")
                              @RequestBody
                              @Valid ResetPasswordRequest request, BindingResult result) {
        log.info("executing resetPassword() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        authorizationService.resetPassword(request);
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.service.AvailableEmployeeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/employees/available")
@Api(tags = {"API for retrieving available employees"})
@Slf4j
public class AvailableEmployeeController {

    private final AvailableEmployeeService availableEmployeeService;

    @Autowired
    public AvailableEmployeeController(AvailableEmployeeService availableEmployeeService) {
        this.availableEmployeeService = availableEmployeeService;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get available employees at the current moment")
    public List<EmployeeDTO> getAvailableEmployeesNow() {
        log.info("executing getAvailableEmployeesNow() method");
        return availableEmployeeService.getAvailableEmployeesNow();
    }

    @GetMapping("/{days}")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get available employees for the next amount of days")
    public List<EmployeeDTO> getAvailableEmployeesNext(@ApiParam(value = "Amount of the next days starting today")
                                                       @PathVariable("days") int days) {
        log.info("executing getAvailableEmployeesNext() method");
        return availableEmployeeService.getAvailableEmployeesNext(days);
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.service.AuthorizationService;
import com.leverx.employeestat.rest.service.CSVReaderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController
@RequestMapping("api/employees/upload")
@Api(tags = {"API for uploading employees from CSV file"})
@Slf4j
public class CSVUploadController {

    private final CSVReaderService readerService;
    private final AuthorizationService authorizationService;

    @Autowired
    public CSVUploadController(CSVReaderService readerService, AuthorizationService authorizationService) {
        this.readerService = readerService;
        this.authorizationService = authorizationService;
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @ApiOperation("Upload employees")
    public List<EmployeeDTO> uploadEmployees(@ApiParam(value = "File with .csv extension, that contains table with employees")
                                             @RequestParam("file") MultipartFile file) {
        log.info("executing uploadEmployees() method");
        List<EmployeeDTO> employees = readerService.getEmployeesFromFile(file);
        return authorizationService.registerAll(employees);
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.controller.tool.BindingResultParser;
import com.leverx.employeestat.rest.dto.DepartmentDTO;
import com.leverx.employeestat.rest.exception.NotValidRecordException;
import com.leverx.employeestat.rest.service.DepartmentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

import static com.leverx.employeestat.rest.controller.tool.UUIDUtils.getUUIDFromString;

@RestController
@RequestMapping("/api/departments")
@Api(tags = "Department CRUD operations")
@Slf4j
public class DepartmentController {

    private final DepartmentService departmentService;
    private final BindingResultParser bindingResultParser;

    @Autowired
    public DepartmentController(DepartmentService departmentService, BindingResultParser bindingResultParser) {
        this.departmentService = departmentService;
        this.bindingResultParser = bindingResultParser;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get list of all departments")
    public List<DepartmentDTO> getAllDepartments() {
        log.info("executing getAllDepartments() method");
        return departmentService.getAll();
    }

    @GetMapping("/{id}")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get department by id")
    public DepartmentDTO getDepartment(@ApiParam(value = "Id of reсeiving department (UUID)")
                                       @PathVariable("id") String id) {
        log.info("executing getDepartment() method");
        return departmentService.getById(getUUIDFromString(id));
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @ApiOperation(value = "Create department")
    public DepartmentDTO postDepartment(@ApiParam(value = "Contains mandatory information of department", name = "Department")
                                        @RequestBody
                                        @Valid DepartmentDTO departmentDTO, BindingResult result) {
        log.info("executing postDepartment() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields of Department have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        return departmentService.save(departmentDTO);
    }

    @PutMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Update department")
    public DepartmentDTO putDepartment(@ApiParam(value = "Contains all information of department with changed fields", name = "Department")
                                       @RequestBody
                                       @Valid DepartmentDTO departmentDTO, BindingResult result) {
        log.info("executing postDepartment() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields of Department have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        return departmentService.update(departmentDTO);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @ApiOperation(value = "Delete department")
    public void deleteDepartment(@ApiParam(value = "Id of deleting department (UUID)")
                                 @PathVariable("id") String id) {
        log.info("executing deleteDepartment() method");
        departmentService.deleteById(getUUIDFromString(id));
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.controller.tool.BindingResultParser;
import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.exception.NotValidRecordException;
import com.leverx.employeestat.rest.service.EmployeeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

import static com.leverx.employeestat.rest.controller.tool.UUIDUtils.getUUIDFromString;

@RestController
@RequestMapping("/api/employees")
@Api(tags = {"Employee CRUD operations"})
@Slf4j
public class EmployeeController {

    private final EmployeeService employeeService;
    private final BindingResultParser bindingResultParser;

    @Autowired
    public EmployeeController(EmployeeService employeeService, BindingResultParser bindingResultParser) {
        this.employeeService = employeeService;
        this.bindingResultParser = bindingResultParser;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get list of all employees")
    public List<EmployeeDTO> getAllEmployees() {
        log.info("executing getAllEmployees() method");
        return employeeService.getAll();
    }

    @GetMapping("/{id}")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get employee by id")
    public EmployeeDTO getEmployee(@ApiParam(value = "Id of received employee")
                                   @PathVariable String id) {
        log.info("executing getEmployee() method");
        return employeeService.getById(getUUIDFromString(id));
    }

    @PutMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Update employee")
    public EmployeeDTO putEmployee(@ApiParam(value = "Contains all information of employee with changed fields", name = "Employee")
                                   @RequestBody
                                   @Valid EmployeeDTO employeeDTO, BindingResult result) {
        log.info("executing putEmployee() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields of Employee have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        return employeeService.update(employeeDTO);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @ApiOperation(value = "Delete employee")
    public void deleteEmployee(@ApiParam(value = "Id of deleting employee")
                               @PathVariable String id) {
        log.info("executing deleteEmployee() method");
        employeeService.deleteById(getUUIDFromString(id));
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.controller.tool.BindingResultParser;
import com.leverx.employeestat.rest.dto.ProjectDTO;
import com.leverx.employeestat.rest.exception.NotValidRecordException;
import com.leverx.employeestat.rest.service.ProjectService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

import static com.leverx.employeestat.rest.controller.tool.UUIDUtils.getUUIDFromString;

@RestController
@RequestMapping("/api/projects")
@Api(tags = "Project CRUD operations")
@Slf4j
public class ProjectController {

    private final ProjectService projectService;
    private final BindingResultParser bindingResultParser;

    @Autowired
    public ProjectController(ProjectService projectService, BindingResultParser bindingResultParser) {
        this.projectService = projectService;
        this.bindingResultParser = bindingResultParser;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get list of all projects")
    public List<ProjectDTO> getAllProjects() {
        log.info("executing getAllProjects() method");
        return projectService.getAll();
    }

    @GetMapping("/{id}")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get project by id")
    public ProjectDTO getProject(@ApiParam(value = "Id of reсeiving project (UUID)")
                                 @PathVariable String id) {
        log.info("executing getProject() method");
        return projectService.getById(getUUIDFromString(id));
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @ApiOperation(value = "Create project")
    public ProjectDTO postProject(@ApiParam(value = "Contains mandatory information of project", name = "Project")
                                  @RequestBody
                                  @Valid ProjectDTO projectDTO, BindingResult result) {
        log.info("executing postProject() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields of Project have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        return projectService.save(projectDTO);
    }

    @PutMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Update project")
    public ProjectDTO putProject(@ApiParam(value = "Contains all information of project with changed fields", name = "Project")
                                 @RequestBody
                                 @Valid ProjectDTO projectDTO, BindingResult result) {
        log.info("executing putProject() method");
        if (result.hasErrors()) {
            throw new NotValidRecordException("Fields of Project have errors: " + bindingResultParser.getFieldErrMismatches(result));
        }
        return projectService.update(projectDTO);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @ApiOperation(value = "Delete project")
    public void deleteProject(@ApiParam(value = "Id of deleting project (UUID)")
                              @PathVariable String id) {
        log.info("executing putProject() method");
        projectService.deleteById(getUUIDFromString(id));
    }

}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.exception.ReportWritingException;
import com.leverx.employeestat.rest.service.ReportService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestController
@RequestMapping("api/employees/export")
@Api(tags = "API for exporting workload reports of employees")
@Slf4j
public class ReportController {

    private final ReportService reportService;

    @Autowired
    public ReportController(ReportService reportService) {
        this.reportService = reportService;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Export occupation-report of employees")
    public void exportEmployees(HttpServletResponse response) {
        log.info("executing exportEmployees() method");
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=Employees.xlsx");
        XSSFWorkbook workbook = reportService.exportOccupationReport();
        writeToResponse(workbook, response);
    }

    @GetMapping("/last")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Export last generated report of available employees for the next month")
    public void exportLastGeneratedReport(HttpServletResponse response) {
        log.info("executing exportLastGeneratedReport() method");
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=Employees-Last.xlsx");
        XSSFWorkbook workbook = reportService.exportLastGeneratedReport();
        writeToResponse(workbook, response);
    }

    private void writeToResponse(XSSFWorkbook workbook, HttpServletResponse response) {
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            workbook.write(outputStream);
        } catch (IOException e) {
            throw new ReportWritingException("Failed to write report", e);
        }
    }
}

package com.leverx.employeestat.rest.controller;

import com.leverx.employeestat.rest.dto.WorkDTO;
import com.leverx.employeestat.rest.service.WorkService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.UUID;

import static com.leverx.employeestat.rest.controller.tool.UUIDUtils.getUUIDFromString;

@RestController
@RequestMapping("/api/works")
@Api(tags = "Work CRUD operations")
@Slf4j
public class WorkController {

    private final WorkService workService;

    @Autowired
    public WorkController(WorkService workService) {
        this.workService = workService;
    }

    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get list of all works")
    public List<WorkDTO> getAllWorks() {
        log.info("executing getAllWorks() method");
        return workService.getAll();
    }

    @GetMapping("/{empId}/{projId}")
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Get work by employee id and project id")
    public WorkDTO getWork(@ApiParam(value = "Employee id (UUID)")
                           @PathVariable("empId") String employeeId,
                           @ApiParam(value = "Project id (UUID)")
                           @PathVariable("projId") String projectId) {
        log.info("executing getWork() method");
        return workService.getByIds(getUUIDFromString(employeeId), getUUIDFromString(projectId));
    }

    @PutMapping
    @ResponseStatus(HttpStatus.OK)
    @ApiOperation(value = "Update work")
    public WorkDTO putWork(@ApiParam(value = "Contains all information of employee work with changed fields", name = "Work")
                           @RequestBody WorkDTO workDTO) {
        log.info("executing putWork() method");
        return workService.update(workDTO);
    }

    @DeleteMapping("/{empId}/{projId}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @ApiOperation(value = "Get work by employee id and project id")
    public void deleteWork(@ApiParam(value = "Employee id (UUID)")
                           @PathVariable("empId") String employeeId,
                           @ApiParam(value = "Project id (UUID)")
                           @PathVariable("projId") String projectId) {
        log.info("executing deleteWork() method");
        workService.deleteByIds(getUUIDFromString(employeeId), getUUIDFromString(projectId));
    }
}

package com.leverx.employeestat.rest.controller.tool;

import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;

@Component
public class BindingResultParser {

    public String getFieldErrMismatches(BindingResult result) {
        StringBuilder sb = new StringBuilder();
        for (FieldError err : result.getFieldErrors()) {
            sb
                    .append(err.getField()).append(": ")
                    .append(err.getDefaultMessage())
                    .append(", ");
        }
        sb.delete(sb.length() - 2, sb.length());
        return sb.toString();
    }
}

package com.leverx.employeestat.rest.controller.tool;

import com.leverx.employeestat.rest.exception.NotValidUUIDException;

import java.util.UUID;

public class UUIDUtils {

    public static UUID getUUIDFromString(String id) {
        UUID uuid = null;
        try {
            uuid = UUID.fromString(id);
        } catch (IllegalArgumentException e) {
            throw new NotValidUUIDException(String.format("Value =%s is not UUID", id), e);
        }
        return uuid;
    }
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.model.ResetPasswordRequest;

import java.util.List;

public interface AuthorizationService {

    EmployeeDTO registerEmployee(EmployeeDTO employeeDTO);

    EmployeeDTO resetPassword(ResetPasswordRequest request);

    List<EmployeeDTO> registerAll(List<EmployeeDTO> employeeDTOs);
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.EmployeeDTO;

import java.util.List;

public interface AvailableEmployeeService {

    List<EmployeeDTO> getAvailableEmployeesNow();

    List<EmployeeDTO> getAvailableEmployeesNext(int days);
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

public interface CSVReaderService {

    List<EmployeeDTO> getEmployeesFromFile(MultipartFile file);
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.DepartmentDTO;

import java.util.List;
import java.util.UUID;

public interface DepartmentService {

    DepartmentDTO save(DepartmentDTO departmentDTO);

    void deleteById(UUID id);

    DepartmentDTO update(DepartmentDTO departmentDTO);

    List<DepartmentDTO> getAll();

    DepartmentDTO getById(UUID id);

    boolean existsById(UUID id);

    boolean existsByName(String name);
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.EmployeeDTO;

import java.util.List;
import java.util.UUID;

public interface EmployeeService {

    public List<EmployeeDTO> getAll();

    public EmployeeDTO getById(UUID id);

    public EmployeeDTO getByUsername(String username);

    public EmployeeDTO save(EmployeeDTO employeeDTO);

    public List<EmployeeDTO> saveAll(List<EmployeeDTO> employeeDTOs);

    public EmployeeDTO update(EmployeeDTO employeeDTO);

    public void deleteById(UUID id);

    public boolean existsById(UUID id);
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.ProjectDTO;

import java.util.List;
import java.util.UUID;

public interface ProjectService {

    ProjectDTO getById(UUID id);

    ProjectDTO getByName(String name);

    List<ProjectDTO> getAll();

    ProjectDTO save(ProjectDTO projectDTO);

    ProjectDTO update(ProjectDTO projectDTO);

    void deleteById(UUID id);

    boolean existsById(UUID id);

    boolean existsByName(String name);
}

package com.leverx.employeestat.rest.service;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public interface ReportService {

    XSSFWorkbook exportOccupationReport();

    XSSFWorkbook exportLastGeneratedReport();

    void generateAvailableEmployeesReport();
}

package com.leverx.employeestat.rest.service;

import com.leverx.employeestat.rest.dto.WorkDTO;

import java.util.List;
import java.util.UUID;

public interface WorkService {

    List<WorkDTO> getAll();

    WorkDTO getByIds(UUID employeeId, UUID projectId);

    //WorkDTO save(WorkDTO workDTO);

    WorkDTO update(WorkDTO workDTO);

    void deleteByIds(UUID employeeId, UUID projectId);
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.dto.converter.EmployeeConverter;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.InvalidPasswordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.model.ResetPasswordRequest;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.service.AuthorizationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class AuthorizationServiceImpl implements AuthorizationService {

    private final EmployeeRepository employeeRepository;
    private final EmployeeConverter converter;
    private final PasswordEncoder encoder;

    @Autowired
    public AuthorizationServiceImpl(EmployeeRepository employeeRepository, EmployeeConverter converter, PasswordEncoder encoder) {
        this.employeeRepository = employeeRepository;
        this.converter = converter;
        this.encoder = encoder;
    }

    @Override
    @Transactional
    public EmployeeDTO registerEmployee(EmployeeDTO employeeDTO) {
        if (employeeRepository.existsByUsername(employeeDTO.getUsername())) {
            throw new DuplicateRecordException
                    (String.format("Employee with username=%s already exists", employeeDTO.getUsername()));
        }
        employeeDTO.setPassword(encoder.encode(employeeDTO.getPassword()));
        return converter.toDTO(employeeRepository.save(converter.toEntity(employeeDTO)));
    }

    @Override
    @Transactional
    public List<EmployeeDTO> registerAll(List<EmployeeDTO> employeeDTOs) {
        List<EmployeeDTO> saved = new ArrayList<>();
        for (EmployeeDTO employeeDTO : employeeDTOs) {
            saved.add(registerEmployee(employeeDTO));
        }
        return saved;
    }

    @Override
    @Transactional
    public EmployeeDTO resetPassword(ResetPasswordRequest request) {
        Employee employee = employeeRepository.findEmployeeByUsername(request.getUsername())
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with username=%s not found", request.getUsername()))
                );
        if (!encoder.matches(request.getOldPassword(), employee.getPassword())) {
            throw new InvalidPasswordException("You entered incorrect old password");
        }
        employee.setPassword(encoder.encode(request.getNewPassword()));
        return converter.toDTO(employee);
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.dto.converter.EmployeeConverter;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.repository.WorkRepository;
import com.leverx.employeestat.rest.service.AvailableEmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class AvailableEmployeeServiceImpl implements AvailableEmployeeService {

    private final WorkRepository workRepository;
    private final EmployeeConverter converter;

    @Autowired
    public AvailableEmployeeServiceImpl(WorkRepository workRepository, EmployeeConverter converter) {
        this.workRepository = workRepository;
        this.converter = converter;
    }

    @Override
    @Transactional
    public List<EmployeeDTO> getAvailableEmployeesNow() {
        return workRepository.findAllAvailableNow()
                .stream()
                .map(work -> converter.toDTO(work.getId().getEmployee()))
                .distinct()
                .collect(Collectors.toList());
    }

    @Override
    @Transactional
    public List<EmployeeDTO> getAvailableEmployeesNext(int days) {
        return workRepository.findAllAvailableNext(days)
                .stream()
                .map(work -> converter.toDTO(work.getId().getEmployee()))
                .distinct()
                .collect(Collectors.toList());
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.exception.CSVReadingException;
import com.leverx.employeestat.rest.service.CSVReaderService;
import com.opencsv.CSVReader;
import com.opencsv.exceptions.CsvValidationException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@Service
public class CSVReaderServiceImpl implements CSVReaderService {

    private final Logger log = LogManager.getLogger(CSVReaderServiceImpl.class);

    private final static int FIRST_NAME_COLUMN = 0;
    private final static int LAST_NAME_COLUMN = 1;
    private final static int USERNAME_COLUMN = 2;
    private final static int PASSWORD_COLUMN = 3;
    private final static int POSITION_COLUMN = 4;
    private final static int ROLE_COLUMN = 5;
    private final static int DEPARTMENT_ID_COLUMN = 6;

    public List<EmployeeDTO> getEmployeesFromFile(MultipartFile file) {
        List<EmployeeDTO> employees = new ArrayList<>();
        try(CSVReader reader = new CSVReader(new InputStreamReader(file.getInputStream()))) {
            String[] cells;
            while ((cells = reader.readNext()) != null) {
                EmployeeDTO employee = new EmployeeDTO();
                employee.setFirstName(cells[FIRST_NAME_COLUMN]);
                employee.setLastName(cells[LAST_NAME_COLUMN]);
                employee.setUsername(cells[USERNAME_COLUMN]);
                employee.setPassword(cells[PASSWORD_COLUMN]);
                employee.setPosition(cells[POSITION_COLUMN]);
                employee.setRole(cells[ROLE_COLUMN]);
                employee.setDepartmentId(UUID.fromString(cells[DEPARTMENT_ID_COLUMN]));
                employees.add(employee);
            }
        } catch (IOException | CsvValidationException e) {
            throw new CSVReadingException(e.getMessage(), e);
        }
        log.info("Multipart file (CSV) read successfully");
        return employees;
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.DepartmentDTO;
import com.leverx.employeestat.rest.dto.converter.DepartmentConverter;
import com.leverx.employeestat.rest.entity.Department;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.DepartmentRepository;
import com.leverx.employeestat.rest.service.DepartmentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class DepartmentServiceImpl implements DepartmentService {

    private final DepartmentRepository departmentRepository;
    private final DepartmentConverter converter;

    @Autowired
    public DepartmentServiceImpl(DepartmentRepository departmentRepository, DepartmentConverter converter) {
        this.departmentRepository = departmentRepository;
        this.converter = converter;
    }

    @Override
    @Transactional
    public DepartmentDTO save(DepartmentDTO departmentDTO) {
        if (departmentRepository.existsByName(departmentDTO.getName())) {
            throw new DuplicateRecordException
                    (String.format("Department with name=%s already exists", departmentDTO.getName()));
        }
        return converter.toDTO(departmentRepository.save(converter.toEntity(departmentDTO)));
    }

    @Override
    @Transactional
    public void deleteById(UUID id) {
        if (!departmentRepository.existsById(id)) {
            throw new NoSuchRecordException
                    (String.format("Department with id=%s not found for deleting", id));
        }
        departmentRepository.deleteById(id);
    }

    @Override
    @Transactional
    public DepartmentDTO update(DepartmentDTO departmentDTO) {
        if (departmentDTO.getId() != null && departmentRepository.existsById(departmentDTO.getId())) {
            return converter.toDTO(departmentRepository.save(converter.toEntity(departmentDTO)));
        } else if (!departmentRepository.existsByName(departmentDTO.getName())) {
            return converter.toDTO(departmentRepository.save(converter.toEntity(departmentDTO)));
        } else {
            throw new DuplicateRecordException
                    (String.format("Department with name=%s already exists", departmentDTO.getName()));
        }
    }

    @Override
    @Transactional(readOnly = true)
    public List<DepartmentDTO> getAll() {
        return departmentRepository.findAll()
                .stream()
                .map(converter::toDTO)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional(readOnly = true)
    public DepartmentDTO getById(UUID id) {
        Department department = departmentRepository.findById(id)
                .orElseThrow(() ->
                    new NoSuchRecordException(String.format("Department with id=%s not found", id))
                );
        return converter.toDTO(department);
    }

    @Override
    @Transactional(readOnly = true)
    public boolean existsById(UUID id) {
        return departmentRepository.existsById(id);
    }

    @Override
    @Transactional(readOnly = true)
    public boolean existsByName(String name) {
        return departmentRepository.existsByName(name);
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.dto.converter.EmployeeConverter;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class EmployeeServiceImpl implements EmployeeService {

    private final EmployeeRepository employeeRepository;
    private final EmployeeConverter converter;

    @Autowired
    public EmployeeServiceImpl(EmployeeRepository employeeRepository, EmployeeConverter converter) {
        this.employeeRepository = employeeRepository;
        this.converter = converter;
    }

    @Override
    @Transactional(readOnly = true)
    public List<EmployeeDTO> getAll() {
        return employeeRepository.findAll()
                .stream()
                .map(converter::toDTO)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional(readOnly = true)
    public EmployeeDTO getById(UUID id) {
        Employee employee = employeeRepository.findEmployeeById(id)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with id=%s not found", id))
                );
        return converter.toDTO(employee);
    }

    @Override
    @Transactional(readOnly = true)
    public EmployeeDTO getByUsername(String username) {
        Employee employee = employeeRepository.findEmployeeByUsername(username)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with username=%s not found", username))
                );
        return converter.toDTO(employee);
    }

    @Override
    @Transactional
    public EmployeeDTO save(EmployeeDTO employeeDTO) {
        if (employeeRepository.existsByUsername(employeeDTO.getUsername())) {
            throw new DuplicateRecordException
                    (String.format("Employee with username=%s already exists", employeeDTO.getUsername()));
        }
        return converter.toDTO(employeeRepository.save(converter.toEntity(employeeDTO)));
    }

    @Override
    @Transactional
    public List<EmployeeDTO> saveAll(List<EmployeeDTO> employeeDTOs) {
        List<EmployeeDTO> saved = new ArrayList<>();
        for (EmployeeDTO employeeDTO : employeeDTOs) {
            saved.add(save(employeeDTO));
        }
        return saved;
    }

    @Override
    @Transactional
    public EmployeeDTO update(EmployeeDTO employeeDTO) {
        Employee employee = employeeRepository.findEmployeeById(employeeDTO.getId())
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with id=%s not found", employeeDTO.getId()))
                );
        converter.updateEmployeeFields(employeeDTO, employee);
        return converter.toDTO(employee);
    }

    @Override
    @Transactional
    public void deleteById(UUID id) {
        if (!employeeRepository.existsById(id)) {
            throw new NoSuchRecordException
                    (String.format("Employee with id=%s not found for deleting", id));
        }
        employeeRepository.deleteById(id);
    }

    @Override
    @Transactional(readOnly = true)
    public boolean existsById(UUID id) {
        return employeeRepository.existsById(id);
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.ProjectDTO;
import com.leverx.employeestat.rest.dto.converter.ProjectConverter;
import com.leverx.employeestat.rest.entity.Project;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import com.leverx.employeestat.rest.service.ProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class ProjectServiceImpl implements ProjectService {

    private final ProjectRepository projectRepository;
    private final ProjectConverter converter;

    @Autowired
    public ProjectServiceImpl(ProjectRepository projectRepository, ProjectConverter converter) {
        this.projectRepository = projectRepository;
        this.converter = converter;
    }

    @Override
    @Transactional(readOnly = true)
    public ProjectDTO getById(UUID id) {
        Project project = projectRepository.findProjectById(id)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Project with id=%s not found", id))
                );
        return converter.toDTO(project);
    }

    @Override
    @Transactional(readOnly = true)
    public ProjectDTO getByName(String name) {
        Project project = projectRepository.findProjectByName(name).
                orElseThrow(() -> new NoSuchRecordException
                        (String.format("Project with name=%s not found", name))
                );
        return converter.toDTO(project);
    }

    @Override
    @Transactional(readOnly = true)
    public List<ProjectDTO> getAll() {
        return projectRepository.findAll()
                .stream()
                .map(converter::toDTO)
                .collect(Collectors.toList());
    }

    @Override
    public ProjectDTO save(ProjectDTO projectDTO) {
        if (projectRepository.existsByName(projectDTO.getName())) {
            throw new DuplicateRecordException
                    (String.format("Project with name=%s already exists", projectDTO.getName()));
        }
        return converter.toDTO(projectRepository.save(converter.toEntity(projectDTO)));
    }

    @Override
    @Transactional
    public ProjectDTO update(ProjectDTO projectDTO) {
        if (projectDTO.getId() != null && projectRepository.existsById(projectDTO.getId())) {
            return converter.toDTO(projectRepository.save(converter.toEntity(projectDTO)));
        } else if (!projectRepository.existsByName(projectDTO.getName())) {
            return converter.toDTO(projectRepository.save(converter.toEntity(projectDTO)));
        } else {
            throw new DuplicateRecordException
                    (String.format("Project with name=%s already exists", projectDTO.getName()));
        }
    }

    @Override
    @Transactional
    public void deleteById(UUID id) {
        if (!projectRepository.existsById(id)) {
            throw new NoSuchRecordException
                    (String.format("Department with id=%s not found for deleting", id));
        }
        projectRepository.deleteById(id);
    }

    @Override
    @Transactional(readOnly = true)
    public boolean existsById(UUID id) {
        return projectRepository.existsById(id);
    }

    @Override
    @Transactional(readOnly = true)
    public boolean existsByName(String name) {
        return projectRepository.existsByName(name);
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.entity.*;
import com.leverx.employeestat.rest.exception.AttributesReadingException;
import com.leverx.employeestat.rest.exception.NoSuchReportException;
import com.leverx.employeestat.rest.exception.ReportWritingException;
import com.leverx.employeestat.rest.repository.WorkRepository;
import com.leverx.employeestat.rest.service.ReportService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ReportServiceImpl implements ReportService {

    private final Logger log = LogManager.getLogger(ReportServiceImpl.class);

    private final static String FIRST_NAME_COL = "First Name";
    private final static String LAST_NAME_COL = "Last Name";
    private final static String DEPARTMENT_COL = "Department";
    private final static String PROJECT_OCCUPATION_COL = "Project - Occupation";

    @Value("${reports-path}")
    private String reportsPath;
    private XSSFWorkbook workbook;
    private final XSSFSheet sheet;
    private final WorkRepository workRepository;

    @Autowired
    public ReportServiceImpl(WorkRepository workRepository) {
        this.workbook = new XSSFWorkbook();
        this.sheet = (workbook.createSheet("Employees info"));
        this.workRepository = workRepository;
    }

    @Override
    @Scheduled(cron = "${reports-generating-cron}")
    @Transactional
    public void generateAvailableEmployeesReport() {
        createTableHeaders(FIRST_NAME_COL, LAST_NAME_COL, DEPARTMENT_COL);
        List<Employee> availableEmployees = workRepository.findAllAvailableNext(30)
                .stream()
                .map(Work::getId)
                .map(WorkId::getEmployee)
                .collect(Collectors.toList());

        for (int i = 0; i < availableEmployees.size(); i++) {
            Employee employee = availableEmployees.get(i);
            Row row = sheet.createRow(i + 1);

            Cell firstName = row.createCell(0);
            firstName.setCellValue(employee.getFirstName());

            Cell lastName = row.createCell(1);
            lastName.setCellValue(employee.getLastName());

            Cell department = row.createCell(2);
            department.setCellValue(employee.getDepartment().getName());
        }

        File file = new File(String.format("%s/AvailableEmployees-%s.xlsx", reportsPath, LocalDate.now()));
        try (FileOutputStream outputStream = new FileOutputStream(file)) {
            workbook.write(outputStream);
        } catch (IOException e) {
            throw new ReportWritingException("Failed to write report", e);
        }
        log.info("Report generated successfully (every month report)");
    }

    @Override
    @Transactional
    public XSSFWorkbook exportOccupationReport() {
        createTableHeaders(FIRST_NAME_COL, LAST_NAME_COL, DEPARTMENT_COL, PROJECT_OCCUPATION_COL);
        List<Work> works = workRepository.findAll();
        for (int i = 0; i < works.size(); i++) {
            Work work = works.get(i);
            Employee employee = work.getId().getEmployee();
            Project project = work.getId().getProject();

            Row row = sheet.createRow(i + 1);

            Cell firstName = row.createCell(0);
            firstName.setCellValue(employee.getFirstName());

            Cell lastName = row.createCell(1);
            lastName.setCellValue(employee.getLastName());

            Cell departmentName = row.createCell(2);
            Department department = employee.getDepartment();
            departmentName.setCellValue(department == null ? null : department.getName());

            Cell occupation = row.createCell(3);
            occupation.setCellValue(String.format("%s - (%s - %s)", project.getName(), work.getPositionStartDate(), work.getPositionEndDate()));
        }
        log.info("Occupation report created successfully");
        return workbook;
    }

    @Override
    public XSSFWorkbook exportLastGeneratedReport() {
        File latestReport = getLatestReport();
        log.info("Latest report retrieved successfully");
        try {
            return new XSSFWorkbook(latestReport);
        } catch (IOException | InvalidFormatException e) {
            throw new ReportWritingException("Failed to write report", e);
        }
    }

    private File getLatestReport() {
        File[] reports = new File(reportsPath).listFiles();
        return Arrays.stream(reports)
                .sorted((f1, f2) -> {
                    BasicFileAttributes attr1 = null;
                    BasicFileAttributes attr2 = null;
                    try {
                        attr1 = Files.readAttributes(f1.toPath(), BasicFileAttributes.class);
                        attr2 = Files.readAttributes(f2.toPath(), BasicFileAttributes.class);
                    } catch (IOException e) {
                        throw new AttributesReadingException("Failed to read file attributes", e);
                    }
                    return (-1) * attr1.creationTime().compareTo(attr2.creationTime());
                })
                .findFirst()
                .orElseThrow(() -> new NoSuchReportException("No reports found"));
    }

    private void createTableHeaders(String ... names) {
        Row row = sheet.createRow(0);
        for (int i = 0; i < names.length; i++) {
            sheet.setColumnWidth(i, 12000);
            Cell cell = row.createCell(i);
            cell.setCellValue(names[i]);
        }
    }
}

package com.leverx.employeestat.rest.service.impl;

import com.leverx.employeestat.rest.dto.WorkDTO;
import com.leverx.employeestat.rest.dto.converter.WorkConverter;
import com.leverx.employeestat.rest.entity.Work;
import com.leverx.employeestat.rest.entity.WorkId;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import com.leverx.employeestat.rest.repository.WorkRepository;
import com.leverx.employeestat.rest.service.WorkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class WorkServiceImpl implements WorkService {

    private final WorkRepository workRepository;
    private final EmployeeRepository employeeRepository;
    private final ProjectRepository projectRepository;
    private final WorkConverter converter;

    @Autowired
    public WorkServiceImpl(WorkRepository workRepository,
                           EmployeeRepository employeeRepository,
                           ProjectRepository projectRepository,
                           WorkConverter converter) {
        this.workRepository = workRepository;
        this.employeeRepository = employeeRepository;
        this.projectRepository = projectRepository;
        this.converter = converter;
    }

    @Override
    @Transactional
    public List<WorkDTO> getAll() {
        return workRepository.findAll()
                .stream()
                .map(converter::toDTO)
                .collect(Collectors.toList());
    }

    @Override
    @Transactional
    public WorkDTO getByIds(UUID employeeId, UUID projectId) {
        WorkId workId = createWorkId(employeeId, projectId);
        Work work = workRepository.findWorkById(workId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Work with id=%s not found", workId))
                );
        return converter.toDTO(work);
    }

    @Override
    @Transactional
    public WorkDTO update(WorkDTO workDTO) {
        WorkId workId = createWorkId(workDTO.getEmployeeId(), workDTO.getProjectId());
        Work work = workRepository.findWorkById(workId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Work with id=%s not found", workId))
                );

        work.setPositionEndDate(workDTO.getPositionEndDate());
        work.setPositionStartDate(workDTO.getPositionStartDate());
        work.setWorkingHours(workDTO.getWorkingHours());
        return converter.toDTO(work);
    }

    @Override
    @Transactional
    public void deleteByIds(UUID employeeId, UUID projectId) {
        WorkId workId = createWorkId(employeeId, projectId);
        if (!workRepository.existsById(workId)) {
            throw new NoSuchRecordException
                    (String.format("Work with id=%s not found", workId));
        }
        workRepository.deleteById(workId);
    }

    private WorkId createWorkId(UUID employeeId, UUID projectId) {
        WorkId workId = new WorkId();
        workId.setEmployee(employeeRepository.findEmployeeById(employeeId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with id=%s not found", employeeId)))
        );
        workId.setProject(projectRepository.findProjectById(projectId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Project with id=%s not found", projectId)))
        );
        return workId;
    }
}

package com.leverx.employeestat.rest.repository;

import com.leverx.employeestat.rest.entity.Department;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;
import java.util.UUID;

public interface DepartmentRepository extends JpaRepository<Department, UUID> {

    @Override
    Optional<Department> findById(UUID uuid);

    boolean existsById(UUID uuid);

    boolean existsByName(String name);
}

package com.leverx.employeestat.rest.repository;

import com.leverx.employeestat.rest.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;
import java.util.UUID;

public interface EmployeeRepository extends JpaRepository<Employee, UUID> {

    Optional<Employee> findEmployeeById(UUID id);

    Optional<Employee> findEmployeeByUsername(String username);

    boolean existsByUsername(String username);
}

package com.leverx.employeestat.rest.repository;

import com.leverx.employeestat.rest.entity.Project;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

public interface ProjectRepository extends JpaRepository<Project, UUID> {

    Optional<Project> findProjectById(UUID uuid);

    Optional<Project> findProjectByName(String name);

    @Override
    List<Project> findAll();

    boolean existsByName(String name);
}

package com.leverx.employeestat.rest.repository;

import com.leverx.employeestat.rest.entity.Role;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;
import java.util.UUID;

public interface RoleRepository extends JpaRepository<Role, UUID> {
    Optional<Role> findByName(String name);
}

package com.leverx.employeestat.rest.repository;

import com.leverx.employeestat.rest.entity.Work;
import com.leverx.employeestat.rest.entity.WorkId;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import java.util.List;
import java.util.Optional;

public interface WorkRepository extends JpaRepository<Work, WorkId> {

    Optional<Work> findWorkById(WorkId workId);

    @Override
    List<Work> findAll();

    void deleteById(WorkId workId);

    @Query(nativeQuery = true, value =
            "SELECT * FROM project_employee " +
            "WHERE position_end_date < current_date OR position_start_date > current_date")
    List<Work> findAllAvailableNow();

    @Query(nativeQuery = true, value =
            "SELECT * FROM project_employee " +
            "WHERE position_start_date < current_date and position_end_date < current_date " +
            "or position_start_date > current_date + ?1 and position_end_date > current_date + ?1")
    List<Work> findAllAvailableNext(int days);

}

package com.leverx.employeestat.rest.security.config;

import com.leverx.employeestat.rest.security.employeedetails.EmployeeDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;

@Configuration
@EnableWebSecurity
public class MultipleSecurityConfig {

    @Order(1)
    @Configuration
    public static class OAuth2Config extends WebSecurityConfigurerAdapter {

        private final ClientRegistrationRepository clientRegistrationRepository;
        private final OAuth2AuthorizedClientService authorizedClientService;

        @Autowired
        public OAuth2Config(ClientRegistrationRepository clientRegistrationRepository,
                            OAuth2AuthorizedClientService authorizedClientService) {
            this.clientRegistrationRepository = clientRegistrationRepository;
            this.authorizedClientService = authorizedClientService;
        }

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .requestMatchers()
                    .antMatchers(
                            "/oauth2/authorization/google",
                            "/api/employees/export",
                            "/api/employees/export/last",
                            "/login/oauth2/code/google/**")
                    .and()
                    .authorizeRequests()
                    .anyRequest().authenticated()
                    .and()
                    .oauth2Login()
                    .clientRegistrationRepository(clientRegistrationRepository)
                    .authorizedClientService(authorizedClientService);
        }
    }

    @Order(2)
    @Configuration
    public static class BasicAuthorizationConfig extends WebSecurityConfigurerAdapter {

        private final EmployeeDetailsService employeeDetailsService;
        private final CustomBasicAuthenticationEntryPoint authenticationEntryPoint;
        private final CustomAccessDeniedHandler accessDeniedHandler;

        @Autowired
        public BasicAuthorizationConfig(EmployeeDetailsService employeeDetailsService,
                                        CustomBasicAuthenticationEntryPoint authenticationEntryPoint,
                                        CustomAccessDeniedHandler accessDeniedHandler) {
            this.employeeDetailsService = employeeDetailsService;
            this.authenticationEntryPoint = authenticationEntryPoint;
            this.accessDeniedHandler = accessDeniedHandler;
        }

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .csrf().disable()
                    .authorizeRequests()
                    .antMatchers("/api/register").permitAll()
                    .antMatchers("/api/reset-password").permitAll()
                    .antMatchers("/api/doc").permitAll()
                    .antMatchers(HttpMethod.GET, "/api/**/**/").permitAll()
                    .antMatchers(HttpMethod.POST, "/api/*").hasRole("MANAGER")
                    .antMatchers(HttpMethod.PUT, "/api/*").hasRole("MANAGER")
                    .antMatchers(HttpMethod.DELETE, "/api/**/**").hasRole("MANAGER")
                    .anyRequest().authenticated()
                    .and().httpBasic().authenticationEntryPoint(authenticationEntryPoint)
                    .and().sessionManagement().disable()
                    .exceptionHandling().accessDeniedHandler(accessDeniedHandler);
        }

        @Override
        public void configure(AuthenticationManagerBuilder builder) throws Exception {
            builder.userDetailsService(employeeDetailsService);
        }
    }
}

package com.leverx.employeestat.rest.security.config;

import com.leverx.employeestat.rest.exceptionhandler.ExceptionInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static com.leverx.employeestat.rest.util.JsonUtils.toJson;

@Slf4j
@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        response.setStatus(HttpStatus.FORBIDDEN.value());
        ExceptionInfo info = new ExceptionInfo(accessDeniedException.getMessage(), HttpStatus.FORBIDDEN);
        response.getOutputStream().println(toJson(info));
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);

        log.info("Access denied: " + accessDeniedException.getMessage());
    }
}

package com.leverx.employeestat.rest.security.config;

import com.leverx.employeestat.rest.exceptionhandler.ExceptionInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static com.leverx.employeestat.rest.util.JsonUtils.toJson;

@Component
@Slf4j
public class CustomBasicAuthenticationEntryPoint extends BasicAuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        ExceptionInfo info = new ExceptionInfo(authException.getMessage(), HttpStatus.UNAUTHORIZED);
        response.getOutputStream().println(toJson(info));
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);

        log.info("Authentication failed: " + authException.getMessage());
    }

    @Override
    public void afterPropertiesSet() {
        setRealmName("Access to secured endpoints");
        super.afterPropertiesSet();
    }
}

package com.leverx.employeestat.rest.security.employeedetails;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Collections;

@Component
public class EmployeeDetails implements UserDetails {

    private String username;
    private String password;
    private Collection<? extends GrantedAuthority> grantedAuthorities;

    public EmployeeDetails toEmployeeDetails(EmployeeDTO employee) {
        this.username = employee.getUsername();
        this.password = employee.getPassword();
        this.grantedAuthorities = Collections.singletonList(new SimpleGrantedAuthority(employee.getRole()));
        return this;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return grantedAuthorities;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

package com.leverx.employeestat.rest.security.employeedetails;

import com.leverx.employeestat.rest.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class EmployeeDetailsService implements UserDetailsService {

    private final EmployeeDetails employeeDetails;
    private final EmployeeService employeeService;

    @Autowired
    public EmployeeDetailsService(EmployeeDetails employeeDetails, EmployeeService employeeService) {
        this.employeeDetails = employeeDetails;
        this.employeeService = employeeService;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return employeeDetails.toEmployeeDetails(employeeService.getByUsername(username));
    }
}

package com.leverx.employeestat.rest.exceptionhandler;

import com.leverx.employeestat.rest.exception.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@Slf4j
@Order(Ordered.HIGHEST_PRECEDENCE)
@RestControllerAdvice("com.leverx.employeestat.rest.controller")
public class GlobalControllerAdvice extends ResponseEntityExceptionHandler {

    @ExceptionHandler(NoSuchRecordException.class)
    public ResponseEntity<ExceptionInfo> handleNoSuchRecordException(NoSuchRecordException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.NOT_FOUND);
        return new ResponseEntity<>(info, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(DuplicateRecordException.class)
    public ResponseEntity<ExceptionInfo> handleDuplicateRecordException(DuplicateRecordException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.BAD_REQUEST);
        return new ResponseEntity<>(info, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(EntityConversionException.class)
    public ResponseEntity<ExceptionInfo> handleEntityConversionException(EntityConversionException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.BAD_REQUEST);
        return new ResponseEntity<>(info, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(NotValidRecordException.class)
    public ResponseEntity<ExceptionInfo> handleNotValidRecordException(NotValidRecordException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.BAD_REQUEST);
        return new ResponseEntity<>(info, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(NotValidUUIDException.class)
    public ResponseEntity<ExceptionInfo> handleNotValidUUIDException(NotValidUUIDException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.BAD_REQUEST);
        return new ResponseEntity<>(info, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(InvalidPasswordException.class)
    public ResponseEntity<ExceptionInfo> handleInvalidPasswordException(InvalidPasswordException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.UNAUTHORIZED);
        return new ResponseEntity<>(info, HttpStatus.UNAUTHORIZED);
    }

    @ExceptionHandler(CSVReadingException.class)
    public ResponseEntity<ExceptionInfo> handleCSVReadingException(CSVReadingException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.BAD_REQUEST);
        return new ResponseEntity<>(info, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(NoSuchReportException.class)
    public ResponseEntity<ExceptionInfo> handleNoSuchReportException(NoSuchReportException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    @ExceptionHandler(ReportWritingException.class)
    public ResponseEntity<ExceptionInfo> handleReportWritingException(ReportWritingException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        return new ResponseEntity<>(info, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(AttributesReadingException.class)
    public ResponseEntity<ExceptionInfo> handleAttributesReadingException(AttributesReadingException exception) {
        log.info(String.format("Handled exception - %s", exception), exception);
        ExceptionInfo info = new ExceptionInfo(exception.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        return new ResponseEntity<>(info, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

package com.leverx.employeestat.rest.dto.converter;

import com.leverx.employeestat.rest.dto.DepartmentDTO;
import com.leverx.employeestat.rest.entity.Department;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

@Component
public class DepartmentConverter {

    private final EmployeeRepository employeeRepository;

    @Autowired
    public DepartmentConverter(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public Department toEntity(DepartmentDTO departmentDTO) {
        Department department = Department.builder()
                .name(departmentDTO.getName())
                .id(departmentDTO.getId())
                .build();

        Optional.ofNullable(departmentDTO.getEmployeeIds())
                .ifPresent(employeeIds -> employeeIds.forEach(id -> {
                    department.addEmployee(employeeRepository.findEmployeeById(id)
                            .orElseThrow(() -> new NoSuchRecordException
                                    (String.format("Employee with id=%s not found", id)))
                    );
                }));

        return department;
    }

    public DepartmentDTO toDTO(Department department) {
        DepartmentDTO departmentDTO = DepartmentDTO.builder()
                .name(department.getName())
                .id(department.getId())
                .build();

        Optional.ofNullable(department.getEmployees())
                .ifPresent(employees -> employees.forEach(employee -> departmentDTO.addEmployeeId(employee.getId())));

        return departmentDTO;
    }
}

package com.leverx.employeestat.rest.dto.converter;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.entity.Department;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.entity.Project;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.DepartmentRepository;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import com.leverx.employeestat.rest.repository.RoleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

@Component
public class EmployeeConverter {

    private final DepartmentRepository departmentRepository;
    private final ProjectRepository projectRepository;
    private final RoleRepository roleRepository;

    @Autowired
    public EmployeeConverter(DepartmentRepository departmentRepository,
                             ProjectRepository projectRepository,
                             RoleRepository roleRepository) {
        this.departmentRepository = departmentRepository;
        this.projectRepository = projectRepository;
        this.roleRepository = roleRepository;
    }

    public Employee toEntity(EmployeeDTO employeeDTO) {
        Employee employee = Employee.builder()
                .username(employeeDTO.getUsername())
                .id(employeeDTO.getId())
                .firstName(employeeDTO.getFirstName())
                .lastName(employeeDTO.getLastName())
                .password(employeeDTO.getPassword())
                .position(employeeDTO.getPosition())
                .build();

        employee.setRole(roleRepository.findByName(employeeDTO.getRole())
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Role with name=%s does not exists", employeeDTO.getRole())))
        );

        Optional.ofNullable(employeeDTO.getDepartmentId())
                .ifPresent(id -> {
                    Department department = departmentRepository.findById(employeeDTO.getDepartmentId())
                            .orElseThrow(() -> new NoSuchRecordException
                                    (String.format("Department with id=%s not found", employeeDTO.getDepartmentId()))
                            );
                    employee.setDepartment(department);
                });

        Optional.ofNullable(employeeDTO.getProjectIds())
                .ifPresent(projectIds -> projectIds.forEach(id -> {
                    Project project = projectRepository.findProjectById(id)
                            .orElseThrow(() -> new NoSuchRecordException
                                    (String.format("Project with id=%s not found", id))
                            );
                    employee.addProject(project);
                }));

        return employee;
    }

    public void updateEmployeeFields(EmployeeDTO employeeDTO, Employee employee) {
        employee.setUsername(employeeDTO.getUsername());
        employee.setFirstName(employeeDTO.getFirstName());
        employee.setLastName(employeeDTO.getLastName());
        employee.setPosition(employeeDTO.getPosition());

        employee.setRole(roleRepository.findByName(employeeDTO.getRole())
                .orElseThrow(() -> new NoSuchRecordException
                        ("Role with name=" + employeeDTO.getRole() + " does not exists"))
        );

        if (employeeDTO.getDepartmentId() != null) {
            Department department = departmentRepository.findById(employeeDTO.getDepartmentId())
                    .orElseThrow(() -> new NoSuchRecordException
                            (String.format("Department with id=%s not found", employeeDTO.getDepartmentId()))
                    );
            employee.setDepartment(department);
        } else {
            employee.setDepartment(null);
        }

        if (employeeDTO.getProjectIds() != null) {
            employee.setProjects(null);
            for (UUID id : employeeDTO.getProjectIds()) {
                Project project = projectRepository.findProjectById(id)
                        .orElseThrow(() -> new NoSuchRecordException
                                (String.format("Project with id=%s not found", id))
                        );
                employee.addProject(project);
            }
        } else {
            employee.setProjects(null);
        }
    }

    public EmployeeDTO toDTO(Employee employee) {
        EmployeeDTO employeeDTO = EmployeeDTO.builder()
                .username(employee.getUsername())
                .id(employee.getId())
                .firstName(employee.getFirstName())
                .lastName(employee.getLastName())
                .password(employee.getPassword())
                .position(employee.getPosition())
                .role(employee.getRoleName())
                .build();

        Optional.ofNullable(employee.getDepartment())
                .ifPresent(department -> employeeDTO.setDepartmentId(department.getId()));

        Optional.ofNullable(employee.getProjects())
                .ifPresent((projects -> projects.forEach(project -> employeeDTO.addProjectId(project.getId()))));

        return employeeDTO;
    }

package com.leverx.employeestat.rest.dto.converter;

import com.leverx.employeestat.rest.dto.ProjectDTO;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.entity.Project;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

@Component
public class ProjectConverter {

    private final EmployeeRepository employeeRepository;

    @Autowired
    public ProjectConverter(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public Project toEntity(ProjectDTO projectDTO) {
        Project project = Project.builder()
                .id(projectDTO.getId())
                .name(projectDTO.getName())
                .begin(projectDTO.getBegin())
                .end(projectDTO.getEnd())
                .build();

        Optional.ofNullable(projectDTO.getEmployeeIds())
                .ifPresent(employeeIds -> employeeIds.forEach(id -> {
                    project.addEmployee(employeeRepository.findEmployeeById(id)
                            .orElseThrow(() -> new NoSuchRecordException
                                    (String.format("Employee with id=%s not found", id)))
                    );
                }));

        return project;
    }

    public ProjectDTO toDTO(Project project) {
        ProjectDTO projectDTO = ProjectDTO.builder()
                .name(project.getName())
                .begin(project.getBegin())
                .end(project.getEnd())
                .id(project.getId())
                .build();

        Optional.ofNullable(project.getEmployees())
                .ifPresent(employees -> employees.forEach(employee -> projectDTO.addEmployeeId(employee.getId())));

        return projectDTO;
    }
}

package com.leverx.employeestat.rest.dto.converter;

import com.leverx.employeestat.rest.dto.WorkDTO;
import com.leverx.employeestat.rest.entity.Work;
import com.leverx.employeestat.rest.entity.WorkId;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

@Component
public class WorkConverter {

    private final EmployeeRepository employeeRepository;
    private final ProjectRepository projectRepository;

    @Autowired
    public WorkConverter(EmployeeRepository employeeRepository, ProjectRepository projectRepository) {
        this.employeeRepository = employeeRepository;
        this.projectRepository = projectRepository;
    }

    public Work toEntity(WorkDTO workDTO) {
        UUID employeeId = workDTO.getEmployeeId();
        UUID projectId = workDTO.getProjectId();
        WorkId workId = new WorkId();
        workId.setEmployee(employeeRepository.findEmployeeById(employeeId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Employee with id=%s not found", employeeId)))
        );
        workId.setProject(projectRepository.findProjectById(projectId)
                .orElseThrow(() -> new NoSuchRecordException
                        (String.format("Project with id=%s not found", projectId)))
        );

        Work work = Work.builder()
                .id(workId)
                .positionEndDate(workDTO.getPositionEndDate())
                .positionStartDate(workDTO.getPositionStartDate())
                .workingHours(workDTO.getWorkingHours())
                .build();

        return work;
    }

    public WorkDTO toDTO(Work work) {
        return WorkDTO.builder()
                .employeeId(work.getId().getEmployee().getId())
                .projectId(work.getId().getProject().getId())
                .workingHours(work.getWorkingHours())
                .positionEndDate(work.getPositionEndDate())
                .positionStartDate(work.getPositionStartDate())
                .build();
    }
}

package com.leverx.employeestat.rest.dto;

import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@ApiModel(value = "Department", description = "Contains all information about department and its employees(ids)")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class DepartmentDTO {

    private UUID id;

    @NotBlank
    private String name;

    private List<UUID> employeeIds;

    public void addEmployeeId(UUID id) {
        if (employeeIds == null) {
            employeeIds = new ArrayList<>();
        }
        employeeIds.add(id);
    }
}

package com.leverx.employeestat.rest.dto;

import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

@ApiModel(value = "Employee", description = "Contains all information about employee and its projects(ids) and department(id)")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class EmployeeDTO {

    private UUID id;

    @NotBlank
    private String firstName;

    @NotBlank
    private String lastName;

    @NotBlank
    private String username;

    @JsonIgnore
    private String password;

    @NotBlank
    private String position;

    @NotBlank
    private String role;

    private UUID departmentId;

    private List<UUID> projectIds;

    public void addProjectId(UUID id) {
        if (projectIds == null) {
            projectIds = new ArrayList<>();
        }
        projectIds.add(id);
    }

    @Override
    public String toString() {
        return "EmployeeDTO{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", position='" + position + '\'' +
                ", role='" + role + '\'' +
                ", departmentId=" + departmentId +
                ", projectsIds=" + projectIds +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EmployeeDTO that = (EmployeeDTO) o;
        return Objects.equals(id, that.id) && firstName.equals(that.firstName) && lastName.equals(that.lastName) && username.equals(that.username) && password.equals(that.password) && position.equals(that.position) && role.equals(that.role) && Objects.equals(departmentId, that.departmentId) && Objects.equals(projectIds, that.projectIds);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, firstName, lastName, username, password, position, role, departmentId, projectIds);
    }
}

package com.leverx.employeestat.rest.dto;

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@ApiModel(value = "Project", description = "Contains all information about project and its employees(ids)")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ProjectDTO {

    private UUID id;

    @NotBlank
    private String name;

    @NotNull
    @JsonSerialize(using = ToStringSerializer.class)
    @JsonDeserialize(using = LocalDateDeserializer.class)
    private LocalDate begin;

    @NotNull
    @JsonSerialize(using = ToStringSerializer.class)
    @JsonDeserialize(using = LocalDateDeserializer.class)
    private LocalDate end;

    private List<UUID> employeeIds;

    public void addEmployeeId(UUID id) {
        if (employeeIds == null) {
            employeeIds = new ArrayList<>();
        }
        employeeIds.add(id);
    }
}

package com.leverx.employeestat.rest.dto;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.util.UUID;

@ApiModel(value = "Works", description = "Representation of the workload of employees on the project")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class WorkDTO {

    private UUID employeeId;

    private UUID projectId;

    @JsonSerialize(using = ToStringSerializer.class)
    private LocalDate positionStartDate;

    @JsonSerialize(using = ToStringSerializer.class)
    private LocalDate positionEndDate;

    private Integer workingHours;

}

package com.leverx.employeestat.rest.entity;

import lombok.*;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

@Entity
@Table(name = "department")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Department {

    @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
    @Column(name = "id")
    private UUID id;

    @Column(name = "name")
    private String name;

    @OneToMany(mappedBy = "department", fetch = FetchType.EAGER)
    @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
    private List<Employee> employees;

    public void addEmployee(Employee employee) {
        if (employees == null) {
            employees = new ArrayList<>();
        }
        employees.add(employee);
        employee.setDepartment(this);
    }
}

package com.leverx.employeestat.rest.entity;

import lombok.*;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

@Entity
@Table(name = "employee")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Employee {

    @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
    @Column(name = "id")
    private UUID id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "username")
    private String username;

    @Column(name = "password")
    private String password;

    @Column(name = "position")
    private String position;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "role_id")
    private Role role;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "department_id")
    @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
    private Department department;

    @ManyToMany(fetch = FetchType.EAGER)
    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.PERSIST})
    @JoinTable(name = "project_employee",
               joinColumns = @JoinColumn(name = "employee_id"),
               inverseJoinColumns = @JoinColumn(name = "project_id"))
    private List<Project> projects;

    public String getRoleName() {
        return role.getName();
    }

    public void addProject(Project project) {
        if (projects == null) {
            projects = new ArrayList<>();
        }
        projects.add(project);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id.equals(employee.id) && firstName.equals(employee.firstName) && lastName.equals(employee.lastName) && username.equals(employee.username) && password.equals(employee.password) && position.equals(employee.position) && Objects.equals(role, employee.role) && Objects.equals(department, employee.department) && Objects.equals(projects, employee.projects);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, firstName, lastName, username, password, position, role, department, projects);
    }
}

package com.leverx.employeestat.rest.entity;

import lombok.*;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

@Entity
@Table(name = "project")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Project {
    @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
    @Column(name = "id")
    private UUID id;

    @Column(name = "name")
    private String name;

    @Column(name = "begin_date")
    private LocalDate begin;

    @Column(name = "end_date")
    private LocalDate end;

    @ManyToMany(fetch = FetchType.EAGER)
    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.PERSIST})
    @JoinTable(name = "project_employee",
            joinColumns = @JoinColumn(name = "project_id"),
            inverseJoinColumns = @JoinColumn(name = "employee_id"))
    private List<Employee> employees;

    public void addEmployee(Employee employee) {
        if (employees == null) {
            employees = new ArrayList<>();
        }
        employees.add(employee);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Project project = (Project) o;
        return Objects.equals(id, project.id) && Objects.equals(name, project.name) && Objects.equals(begin, project.begin) && Objects.equals(end, project.end) && Objects.equals(employees, project.employees);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, begin, end, employees);
    }
}

package com.leverx.employeestat.rest.entity;

import lombok.*;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.util.List;
import java.util.UUID;

@Entity
@Table(name = "role")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Role {

    @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
    @Column(name = "id")
    private UUID id;

    @Column(name = "name")
    private String name;

    @OneToMany(mappedBy = "role")
    private List<Employee> employees;

}

package com.leverx.employeestat.rest.entity;

import lombok.*;

import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.time.LocalDate;

@Entity
@Table(name = "project_employee")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Work {

    @EmbeddedId
    private WorkId id;

    @Column(name = "position_start_date")
    private LocalDate positionStartDate;

    @Column(name = "position_end_date")
    private LocalDate positionEndDate;

    @Column(name = "working_hours")
    private Integer workingHours;

}

package com.leverx.employeestat.rest.entity;

import lombok.*;

import javax.persistence.Embeddable;
import javax.persistence.ManyToOne;
import java.io.Serializable;
import java.util.Objects;

@Embeddable
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class WorkId implements Serializable {

    @ManyToOne(targetEntity = Employee.class)
    private Employee employee;

    @ManyToOne(targetEntity = Project.class)
    private Project project;

    @Override
    public String toString(){
        return "(employeeId=" + employee.getId() + "; projectId=" + project.getId() + ")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        WorkId workId = (WorkId) o;
        return employee.equals(workId.employee) && project.equals(workId.project);
    }

    @Override
    public int hashCode() {
        return Objects.hash(employee, project);
    }
}

package com.leverx.employeestat.rest.model;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;

@ApiModel(value = "Registration request", description = "Contains mandatory fields for registration of employee")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class RegistrationRequest {

    @NotBlank
    private String firstName;

    @NotBlank
    private String lastName;

    @NotBlank
    private String username;

    @NotBlank
    private String password;

    @NotBlank
    private String position;

    @NotBlank
    private String role;

    public EmployeeDTO toDTO() {
        return EmployeeDTO.builder()
                .firstName(firstName)
                .lastName(lastName)
                .password(password)
                .role(role)
                .position(position)
                .username(username)
                .build();
    }
}

package com.leverx.employeestat.rest.model;

import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;

@ApiModel(value = "Reset password request", description = "Contains username, old and new password of employee")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ResetPasswordRequest {

    @NotBlank
    private String username;

    @NotBlank
    private String oldPassword;

    @NotBlank
    private String newPassword;

}

------------------------------
TESTS
------------------------------

package com.leverx.employeestat.rest.integration.config;

import com.leverx.employeestat.rest.configuration.Config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import liquibase.integration.spring.SpringLiquibase;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

public class TestConfig extends Config {

    private final Environment env;

    @Autowired
    public TestConfig(Environment env) {
        super(env);
        this.env = env;
    }

    @Bean
    @Override
    public DataSource dataSource() {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(env.getRequiredProperty("driverClass"));
            dataSource.setJdbcUrl(env.getRequiredProperty("testUrl"));
            dataSource.setUser(env.getRequiredProperty("dbuser"));
            dataSource.setPassword(env.getRequiredProperty("password"));
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

    @Bean
    @Override
    public SpringLiquibase liquibase() {
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setChangeLog("classpath:db/changelog/liquibase-changeLog-test.xml");
        liquibase.setDataSource(dataSource());
        return liquibase;
    }

    @Bean
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        return new MethodValidationPostProcessor();
    }


}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.exceptionhandler.GlobalControllerAdvice;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import com.leverx.employeestat.rest.model.RegistrationRequest;
import com.leverx.employeestat.rest.model.ResetPasswordRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import static com.leverx.employeestat.rest.integration.util.JsonUtils.toJson;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class AuthorizationIntegrationTest {

    private static final String REGISTER_ENDPOINT = "/api/register";
    private static final String RESET_ENDPOINT = "/api/reset-password";

    private final WebApplicationContext webAppContext;

    private MockMvc mvc;

    private RegistrationRequest registrationRequest;
    private ResetPasswordRequest resetPasswordRequest;

    @Autowired
    public AuthorizationIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    public void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(webAppContext).build();
    }

    @BeforeEach
    public void init() {
        registrationRequest = new RegistrationRequest();
        resetPasswordRequest = new ResetPasswordRequest();

        registrationRequest.setFirstName("name");
        registrationRequest.setLastName("last name");
        registrationRequest.setPassword("init");
        registrationRequest.setPosition("position");
        registrationRequest.setUsername("username");
        registrationRequest.setRole("ROLE_EMPLOYEE");

        resetPasswordRequest.setOldPassword("init");
        resetPasswordRequest.setNewPassword("new");
        resetPasswordRequest.setUsername("username");
    }

    @Test
    public void shouldExistsGlobalControllerAdvice() {
        GlobalControllerAdvice advice = this.webAppContext.getBean(GlobalControllerAdvice.class);
        assertNotNull(advice);
    }

    @Test
    public void shouldReturnOkStatusIfJsonIsCorrectForRegisterEmployee() throws Exception {
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").isNotEmpty());
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonFieldsIsNotValidForRegisterEmployee() throws Exception {
        registrationRequest.setUsername("");
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonContainsExistingUsernameForRegisterEmployee() throws Exception {
        registrationRequest.setUsername("Vanechka");
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.message").value(String.format("Employee with username=%s already exists", registrationRequest.getUsername())));
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsNotCorrectForRegisterEmployee() throws Exception {
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnNotFoundStatusIfJsonContainsNotExistingRoleForRegisterEmployee() throws Exception {
        registrationRequest.setRole("not existing");
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Role with name=%s does not exists", registrationRequest.getRole())));
    }

    @Test
    public void shouldReturnOkStatusIfJsonIsCorrectAndContainsIsValidOldPasswordForResetPassword() throws Exception {
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isCreated());

        mvc.perform(post(RESET_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(resetPasswordRequest)))
                .andExpect(status().isNoContent());
    }

    @Test
    public void shouldReturnNotFoundStatusIfEmployeeDoesNotExistByUsernameForResetPassword() throws Exception {
        mvc.perform(post(RESET_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(resetPasswordRequest)))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Employee with username=%s not found", resetPasswordRequest.getUsername())));
    }

    @Test
    public void shouldReturnUnauthorizedStatusIfOldPasswordMismatchesWithCurrentForResetPassword() throws Exception {
        mvc.perform(post(REGISTER_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(registrationRequest)))
                .andExpect(status().isCreated());
        resetPasswordRequest.setOldPassword("incorrect");
        mvc.perform(post(RESET_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(resetPasswordRequest)))
                .andExpect(status().isUnauthorized())
                .andExpect(jsonPath("$.message").value("You entered incorrect old password"));
    }
}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class AvailableEmployeeIntegrationTest {

    public static final String AVAILABLE_EMPLOYEES_ENDPOINT = "/api/employees/available";

    private final WebApplicationContext webAppContext;
    private MockMvc mvc;

    private String firstEmployeeId;
    private String secondEmployeeId;

    @Autowired
    public AvailableEmployeeIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    public void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(this.webAppContext).build();
    }

    @Test
    public void shouldReturnTwoAvailableEmployeesNow() throws Exception {
        final String firstExpectedId = "c7fa1cd3-b281-47b1-b72f-92b9391fc5c7";
        final String secondExpectedId = "e9a4e12b-1555-48bd-9275-629856bcdb51";
        final String thirdExpectedId = "2174c05c-e885-4521-985d-774b1f05cd37";

        mvc.perform(get(AVAILABLE_EMPLOYEES_ENDPOINT))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk()).andDo(print())
                .andExpect(jsonPath("$[0].id").value(firstExpectedId))
                .andExpect(jsonPath("$[1].id").value(secondExpectedId))
                .andExpect(jsonPath("$[2].id").value(thirdExpectedId));
    }

    @Test
    public void shouldReturnOneAvailableEmployeeWithinMonth() throws Exception {
        final String firstExpectedId = "c7fa1cd3-b281-47b1-b72f-92b9391fc5c7";
        mvc.perform(get(AVAILABLE_EMPLOYEES_ENDPOINT + "/20"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk()).andDo(print())
                .andExpect(jsonPath("$[0].id").value(firstExpectedId));
    }
}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.dto.DepartmentDTO;
import com.leverx.employeestat.rest.exceptionhandler.GlobalControllerAdvice;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import java.util.UUID;

import static com.leverx.employeestat.rest.integration.util.JsonUtils.toJson;
import static com.leverx.employeestat.rest.integration.util.JsonUtils.toObject;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class DepartmentIntegrationTest {

    private static final String DEPARTMENTS_ENDPOINT = "/api/departments";

    private final WebApplicationContext webAppContext;
    private MockMvc mvc;

    @Autowired
    public DepartmentIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    public void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(this.webAppContext).build();
    }

    @Test
    public void shouldExistsGlobalControllerAdvice() {
        GlobalControllerAdvice advice = this.webAppContext.getBean(GlobalControllerAdvice.class);
        assertNotNull(advice);
    }

    @Test
    public void shouldReturnJsonIfGetRequest() throws Exception {
        mvc.perform(get(DEPARTMENTS_ENDPOINT))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());
    }

    @Test
    public void shouldReturnCorrectJsonIfGetRequestById() throws Exception {
        mvc.perform(get(DEPARTMENTS_ENDPOINT + "/{id}", "edf939d2-dbc2-4473-80a1-4bb3826e666e"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.name").value("HR"));
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForGetRequestById() throws Exception {
        mvc.perform(get(DEPARTMENTS_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnNotFoundIfRecordNotFoundById() throws Exception {
        String id = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";

        mvc.perform(get(DEPARTMENTS_ENDPOINT + "/{id}", id))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.status").value("NOT_FOUND"))
                .andExpect(jsonPath("$.code").value(404));
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsNotCorrectForPost() throws Exception {
        mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnBadRequestIfNameOfDepartmentAlreadyExistsForPost() throws Exception {
        DepartmentDTO departmentDTO = new DepartmentDTO();
        String name = "Department";
        departmentDTO.setName(name);

        mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isCreated());

        mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnOkStatusIfJsonIsCorrectForPost() throws Exception {
        DepartmentDTO departmentDTO = new DepartmentDTO();
        String expected = "Test";
        departmentDTO.setName(expected);

        mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.name").value(expected))
                .andExpect(jsonPath("$.id").isNotEmpty());
    }

    @Test
    public void shouldReturnBadRequestIfNameOfDepartmentAlreadyExistsForPut() throws Exception {
        DepartmentDTO departmentDTO = new DepartmentDTO();
        String name = "Department";
        departmentDTO.setName(name);

        mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isCreated());

        mvc.perform(put(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsNotCorrectForPut() throws Exception {
        mvc.perform(put(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnOkStatusIfJsonWithoutIdIsCorrectForPut() throws Exception{
        DepartmentDTO departmentDTO = new DepartmentDTO();
        String expected = "Test";
        departmentDTO.setName(expected);

        mvc.perform(put(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value(expected))
                .andExpect(jsonPath("$.id").isNotEmpty());

        assertNull(departmentDTO.getId());
    }

    @Test
    public void shouldReturnUpdatedDepartmentIfItExistsById() throws Exception {
        DepartmentDTO departmentDTO = new DepartmentDTO();
        String name = "Test";
        String expectedName = "Expected";
        departmentDTO.setName(name);

        MvcResult result = mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isCreated())
                .andReturn();

        departmentDTO = toObject(result.getResponse().getContentAsString(), DepartmentDTO.class);
        departmentDTO.setName(expectedName);
        UUID expectedId = departmentDTO.getId();

        mvc.perform(put(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(expectedId.toString()))
                .andExpect(jsonPath("$.name").value(expectedName));
    }

    @Test
    public void shouldDeleteDepartmentIfIdIsCorrectAndExists() throws Exception{
        DepartmentDTO departmentDTO = new DepartmentDTO();
        departmentDTO.setName("Test");
        MvcResult result = mvc.perform(post(DEPARTMENTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(departmentDTO)))
                .andExpect(status().isCreated())
                .andReturn();
        departmentDTO = toObject(result.getResponse().getContentAsString(), DepartmentDTO.class);
        UUID id = departmentDTO.getId();
        mvc.perform(delete(DEPARTMENTS_ENDPOINT + "/{id}", id.toString()))
                .andExpect(status().isNoContent());
    }

    @Test
    public void shouldReturnMethodNotAllowedIfUUIDIsEmptyForDelete() throws Exception {
        mvc.perform(delete(DEPARTMENTS_ENDPOINT + "/{id}", ""))
                .andExpect(status().isMethodNotAllowed());
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForDeleteRequestById() throws Exception {
        mvc.perform(delete(DEPARTMENTS_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }
}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.exceptionhandler.GlobalControllerAdvice;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import java.util.UUID;

import static com.leverx.employeestat.rest.integration.util.JsonUtils.toJson;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class EmployeeIntegrationTest {

    public static final String EMPLOYEES_ENDPOINT = "/api/employees";

    private final WebApplicationContext webAppContext;
    private MockMvc mvc;
    private EmployeeDTO employeeDTO;

    @Autowired
    public EmployeeIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    public void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(this.webAppContext).build();
    }

    @BeforeEach
    public void init() {
        employeeDTO = new EmployeeDTO();
        String id = "c7fa1cd3-b281-47b1-b72f-92b9391fc5c7";
        String expectedFirstName = "Ivan";
        String expectedLastName = "Shestakov";
        String expectedUsername = "Vanechka";
        String expectedPosition = "Java Developer";
        String role = "ROLE_MANAGER";
        employeeDTO.setFirstName(expectedFirstName);
        employeeDTO.setLastName(expectedLastName);
        employeeDTO.setUsername(expectedUsername);
        employeeDTO.setPosition(expectedPosition);
        employeeDTO.setRole(role);
        employeeDTO.setId(UUID.fromString(id));
    }

    @Test
    public void shouldExistsGlobalControllerAdvice() {
        GlobalControllerAdvice advice = this.webAppContext.getBean(GlobalControllerAdvice.class);
        assertNotNull(advice);
    }

    @Test
    public void shouldReturnJsonIfGetRequest() throws Exception {
        mvc.perform(get(EMPLOYEES_ENDPOINT))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());
    }

    @Test
    public void shouldReturnCorrectJsonIfGetRequestById() throws Exception {
        mvc.perform(get(EMPLOYEES_ENDPOINT + "/{id}", employeeDTO.getId().toString()))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.firstName").value(employeeDTO.getFirstName()))
                .andExpect(jsonPath("$.lastName").value(employeeDTO.getLastName()))
                .andExpect(jsonPath("$.username").value(employeeDTO.getUsername()))
                .andExpect(jsonPath("$.position").value(employeeDTO.getPosition()));
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForGetRequestById() throws Exception {
        mvc.perform(get(EMPLOYEES_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnMethodNotAllowedForPost() throws Exception {
        mvc.perform(post(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(employeeDTO)))
                .andExpect(status().isMethodNotAllowed());
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsEmptyForPut() throws Exception {
        mvc.perform(put(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnBadRequestIfJsonHasEmptyFieldsForPut() throws Exception {
        employeeDTO.setPosition("");
        employeeDTO.setUsername("");
        mvc.perform(put(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(employeeDTO)))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnNotFoundIfRoleDoesNotExistForPut() throws Exception {
        employeeDTO.setRole("Test");
        mvc.perform(put(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(employeeDTO)))
                .andExpect(status().isNotFound());
    }

    @Test
    public void shouldReturnOkStatusIfJsonIsCorrectForPut() throws Exception {
        mvc.perform(put(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(employeeDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.firstName").value(employeeDTO.getFirstName()))
                .andExpect(jsonPath("$.lastName").value(employeeDTO.getLastName()))
                .andExpect(jsonPath("$.username").value(employeeDTO.getUsername()))
                .andExpect(jsonPath("$.position").value(employeeDTO.getPosition()))
                .andExpect(jsonPath("$.id").value(employeeDTO.getId().toString()));
    }

    @Test
    public void shouldReturnUpdatedEmployeeIfItExistsById() throws Exception {
        mvc.perform(put(EMPLOYEES_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(employeeDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(employeeDTO.getId().toString()))
                .andExpect(jsonPath("$.firstName").value(employeeDTO.getFirstName()));
    }

    @Test
    public void shouldDeleteEmployeeIfIdIsCorrectAndExists() throws Exception{
        mvc.perform(delete(EMPLOYEES_ENDPOINT + "/{id}", "c7fa1cd3-b281-47b1-b72f-92b9391fc5c7"))
                .andExpect(status().isNoContent());
    }

    @Test
    public void shouldReturnMethodNotAllowedIfUUIDIsEmptyForDelete() throws Exception {
        mvc.perform(delete(EMPLOYEES_ENDPOINT + "/{id}", ""))
                .andExpect(status().isMethodNotAllowed());
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForDeleteRequestById() throws Exception {
        mvc.perform(delete(EMPLOYEES_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }
}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.dto.ProjectDTO;
import com.leverx.employeestat.rest.exceptionhandler.GlobalControllerAdvice;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import java.time.LocalDate;
import java.util.UUID;

import static com.leverx.employeestat.rest.integration.util.JsonUtils.toJson;
import static com.leverx.employeestat.rest.integration.util.JsonUtils.toObject;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class ProjectIntegrationTest {

    public static final String PROJECTS_ENDPOINT = "/api/projects";

    private final WebApplicationContext webAppContext;
    private MockMvc mvc;
    private ProjectDTO projectDTO;

    @Autowired
    public ProjectIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    public void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(this.webAppContext).build();
        String name = "project";
        String begin = "2021-09-11";
        String end = "2021-11-20";
        projectDTO = new ProjectDTO();
        projectDTO.setName(name);
        projectDTO.setBegin(LocalDate.parse(begin));
        projectDTO.setEnd(LocalDate.parse(end));
    }

    @Test
    public void shouldExistsGlobalControllerAdvice() {
        GlobalControllerAdvice advice = this.webAppContext.getBean(GlobalControllerAdvice.class);
        assertNotNull(advice);
    }

    @Test
    public void shouldReturnJsonIfGetRequest() throws Exception {
        mvc.perform(get(PROJECTS_ENDPOINT))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());
    }

    @Test
    public void shouldReturnCorrectJsonIfGetRequestById() throws Exception {
        String expectedName = "Bank system";
        String expectedBeginDate = "2020-10-08";
        String expectedEndDate = "2020-12-16";

        mvc.perform(get(PROJECTS_ENDPOINT + "/{id}", "7c8697b8-530d-4a00-ba00-3dfec6b1bb79"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value(expectedName))
                .andExpect(jsonPath("$.begin").value(expectedBeginDate))
                .andExpect((jsonPath("$.end").value(expectedEndDate)));
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsNotCorrectForPosting() throws Exception {
        mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForGetRequestById() throws Exception {
        mvc.perform(get(PROJECTS_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnOkStatusIfJsonIsCorrectForPosting() throws Exception{
        String expectedName = "project";
        String expectedBeginDate = "2021-09-11";
        String expectedEndDate = "2021-11-20";

        mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.name").value(expectedName))
                .andExpect(jsonPath("$.begin").value(expectedBeginDate))
                .andExpect((jsonPath("$.end").value(expectedEndDate)))
                .andExpect(jsonPath("$.id").isNotEmpty());
    }

    @Test
    public void shouldReturnBadRequestIfNameOfProjectAlreadyExistsForPosting() throws Exception {
        mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isCreated());

        mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnBadRequestStatusIfJsonIsNotCorrectForPutting() throws Exception {
        mvc.perform(put(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(""))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnOkStatusIfJsonWithoutIdIsCorrectForPutting() throws Exception {
        ProjectDTO projectDTO = new ProjectDTO();
        projectDTO.setName("expected");
        projectDTO.setEnd(LocalDate.of(2021, 5, 11));
        projectDTO.setBegin(LocalDate.of(2021, 2, 11));

        mvc.perform(put(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value(projectDTO.getName()))
                .andExpect(jsonPath("$.begin").value(projectDTO.getBegin().toString()))
                .andExpect(jsonPath("$.end").value(projectDTO.getEnd().toString()))
                .andExpect(jsonPath("$.id").isNotEmpty());

        assertNull(projectDTO.getId());
    }

    @Test
    public void shouldReturnBadRequestIfNameOfProjectAlreadyExistsForPutting() throws Exception {
        mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isCreated());

        mvc.perform(put(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    public void shouldReturnUpdatedProjectIfItExistsById() throws Exception {
        MvcResult result = mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isCreated())
                .andReturn();

        String expectedName = "New";
        projectDTO = toObject(result.getResponse().getContentAsString(), ProjectDTO.class);
        projectDTO.setName(expectedName);
        UUID expectedId = projectDTO.getId();

        mvc.perform(put(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(expectedId.toString()))
                .andExpect(jsonPath("$.name").value(expectedName));
    }

    @Test
    public void shouldDeleteProjectIfIdIsCorrectAndExists() throws Exception {
        MvcResult result = mvc.perform(post(PROJECTS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(projectDTO)))
                .andExpect(status().isCreated())
                .andReturn();

        projectDTO = toObject(result.getResponse().getContentAsString(), ProjectDTO.class);
        UUID id = projectDTO.getId();

        mvc.perform(delete(PROJECTS_ENDPOINT + "/{id}", id.toString()))
                .andExpect(status().isNoContent());
    }

    @Test
    public void shouldReturnMethodNotAllowedIfUUIDIsEmptyForDeleting() throws Exception {
        mvc.perform(delete(PROJECTS_ENDPOINT + "/{id}", ""))
                .andExpect(status().isMethodNotAllowed());
    }

    @Test
    public void shouldReturnBadRequestIfUUIDIsNotCorrectForDeleteRequestById() throws Exception {
        mvc.perform(delete(PROJECTS_ENDPOINT + "/{id}", "incorrect"))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status").value("BAD_REQUEST"))
                .andExpect(jsonPath("$.code").value(400));
    }
}

package com.leverx.employeestat.rest.integration;

import com.leverx.employeestat.rest.configuration.WebInitializer;
import com.leverx.employeestat.rest.dto.WorkDTO;
import com.leverx.employeestat.rest.exceptionhandler.GlobalControllerAdvice;
import com.leverx.employeestat.rest.integration.config.TestConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;

import java.util.UUID;

import static com.leverx.employeestat.rest.integration.util.JsonUtils.toJson;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {TestConfig.class, WebInitializer.class})
@WebAppConfiguration
@Transactional
public class WorkIntegrationTest {

    private final static String WORKS_ENDPOINT = "/api/works";
    private final static String IDS_POSTFIX = "/{empId}/{projId}";
    private final static String NON_EXISTING_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
    private final WebApplicationContext webAppContext;
    private MockMvc mvc;

    private WorkDTO firstWork;
    private WorkDTO secondWork;
    private WorkDTO thirdWork;

    @Autowired
    public WorkIntegrationTest(WebApplicationContext webAppContext) {
        this.webAppContext = webAppContext;
    }

    @BeforeEach
    void setup() {
        this.mvc = MockMvcBuilders.webAppContextSetup(webAppContext).build();
    }

    @BeforeEach
    public void init() {
        firstWork = new WorkDTO();
        secondWork = new WorkDTO();
        thirdWork = new WorkDTO();

        firstWork.setEmployeeId(UUID.fromString("c7fa1cd3-b281-47b1-b72f-92b9391fc5c7"));
        firstWork.setProjectId(UUID.fromString("7c8697b8-530d-4a00-ba00-3dfec6b1bb79"));

        secondWork.setEmployeeId(UUID.fromString("e9a4e12b-1555-48bd-9275-629856bcdb51"));
        secondWork.setProjectId(UUID.fromString("7c8697b8-530d-4a00-ba00-3dfec6b1bb79"));

        thirdWork.setEmployeeId(UUID.fromString("2174c05c-e885-4521-985d-774b1f05cd37"));
        thirdWork.setProjectId(UUID.fromString("6f6bd93b-fcdd-4c3f-a144-1e03139559d6"));
    }

    @Test
    public void shouldExistsGlobalControllerAdvice() {
        GlobalControllerAdvice advice = this.webAppContext.getBean(GlobalControllerAdvice.class);
        assertNotNull(advice);
    }

    @Test
    public void shouldReturnJsonListForGetAllWorks() throws Exception {
        mvc.perform(get(WORKS_ENDPOINT))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk()).andDo(print())
                .andExpect(jsonPath("$[0].employeeId").value(firstWork.getEmployeeId().toString()))
                .andExpect(jsonPath("$[1].employeeId").value(secondWork.getEmployeeId().toString()))
                .andExpect(jsonPath("$[2].employeeId").value(thirdWork.getEmployeeId().toString()))
                .andExpect(jsonPath("$[0].projectId").value(firstWork.getProjectId().toString()))
                .andExpect(jsonPath("$[1].projectId").value(secondWork.getProjectId().toString()))
                .andExpect(jsonPath("$[2].projectId").value(thirdWork.getProjectId().toString()));
    }

    @Test
    public void shouldReturnWorkByEmployeeIdAndProjectIdIfTheyAreCorrectForGetWork() throws Exception {
        final String expectedEmpId = firstWork.getEmployeeId().toString();
        final String expectedProjId = firstWork.getProjectId().toString();

        mvc.perform(get(WORKS_ENDPOINT + IDS_POSTFIX, expectedEmpId, expectedProjId))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.projectId").value(expectedProjId))
                .andExpect(jsonPath("$.employeeId").value(expectedEmpId));
    }

    @Test
    public void shouldReturnBadRequestIfEmployeeIdAndProjectIdIsNotValidForGetWork() throws Exception {
        final String notValidEmpId = "not valid";
        final String notValidProjId = "not valid";

        mvc.perform(get(WORKS_ENDPOINT + IDS_POSTFIX, notValidEmpId, notValidEmpId))
                .andExpect(status().isBadRequest());
    }

    @Test
    public void shouldReturnNotFoundIfEmployeeDoesNotExistByEmployeeIdForGetWork() throws Exception {
        final String projId = firstWork.getProjectId().toString();

        mvc.perform(get(WORKS_ENDPOINT + IDS_POSTFIX, NON_EXISTING_ID, projId))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Employee with id=%s not found", NON_EXISTING_ID)));
    }

    @Test
    public void shouldReturnNotFoundIfProjectDoesNotExistByProjectIdForGetWork() throws Exception {
        final String empId = firstWork.getEmployeeId().toString();

        mvc.perform(get(WORKS_ENDPOINT + IDS_POSTFIX, empId, NON_EXISTING_ID))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Project with id=%s not found", NON_EXISTING_ID)));
    }

    @Test
    public void shouldReturnNotFoundStatusIfProjectIdAndEmployeeIdExistButWorkIdDoesNotExistForGetWork() throws Exception {
        final String empId = firstWork.getEmployeeId().toString();
        final String projId = thirdWork.getProjectId().toString();

        mvc.perform(get(WORKS_ENDPOINT + IDS_POSTFIX, empId, projId))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Work with id=(employeeId=%s; projectId=%s) not found", empId, projId)));
    }

    @Test
    public void shouldReturnOkStatusIfWorkExistsByIdForPutWork() throws Exception {
        final int expectedWorkingHours = 0;
        firstWork.setWorkingHours(expectedWorkingHours);
        mvc.perform(put(WORKS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(firstWork)))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.workingHours").value(expectedWorkingHours));
    }

    @Test
    public void shouldThrowExceptionIfWorkDoesNotExistByIdForPutWork() throws Exception {
        firstWork.setProjectId(thirdWork.getProjectId());
        mvc.perform(put(WORKS_ENDPOINT).contentType(MediaType.APPLICATION_JSON).content(toJson(firstWork)))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Work with id=(employeeId=%s; projectId=%s) not found", firstWork.getEmployeeId(), firstWork.getProjectId())));
    }

    @Test
    public void shouldReturnNoContentStatusIfWorkExistsByIdForDeleteWork() throws Exception {
        final String empId = firstWork.getEmployeeId().toString();
        final String projId = firstWork.getProjectId().toString();

        mvc.perform(delete(WORKS_ENDPOINT + IDS_POSTFIX, empId, projId))
                .andExpect(status().isNoContent());
    }

    @Test
    public void shouldReturnNotFoundStatusIfProjectIdAndEmployeeIdExistButWorkIdDoesNotExistForDeleteWork() throws Exception {
        final String empId = firstWork.getEmployeeId().toString();
        final String projId = thirdWork.getProjectId().toString();

        mvc.perform(delete(WORKS_ENDPOINT + IDS_POSTFIX, empId, projId))
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("$.message").value(String.format("Work with id=(employeeId=%s; projectId=%s) not found", empId, projId)));
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.dto.converter.EmployeeConverter;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.InvalidPasswordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.model.ResetPasswordRequest;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.service.impl.AuthorizationServiceImpl;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.security.crypto.password.PasswordEncoder;

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

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class AuthorizationServiceTest {

    @Mock
    private EmployeeRepository employeeRepository;

    @Mock
    private EmployeeConverter converter;

    @Mock
    private PasswordEncoder encoder;

    @InjectMocks
    private AuthorizationServiceImpl authorizationService;

    private EmployeeDTO employeeDTO;
    private Employee employee;
    private ResetPasswordRequest request;

    @BeforeEach
    public void init() {
        employeeDTO = new EmployeeDTO();
        employee = new Employee();
        request = new ResetPasswordRequest();

        employeeDTO.setUsername("username");
        employeeDTO.setPassword("password");

        employee.setUsername("username");
        employee.setPassword("password");

        request.setUsername("username");
        request.setOldPassword("password");
        request.setNewPassword("new");
    }

    @Test
    public void shouldReturnRegisteredEmployeeIfItDoesNotExistByUsernameWhenRegisterEmployee() {
        final String expected = "encoded";

        when(employeeRepository.existsByUsername(employeeDTO.getUsername())).thenReturn(false);
        when(encoder.encode(employeeDTO.getPassword())).thenReturn(expected);
        when(converter.toEntity(employeeDTO)).thenReturn(employee);
        when(employeeRepository.save(employee)).thenReturn(employee);
        when(converter.toDTO(employee)).thenReturn(employeeDTO);

        assertEquals(expected, authorizationService.registerEmployee(employeeDTO).getPassword());

        verify(employeeRepository).existsByUsername(employeeDTO.getUsername());
        verify(encoder).encode("password");
        verify(converter).toEntity(employeeDTO);
        verify(converter).toDTO(employee);
        verify(employeeRepository).save(employee);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeAlreadyExistsByUsernameWhenRegisterEmployee() {
        when(employeeRepository.existsByUsername(employeeDTO.getUsername())).thenReturn(true);

        assertThrows(DuplicateRecordException.class, () -> authorizationService.registerEmployee(employeeDTO));

        verify(employeeRepository).existsByUsername(employeeDTO.getUsername());
    }

    @Test
    public void shouldResetPasswordIfEmployeeExistsByUsernameAndHasCorrectOldPasswordWhenResetPassword() {
        final String expected = "encoded";
        when(employeeRepository.findEmployeeByUsername(request.getUsername())).thenReturn(Optional.of(employee));
        when(encoder.matches(request.getOldPassword(), "password")).thenReturn(true);
        when(encoder.encode(request.getNewPassword())).thenReturn(expected);
        employeeDTO.setPassword(expected);
        when(converter.toDTO(employee)).thenReturn(employeeDTO);

        assertEquals(expected, authorizationService.resetPassword(request).getPassword());

        verify(employeeRepository).findEmployeeByUsername(request.getUsername());
        verify(encoder).matches(request.getOldPassword(), "password");
        verify(encoder).encode(request.getNewPassword());
        verify(converter).toDTO(employee);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistsByUsernameWhenResetPassword() {
        when(employeeRepository.findEmployeeByUsername(request.getUsername())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> authorizationService.resetPassword(request));

        verify(employeeRepository).findEmployeeByUsername(request.getUsername());
    }

    @Test
    public void shouldThrowExceptionIfOldPasswordMismatchesCurrentPasswordWhenResetPassword() {
        when(employeeRepository.findEmployeeByUsername(request.getUsername())).thenReturn(Optional.of(employee));
        when(encoder.matches(request.getOldPassword(), "password")).thenReturn(false);

        assertThrows(InvalidPasswordException.class, () -> authorizationService.resetPassword(request));

        verify(employeeRepository).findEmployeeByUsername(request.getUsername());
        verify(encoder).matches(request.getOldPassword(), "password");
    }

    @Test
    public void test() {
        final String expectedPassword = "encoded";
        final int expectedAmount = 3;
        when(employeeRepository.existsByUsername(employeeDTO.getUsername())).thenReturn(false);
        when(encoder.encode(employeeDTO.getPassword())).thenReturn(expectedPassword);
        when(converter.toEntity(employeeDTO)).thenReturn(employee);
        when(employeeRepository.save(employee)).thenReturn(employee);
        when(converter.toDTO(employee)).thenReturn(employeeDTO);

        List<EmployeeDTO> employees = new ArrayList<>();
        for (int i = 0; i < expectedAmount; i++) {
            employees.add(employeeDTO);
        }

        assertEquals(expectedAmount, authorizationService.registerAll(employees).size());

        verify(employeeRepository, times(expectedAmount)).existsByUsername(employeeDTO.getUsername());
        verify(encoder).encode("password");
        verify(converter, times(expectedAmount)).toEntity(employeeDTO);
        verify(converter, times(expectedAmount)).toDTO(employee);
        verify(employeeRepository, times(expectedAmount)).save(employee);
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.service.CSVReaderService;
import com.leverx.employeestat.rest.service.impl.CSVReaderServiceImpl;
import com.leverx.employeestat.rest.unit.fileitems.FileItemImpl;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CSVReaderServiceTest {

    private final static String CORRECT_FILE = "csv-test/employees.csv";

    private CSVReaderService csvReaderService;

    @BeforeEach
    public void init() {
        csvReaderService = new CSVReaderServiceImpl();
    }

    @Test
    public void shouldReturnNotEmptyListIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);
        Assertions.assertFalse(employees.isEmpty());
    }

    @Test
    public void shouldReturnCorrectEmployeesAmountIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);

        int expectedAmount = 5;
        int actualAmount = employees.size();

        Assertions.assertEquals(expectedAmount, actualAmount);
    }

    @Test
    public void shouldReturnCorrectFirstNamesIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);

        List<String> expectedNames = Arrays.asList(new String[] { "Vlad", "Artiom", "Kirill", "Aleksander", "Dasha"});
        List<String> actualNames = employees
                .stream()
                .map(EmployeeDTO::getFirstName)
                .collect(Collectors.toList());

        Assertions.assertEquals(expectedNames, actualNames);
    }

    @Test
    public void shouldReturnCorrectLastNamesIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);

        List<String> expectedLastNames = Arrays.asList(new String[] {"Vladov", "Ivanov", "Avtobusov", "Sosiskin", "Glavnaya"});
        List<String> actualLastNames = employees
                .stream()
                .map(EmployeeDTO::getLastName)
                .collect(Collectors.toList());

        Assertions.assertEquals(expectedLastNames, actualLastNames);
    }

    @Test
    public void shouldReturnCorrectUsernamesIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);

        List<String> expectedUsernames = Arrays.asList(new String[] {"Turbo3000", "Tema", "Kiruha", "Sanek1000", "Dashka"});
        List<String> actualUsernames = employees
                .stream()
                .map(EmployeeDTO::getUsername)
                .collect(Collectors.toList());

        Assertions.assertEquals(expectedUsernames, actualUsernames);
    }

    @Test
    public void shouldReturnCorrectPositionIfFileIsCorrect() {
        MultipartFile file = new CommonsMultipartFile(new FileItemImpl(CORRECT_FILE));
        List<EmployeeDTO> employees = csvReaderService.getEmployeesFromFile(file);

        List<String> expectedPositions = Arrays.asList(new String[] {"Java Developer", "JS Developer", ".NET Developer", "HR", "Boss"});
        List<String> actualPositions = employees
                .stream()
                .map(EmployeeDTO::getPosition)
                .collect(Collectors.toList());

        Assertions.assertEquals(expectedPositions, actualPositions);
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.DepartmentDTO;
import com.leverx.employeestat.rest.dto.converter.DepartmentConverter;
import com.leverx.employeestat.rest.entity.Department;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.DepartmentRepository;
import com.leverx.employeestat.rest.service.impl.DepartmentServiceImpl;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.*;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
public class DepartmentServiceTest {

    @Mock
    private DepartmentRepository departmentRepository;

    @Mock
    private DepartmentConverter converter;

    @InjectMocks
    private DepartmentServiceImpl departmentService;


    @Test
    public void shouldReturnDepartmentIfItExistsById() {
        UUID id = UUID.randomUUID();
        Department department = new Department();
        DepartmentDTO departmentDTO = new DepartmentDTO();

        when(converter.toDTO(department)).thenReturn(departmentDTO);
        when(departmentRepository.findById(id)).thenReturn(Optional.of(department));

        Assertions.assertNotNull(departmentService.getById(id));

        verify(converter).toDTO(department);
        verify(departmentRepository).findById(id);
    }

    @Test
    public void shouldThrowExceptionIfDepartmentDoesNotExistsById() {
        UUID id = UUID.randomUUID();
        when(departmentRepository.findById(id)).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> departmentService.getById(id));

        verify(departmentRepository).findById(id);
    }

    @Test
    public void shouldReturnEmptyListIfDbTableIsEmpty() {
        when(departmentRepository.findAll()).thenReturn(new ArrayList<Department>());

        Assertions.assertTrue(departmentService.getAll().isEmpty());

        verify(departmentRepository).findAll();
    }

    @Test
    public void shouldReturnNotEmptyListIfDbTableIsNotEmpty() {
        when(departmentRepository.findAll()).thenReturn(Arrays.asList(new Department[] {new Department(), new Department()}));

        Assertions.assertFalse(departmentService.getAll().isEmpty());

        verify(departmentRepository).findAll();
    }

    @Test
    public void shouldReturnSavedDepartmentIfProjectDoesNotExists() {
        String name = "Department name";
        DepartmentDTO departmentDTO = new DepartmentDTO();
        departmentDTO.setName(name);
        Department department = new Department();
        department.setName(name);

        when(converter.toEntity(departmentDTO)).thenReturn(department);
        when(converter.toDTO(department)).thenReturn(departmentDTO);
        when(departmentRepository.existsByName(name)).thenReturn(false);
        when(departmentRepository.save(department)).thenReturn(department);

        Assertions.assertEquals(departmentService.save(departmentDTO), departmentDTO);

        verify(converter).toEntity(departmentDTO);
        verify(converter).toDTO(department);
        verify(departmentRepository).existsByName(name);
        verify(departmentRepository).save(department);
    }

    @Test
    public void shouldThrowExceptionIfDepartmentExists() {
        String name = "Department name";
        DepartmentDTO departmentDTO = new DepartmentDTO();
        departmentDTO.setName(name);

        when(departmentRepository.existsByName(name)).thenReturn(true);

        Assertions.assertThrows(DuplicateRecordException.class, () -> departmentService.save(departmentDTO));

        verify(departmentRepository).existsByName(name);
    }

    @Test
    public void shouldReturnUpdatedDepartmentIfItExistsById() {
        UUID id = UUID.randomUUID();
        DepartmentDTO departmentDTO = new DepartmentDTO();
        departmentDTO.setId(id);
        Department department = new Department();
        department.setId(id);

        when(converter.toEntity(departmentDTO)).thenReturn(department);
        when(converter.toDTO(department)).thenReturn(departmentDTO);
        when(departmentRepository.existsById(id)).thenReturn(true);
        when(departmentRepository.save(department)).thenReturn(department);

        Assertions.assertEquals(departmentDTO, departmentService.update(departmentDTO));

        verify(converter).toEntity(departmentDTO);
        verify(converter).toDTO(department);
        verify(departmentRepository).existsById(id);
        verify(departmentRepository).save(department);
    }

    @Test
    public void shouldThrowExceptionIfDepartmentAlreadyExists() {
        DepartmentDTO departmentDTO = new DepartmentDTO();
        UUID id = UUID.randomUUID();
        String name = "Department";

        departmentDTO.setId(id);
        departmentDTO.setName(name);

        when(departmentRepository.existsById(departmentDTO.getId())).thenReturn(false);
        when(departmentRepository.existsByName(departmentDTO.getName())).thenReturn(true);
        Assertions.assertThrows(DuplicateRecordException.class,
                () -> departmentService.update(departmentDTO));

        verify(departmentRepository).existsByName(departmentDTO.getName());
        verify(departmentRepository).existsById(departmentDTO.getId());
    }

    @Test
    public void shouldReturnTrueIfDepartmentExistsById() {
        when(departmentRepository.existsById(any())).thenReturn(true);

        Assertions.assertTrue(departmentService.existsById(UUID.randomUUID()));

        verify(departmentRepository).existsById(any());
    }

    @Test
    public void shouldReturnFalseIfDepartmentExistsById() {
        when(departmentRepository.existsById(any())).thenReturn(false);

        Assertions.assertFalse(departmentService.existsById(UUID.randomUUID()));

        verify(departmentRepository).existsById(any());
    }

    @Test
    public void shouldReturnTrueIfDepartmentExistsByName() {
        String name = "Department name";
        when(departmentRepository.existsByName(any())).thenReturn(true);

        Assertions.assertTrue(departmentService.existsByName(name));

        verify(departmentRepository).existsByName(any());
    }

    @Test
    public void shouldReturnFalseIfDepartmentExistsByName() {
        String name = "Department name";
        when(departmentRepository.existsByName(any())).thenReturn(false);

        Assertions.assertFalse(departmentService.existsByName(name));

        verify(departmentRepository).existsByName(any());
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.EmployeeDTO;
import com.leverx.employeestat.rest.dto.converter.EmployeeConverter;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.service.impl.EmployeeServiceImpl;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Optional;
import java.util.UUID;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
public class EmployeeServiceTest {

    @Mock
    private EmployeeRepository employeeRepository;

    @Mock
    private EmployeeConverter converter;

    @InjectMocks
    private EmployeeServiceImpl employeeService;

    @Test
    public void shouldReturnEmployeeIfItExistsById() {
        UUID id = UUID.randomUUID();
        Employee employee = new Employee();
        employee.setId(id);
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setId(id);

        when(converter.toDTO(employee)).thenReturn(employeeDTO);
        when(employeeRepository.findEmployeeById(id)).thenReturn(Optional.of(employee));

        Assertions.assertNotNull(employeeService.getById(id));

        verify(converter).toDTO(employee);
        verify(employeeRepository).findEmployeeById(id);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistsById() {
        UUID id = UUID.randomUUID();
        when(employeeRepository.findEmployeeById(id)).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> employeeService.getById(id));

        verify(employeeRepository).findEmployeeById(id);
    }

    @Test
    public void shouldReturnEmployeeIfItExistsByUsername() {
        String name = "employee";
        Employee employee = new Employee();
        employee.setUsername(name);
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setUsername(name);

        when(converter.toDTO(employee)).thenReturn(employeeDTO);
        when(employeeRepository.findEmployeeByUsername(name)).thenReturn(Optional.of(employee));

        Assertions.assertNotNull(employeeService.getByUsername(name));

        verify(converter).toDTO(employee);
        verify(employeeRepository).findEmployeeByUsername(name);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistsByUsername() {
        String name = "employee";
        when(employeeRepository.findEmployeeByUsername(name)).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> employeeService.getByUsername(name));

        verify(employeeRepository).findEmployeeByUsername(name);
    }

    @Test
    public void shouldReturnEmptyListIfDbTableIsEmpty() {
        when(employeeRepository.findAll()).thenReturn(new ArrayList<Employee>());

        Assertions.assertTrue(employeeService.getAll().isEmpty());

        verify(employeeRepository).findAll();
    }

    @Test
    public void shouldReturnNotEmptyListIfRepositoryIsNotEmpty() {
        when(employeeRepository.findAll()).thenReturn(Arrays.asList(new Employee(), new Employee()));

        Assertions.assertFalse(employeeService.getAll().isEmpty());

        verify(employeeRepository).findAll();
    }

    @Test
    public void shouldReturnSavedEmployeeIfEmployeeDoesNotExists() {
        String name = "Employee name";
        Employee employee = new Employee();
        employee.setUsername(name);
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setUsername(name);

        when(converter.toEntity(employeeDTO)).thenReturn(employee);
        when(converter.toDTO(employee)).thenReturn(employeeDTO);
        when(employeeRepository.existsByUsername(name)).thenReturn(false);
        when(employeeRepository.save(employee)).thenReturn(employee);

        Assertions.assertEquals(employeeService.save(employeeDTO), employeeDTO);

        verify(converter).toEntity(employeeDTO);
        verify(converter).toDTO(employee);
        verify(employeeRepository).existsByUsername(name);
        verify(employeeRepository).save(employee);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeExists() {
        String name = "Employee name";
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setUsername(name);

        when(employeeRepository.existsByUsername(name)).thenReturn(true);

        Assertions.assertThrows(DuplicateRecordException.class, () -> employeeService.save(employeeDTO));

        verify(employeeRepository).existsByUsername(name);
    }

    @Test
    public void shouldReturnUpdatedEmployeeIfItExistsById() {
        UUID id = UUID.randomUUID();
        Employee employee = new Employee();
        employee.setId(id);
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setId(id);

        when(converter.toDTO(employee)).thenReturn(employeeDTO);
        when(employeeRepository.findEmployeeById(employeeDTO.getId())).thenReturn(Optional.of(employee));

        Assertions.assertEquals(employeeDTO, employeeService.update(employeeDTO));

        verify(converter).toDTO(employee);
        verify(employeeRepository).findEmployeeById(employeeDTO.getId());
    }

    @Test
    public void shouldThrowExceptionIfEmployeeNotFound() {
        EmployeeDTO employeeDTO = new EmployeeDTO();
        employeeDTO.setId(UUID.randomUUID());
        employeeDTO.setUsername("Username");

        when(employeeRepository.findEmployeeById(employeeDTO.getId())).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> employeeService.update(employeeDTO));

        verify(employeeRepository).findEmployeeById(employeeDTO.getId());
    }

    @Test
    public void shouldReturnTrueIfEmployeeExistsById() {
        when(employeeRepository.existsById(any())).thenReturn(true);

        Assertions.assertTrue(employeeService.existsById(UUID.randomUUID()));

        verify(employeeRepository).existsById(any());
    }

    @Test
    public void shouldReturnFalseIfEmployeeExistsById() {
        when(employeeRepository.existsById(any())).thenReturn(false);

        Assertions.assertFalse(employeeService.existsById(UUID.randomUUID()));

        verify(employeeRepository).existsById(any());
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.ProjectDTO;
import com.leverx.employeestat.rest.dto.converter.ProjectConverter;
import com.leverx.employeestat.rest.entity.Project;
import com.leverx.employeestat.rest.exception.DuplicateRecordException;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import com.leverx.employeestat.rest.service.impl.ProjectServiceImpl;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.*;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
public class ProjectServiceTest {

    @Mock
    private ProjectRepository projectRepository;

    @Mock
    private ProjectConverter converter;

    @InjectMocks
    private ProjectServiceImpl projectService;

    @Test
    public void shouldReturnProjectIfItExistsById() {
        UUID id = UUID.randomUUID();
        Project project = new Project();
        ProjectDTO projectDTO = new ProjectDTO();

        when(converter.toDTO(project)).thenReturn(projectDTO);
        when(projectRepository.findProjectById(id)).thenReturn(Optional.of(project));

        Assertions.assertNotNull(projectService.getById(id));

        verify(converter).toDTO(project);
        verify(projectRepository).findProjectById(id);
    }

    @Test
    public void shouldThrowExceptionIfProjectDoesNotExistsById() {
        UUID id = UUID.randomUUID();
        when(projectRepository.findProjectById(id)).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> projectService.getById(id));

        verify(projectRepository).findProjectById(id);
    }

    @Test
    public void shouldReturnProjectIfItExistsByName() {
        String name = "project";
        Project project = new Project();
        ProjectDTO projectDTO = new ProjectDTO();
        project.setName(name);
        projectDTO.setName(name);

        when(converter.toDTO(project)).thenReturn(projectDTO);
        when(projectRepository.findProjectByName(name)).thenReturn(Optional.of(project));

        Assertions.assertNotNull(projectService.getByName(name));

        verify(converter).toDTO(project);
        verify(projectRepository).findProjectByName(name);
    }

    @Test
    public void shouldThrowExceptionIfProjectDoesNotExistsByName() {
        String name = "project";

        when(projectRepository.findProjectByName(name)).thenReturn(Optional.ofNullable(null));

        Assertions.assertThrows(NoSuchRecordException.class, () -> projectService.getByName(name));

        verify(projectRepository).findProjectByName(name);
    }

    @Test
    public void shouldReturnEmptyListIfDbTableIsEmpty() {
        when(projectRepository.findAll()).thenReturn(new ArrayList<Project>());

        Assertions.assertTrue(projectService.getAll().isEmpty());

        verify(projectRepository).findAll();
    }

    @Test
    public void shouldReturnNotEmptyListIfDbTableIsNotEmpty() {
        when(projectRepository.findAll()).thenReturn(Arrays.asList( new Project[] {new Project(), new Project()}));

        Assertions.assertFalse(projectService.getAll().isEmpty());

        verify(projectRepository).findAll();
    }

    @Test
    public void shouldReturnSavedProjectIfProjectDoesNotExists() {
        String name = "Project name";
        Project project = new Project();
        project.setName(name);
        ProjectDTO projectDTO = new ProjectDTO();
        projectDTO.setName(name);

        when(converter.toEntity(projectDTO)).thenReturn(project);
        when(converter.toDTO(project)).thenReturn(projectDTO);
        when(projectRepository.existsByName(name)).thenReturn(false);
        when(projectRepository.save(project)).thenReturn(project);

        Assertions.assertEquals(projectService.save(projectDTO), projectDTO);

        verify(converter).toEntity(projectDTO);
        verify(converter).toDTO(project);
        verify(projectRepository).existsByName(name);
        verify(projectRepository).save(project);
    }

    @Test
    public void shouldThrowExceptionIfProjectExists() {
        String name = "Project name";
        ProjectDTO projectDTO = new ProjectDTO();
        projectDTO.setName(name);

        when(projectRepository.existsByName(name)).thenReturn(true);

        Assertions.assertThrows(DuplicateRecordException.class, () -> projectService.save(projectDTO));

        verify(projectRepository).existsByName(name);
    }

    @Test
    public void shouldReturnUpdatedProjectIfItExistsById() {
        UUID id = UUID.randomUUID();
        Project project = new Project();
        project.setId(id);
        ProjectDTO projectDTO = new ProjectDTO();
        projectDTO.setId(id);

        when(converter.toEntity(projectDTO)).thenReturn(project);
        when(converter.toDTO(project)).thenReturn(projectDTO);
        when(projectRepository.existsById(id)).thenReturn(true);
        when(projectRepository.save(project)).thenReturn(project);

        Assertions.assertEquals(projectDTO, projectService.update(projectDTO));

        verify(converter).toEntity(projectDTO);
        verify(converter).toDTO(project);
        verify(projectRepository).existsById(id);
        verify(projectRepository).save(project);
    }

    @Test
    public void shouldThrowExceptionIfProjectAlreadyExists() {
        ProjectDTO projectDTO = new ProjectDTO();
        projectDTO.setId(UUID.randomUUID());
        projectDTO.setName("Project");

        when(projectRepository.existsById(projectDTO.getId())).thenReturn(false);
        when(projectRepository.existsByName(projectDTO.getName())).thenReturn(true);

        Assertions.assertThrows(DuplicateRecordException.class, () -> projectService.update(projectDTO));

        verify(projectRepository).existsById(projectDTO.getId());
        verify(projectRepository).existsByName(projectDTO.getName());
    }

    @Test
    public void shouldReturnTrueIfProjectExistsById() {
        when(projectRepository.existsById(any())).thenReturn(true);

        Assertions.assertTrue(projectService.existsById(UUID.randomUUID()));

        verify(projectRepository).existsById(any());
    }

    @Test
    public void shouldReturnFalseIfProjectExistsById() {
        when(projectRepository.existsById(any())).thenReturn(false);

        Assertions.assertFalse(projectService.existsById(UUID.randomUUID()));

        verify(projectRepository).existsById(any());
    }

    @Test
    public void shouldReturnTrueIfProjectExistsByName() {
        String name = "Project name";
        when(projectRepository.existsByName(any())).thenReturn(true);

        Assertions.assertTrue(projectService.existsByName(name));

        verify(projectRepository).existsByName(any());
    }

    @Test
    public void shouldReturnFalseIfProjectExistsByName() {
        String name = "Project name";
        when(projectRepository.existsByName(any())).thenReturn(false);

        Assertions.assertFalse(projectService.existsByName(name));

        verify(projectRepository).existsByName(any());
    }
}

package com.leverx.employeestat.rest.unit;

import com.leverx.employeestat.rest.dto.WorkDTO;
import com.leverx.employeestat.rest.dto.converter.WorkConverter;
import com.leverx.employeestat.rest.entity.Employee;
import com.leverx.employeestat.rest.entity.Project;
import com.leverx.employeestat.rest.entity.Work;
import com.leverx.employeestat.rest.entity.WorkId;
import com.leverx.employeestat.rest.exception.NoSuchRecordException;
import com.leverx.employeestat.rest.repository.EmployeeRepository;
import com.leverx.employeestat.rest.repository.ProjectRepository;
import com.leverx.employeestat.rest.repository.WorkRepository;
import com.leverx.employeestat.rest.service.impl.WorkServiceImpl;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.time.LocalDate;
import java.util.*;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class WorkServiceTest {

    @Mock
    private WorkRepository workRepository;

    @Mock
    private EmployeeRepository employeeRepository;

    @Mock
    private ProjectRepository projectRepository;

    @Mock
    private WorkConverter converter;

    @InjectMocks
    private WorkServiceImpl workService;

    private WorkDTO workDTO;
    private Work work;
    private WorkId workId;
    private Employee employee;
    private Project project;

    @BeforeEach
    public void init() {
        workDTO = new WorkDTO();
        work = new Work();
        workId = new WorkId();
        employee = new Employee();
        project = new Project();

        UUID empId = UUID.randomUUID();
        UUID projId = UUID.randomUUID();
        employee.setId(empId);
        project.setId(projId);

        workId.setEmployee(employee);
        workId.setProject(project);

        workDTO.setEmployeeId(empId);
        workDTO.setProjectId(projId);
    }

    @Test
    public void shouldReturnNotEmptyListOfWorksIfRepositoryIsNotEmptyWhenGetAll() {
        final int expectedSize = 3;

        when(workRepository.findAll()).thenReturn(Arrays.asList(work, work, work));
        when(converter.toDTO(work)).thenReturn(workDTO);

        List<WorkDTO> actualList = workService.getAll();
        assertFalse(actualList.isEmpty());
        assertEquals(expectedSize, actualList.size());
        assertSame(actualList.get(0).getClass(), WorkDTO.class);

        verify(workRepository).findAll();
        verify(converter, times(expectedSize)).toDTO(work);
    }

    @Test
    public void shouldReturnEmptyListOfWorksIfRepositoryIsEmptyWhenGetAll() {
        when(workRepository.findAll()).thenReturn(new ArrayList<>());

        List<WorkDTO> actualList = workService.getAll();
        assertTrue(actualList.isEmpty());

        verify(workRepository).findAll();
    }

    @Test
    public void shouldReturnWorkByIdsIfTheyExistInRepositoryWhenGetByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.of(project));
        when(workRepository.findWorkById(workId)).thenReturn(Optional.of(work));
        when(converter.toDTO(work)).thenReturn(workDTO);

        assertSame(WorkDTO.class, workService.getByIds(employee.getId(), project.getId()).getClass());
        assertDoesNotThrow(() -> workService.getByIds(employee.getId(), project.getId()));

        verify(employeeRepository, times(2)).findEmployeeById(employee.getId());
        verify(projectRepository, times(2)).findProjectById(project.getId());
        verify(workRepository, times(2)).findWorkById(workId);
        verify(converter, times(2)).toDTO(work);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistByEmployeeIdWhenGetByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.getByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
    }

    @Test
    public void shouldThrowExceptionIfProjectDoesNotExistByProjectIdWhenGetByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.getByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
    }

    @Test
    public void shouldThrowExceptionIfWorkDoesNotExistByWorkIdWhenGetByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.of(project));
        when(workRepository.findWorkById(workId)).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.getByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
        verify(workRepository).findWorkById(workId);
    }

    @Test
    public void shouldUpdateWorkIfItExistsByIdWhenUpdate() {
        final int expectedWorkingHours = 3;
        final LocalDate expectedPositionStartDate = LocalDate.of(2021, 1, 1);
        final LocalDate expectedPositionEndDate = LocalDate.of(2022, 1, 1);

        workDTO.setWorkingHours(3);
        workDTO.setPositionStartDate(expectedPositionStartDate);
        workDTO.setPositionEndDate(expectedPositionEndDate);

        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.of(project));
        when(workRepository.findWorkById(workId)).thenReturn(Optional.of(work));
        when(converter.toDTO(work)).thenReturn(workDTO);

        WorkDTO actual =  workService.update(workDTO);

        assertSame(WorkDTO.class, actual.getClass());
        assertDoesNotThrow(() -> workService.update(workDTO));
        assertEquals(expectedWorkingHours, actual.getWorkingHours());
        assertEquals(expectedPositionStartDate, actual.getPositionStartDate());
        assertEquals(expectedPositionEndDate, actual.getPositionEndDate());

        verify(employeeRepository, times(2)).findEmployeeById(employee.getId());
        verify(projectRepository, times(2)).findProjectById(project.getId());
        verify(workRepository, times(2)).findWorkById(workId);
        verify(converter, times(2)).toDTO(work);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistByEmployeeIdWhenUpdate() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.update(workDTO));

        verify(employeeRepository).findEmployeeById(employee.getId());
    }

    @Test
    public void shouldThrowExceptionIfProjectDoesNotExistByProjectIdWhenUpdate() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.update(workDTO));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
    }

    @Test
    public void shouldThrowExceptionIfWorkDoesNotExistByWorkIdWhenUpdate() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.of(project));
        when(workRepository.findWorkById(workId)).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.update(workDTO));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
        verify(workRepository).findWorkById(workId);
    }

    @Test
    public void shouldThrowExceptionIfEmployeeDoesNotExistByEmployeeIdWhenDeleteByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.deleteByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
    }

    @Test
    public void shouldThrowExceptionIfProjectDoesNotExistByProjectIdWhenDeleteByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.ofNullable(null));

        assertThrows(NoSuchRecordException.class, () -> workService.deleteByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
    }

    @Test
    public void shouldThrowExceptionIfWorkDoesNotExistByWorkIdWhenDeleteByIds() {
        when(employeeRepository.findEmployeeById(employee.getId())).thenReturn(Optional.of(employee));
        when(projectRepository.findProjectById(project.getId())).thenReturn(Optional.of(project));
        when(workRepository.existsById(workId)).thenReturn(false);

        assertThrows(NoSuchRecordException.class, () -> workService.deleteByIds(employee.getId(), project.getId()));

        verify(employeeRepository).findEmployeeById(employee.getId());
        verify(projectRepository).findProjectById(project.getId());
        verify(workRepository).existsById(workId);
    }

}

------------------
RESOURCES
------------------


<databaseChangeLog
        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
        xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog-ext
   http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd
   http://www.liquibase.org/xml/ns/dbchangelog
   http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.4.xsd">

    <preConditions>
        <dbms type="postgresql"/>
    </preConditions>

    <changeSet id="4" author="Ivan">
<!--        <sqlFile dbms="postgresql"-->
<!--                 encoding="UTF-8"-->
<!--                 relativeToChangelogFile="true"-->
<!--                 splitStatements="true"-->
<!--                 stripComments="true"-->
<!--                 path="sql-scripts/create-db.sql"/>-->

        <sql dbms="postgresql" endDelimiter=";">CREATE SCHEMA employee_db_test</sql>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-department-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-project-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-role-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-employee-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-project_employee-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter="\n"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/insert-roles.sql"/>
    </changeSet>
</databaseChangeLog>

<databaseChangeLog
        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
        xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog-ext
   http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd
   http://www.liquibase.org/xml/ns/dbchangelog
   http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.4.xsd">

    <preConditions>
        <dbms type="postgresql"/>
    </preConditions>

    <changeSet id="6" author="Ivan">
        <preConditions onFail="MARK_RAN">
            <and>
                <tableExists tableName="department"/>
                <tableExists tableName="employee"/>
                <tableExists tableName="project"/>
                <tableExists tableName="project_employee"/>
                <tableExists tableName="role"/>
            </and>
        </preConditions>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter=";"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/drop-tables.sql"/>
    </changeSet>

    <changeSet id="4" author="Ivan">
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-department-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-project-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-role-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-employee-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/create-project_employee-table.sql"/>

        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter="\n"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/init-role-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter="\n"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/init-department-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter="\n"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/init-project-table.sql"/>
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter="\n"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/init-employee-table.sql"/>
    </changeSet>
    <changeSet id="5" author="Ivan">
        <sqlFile dbms="postgresql"
                 encoding="UTF-8"
                 endDelimiter=";"
                 relativeToChangelogFile="true"
                 splitStatements="true"
                 stripComments="true"
                 path="sql-scripts/init-project_employee-table.sql"/>
    </changeSet>
</databaseChangeLog>

SQL
create database employee_db_test;

create table department (
      id uuid primary key unique not null,
      name varchar(64) not null
)

create table employee (
    id uuid primary key unique not null,
    first_name varchar(32) not null,
    last_name varchar(32) not null,
    username varchar(32) not null,
    password varchar(256) not null,
    position varchar(32) not null,
    role_id uuid not null,
    department_id uuid,
    foreign key (role_id) references "role" (id),
    foreign key (department_id) references department (id)
)

create table project (
    id uuid primary key unique not null,
    name varchar(64) not null,
    begin_date date not null,
    end_date date not null
)

create table project_employee (
    employee_id uuid not null,
    project_id uuid not null,
    position_start_date date,
    position_end_date date,
    working_hours int,
    primary key (employee_id, project_id),
    foreign key (employee_id) references employee (id),
    foreign key (project_id) references project (id)
)

create table role (
    id uuid primary key unique not null,
    name varchar(16) not null
)

drop table employee cascade;
drop table department cascade;
drop table project cascade;
drop table role cascade;
drop table project_employee cascade;

insert into department (id, name) values ('7bb734c1-c5c6-436f-8b28-ca9ccfc474d5', 'Web-development');
insert into department (id, name) values ('da8f36e3-f2b1-4ee8-a8c1-9fbcb9cfe4bd', 'Mobile-development');
insert into department (id, name) values ('edf939d2-dbc2-4473-80a1-4bb3826e666e', 'HR');
insert into department (id, name) values ('46e3f891-4a03-4133-8ba4-760849a947bb', 'Game-development');

insert into employee (id, first_name, last_name, username, password, position, role_id, department_id)
    values ('c7fa1cd3-b281-47b1-b72f-92b9391fc5c7', 'Ivan', 'Shestakov', 'Vanechka', 'test', 'Java Developer', 'c7e1b538-92a1-414e-85e7-7d90b9d2d861', '7bb734c1-c5c6-436f-8b28-ca9ccfc474d5');

insert into employee (id, first_name, last_name, username, password, position, role_id, department_id)
    values ('e9a4e12b-1555-48bd-9275-629856bcdb51', 'Artiom', 'Ivanov', 'Tema', 'test', 'Dev', 'c7e1b538-92a1-414e-85e7-7d90b9d2d861', 'da8f36e3-f2b1-4ee8-a8c1-9fbcb9cfe4bd');

insert into employee (id, first_name, last_name, username, password, position, role_id, department_id)
    values ('2174c05c-e885-4521-985d-774b1f05cd37', 'Vlad', 'Vladov', 'Turbo3000', 'test', 'HR', 'a8727b4b-d91d-4e42-bd83-13261ae7bd64', 'edf939d2-dbc2-4473-80a1-4bb3826e666e');

insert into project (id, name, begin_date, end_date)
    values ('7c8697b8-530d-4a00-ba00-3dfec6b1bb79', 'Bank system', to_date('2020-10-08', 'YYYY-MM-DD'), to_date('2020-12-16', 'YYYY-MM-DD'));

insert into project (id, name, begin_date, end_date)
    values ('507eeff6-3563-4a43-99c8-b1706d6b17cd', 'Online shop', to_date('2018-11-09', 'YYYY-MM-DD'), to_date('2021-10-16', 'YYYY-MM-DD'));

insert into project (id, name, begin_date, end_date)
    values ('6f6bd93b-fcdd-4c3f-a144-1e03139559d6', 'Employees service', to_date('2019-05-18', 'YYYY-MM-DD'), to_date('2021-11-25', 'YYYY-MM-DD'));

insert into project_employee (employee_id, project_id, position_start_date, position_end_date, working_hours)
values ('c7fa1cd3-b281-47b1-b72f-92b9391fc5c7',
        '7c8697b8-530d-4a00-ba00-3dfec6b1bb79',
        to_date('2021-01-01', 'YYYY-MM-DD'),
        to_date('2021-06-01', 'YYYY-MM-DD'),
        8);

insert into project_employee (employee_id, project_id, position_start_date, position_end_date, working_hours)
values ('e9a4e12b-1555-48bd-9275-629856bcdb51',
        '7c8697b8-530d-4a00-ba00-3dfec6b1bb79',
        to_date('2021-02-01', 'YYYY-MM-DD'),
        to_date('2021-08-01', 'YYYY-MM-DD'),
        6);

insert into project_employee (employee_id, project_id, position_start_date, position_end_date, working_hours)
values ('2174c05c-e885-4521-985d-774b1f05cd37',
        '6f6bd93b-fcdd-4c3f-a144-1e03139559d6',
        to_date('2020-01-01', 'YYYY-MM-DD'),
        to_date('2020-04-01', 'YYYY-MM-DD'),
        8);

insert into role (id, name) values ('a8727b4b-d91d-4e42-bd83-13261ae7bd64', 'ROLE_EMPLOYEE');
insert into role (id, name) values ('c7e1b538-92a1-414e-85e7-7d90b9d2d861', 'ROLE_MANAGER');

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
insert into role (id, name) values (uuid_generate_v4(), 'ROLE_EMPLOYEE');
insert into role (id, name) values (uuid_generate_v4(), 'ROLE_MANAGER');

PROPERTIES

driverClass=org.postgresql.Driver
jdbcUrl=${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/employee_db_liquibase}
testUrl=jdbc:postgresql://localhost:5432/test_db?useSSL=false&amp
dbuser=${SPRING_DATASOURCE_USERNAME:postgres}
password=${SPRING_DATASOURCE_PASSWORD:postgres}

packagesToScan=com.leverx.employeestat.rest.entity
hibernate.dialect=org.hibernate.dialect.PostgreSQL9Dialect
hibernate.show_sql=false
hibernate.ddl-auto=none

spring.security.oauth2.client.registration.google.client-id=854909843289-i6kivqbpjvt6di44ur0f0p2li5novibf.apps.googleusercontent.com
spring.security.oauth2.client.registration.google.client-secret=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

reports-path=C:/Users/ivan.shastakou/IdeaProjects/employeestat/reports
reports-generating-cron=0 0 0 1 * *

LOGGER CONFIG

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" monitorInterval="30">
    <Properties>
        <Property name="LOG_PATTERN">%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %m%n</Property>
        <Property name="APP_LOG_ROOT">log</Property>
    </Properties>
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT" follow="true">
            <PatternLayout pattern="${LOG_PATTERN}" />
        </Console>

        <RollingFile name="appLog"
                     fileName="${APP_LOG_ROOT}/application.log"
                     filePattern="${APP_LOG_ROOT}/SpringBoot2App/application-%d{yyyy-MM-dd}-%i.log">
            <PatternLayout pattern="${LOG_PATTERN}" />
            <Policies>
                <SizeBasedTriggeringPolicy size="19500KB" />
            </Policies>
            <DefaultRolloverStrategy max="1" />
        </RollingFile>

    </Appenders>
    <Loggers>

        <Logger name="com.employeestat.app" additivity="false">
            <AppenderRef ref="appLog" />
            <AppenderRef ref="Console" />
        </Logger>

        <Root level="debug">
            <AppenderRef ref="Console" />
            <AppenderRef ref="appLog" />
        </Root>

    </Loggers>
</Configuration>

----------------------
DOCKER
----------------------
app:

FROM tomcat:8-jre8

RUN echo "export JAVA_OPTS=\"-Dapp.env=employeestat\"" > /usr/local/tomcat/bin/setenv.sh
COPY employeestat.war /usr/local/tomcat/webapps/employeestat.war

CMD ["catalina.sh", "run"]

db:

FROM postgres:9.4

ENV POSTGRES_USER postgres
ENV POSTGRES_PASSWORD user
ENV POSTGRES_DB employee_db

docker-compose.yml

services:

  app-web:
    build: app
    container_name: application
    ports:
      - "8089:8080"
    links:
      - app-db

  app-db:
    build: db
    container_name: db
    expose:
      - "5433"
    volumes_from:
      - app-db-data

  app-db-data:
    image: cogniteev/echo
    command: echo 'Data Container for PostgreSQL'
    volumes:
      - /var/lib/postgresql/data

-------------------
MAVEN
-------------------

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.leverx</groupId>
  <artifactId>employeestat</artifactId>
  <version>1.0</version>
  <packaging>war</packaging>

  <name>employeestat Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <java.version>1.8</java.version>
        <spring-webmvc-orm.version>5.3.14</spring-webmvc-orm.version>
        <javax.servlet.version>4.0.1</javax.servlet.version>
        <org.hibernate.version>5.5.0.Final</org.hibernate.version>
        <c3p0.version>0.9.5.2</c3p0.version>
        <org.hibernate.validator.version>6.2.0.Final</org.hibernate.validator.version>
        <org.aspectj.version>1.9.6</org.aspectj.version>
        <spring-data-jpa.version>2.6.0</spring-data-jpa.version>
        <jackson-databind.version>2.12.3</jackson-databind.version>
        <postgresql.version>42.3.1</postgresql.version>
        <org.apache.poi.version>5.0.0</org.apache.poi.version>
        <mockito-junit-jupiter.version>3.9.0</mockito-junit-jupiter.version>
        <spring-security-oauth2.version>5.6.0</spring-security-oauth2.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.liquibase</groupId>
            <artifactId>liquibase-core</artifactId>
            <version>4.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring-webmvc-orm.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-webmvc-orm.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>${spring-data-jpa.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>5.6.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>5.6.0</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${org.hibernate.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${org.hibernate.validator.version}</version>
        </dependency>

        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${org.aspectj.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${javax.servlet.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson-databind.version}</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>${jackson-databind.version}</version>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>${postgresql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${org.apache.poi.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${org.apache.poi.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.14</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-junit-jupiter</artifactId>
            <version>${mockito-junit-jupiter.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-library</artifactId>
            <version>2.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <version>2.5.0</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>au.com.dius.pact.provider</groupId>
            <artifactId>junit5spring</artifactId>
            <version>4.3.0</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>com.opencsv</groupId>
            <artifactId>opencsv</artifactId>
            <version>5.5.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-bean-validators</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <version>2.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-oauth2-client</artifactId>
            <version>${spring-security-oauth2.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-oauth2-jose</artifactId>
            <version>${spring-security-oauth2.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>


    </dependencies>

  <build>
    <finalName>employeestat</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>

        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>

        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>

        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.1</version>
        </plugin>

        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
            <configuration>
                <skipTests>false</skipTests>
            </configuration>
        </plugin>

        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>

        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>

        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>

      </plugins>
    </pluginManagement>
    <plugins>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
<!--          <fork>true</fork>-->
<!--          <executable>C:\Program Files\Java\jdk1.8.0_301\bin\javac</executable>-->
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals><goal>copy</goal></goals>
            <configuration>
              <artifactItems>
                <artifactItem>
                  <groupId>com.heroku</groupId>
                  <artifactId>webapp-runner</artifactId>
                  <version>9.0.52.1</version>
                  <destFileName>webapp-runner.jar</destFileName>
                </artifactItem>
              </artifactItems>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>