aboutsummaryrefslogblamecommitdiff
path: root/src/main/java/com/juick/config/WebConfig.java
blob: 59f9a99c35b32eda76de7d9c692408b241a9cc3f (plain) (tree)
1
2
  
                                 













                                                                           
                         
 
                   
                            
                                     
                                                  
                                     


                                                               
                                                                   
                                                                    
                                      



                                                     
                                                          


                                                               
                                            
                                             
                                                                  
                                                                                  
                                                    
                                                                                 
                                                                          
                                                                          
                                                                        
 
                                      
                             
                                     
 
                           



                                   

                                                    






                                                                     
         
                                                
     
























                                                                                                           
                                       



                                              
                                         


                                        





                                                                                     
                                              
                                                 
                                                    
                                       


                                      

































                                                                  
                                        
                                                                                 
                                            

                                                              
                                                                       

                                                         
                                                                                                                       




                                                                                                            
     



                                    
                                     
 


                                                          


                                                          


                                                            
 
/*
 * Copyright (C) 2008-2020, Juick
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.juick.config;

import com.juick.*;
import com.juick.model.User;
import com.juick.service.HelpService;
import com.juick.service.StorageService;
import com.juick.service.FileSystemStorageService;
import com.juick.service.UserService;
import com.mitchellbosecke.pebble.PebbleEngine;
import com.mitchellbosecke.pebble.extension.FormatterExtension;
import com.mitchellbosecke.pebble.loader.ClasspathLoader;
import com.mitchellbosecke.pebble.loader.Loader;
import com.mitchellbosecke.pebble.spring.extension.SpringExtension;
import com.mitchellbosecke.pebble.spring.servlet.PebbleViewResolver;
import com.overzealous.remark.Options;
import com.overzealous.remark.Remark;
import org.apache.commons.codec.CharEncoding;
import org.commonmark.ext.autolink.AutolinkExtension;
import org.commonmark.node.Link;
import org.commonmark.parser.Parser;
import org.commonmark.renderer.html.HtmlRenderer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.http.CacheControl;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.security.web.firewall.HttpStatusRequestRejectedHandler;
import org.springframework.security.web.firewall.RequestRejectedHandler;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.resource.ResourceUrlEncodingFilter;
import org.springframework.web.servlet.resource.VersionResourceResolver;

import java.net.MalformedURLException;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.concurrent.TimeUnit;

import javax.inject.Inject;

/**
 * Created by aalexeev on 11/22/16.
 */
@Configuration
@EnableCaching
@EnableAsync(proxyTargetClass = true)
@EnableScheduling
public class WebConfig implements WebMvcConfigurer {
    @Value("${upload_tmp_dir:#{systemProperties['java.io.tmpdir']}}")
    private String tmpDir;
    @Value("${storage_path:#{systemProperties['java.io.tmpdir']}}")
    private String baseDir;
    @Bean
    public StorageService storageService() {
        return new FileSystemStorageService(baseDir, tmpDir);
    }
    @Bean
    public CaffeineCacheManager cacheManager() {
        return new CaffeineCacheManager("help");
    }

    @Bean
    public HelpService helpService() {
        return new HelpService("help");
    }

    @Bean
    public Parser cmParser() {
        return Parser.builder().extensions(Collections.singletonList(AutolinkExtension.create())).build();
    }
    @Bean
    public HtmlRenderer helpRenderer() {
        return HtmlRenderer.builder()
                .attributeProviderFactory(context -> (node, tagName, attributes) -> {
                    if (node instanceof Link) {
                        Link link = (Link) node;
                        if (link.getDestination().startsWith("/")) {
                            String destination = "/" + helpService().getHelpPath() + link.getDestination();
                            link.setDestination(destination);
                            attributes.put("href", destination);
                        }
                    }
                })
                .build();
    }
    @Bean
    public Loader<?> templateLoader() {
        return new ClasspathLoader();
    }

    @Bean
    public SpringExtension springExtension() {
        return new SpringExtension(null);
    }

    @Bean
    public PebbleEngine pebbleEngine() {
        boolean devToolsArePresent = false;
        try {
            Class.forName("org.springframework.boot.devtools.livereload.Connection");
            devToolsArePresent = true;
        } catch (ClassNotFoundException e) {
            // release mode
        }
        return new PebbleEngine.Builder()
                .loader(this.templateLoader())
                .cacheActive(!devToolsArePresent)
                .extension(springExtension())
                .extension(new FormatterExtension())
                .newLineTrimming(false)
                .strictVariables(true)
                .build();
    }

    @Value("${keystore:classpath:juick-test-key.p12}")
    private Resource keystore;
    @Value("${keystore_password:secret}")
    private String keystorePassword;
    @Bean
    public ResourceUrlEncodingFilter resourceUrlEncodingFilter() {
        return new ResourceUrlEncodingFilter();
    }
    @Bean
    public KeystoreManager keystoreManager() {
        return new KeystoreManager(keystore, keystorePassword);
    }
    @Bean
    public Remark remarkConverter() {
        Options options = new Options();
        options.inlineLinks = true;
        return new Remark(options);
    }
    @Bean
    public CommandsManager commandsManager() {
        return new CommandsManager();
    }
    @Bean
    public ServerManager serverManager() {
        return new ServerManager();
    }
    @Bean
    public SignatureManager signatureManager() {
        return new SignatureManager();
    }
    @Bean
    public TopManager topManager() {
        return new TopManager();
    }

    @Bean
    public ViewResolver viewResolver() {
        PebbleViewResolver viewResolver = new PebbleViewResolver(pebbleEngine());
        viewResolver.setPrefix("templates");
        viewResolver.setSuffix(".html");
        viewResolver.setCharacterEncoding(CharEncoding.UTF_8);
        return viewResolver;
    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        try {
            registry
                    .addResourceHandler("/**", "/i/a/**")
                    .addResourceLocations("classpath:/static/", Paths.get(baseDir, "/i/a/").toUri().toURL().toString())
                    .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS))
                    .resourceChain(false)
                    .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**", "/i/a/**"));
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
    
    @Inject
    private UserService userService;
    @Value("${service_user:juick}")
    private String serviceUsername;
    @Value("${archive_user:archive}")
    private String archiveUsername;

    @Bean
    public User serviceUser() {
        return userService.getUserByName(serviceUsername);
    }
    @Bean
    public User archiveUser() {
        return userService.getUserByName(archiveUsername);
    }
    @Bean
    public RequestRejectedHandler requestRejectedHandler() {
        return new HttpStatusRequestRejectedHandler();
    }
}