@Service
public class Utils {

    @Autowired
    private FleetServices fleetServices;
    @Autowired
    private CarServices carServices;

    public static long stream(InputStream input, OutputStream output) throws IOException {
        try (
                ReadableByteChannel inputChannel = Channels.newChannel(input);
                WritableByteChannel outputChannel = Channels.newChannel(output);
                ) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(10240);
            long size = 0;

            while (inputChannel.read(buffer) != -1) {
                buffer.flip();
                size += outputChannel.write(buffer);
                buffer.clear();
            }
            return size;
        }
    }

    @Transactional
    public void unSetEditingFleet(Integer idFleet) throws QueryException {
        try {
            fleetServices.setEditingFleet(idFleet, false);
            for(Car car : carServices.findByFleetIdFleet(idFleet)){
                carServices.setEditingCar(car.getIdCar(), false);   //Unset cars associated with the fleet
            }
        }catch(Exception e){
            throw new QueryException(e);
        }
    }

    @Transactional
    public void setEditingFleet(User user, FleetForm fleetForm) throws QueryException {
        try{
            fleetServices.setEditingFleet(fleetForm.getIdFleet(), true);
            for(Car car : carServices.findByFleetIdFleet(fleetForm.getIdFleet())){
                carServices.setEditingCar(car.getIdCar(), true);     //Set cars associated with the fleet
                throw new Exception("fleet has been restored Exception");
            }
        }catch(Exception e){
            throw new QueryException(e);
        }
    }
}

@Component
@Aspect
public class AOP {

    @Autowired
    private FleetServices fleetServices;
    @Autowired
    private CarServices carServices;
    @Autowired
    private Utils utils;

    @Before("@annotation(SetEditingFleet) && args(user, fleetForm)")
    public void setEditingFleet(User user, FleetForm fleetForm) throws QueryException {
        utils.setEditingFleet(user, fleetForm);
    }

    @After("@annotation(UnSetEditingFleet) && args(user, fleetForm)")
    public void unSetEditingFleet(User user, FleetForm fleetForm) throws QueryException {
        utils.unSetEditingFleet(fleetForm.getIdFleet());
    }
}

@Service
public class FleetAndCarServicesImpl implements FleetAndCarServices {

    @Autowired
    private DatabaseFleetsAndCarsServices databaseFleetsAndCarsServices;
    @Autowired
    private DatabaseAcquisitionServices databaseAcquisitionServices;
    @Autowired
    private DatabaseAdministrationServices databaseAdministrationServices;
    @Autowired
    private MakeName makeName;
    @Autowired
    private MakeAcquisitionPath makeAcquisitionPath;
    @Autowired
    private Environment env;
    private static String PROPERTY_NAME_FILESYSTEM_BASEPATH = "filesystem.basepath";

    @Override
    @SetEditingFleet
    public void modifyFleet(User user, FleetForm fleetForm) throws Exception{
        databaseFleetsAndCarsServices.modifyFleet(user, fleetForm);
    }
}

@Service
public class FleetAndCarServicesImpl implements FleetAndCarServices {

    @Autowired
    private DatabaseFleetsAndCarsServices databaseFleetsAndCarsServices;
    @Autowired
    private DatabaseAcquisitionServices databaseAcquisitionServices;
    @Autowired
    private DatabaseAdministrationServices databaseAdministrationServices;
    @Autowired
    private MakeName makeName;
    @Autowired
    private MakeAcquisitionPath makeAcquisitionPath;
    @Autowired
    private Environment env;
    private static String PROPERTY_NAME_FILESYSTEM_BASEPATH = "filesystem.basepath";

    @Override
    public void modifyFleet(User user, FleetForm fleetForm) throws Exception{
        databaseFleetsAndCarsServices.modifyFleet(user, fleetForm);
    }
}

@EnableWebSecurity //It allows use of @AuthenticationPrincipal to retrieve current user
@EnableAspectJAutoProxy
@EnableAsync
@EnableWebMvc
@Configuration
@PropertySource(value = { "classpath:application.properties" })
@ComponentScan({ "com.*" })
@EnableTransactionManagement
@Import({ SecurityConfig.class, SpringMvcInitializer.class})
@EnableJpaRepositories("com.repository")
public class AppConfig extends WebMvcConfigurerAdapter implements AsyncConfigurer{
    @Autowired
    private Environment env;
    @Autowired
    private MyAsyncUncaughtExceptionHandler myAsyncUncaughtExceptionHandler;

    private static final String PROPERTY_NAME_DATABASE_DRIVER = "db.driver";
    private static final String PROPERTY_NAME_DATABASE_PASSWORD = "db.password";
    private static final String PROPERTY_NAME_DATABASE_URL = "db.url";
    private static final String PROPERTY_NAME_DATABASE_USERNAME = "db.username";

    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
    //  private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = "entitymanager.packages.to.scan";
    private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = "hibernate.format_sql";

    /**
     * This method allows use of . with pathparam into web services, otherwise it truncate after dot.
     * @param configurer
     */
     public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.setUseSuffixPatternMatch(false);
      }

    /**
     * This and the next methods are used to avoid exception while jackson mapping the entity, so fields are setted with null value
     * unless use Hibernate.initialize
     * @return
     */
    public MappingJackson2HttpMessageConverter jacksonMessageConverter(){
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();

        ObjectMapper mapper = new ObjectMapper();
        //Registering Hibernate4Module to support lazy objects
        mapper.registerModule(new Hibernate4Module());

        messageConverter.setObjectMapper(mapper);
        return messageConverter;

    }
    /**
     * Used for spring security
     * @return
     */
    @Bean
    public SpringSecurityDialect springSecurityDialect() {
        SpringSecurityDialect dialect = new SpringSecurityDialect();
        return dialect;
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        //Here we add our custom-configured HttpMessageConverter
        converters.add(jacksonMessageConverter());
        super.configureMessageConverters(converters);
    }

    private Properties getHibernateProperties() {
        Properties properties = new Properties();
        properties.put(PROPERTY_NAME_HIBERNATE_DIALECT, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
        //      properties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));
        properties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));
        properties.put("hibernate.enable_lazy_load_no_trans",true);
        return properties;
    }

    @Bean(name = "dataSource")
    public BasicDataSource dataSource() {
        BasicDataSource ds = new BasicDataSource();
        ds.setValidationQuery("SELECT 1");
        ds.setDriverClassName(env.getRequiredProperty(PROPERTY_NAME_DATABASE_DRIVER));
        ds.setUrl(env.getRequiredProperty(PROPERTY_NAME_DATABASE_URL));
        ds.setUsername(env.getRequiredProperty(PROPERTY_NAME_DATABASE_USERNAME));
        ds.setPassword(env.getRequiredProperty(PROPERTY_NAME_DATABASE_PASSWORD));
        return ds;
    }

    @Bean
    public ServletContextTemplateResolver TemplateResolver(){
        ServletContextTemplateResolver resolver = new ServletContextTemplateResolver();
        resolver.setPrefix("/WEB-INF/templates/pages/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode("LEGACYHTML5");
        resolver.setCacheable(false);
        return resolver;
        /*ServletContextTemplateResolver resolver = new ServletContextTemplateResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode("HTML5");
        return resolver;*/
    }

    @Bean
    public SpringTemplateEngine templateEngine(){
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(TemplateResolver());
        templateEngine.addDialect(springSecurityDialect());
        return templateEngine;
    }


    @Bean
    public ThymeleafViewResolver viewResolver() {
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateEngine(templateEngine());
        resolver.setOrder(1);
        resolver.setViewNames(new String[]{"*", "js/*", "template/*"});
        return resolver;
    }

    /**
     * Register multipartResolver for file upload
     * @return
     */
    @Bean
    public CommonsMultipartResolver multipartResolver() {
        CommonsMultipartResolver resolver=new CommonsMultipartResolver();
        resolver.setDefaultEncoding("utf-8");
        return resolver;
    }

    /**
     * Allow use of bootstrap
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
        .addResourceLocations("/static/");
    }

    /**
     * Allow use of JPA
     */
    @Bean
    public JpaTransactionManager transactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return transactionManager;
    }
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactoryBean.setDataSource(dataSource());
        entityManagerFactoryBean.setPersistenceProviderClass(HibernatePersistenceProvider.class);
        entityManagerFactoryBean.setPackagesToScan(env.
                getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));
        entityManagerFactoryBean.setJpaProperties(getHibernateProperties());
        return entityManagerFactoryBean;
    }

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }

    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return myAsyncUncaughtExceptionHandler;
    }

    //Concurrent Session Control. Necessary for maximumSessions(1) into securityConfig
    @Bean
    public ServletListenerRegistrationBean<HttpSessionEventPublisher> httpSessionEventPublisher() {
        return new ServletListenerRegistrationBean<HttpSessionEventPublisher>(new HttpSessionEventPublisher());
    }
}

@Service
public class Utils {

@Autowired
private FleetServices fleetServices;
@Autowired
private CarServices carServices;

public static long stream(InputStream input, OutputStream output) throws IOException {
    try (
            ReadableByteChannel inputChannel = Channels.newChannel(input);
            WritableByteChannel outputChannel = Channels.newChannel(output);
            ) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(10240);
        long size = 0;

        while (inputChannel.read(buffer) != -1) {
            buffer.flip();
            size += outputChannel.write(buffer);
            buffer.clear();
        }
        return size;
    }
}

@Test
@Transactional
public void unSetEditingFleet(Integer idFleet) throws QueryException {
    try {
        fleetServices.setEditingFleet(idFleet, false);
        for(Car car : carServices.findByFleetIdFleet(idFleet)){
            carServices.setEditingCar(car.getIdCar(), false);   //Unset cars associated with the fleet
        }
    }catch(Exception e){
        throw new QueryException(e);
    }
}

@Test
@Transactional
public void setEditingFleet(User user, FleetForm fleetForm) throws QueryException {
    try{
        fleetServices.setEditingFleet(fleetForm.getIdFleet(), true);
        for(Car car : carServices.findByFleetIdFleet(fleetForm.getIdFleet())){
            carServices.setEditingCar(car.getIdCar(), true);     //Set cars associated with the fleet
            throw new Exception("fleet has been restored Exception");
        }
    }catch(Exception e){
        throw new QueryException(e);
    }
}
}