#119 Native Sublinks API

src/main/java/com/sublinks/sublinksapi/SublinksApiApplication.java

@@ -34,13 +34,17 @@ public static void main(String[] args) {
   @Bean
   public OpenAPI customOpenAPI() {
 
-    return new OpenAPI().components(new Components().addSecuritySchemes("bearerAuth",
-        new SecurityScheme().type(SecurityScheme.Type.HTTP).scheme("bearer").bearerFormat("JWT")));
+    return new OpenAPI()
+        .components(new Components()
+            .addSecuritySchemes("bearerAuth",
+                new SecurityScheme()
+                    .type(SecurityScheme.Type.HTTP)
+                    .scheme("bearer")
+                    .bearerFormat("JWT")));
   }
 
   @Bean
-  public GroupedOpenApi v3OpenApi(@Value("${springdoc.version}") String appVersion,
-      @Value("${springdoc.pathsToMatch}") String pathsToMatch,
+  public GroupedOpenApi v3LemmyApi(@Value("${springdoc.version}") String appVersion,
       @Value("#{${springdoc.servers}}") List<String> servers) {
 
     return GroupedOpenApi.builder()
@@ -52,7 +56,24 @@ public GroupedOpenApi v3OpenApi(@Value("${springdoc.version}") String appVersion
         .addOpenApiCustomizer(openApi -> openApi.info(
                 new Info().title("Lemmy OpenAPI Documentation").version(appVersion))
             .servers(servers.stream().map(s -> new Server().url(s)).toList()))
-        .pathsToMatch(pathsToMatch)
+        .pathsToMatch("/api/v3/**")
+        .build();
+  }
+
+  @Bean
+  public GroupedOpenApi v1SublinksApi(@Value("${springdoc.version}") String appVersion,
+      @Value("#{${springdoc.servers}}") List<String> servers) {
+
+    return GroupedOpenApi.builder().group("v1")
+        .addOperationCustomizer((operation, handlerMethod) -> {
+          operation.addSecurityItem(new SecurityRequirement().addList("bearerAuth"));
+          return operation;
+        })
+        .addOpenApiCustomizer(openApi -> openApi.info(new Info()
+                .title("OpenAPI Documentation")
+                .version(appVersion))
+            .servers(servers.stream().map(s -> new Server().url(s)).toList()))
+        .pathsToMatch("/api/v1/**")
         .build();
   }
 }

src/main/java/com/sublinks/sublinksapi/api/lemmy/v3/site/controllers/SiteController.java

@@ -148,9 +148,7 @@ public SiteResponse createSite(@Valid @RequestBody final CreateSite createSiteFo
     config.reportEmailAdmins(false);
 
     final InstanceConfig instanceConfig = config.build();
-
     instanceConfigService.createInstanceConfig(instanceConfig);
-
     slurFilterService.updateOrCreateLemmySlur(createSiteForm.slur_filter_regex());
 
     instance.setInstanceConfig(instanceConfig);

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/annoucement/controllers/AnnouncementController.java

@@ -0,0 +1,61 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.annoucement.controllers;
+
+import com.sublinks.sublinksapi.api.sublinks.v1.common.controllers.AbstractSublinksApiController;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@RequestMapping("api/v1/announcement")
+@Tag(name = "Announcement", description = "Announcement API")
+public class AnnouncementController extends AbstractSublinksApiController {
+
+  @Operation(summary = "Get a list of announcements")
+  @GetMapping
+  @ApiResponses(value = {
+      // TODO: add responses
+  })
+  public void index() {
+    // TODO: implement
+  }
+
+  @Operation(summary = "Get a specific announcement")
+  @GetMapping("/{id}")
+  @ApiResponses(value = {
+      // TODO: add responses
+  })
+  public void show(@PathVariable String id) {
+    // TODO: implement
+  }
+
+  @Operation(summary = "Create a new announcement")
+  @PostMapping
+  @ApiResponses(value = {
+      // TODO: add responses
+  })
+  public void create() {
+    // TODO: implement
+  }
+
+  @Operation(summary = "Update an announcement")
+  @PostMapping("/{id}")
+  @ApiResponses(value = {
+      // TODO: add responses
+  })
+  public void update(@PathVariable String id) {
+    // TODO: implement
+  }
+
+  @Operation(summary = "Delete an announcement")
+  @DeleteMapping("/{id}")
+  @ApiResponses(value = {
+      // TODO: add responses
+  })
+  public void delete(@PathVariable String id) {
+    // TODO: implement
+  }
+}

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/annoucement/models/CommentResponseDto.java

@@ -0,0 +1,13 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.annoucement.models;
+
+public record CommentResponseDto(
+    String id,
+    String postId,
+    String personId,
+    String communityId,
+    String content,
+    String createdAt,
+    String updatedAt
+) {
+
+}

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/authentication/JwtFilter.java

@@ -0,0 +1,90 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.authentication;
+
+import com.sublinks.sublinksapi.person.entities.Person;
+import com.sublinks.sublinksapi.person.repositories.PersonRepository;
+import com.sublinks.sublinksapi.person.services.UserDataService;
+import io.jsonwebtoken.ExpiredJwtException;
+import io.jsonwebtoken.security.SignatureException;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.core.annotation.Order;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+@Component
+@RequiredArgsConstructor
+@Order(1)
+public class JwtFilter extends OncePerRequestFilter {
+
+  private final JwtUtil jwtUtil;
+  private final PersonRepository personRepository;
+  private final UserDataService userDataService;
+
+  @Override
+  protected void doFilterInternal(final HttpServletRequest request,
+      final HttpServletResponse response, final FilterChain filterChain)
+      throws ServletException, IOException {
+
+    String authorizingToken = request.getHeader("Authorization");
+
+    if (authorizingToken == null && request.getCookies() != null) {
+      for (Cookie cookie : request.getCookies()) {
+        if (cookie.getName().equals("jwt")) {
+          authorizingToken = cookie.getValue();
+          break;
+        }
+      }
+
+    }
+
+    String token = null;
+    String userName = null;
+
+    try {
+      if (authorizingToken != null) {
+        if (authorizingToken.startsWith("Bearer ")) {
+          token = authorizingToken.substring(7);
+        } else {
+          token = authorizingToken;
+        }
+        userName = jwtUtil.extractUsername(token);
+      }
+    } catch (ExpiredJwtException | SignatureException ex) {
+      response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "invalid_token");
+    }
+
+    if (userName != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+      final Optional<Person> person = personRepository.findOneByName(userName);
+      if (person.isEmpty()) {
+        throw new UsernameNotFoundException("Invalid name");
+      }
+
+      if (jwtUtil.validateToken(token, person.get())) {
+
+        // Add a check if token and ip was changed? To give like a "warning" to the user that he has a new ip logged into his account
+        userDataService.checkAndAddIpRelation(person.get(), request.getRemoteAddr(), token,
+            request.getHeader("User-Agent"));
+        final JwtPerson authenticationToken = new JwtPerson(person.get(),
+            person.get().getAuthorities());
+        authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
+      }
+    }
+    filterChain.doFilter(request, response);
+  }
+
+  @Override
+  protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
+
+    return !request.getServletPath().startsWith("/api/v3");
+  }
+}

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/authentication/JwtPerson.java

@@ -0,0 +1,30 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.authentication;
+
+import com.sublinks.sublinksapi.person.entities.Person;
+import java.util.Collection;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.core.GrantedAuthority;
+
+public class JwtPerson extends AbstractAuthenticationToken {
+
+  private final Person person;
+
+  public JwtPerson(final Person person, final Collection<? extends GrantedAuthority> authorities) {
+
+    super(authorities);
+    this.person = person;
+    setAuthenticated(true);
+  }
+
+  @Override
+  public Object getCredentials() {
+
+    return null;
+  }
+
+  @Override
+  public Object getPrincipal() {
+
+    return this.person;
+  }
+}

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/authentication/JwtUtil.java

@@ -0,0 +1,84 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.authentication;
+
+import com.sublinks.sublinksapi.person.entities.Person;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+import java.io.Serial;
+import java.io.Serializable;
+import java.security.Key;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import javax.crypto.SecretKey;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class JwtUtil implements Serializable {
+
+  public static final long JWT_TOKEN_VALIDITY = 24 * 60 * 60;
+  @Serial
+  private static final long serialVersionUID = -2550185165626007488L;
+  private final String secret;
+
+  public JwtUtil(@Value("${jwt.secret}") final String secret) {
+
+    this.secret = secret;
+  }
+
+  public String generateToken(final Person person) {
+
+    final Map<String, Object> claims = new HashMap<>();
+    return doGenerateToken(claims, person.getUsername());
+  }
+
+  public Boolean validateToken(final String token, final Person person) {
+
+    final String tokenUsername = extractUsername(token);
+    return (tokenUsername.equals(person.getUsername()) && !isTokenExpired(token));
+  }
+
+  public String extractUsername(final String token) {
+
+    return extractClaim(token, Claims::getSubject);
+  }
+
+  public Date extractExpiration(final String token) {
+
+    return extractClaim(token, Claims::getExpiration);
+  }
+
+  public <T> T extractClaim(final String token, final Function<Claims, T> claimsResolver) {
+
+    final Claims claims = extractAllClaims(token);
+    return claimsResolver.apply(claims);
+  }
+
+  private Claims extractAllClaims(final String token) {
+
+    final SecretKey key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(secret));
+    return Jwts.parser().verifyWith(key).build().parseSignedClaims(token).getPayload();
+  }
+
+  private Boolean isTokenExpired(final String token) {
+
+    return extractExpiration(token).before(new Date());
+  }
+
+  private String doGenerateToken(final Map<String, Object> claims, final String subject) {
+
+    final byte[] keyBytes = Decoders.BASE64.decode(secret);
+    final Key key = Keys.hmacShaKeyFor(keyBytes);
+    return Jwts.builder()
+        .claims(claims)
+        .subject(subject)
+        .issuedAt(new Date(System.currentTimeMillis()))
+        .expiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))
+        .signWith(key)
+        .compact();
+  }
+
+}

src/main/java/com/sublinks/sublinksapi/api/sublinks/v1/authentication/config/SecurityConfig.java

@@ -0,0 +1,36 @@
+package com.sublinks.sublinksapi.api.sublinks.v1.authentication.config;
+
+import com.sublinks.sublinksapi.api.sublinks.v1.authentication.JwtFilter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+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.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+  private final JwtFilter jwtFilter;
+
+  @Bean
+  public SecurityFilterChain filterChain(final HttpSecurity http) throws Exception {
+
+    http
+        .csrf(AbstractHttpConfigurer::disable)
+        .authorizeHttpRequests((requests) -> requests
+            .anyRequest().permitAll()
+        )
+        .sessionManagement(
+            (sessionManagement) -> sessionManagement.sessionCreationPolicy(
+                SessionCreationPolicy.STATELESS)
+        )
+        .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
+    return http.build();
+  }
+}