@eui/cli 21.0.0-alpha.4 → 21.0.0-alpha.5

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/resources/BuildingResource.java

@@ -0,0 +1,26 @@
+package @app.group.id@.@app.name@.resources;
+
+import @app.group.id@.@app.name@.resources.support.HypermediaSupport;
+import @app.group.id@.@app.name@.services.BuildingService;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("api/buildings")
+public class BuildingResource {
+    private BuildingService buildingService;
+    private HypermediaSupport hateoasPageSupport;
+
+    public BuildingResource(BuildingService buildingService, HypermediaSupport hateoasPageSupport) {
+        this.buildingService = buildingService;
+        this.hateoasPageSupport = hateoasPageSupport;
+    }
+
+    @GetMapping()
+    public ResponseEntity getAllBuildings(Pageable pageable) {
+        return hateoasPageSupport.wrap(buildingService.findAll(pageable), pageable);
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/resources/SwaggerConfig.java

@@ -0,0 +1,16 @@
+package @app.group.id@.@app.name@.resources;
+
+import org.springdoc.core.models.GroupedOpenApi;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SwaggerConfig {
+    @Bean
+    public GroupedOpenApi publicApi() {
+        return GroupedOpenApi.builder()
+                .group("springshop-public")
+                .pathsToMatch("/api/**")
+                .build();
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/resources/support/HateoasPageableHandlerMethodArgumentResolver.java

@@ -0,0 +1,45 @@
+package @app.group.id@.@app.name@.resources.support;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+public class HateoasPageableHandlerMethodArgumentResolver extends PageableHandlerMethodArgumentResolver {
+    protected int defaultPageSize = 10;
+
+    @Override
+    public Pageable resolveArgument(MethodParameter methodParameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
+        String contentRange = webRequest.getHeader("Content-Range");
+        if (contentRange != null && contentRange.length() > 0) {
+            contentRange = contentRange.trim();
+            if (contentRange.startsWith("item ")) {
+                int index = contentRange.indexOf("/");
+                String [] range = null;
+                if (index > 0) {
+                    range = contentRange.substring("item ".length(), index).split("-");
+                } else {
+                    range = contentRange.substring("item ".length()).split("-");
+                }
+
+                int from = Integer.parseInt(range [0]);
+                int to = defaultPageSize;
+                if (range.length > 1) {
+                    to = Integer.parseInt(range [1]);
+                }
+
+                // Page size is never <= 0:
+                int pageSize = Math.max(to - from + 1, 1);
+                // Page is zero-based:
+                int page = from / pageSize;
+
+                return PageRequest.of(page, pageSize);
+            }
+        }
+
+        return super.resolveArgument(methodParameter, mavContainer, webRequest, binderFactory);
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/resources/support/HypermediaSupport.java

@@ -0,0 +1,25 @@
+package @app.group.id@.@app.name@.resources.support;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+@Component
+public class HypermediaSupport {
+    public ResponseEntity<Page> wrap(Page page, Pageable pageable) {
+        HttpHeaders headers = new HttpHeaders();
+
+        long total = page.getTotalElements();
+        // Page and range are zero-based:
+        long from = page.getNumber() * page.getSize();
+        long to = from + pageable.getPageSize() - 1;
+
+        headers.add("Accept-Ranges", "item");
+        headers.add("Content-Range", "item " + from + "-" + to + "/" + total);
+
+        return new ResponseEntity<Page>(page, headers, HttpStatus.PARTIAL_CONTENT);
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/resources/support/PageJsonSerializer.java

@@ -0,0 +1,17 @@
+package @app.group.id@.@app.name@.resources.support;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import org.springframework.data.domain.Page;
+
+import java.io.IOException;
+
+public class PageJsonSerializer extends JsonSerializer {
+    @Override
+    public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
+        // Remove the page information that will be serialized to the HTTP headers instead:
+        Page page = (Page) o;
+        jsonGenerator.writeObject(page.getContent());
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/security/CachingPreventionFilter.java

@@ -0,0 +1,29 @@
+package @app.group.id@.@app.name@.security;
+
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+// Prevents caching of REST service responses.
+public class CachingPreventionFilter implements Filter {
+    public void init(FilterConfig filterConfig) throws ServletException {
+        // do nothing
+    }
+
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
+        HttpServletResponse response = (HttpServletResponse) servletResponse;
+        response.addIntHeader("Age", 0);
+        response.addHeader("Cache-Control", "no-cache,no-store,no-transform,must-revalidate");
+        response.addHeader("Expires", "Wed, 31 Dec 1969 23:59:59 GMT");
+        response.addHeader("Pragma", "no-cache");
+        response.addHeader("X-Robots-Tag", "noindex, nofollow");
+
+        if (filterChain != null) {
+            filterChain.doFilter(servletRequest, servletResponse);
+        }
+    }
+
+    public void destroy() {
+        // do nothing
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/security/CsrfPreventionFilter.java

@@ -0,0 +1,35 @@
+package @app.group.id@.@app.name@.security;
+
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+// Prevents non-ajax requests for REST services. This is to prevent Cross-Site Request Forgery (CSRF) attacks.
+public class CsrfPreventionFilter implements Filter {
+    public void init(FilterConfig filterConfig) throws ServletException {
+        // do nothing
+    }
+
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
+        HttpServletRequest request = (HttpServletRequest) servletRequest;
+        HttpServletResponse response = (HttpServletResponse) servletResponse;
+
+        String origin = request.getHeader("Origin");
+        if ("XMLHttpRequest".equals(request.getHeader("X-Requested-With")) || "OPTIONS".equalsIgnoreCase(request.getMethod()) || (origin != null && origin.trim().length() > 0)) {
+            response.addHeader("Content-Security-Policy", "default-src 'self'; connect-src 'self'; font-src 'none'; img-src 'self'; media-src 'self'; object-src 'self'; plugin-types application/pdf audio/x-wav; referrer no-referrer; reflected-xss block; script-src 'self'; style-src 'self'");
+            response.addHeader("X-Content-Security-Policy", "default-src 'self'; connect-src 'self'; font-src 'none'; img-src 'self'; media-src 'self'; object-src 'self'; plugin-types application/pdf audio/x-wav; referrer no-referrer; reflected-xss block; script-src 'self'; style-src 'self'");
+            response.addHeader("X-Content-Type-Options", "nosniff");
+            if (filterChain != null) {
+                filterChain.doFilter(servletRequest, servletResponse);
+            }
+        } else {
+            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
+            response.getWriter().write("The REST service can only be accessed programmatically.");
+        }
+    }
+
+    public void destroy() {
+        // do nothing
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/security/FakeAuthenticationFilter.java

@@ -0,0 +1,372 @@
+package @app.group.id@.@app.name@.security;
+
+import com.sun.security.auth.UserPrincipal;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+
+import jakarta.servlet.*;
+import jakarta.servlet.http.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.AuthProvider;
+import java.security.Principal;
+import java.util.*;
+
+// Filter used to fake user login. This allows for testing different user roles in the same application.
+// WARNING: do NOT use this in production; security will be compromised! For now, it will only be activated from requests coming from localhost.
+@Component
+public class FakeAuthenticationFilter implements Filter {
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        // do nothing
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
+        final HttpServletRequest request = (HttpServletRequest) servletRequest;
+        HttpServletResponse response = (HttpServletResponse) servletResponse;
+
+        if (!"localhost".equals(request.getServerName())) {
+            filterChain.doFilter(request, response);
+        } else {
+            final String fakeUsername = request.getHeader("x-fake-authentication");
+            if (fakeUsername == null) {
+                filterChain.doFilter(request, response);
+            } else {
+                /*
+                System.out.println("---------- got fake userid: " + fakeUsername);
+                HttpServletRequest fakeRequest = new HttpServletRequest() {
+                    public Principal getUserPrincipal() {
+                        return new UserPrincipal(fakeUsername);
+                    }
+
+                    // Delegate all the other methods:
+                    public String getAuthType() {
+                        return request.getAuthType();
+                    }
+
+                    public Cookie[] getCookies() {
+                        return request.getCookies();
+                    }
+
+                    public long getDateHeader(String s) {
+                        return request.getDateHeader(s);
+                    }
+
+                    public String getHeader(String s) {
+                        return request.getHeader(s);
+                    }
+
+                    public Enumeration<String> getHeaders(String s) {
+                        return request.getHeaders(s);
+                    }
+
+                    public Enumeration<String> getHeaderNames() {
+                        return request.getHeaderNames();
+                    }
+
+                    public int getIntHeader(String s) {
+                        return request.getIntHeader(s);
+                    }
+
+                    public String getMethod() {
+                        return request.getMethod();
+                    }
+
+                    public String getPathInfo() {
+                        return request.getPathInfo();
+                    }
+
+                    public String getPathTranslated() {
+                        return request.getPathTranslated();
+                    }
+
+                    public String getContextPath() {
+                        return request.getContextPath();
+                    }
+
+                    public String getQueryString() {
+                        return request.getQueryString();
+                    }
+
+                    public String getRemoteUser() {
+                        return request.getRemoteUser();
+                    }
+
+                    public boolean isUserInRole(String s) {
+                        return request.isUserInRole(s);
+                    }
+
+                    public String getRequestedSessionId() {
+                        return request.getRequestedSessionId();
+                    }
+
+                    public String getRequestURI() {
+                        return request.getRequestURI();
+                    }
+
+                    public StringBuffer getRequestURL() {
+                        return request.getRequestURL();
+                    }
+
+                    public String getServletPath() {
+                        return request.getServletPath();
+                    }
+
+                    public HttpSession getSession(boolean b) {
+                        return request.getSession(b);
+                    }
+
+                    public HttpSession getSession() {
+                        return request.getSession();
+                    }
+
+                    public String changeSessionId() {
+                        return request.changeSessionId();
+                    }
+
+                    public boolean isRequestedSessionIdValid() {
+                        return request.isRequestedSessionIdValid();
+                    }
+
+                    public boolean isRequestedSessionIdFromCookie() {
+                        return request.isRequestedSessionIdFromCookie();
+                    }
+
+                    public boolean isRequestedSessionIdFromURL() {
+                        return request.isRequestedSessionIdFromURL();
+                    }
+
+                    public boolean isRequestedSessionIdFromUrl() {
+                        return request.isRequestedSessionIdFromUrl();
+                    }
+
+                    public boolean authenticate(HttpServletResponse httpServletResponse) throws IOException, ServletException {
+                        return request.authenticate(httpServletResponse);
+                    }
+
+                    public void login(String s, String s1) throws ServletException {
+                        request.login(s, s1);
+                    }
+
+                    public void logout() throws ServletException {
+                        request.logout();
+                    }
+
+                    public Collection<Part> getParts() throws IOException, ServletException {
+                        return request.getParts();
+                    }
+
+                    public Part getPart(String s) throws IOException, ServletException {
+                        return request.getPart(s);
+                    }
+
+                    public <T extends HttpUpgradeHandler> T upgrade(Class<T> aClass) throws IOException, ServletException {
+                        return request.upgrade(aClass);
+                    }
+
+                    public Object getAttribute(String s) {
+                        return request.getAttribute(s);
+                    }
+
+                    public Enumeration<String> getAttributeNames() {
+                        return request.getAttributeNames();
+                    }
+
+                    public String getCharacterEncoding() {
+                        return request.getCharacterEncoding();
+                    }
+
+                    public void setCharacterEncoding(String s) throws UnsupportedEncodingException {
+                        request.setCharacterEncoding(s);
+                    }
+
+                    public int getContentLength() {
+                        return request.getContentLength();
+                    }
+
+                    public long getContentLengthLong() {
+                        return request.getContentLengthLong();
+                    }
+
+                    public String getContentType() {
+                        return request.getContentType();
+                    }
+
+                    public ServletInputStream getInputStream() throws IOException {
+                        return request.getInputStream();
+                    }
+
+                    public String getParameter(String s) {
+                        return request.getParameter(s);
+                    }
+
+                    public Enumeration<String> getParameterNames() {
+                        return request.getParameterNames();
+                    }
+
+                    public String[] getParameterValues(String s) {
+                        return request.getParameterValues(s);
+                    }
+
+                    public Map<String, String[]> getParameterMap() {
+                        return request.getParameterMap();
+                    }
+
+                    public String getProtocol() {
+                        return request.getProtocol();
+                    }
+
+                    public String getScheme() {
+                        return request.getScheme();
+                    }
+
+                    public String getServerName() {
+                        return request.getServerName();
+                    }
+
+                    public int getServerPort() {
+                        return request.getServerPort();
+                    }
+
+                    public BufferedReader getReader() throws IOException {
+                        return request.getReader();
+                    }
+
+                    public String getRemoteAddr() {
+                        return request.getRemoteAddr();
+                    }
+
+                    public String getRemoteHost() {
+                        return request.getRemoteHost();
+                    }
+
+                    public void setAttribute(String s, Object o) {
+                        request.setAttribute(s, o);
+                    }
+
+                    public void removeAttribute(String s) {
+                        request.removeAttribute(s);
+                    }
+
+                    public Locale getLocale() {
+                        return request.getLocale();
+                    }
+
+                    public Enumeration<Locale> getLocales() {
+                        return request.getLocales();
+                    }
+
+                    public boolean isSecure() {
+                        return request.isSecure();
+                    }
+
+                    public RequestDispatcher getRequestDispatcher(String s) {
+                        return request.getRequestDispatcher(s);
+                    }
+
+                    public String getRealPath(String s) {
+                        return request.getRealPath(s);
+                    }
+
+                    public int getRemotePort() {
+                        return request.getRemotePort();
+                    }
+
+                    public String getLocalName() {
+                        return request.getLocalName();
+                    }
+
+                    public String getLocalAddr() {
+                        return request.getLocalAddr();
+                    }
+
+                    public int getLocalPort() {
+                        return request.getLocalPort();
+                    }
+
+                    public ServletContext getServletContext() {
+                        return request.getServletContext();
+                    }
+
+                    public AsyncContext startAsync() throws IllegalStateException {
+                        return request.startAsync();
+                    }
+
+                    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
+                        return request.startAsync(servletRequest, servletResponse);
+                    }
+
+                    public boolean isAsyncStarted() {
+                        return request.isAsyncStarted();
+                    }
+
+                    public boolean isAsyncSupported() {
+                        return request.isAsyncSupported();
+                    }
+
+                    public AsyncContext getAsyncContext() {
+                        return request.getAsyncContext();
+                    }
+
+                    public DispatcherType getDispatcherType() {
+                        return request.getDispatcherType();
+                    }
+                };
+                */
+
+                final Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+                Authentication fakeAuthentication = new Authentication() {
+                    @Override
+                    public Collection<? extends GrantedAuthority> getAuthorities() {
+                        Collection<GrantedAuthority> authorities = new LinkedList<GrantedAuthority>();
+
+                        if ("admin".equalsIgnoreCase(fakeUsername)) {
+                            GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ADMIN");
+                            authorities.add(grantedAuthority);
+                        }
+
+                        return authorities;
+                    }
+
+                    // delegate the rest of the methods:
+                    public Object getCredentials() {
+                        return authentication.getCredentials();
+                    }
+
+                    public Object getDetails() {
+                        return authentication.getDetails();
+                    }
+
+                    public Object getPrincipal() {
+                        return authentication.getPrincipal();
+                    }
+
+                    public boolean isAuthenticated() {
+                        return authentication.isAuthenticated();
+                    }
+
+                    public void setAuthenticated(boolean b) throws IllegalArgumentException {
+                        authentication.setAuthenticated(b);
+                    }
+
+                    public String getName() {
+                        return authentication.getName();
+                    }
+                };
+                SecurityContextHolder.getContext().setAuthentication(fakeAuthentication);
+
+                filterChain.doFilter(request, response);
+            }
+        }
+    }
+
+    @Override
+    public void destroy() {
+        // do nothing
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/security/SecurityConfig.java

@@ -0,0 +1,47 @@
+package @app.group.id@.@app.name@.security;
+
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.web.SecurityFilterChain;
+
+import jakarta.servlet.DispatcherType;
+import jakarta.servlet.Filter;
+import java.util.Collections;
+
+@EnableWebSecurity
+public class SecurityConfig {
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http.authorizeHttpRequests((authz) -> authz
+                .requestMatchers(HttpMethod.DELETE, "/api/buildings")
+                .hasRole("ADMIN")
+                .anyRequest()
+                .permitAll()
+                );
+        return http.build();
+    }
+
+    @Bean
+    public FilterRegistrationBean csrfPreventionFilter() {
+        FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>();
+        registration.setFilter(new CsrfPreventionFilter());
+        registration.setUrlPatterns(Collections.singleton("/api/*"));
+        registration.setDispatcherTypes(DispatcherType.REQUEST);
+
+        return registration;
+    }
+
+    @Bean
+    public FilterRegistrationBean cachingPreventionFilter() {
+        FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>();
+        registration.setFilter(new CachingPreventionFilter());
+        registration.setUrlPatterns(Collections.singleton("/api/*"));
+        registration.setDispatcherTypes(DispatcherType.REQUEST);
+
+        return registration;
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/services/BuildingSearchCriteria.java

@@ -0,0 +1,26 @@
+package @app.group.id@.@app.name@.services;
+
+import org.springframework.util.Assert;
+
+import java.io.Serializable;
+
+public class BuildingSearchCriteria implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private String name;
+
+    public BuildingSearchCriteria() {
+    }
+
+    public BuildingSearchCriteria(String name) {
+        Assert.notNull(name, "The name of the building should not be null.");
+        this.name = name;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/services/BuildingService.java

@@ -0,0 +1,10 @@
+package @app.group.id@.@app.name@.services;
+
+import @app.group.id@.@app.name@.domain.Building;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface BuildingService {
+    Page<Building> findAll(Pageable pageable);
+    Page<Building> find(BuildingSearchCriteria criteria, Pageable pageable);
+}

package/lib/skeletons/web-spring-boot/myapp-web-rest/src/main/java/myapp/services/BuildingServiceImpl.java

@@ -0,0 +1,26 @@
+package @app.group.id@.@app.name@.services;
+
+import @app.group.id@.@app.name@.domain.Building;
+import @app.group.id@.@app.name@.repositories.BuildingRepository;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Component;
+
+@Component()
+public class BuildingServiceImpl implements BuildingService {
+    private BuildingRepository buildingRepository;
+
+    public BuildingServiceImpl(BuildingRepository buildingRepository) {
+        this.buildingRepository = buildingRepository;
+    }
+
+    @Override
+    public Page<Building> findAll(Pageable pageable) {
+        return buildingRepository.findAll(pageable);
+    }
+
+    @Override
+    public Page<Building> find(BuildingSearchCriteria criteria, Pageable pageable) {
+        return buildingRepository.findByNameContainingAllIgnoringCase(criteria.getName(), pageable);
+    }
+}