This commit is contained in:
2026-10-06 14:32:54 +03:00
parent 65003b6119
commit b95197a6fc
75 changed files with 4403 additions and 28 deletions
+4
View File
@@ -0,0 +1,4 @@
/gradlew text eol=lf
*.bat text eol=crlf
*.jar binary
scripts/*.sh text eol=lf
+114 -28
View File
@@ -1,32 +1,118 @@
# Local/private state
/target/
!.mvn/wrapper/maven-wrapper.jar
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
# Created by https://www.gitignore.io/api/git,java,maven,eclipse,windows
### Git ###
# Created by git for backups. To disable backups in Git:
# $ git config --global mergetool.keepBackup false
*.orig
# Created by git when using merge tools for conflicts
*.BACKUP.*
*.BASE.*
*.LOCAL.*
*.REMOTE.*
*_BACKUP_*.txt
*_BASE_*.txt
*_LOCAL_*.txt
*_REMOTE_*.txt
### Java ###
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
### Windows ###
# Windows thumbnail cache files
Thumbs.db
ehthumbs.db
ehthumbs_vista.db
# Dump file
*.stackdump
# Folder config file
[Dd]esktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Windows Installer files
*.cab
*.msi
*.msix
*.msm
*.msp
# Windows shortcuts
*.lnk
### IntelliJ IDEA ###
SpringTech/.idea
*.iws
*.iml
*.ipr
### VS Code ###
.vscode/
### Some additional ignores (sort later)
*.DS_Store
*.sw?
.#*
*#
*~
.classpath
.project
.settings
bin
/build/*
target
dependency-reduced-pom.xml
*.sublime-*
/scratch
.gradle
README.html
*.iml
.idea
.exercism
# Environment
.env
.env.*
!.env.example
secrets/
certs/private/
*.key
*.p12
*.pfx
*.jks
*.pem
*.tfstate*
volumes/
data/
backups/
# Runtime/build artifacts
.venv/
__pycache__/
*.py[cod]
node_modules/
dist/
build/
target/
bin/
obj/
coverage/
*.log
.DS_Store
.idea/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
*.pyc
!gradle/wrapper/gradle-wrapper.jar
secrets/
+20
View File
@@ -0,0 +1,20 @@
FROM eclipse-temurin:21-jdk-jammy AS builder
WORKDIR /build
COPY gradle gradle
COPY gradlew settings.gradle build.gradle ./
RUN ./gradlew dependencies --no-daemon
COPY contracts contracts
COPY src src
RUN ./gradlew bootJar -x test --no-daemon
FROM eclipse-temurin:21-jre-alpine AS runner
WORKDIR /app
RUN addgroup -S spring && adduser -S spring -G spring
COPY --from=builder /build/build/libs/*.jar app.jar
RUN chown spring:spring app.jar
USER spring
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \
CMD wget -qO- http://127.0.0.1:8080/actuator/health/readiness | grep -q UP || exit 1
ENV JAVA_OPTS="-XX:MaxRAMPercentage=75 -Xss512k"
ENTRYPOINT ["sh", "-c", "exec java -Dfile.encoding=UTF-8 $JAVA_OPTS -jar app.jar"]
+63
View File
@@ -0,0 +1,63 @@
plugins {
id 'java'
id 'org.springframework.boot' version '4.1.1'
id 'io.spring.dependency-management' version '1.1.7'}
group = 'ru.mtusi'
version = '0.0.1-SNAPSHOT'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(21)
}
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation 'org.springframework.boot:spring-boot-starter-webmvc'
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:3.1.0'
implementation 'com.bucket4j:bucket4j-core:8.10.1'
implementation 'org.mapstruct:mapstruct:1.6.3'
// Source: https://mvnrepository.com/artifact/org.postgresql/postgresql
implementation 'org.postgresql:postgresql:42.7.13'
implementation 'org.springframework.boot:spring-boot-starter-flyway'
runtimeOnly 'org.flywaydb:flyway-database-postgresql'
// Source: https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa
implementation 'org.springframework.boot:spring-boot-starter-data-jpa:4.1.1'
// Source: https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis
implementation 'org.springframework.boot:spring-boot-starter-data-redis:4.1.1'
implementation 'org.springframework.security:spring-security-crypto'
implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-oauth2-resource-server'
implementation 'com.fasterxml.jackson.core:jackson-databind'
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
testImplementation 'org.springframework.boot:spring-boot-starter-test:4.1.1'
testImplementation 'org.springframework.boot:spring-boot-starter-restclient-test'
testImplementation 'org.springframework.boot:spring-boot-resttestclient'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.mapstruct:mapstruct-processor:1.6.3'
annotationProcessor 'org.projectlombok:lombok-mapstruct-binding:0.2.0'
annotationProcessor 'org.projectlombok:lombok'
testCompileOnly 'org.projectlombok:lombok'
testAnnotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-starter-actuator-test'
testImplementation 'org.springframework.boot:spring-boot-starter-validation-test'
testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
tasks.named('test') {
useJUnitPlatform()
}
+68
View File
@@ -0,0 +1,68 @@
services:
db:
image: postgres:16-alpine
container_name: messenger-db
restart: unless-stopped
environment:
POSTGRES_DB_FILE: /run/secrets/postgres_db
POSTGRES_USER_FILE: /run/secrets/postgres_user
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
secrets:
- postgres_db
- postgres_user
- postgres_password
networks:
- messenger-net
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$(cat /run/secrets/postgres_user) -d $$(cat /run/secrets/postgres_db)"]
interval: 5s
timeout: 5s
retries: 10
start_period: 10s
api:
build:
context: .
dockerfile: Dockerfile
container_name: messenger-api
restart: unless-stopped
depends_on:
db:
condition: service_healthy
environment:
SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/messenger
SPRING_DATASOURCE_USERNAME_FILE: /run/secrets/postgres_user
SPRING_DATASOURCE_PASSWORD_FILE: /run/secrets/postgres_password
SPRING_PROFILES_ACTIVE: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-400}
SESSION_STORE: ${SESSION_STORE:-postgres}
ports:
- "127.0.0.1:8080:8080"
secrets:
- postgres_user
- postgres_password
networks:
- messenger-net
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8080/health/ready | grep -q '\"status\":\"ok\"'"]
interval: 5s
timeout: 3s
retries: 20
start_period: 40s
volumes:
pgdata:
networks:
messenger-net:
driver: bridge
secrets:
postgres_db:
file: ./secrets/postgres_db.txt
postgres_user:
file: ./secrets/postgres_user.txt
postgres_password:
file: ./secrets/postgres_password.txt
Binary file not shown.
+9
View File
@@ -0,0 +1,9 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
networkTimeout=10000
retries=0
retryBackOffMs=500
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
Vendored
+248
View File
@@ -0,0 +1,248 @@
#!/bin/sh
#
# Copyright © 2015 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#
##############################################################################
#
# gradlew start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh gradlew
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
if ! command -v java >/dev/null 2>&1
then
die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"
Vendored
+82
View File
@@ -0,0 +1,82 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem gradlew startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables, and ensure extensions are enabled
setlocal EnableExtensions
set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
"%COMSPEC%" /c exit 1
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
"%COMSPEC%" /c exit 1
:execute
@rem Setup the command line
@rem Execute gradlew
@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
@rem which allows us to clear the local environment before executing the java command
endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
:exitWithErrorLevel
@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
"%COMSPEC%" /c exit %ERRORLEVEL%
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
# Restart API and all state stores used in lab2 (Postgres).
# Preserve persistent volumes and data: never `down -v`, never flush or re-seed.
# Exit 0 only after issuing the restart; the test waits for API readiness separately.
docker compose --env-file .env restart api db
+1
View File
@@ -0,0 +1 @@
rootProject.name = 'messenger-lab1'
@@ -0,0 +1,16 @@
package ru.mtusi.messenger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.boot.security.autoconfigure.UserDetailsServiceAutoConfiguration;
@ConfigurationPropertiesScan
@SpringBootApplication(exclude = UserDetailsServiceAutoConfiguration.class)
public class MessengerLab1Application {
public static void main(String[] args) {
SpringApplication.run(MessengerLab1Application.class, args);
}
}
@@ -0,0 +1,8 @@
package ru.mtusi.messenger.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "app.limits")
public record AppProperties(
int maxMessagesPerChat
) {}
@@ -0,0 +1,20 @@
package ru.mtusi.messenger.config;
import io.swagger.v3.oas.annotations.enums.SecuritySchemeType;
import io.swagger.v3.oas.annotations.security.SecurityScheme;
import org.springframework.context.annotation.Configuration;
@Configuration
@SecurityScheme(
name = "basicAuth",
type = SecuritySchemeType.HTTP,
scheme = "basic"
)
@SecurityScheme(
name = "bearerAuth",
type = SecuritySchemeType.HTTP,
scheme = "bearer",
bearerFormat = "opaque session token"
)
public class OpenApiConfig {
}
@@ -0,0 +1,24 @@
package ru.mtusi.messenger.config;
import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;
@Configuration
@RequiredArgsConstructor
public class RateLimitConfig {
private final RateLimitProperties props;
@Bean
public Bucket rateLimitBucket() {
Bandwidth limit = Bandwidth.builder()
.capacity(props.ratePerMinute())
.refillGreedy(props.ratePerMinute(), Duration.ofMinutes(1))
.build();
return Bucket.builder().addLimit(limit).build();
}
}
@@ -0,0 +1,6 @@
package ru.mtusi.messenger.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "app.rate")
public record RateLimitProperties(int ratePerMinute, int retryAfterSeconds) {}
@@ -0,0 +1,74 @@
package ru.mtusi.messenger.config;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import ru.mtusi.messenger.security.ApiAuthenticationEntryPoint;
import ru.mtusi.messenger.security.SessionAuthenticationFilter;
import ru.mtusi.messenger.security.SessionAuthenticationProvider;
import org.springframework.security.oauth2.server.resource.web.BearerTokenResolver;
import org.springframework.security.oauth2.server.resource.web.DefaultBearerTokenResolver;
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {
private final SessionAuthenticationProvider sessionAuthenticationProvider;
private final ApiAuthenticationEntryPoint entryPoint;
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public AuthenticationManager authenticationManager() {
return new ProviderManager(sessionAuthenticationProvider);
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http,
AuthenticationManager authenticationManager,
BearerTokenResolver bearerTokenResolver) throws Exception {
SessionAuthenticationFilter sessionFilter =
new SessionAuthenticationFilter(bearerTokenResolver, authenticationManager);
http
.csrf(AbstractHttpConfigurer::disable)
.httpBasic(AbstractHttpConfigurer::disable)
.formLogin(AbstractHttpConfigurer::disable)
.logout(AbstractHttpConfigurer::disable)
.sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers("/health/**").permitAll()
.requestMatchers(
"/swagger-ui.html",
"/swagger-ui/**",
"/v3/api-docs",
"/v3/api-docs/**"
).permitAll()
.requestMatchers(HttpMethod.POST, "/api/v1/users").permitAll()
.requestMatchers(HttpMethod.POST, "/api/v1/auth/sessions").permitAll()
.anyRequest().authenticated())
.addFilterBefore(sessionFilter, UsernamePasswordAuthenticationFilter.class)
.exceptionHandling(eh -> eh.authenticationEntryPoint(entryPoint));
return http.build();
}
@Bean
public BearerTokenResolver bearerTokenResolver() {
return new DefaultBearerTokenResolver();
}
}
@@ -0,0 +1,10 @@
package ru.mtusi.messenger.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.time.Duration;
@ConfigurationProperties(prefix = "app.session")
public record SessionProperties(
Duration ttl
) {}
@@ -0,0 +1,118 @@
/**
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech) (7.10.0).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package ru.mtusi.messenger.controller;
import ru.mtusi.messenger.dto.SessionDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import jakarta.annotation.Generated;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
@Validated
@Tag(name = "Auth", description = "Аутентификация: вход по Basic и выдача/отзыв сессионного Bearer-токена.")
@RequestMapping("${openapi.mTUSIMessenger2.base-path:}")
public interface AuthApi {
/**
* POST /api/v1/auth/sessions : Вход: Basic username:password; выдаёт сессию
*
* @return Успех (status code 201)
* or Неверный запрос (status code 400)
* or Нет действительной аутентификации (status code 401)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "createSession",
summary = "Вход: Basic username:password; выдаёт сессию",
tags = { "Auth" },
responses = {
@ApiResponse(responseCode = "201", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = SessionDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
})
},
security = {
@SecurityRequirement(name = "basicAuth")
}
)
@RequestMapping(
method = RequestMethod.POST,
value = "/api/v1/auth/sessions",
produces = { "application/json" }
)
ResponseEntity<SessionDTO> createSession(
);
/**
* DELETE /api/v1/auth/sessions/current : Отозвать текущую сессию
*
* @return Успех (status code 204)
* or Нет действительной аутентификации (status code 401)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "revokeSession",
summary = "Отозвать текущую сессию",
tags = { "Auth" },
responses = {
@ApiResponse(responseCode = "204", description = "Успех"),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.DELETE,
value = "/api/v1/auth/sessions/current",
produces = { "application/json" }
)
ResponseEntity<Void> revokeSession(
);
}
@@ -0,0 +1,28 @@
package ru.mtusi.messenger.controller;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;
import ru.mtusi.messenger.dto.SessionDTO;
import ru.mtusi.messenger.service.AuthService;
@RestController
@RequiredArgsConstructor
public class AuthController implements AuthApi {
private final AuthService authService;
private final HttpServletRequest request;
@Override
public ResponseEntity<SessionDTO> createSession() {
return ResponseEntity.status(HttpStatus.CREATED).body(authService.login(request.getHeader(HttpHeaders.AUTHORIZATION)));
}
@Override
public ResponseEntity<Void> revokeSession() {
authService.logout();
return ResponseEntity.noContent().build();
}
}
@@ -0,0 +1,35 @@
package ru.mtusi.messenger.controller;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.RestController;
import ru.mtusi.messenger.dto.ChatDTO;
import ru.mtusi.messenger.dto.ChatPageDTO;
import ru.mtusi.messenger.security.SessionPrincipal;
import ru.mtusi.messenger.service.ChatService;
import java.util.UUID;
@RestController
@RequiredArgsConstructor
public class ChatController implements ChatsApi {
private final ChatService chatService;
@Override
public ResponseEntity<ChatDTO> createChat(ChatDTO chatDTO, @AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.status(HttpStatus.CREATED)
.body(chatService.createChat(principal.userId(), chatDTO));
}
@Override
public ResponseEntity<ChatDTO> getChat(UUID chatId , @AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.ok(chatService.getChat(principal.userId(), chatId));
}
@Override
public ResponseEntity<ChatPageDTO> listChats(Integer limit, String cursor , @AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.ok(chatService.listChats(principal.userId(), limit, cursor));
}
}
@@ -0,0 +1,215 @@
/**
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech) (7.10.0).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package ru.mtusi.messenger.controller;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import ru.mtusi.messenger.dto.ChatDTO;
import ru.mtusi.messenger.dto.ChatPageDTO;
import ru.mtusi.messenger.dto.ErrorDTO;
import java.util.UUID;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import jakarta.annotation.Generated;
import ru.mtusi.messenger.security.SessionPrincipal;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
@Validated
@Tag(name = "Chats", description = "Управление чатами и доступ к чатам текущего пользователя.")
@RequestMapping("${openapi.mTUSIMessenger2.base-path:}")
public interface ChatsApi {
/**
* POST /api/v1/chats : Создать чат; вызывающий должен входить в member_ids
*
* @param chatDTO (required)
* @return Успех (status code 201)
* or Неверный запрос (status code 400)
* or Нет действительной аутентификации (status code 401)
* or Объект отсутствует или недоступен (status code 404)
* or Конфликт (status code 409)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "createChat",
summary = "Создать чат; вызывающий должен входить в member_ids",
tags = { "Chats" },
responses = {
@ApiResponse(responseCode = "201", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ChatDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.POST,
value = "/api/v1/chats",
produces = { "application/json" },
consumes = { "application/json" }
)
ResponseEntity<ChatDTO> createChat(
@Parameter(name = "CreateChatDTO", description = "", required = true) @Valid @RequestBody ChatDTO chatDTO, @AuthenticationPrincipal SessionPrincipal principal
);
/**
* GET /api/v1/chats/{chat_id} : Получить доступный чат
*
* @param chatId (required)
* @return Успех (status code 200)
* or Неверный запрос (status code 400)
* or Нет действительной аутентификации (status code 401)
* or Объект отсутствует или недоступен (status code 404)
* or Конфликт (status code 409)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "getChat",
summary = "Получить доступный чат",
tags = { "Chats" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ChatDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/api/v1/chats/{chat_id}",
produces = { "application/json" }
)
ResponseEntity<ChatDTO> getChat(
@Parameter(name = "chat_id", description = "", required = true, in = ParameterIn.PATH) @PathVariable("chat_id") UUID chatId,
@AuthenticationPrincipal SessionPrincipal principal
);
/**
* GET /api/v1/chats : Чаты текущего пользователя
*
* @param limit (optional, default to 50)
* @param cursor (optional)
* @return Успех (status code 200)
* or Неверный запрос (status code 400)
* or Нет действительной аутентификации (status code 401)
* or Объект отсутствует или недоступен (status code 404)
* or Конфликт (status code 409)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "listChats",
summary = "Чаты текущего пользователя",
tags = { "Chats" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ChatPageDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/api/v1/chats",
produces = { "application/json" }
)
ResponseEntity<ChatPageDTO> listChats(
@Min(1) @Max(100) @Parameter(name = "limit", description = "", in = ParameterIn.QUERY) @Valid @RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit,
@Size(min = 1) @Parameter(name = "cursor", description = "", in = ParameterIn.QUERY) @Valid @RequestParam(value = "cursor", required = false) String cursor,
@AuthenticationPrincipal SessionPrincipal principal
);
}
@@ -0,0 +1,89 @@
/**
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech) (7.10.0).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package ru.mtusi.messenger.controller;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import jakarta.annotation.Generated;
import ru.mtusi.messenger.dto.HealthDTO;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
@Validated
@Tag(name = "Health", description = "Проверки живости и готовности процесса. Публичные, без аутентификации.")
@RequestMapping("${openapi.mTUSIMessenger2.base-path:}")
public interface HealthApi {
/**
* GET /health/live : Процесс жив
*
* @return Успех (status code 200)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "liveness",
summary = "Процесс жив",
tags = { "Health" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = HealthDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
})
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/health/live",
produces = { "application/json" }
)
ResponseEntity<HealthDTO> liveness(
);
/**
* GET /health/ready : Готов принимать трафик
*
* @return Успех (status code 200)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "readiness",
summary = "Готов принимать трафик",
tags = { "Health" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = HealthDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = Error.class))
})
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/health/ready",
produces = { "application/json" }
)
ResponseEntity<HealthDTO> readiness(
);
}
@@ -0,0 +1,26 @@
package ru.mtusi.messenger.controller;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;
import ru.mtusi.messenger.dto.HealthDTO;
@RestController
public class HealthController implements HealthApi {
private static final HealthDTO OK = createOk();
@Override
public ResponseEntity<HealthDTO> liveness() {
return ResponseEntity.ok(OK);
}
@Override
public ResponseEntity<HealthDTO> readiness() {
return ResponseEntity.ok(OK);
}
private static HealthDTO createOk() {
HealthDTO h = new HealthDTO();
h.setStatus(HealthDTO.StatusEnum.OK);
return h;
}
}
@@ -0,0 +1,29 @@
package ru.mtusi.messenger.controller;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.RestController;
import ru.mtusi.messenger.dto.MessageDTO;
import ru.mtusi.messenger.dto.MessagePageDTO;
import ru.mtusi.messenger.security.SessionPrincipal;
import ru.mtusi.messenger.service.MessageService;
import java.util.UUID;
@RestController
@RequiredArgsConstructor
public class MessageController implements MessagesApi {
private final MessageService messageService;
@Override
public ResponseEntity<MessageDTO> createMessage(UUID chatId, MessageDTO messageDTO, @AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.status(HttpStatus.CREATED).body(messageService.createMessage(principal.userId(), chatId, messageDTO));
}
@Override
public ResponseEntity<MessagePageDTO> listMessages(UUID chatId, Integer limit, String cursor, @AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.ok(messageService.listMessages(principal.userId(), chatId, limit, cursor));
}
}
@@ -0,0 +1,135 @@
/**
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech) (7.10.0).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package ru.mtusi.messenger.controller;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import ru.mtusi.messenger.dto.MessageDTO;
import ru.mtusi.messenger.dto.ErrorDTO;
import ru.mtusi.messenger.dto.MessagePageDTO;
import ru.mtusi.messenger.security.SessionPrincipal;
import java.util.UUID;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import jakarta.annotation.Generated;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
@Validated
@Tag(name = "Messages", description = "Отправка и чтение сообщений внутри доступного чата.")
@RequestMapping("${openapi.mTUSIMessenger2.base-path:}")
public interface MessagesApi {
@Operation(
operationId = "createMessage",
summary = "Отправить сообщение",
tags = { "Messages" },
responses = {
@ApiResponse(responseCode = "201", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = MessageDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.POST,
value = "/api/v1/chats/{chat_id}/messages",
produces = { "application/json" },
consumes = { "application/json" }
)
ResponseEntity<MessageDTO> createMessage(
@Parameter(name = "chat_id", description = "", required = true, in = ParameterIn.PATH)
@PathVariable("chat_id") UUID chatId,
@Parameter(name = "MessageDTO", description = "", required = true)
@Valid @RequestBody MessageDTO messageDTO,
@AuthenticationPrincipal SessionPrincipal principal
);
@Operation(
operationId = "listMessages",
summary = "Сообщения по (created_at, id) по возрастанию",
tags = { "Messages" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = MessagePageDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/api/v1/chats/{chat_id}/messages",
produces = { "application/json" }
)
ResponseEntity<MessagePageDTO> listMessages(
@Parameter(name = "chat_id", description = "", required = true, in = ParameterIn.PATH)
@PathVariable("chat_id") UUID chatId,
@Min(1) @Max(100)
@Parameter(name = "limit", description = "", in = ParameterIn.QUERY)
@Valid @RequestParam(value = "limit", required = false, defaultValue = "50") Integer limit,
@Size(min = 1)
@Parameter(name = "cursor", description = "", in = ParameterIn.QUERY)
@Valid @RequestParam(value = "cursor", required = false) String cursor,
@AuthenticationPrincipal SessionPrincipal principal
);
}
@@ -0,0 +1,26 @@
package ru.mtusi.messenger.controller;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.RestController;
import ru.mtusi.messenger.dto.UserDTO;
import ru.mtusi.messenger.security.SessionPrincipal;
import ru.mtusi.messenger.service.UserService;
@RestController
@RequiredArgsConstructor
public class UserController implements UsersApi {
private final UserService userService;
@Override
public ResponseEntity<UserDTO> currentUser(@AuthenticationPrincipal SessionPrincipal principal) {
return ResponseEntity.ok(userService.currentUser(principal.userId()));
}
@Override
public ResponseEntity<UserDTO> registerUser(UserDTO userDTO) {
return ResponseEntity.status(HttpStatus.CREATED).body(userService.registerUser(userDTO));
}
}
@@ -0,0 +1,136 @@
/**
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech) (7.10.0).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package ru.mtusi.messenger.controller;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import ru.mtusi.messenger.dto.ErrorDTO;
import ru.mtusi.messenger.dto.UserDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.annotation.Generated;
import ru.mtusi.messenger.security.SessionPrincipal;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
@Validated
@Tag(name = "Users", description = "Регистрация пользователей и доступ к профилю текущего пользователя.")
@RequestMapping("${openapi.mTUSIMessenger2.base-path:}")
public interface UsersApi {
/**
* GET /api/v1/users/me : Текущий пользователь
*
* @return Успех (status code 200)
* or Неверный запрос (status code 400)
* or Нет действительной аутентификации (status code 401)
* or Объект отсутствует или недоступен (status code 404)
* or Конфликт (status code 409)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "currentUser",
summary = "Текущий пользователь",
tags = { "Users" },
responses = {
@ApiResponse(responseCode = "200", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = UserDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "401", description = "Нет действительной аутентификации", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "404", description = "Объект отсутствует или недоступен", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
},
security = {
@SecurityRequirement(name = "bearerAuth")
}
)
@RequestMapping(
method = RequestMethod.GET,
value = "/api/v1/users/me",
produces = { "application/json" }
)
ResponseEntity<UserDTO> currentUser(
@AuthenticationPrincipal SessionPrincipal principal
);
/**
* POST /api/v1/users : Создать пользователя
*
* @param userDTO (required)
* @return Успех (status code 201)
* or Неверный запрос (status code 400)
* or Конфликт (status code 409)
* or Ограничение частоты запросов (status code 429)
* or Зависимость недоступна (status code 503)
* or Неожиданная ошибка без внутренних деталей (status code 500)
*/
@Operation(
operationId = "registerUser",
summary = "Создать пользователя",
tags = { "Users" },
responses = {
@ApiResponse(responseCode = "201", description = "Успех", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = UserDTO.class))
}),
@ApiResponse(responseCode = "400", description = "Неверный запрос", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "409", description = "Конфликт", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "429", description = "Ограничение частоты запросов", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "503", description = "Зависимость недоступна", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
}),
@ApiResponse(responseCode = "500", description = "Неожиданная ошибка без внутренних деталей", content = {
@Content(mediaType = "application/json", schema = @Schema(implementation = ErrorDTO.class))
})
}
)
@RequestMapping(
method = RequestMethod.POST,
value = "/api/v1/users",
produces = { "application/json" },
consumes = { "application/json" }
)
ResponseEntity<UserDTO> registerUser(
@Parameter(name = "UserDTO", description = "", required = true) @Valid @RequestBody UserDTO userDTO
);
}
@@ -0,0 +1,126 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.UUID;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import org.hibernate.validator.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
import jakarta.annotation.Generated;
@Generated(value = "org.openapitools.codegen.languages.SpringCodegen", comments = "Generator version: 7.10.0")
public class ChatDTO {
private String title;
@Valid
private Set<UUID> memberIds = new LinkedHashSet<>();
public ChatDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public ChatDTO(String title, Set<UUID> memberIds) {
this.title = title;
this.memberIds = memberIds;
}
public ChatDTO title(String title) {
this.title = title;
return this;
}
/**
* Get title
* @return title
*/
@NotNull @Size(min = 1, max = 100)
@Schema(name = "title", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("title")
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public ChatDTO memberIds(Set<UUID> memberIds) {
this.memberIds = memberIds;
return this;
}
public ChatDTO addMemberIdsItem(UUID memberIdsItem) {
if (this.memberIds == null) {
this.memberIds = new LinkedHashSet<>();
}
this.memberIds.add(memberIdsItem);
return this;
}
/**
* Get memberIds
* @return memberIds
*/
@NotNull @Valid @Size(min = 1, max = 100)
@Schema(name = "member_ids", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("member_ids")
public Set<UUID> getMemberIds() {
return memberIds;
}
@JsonDeserialize(as = LinkedHashSet.class)
public void setMemberIds(Set<UUID> memberIds) {
this.memberIds = memberIds;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ChatDTO createChat = (ChatDTO) o;
return Objects.equals(this.title, createChat.title) &&
Objects.equals(this.memberIds, createChat.memberIds);
}
@Override
public int hashCode() {
return Objects.hash(title, memberIds);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class CreateChat {\n");
sb.append(" title: ").append(toIndentedString(title)).append("\n");
sb.append(" memberIds: ").append(toIndentedString(memberIds)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,121 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.ArrayList;
import java.util.List;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* ChatPageDTO
*/
public class ChatPageDTO {
@Valid
private List<@Valid ChatDTO> items = new ArrayList<>();
private String nextCursor = null;
public ChatPageDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public ChatPageDTO(List<@Valid ChatDTO> items, String nextCursor) {
this.items = items;
this.nextCursor = nextCursor;
}
public ChatPageDTO items(List<@Valid ChatDTO> items) {
this.items = items;
return this;
}
public ChatPageDTO addItemsItem(ChatDTO itemsItem) {
if (this.items == null) {
this.items = new ArrayList<>();
}
this.items.add(itemsItem);
return this;
}
/**
* Get items
* @return items
*/
@NotNull @Valid
@Schema(name = "items", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("items")
public List<@Valid ChatDTO> getItems() {
return items;
}
public void setItems(List<@Valid ChatDTO> items) {
this.items = items;
}
public ChatPageDTO nextCursor(String nextCursor) {
this.nextCursor = nextCursor;
return this;
}
/**
* Get nextCursor
* @return nextCursor
*/
@Schema(name = "next_cursor", requiredMode = Schema.RequiredMode.NOT_REQUIRED)
@JsonProperty("next_cursor")
public String getNextCursor() {
return nextCursor;
}
public void setNextCursor(String nextCursor) {
this.nextCursor = nextCursor;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ChatPageDTO chatPageDTO = (ChatPageDTO) o;
return Objects.equals(this.items, chatPageDTO.items) &&
Objects.equals(this.nextCursor, chatPageDTO.nextCursor);
}
@Override
public int hashCode() {
return Objects.hash(items, nextCursor);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ChatPageDTO {\n");
sb.append(" items: ").append(toIndentedString(items)).append("\n");
sb.append(" nextCursor: ").append(toIndentedString(nextCursor)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,38 @@
package ru.mtusi.messenger.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.util.Objects;
@Schema(name = "CreateMessage")
public class CreateMessageDTO {
private String text;
public CreateMessageDTO() {}
public CreateMessageDTO text(String text) {
this.text = text;
return this;
}
@NotNull @Size(min = 1, max = 4000)
@Schema(name = "text", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("text")
public String getText() { return text; }
public void setText(String text) { this.text = text; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof CreateMessageDTO d)) return false;
return Objects.equals(text, d.text);
}
@Override
public int hashCode() { return Objects.hash(text); }
}
@@ -0,0 +1,87 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import ru.mtusi.messenger.dto.ErrorErrorDTO;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* ErrorDTO
*/
public class ErrorDTO {
private ErrorErrorDTO error;
public ErrorDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public ErrorDTO(ErrorErrorDTO error) {
this.error = error;
}
public ErrorDTO error(ErrorErrorDTO error) {
this.error = error;
return this;
}
/**
* Get error
* @return error
*/
@NotNull @Valid
@Schema(name = "error", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("error")
public ErrorErrorDTO getError() {
return error;
}
public void setError(ErrorErrorDTO error) {
this.error = error;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ErrorDTO errorDTO = (ErrorDTO) o;
return Objects.equals(this.error, errorDTO.error);
}
@Override
public int hashCode() {
return Objects.hash(error);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ErrorDTO {\n");
sb.append(" error: ").append(toIndentedString(error)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,178 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* ErrorErrorDTO
*/
public class ErrorErrorDTO {
/**
* Gets or Sets code
*/
public enum CodeEnum {
INVALID_REQUEST("invalid_request"),
UNAUTHORIZED("unauthorized"),
NOT_FOUND("not_found"),
CONFLICT("conflict"),
PAYLOAD_TOO_LARGE("payload_too_large"),
UNSUPPORTED_MEDIA_TYPE("unsupported_media_type"),
RATE_LIMITED("rate_limited"),
UNAVAILABLE("unavailable"),
INTERNAL_ERROR("internal_error");
private String value;
CodeEnum(String value) {
this.value = value;
}
@JsonValue
public String getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static CodeEnum fromValue(String value) {
for (CodeEnum b : CodeEnum.values()) {
if (b.value.equals(value)) {
return b;
}
}
throw new IllegalArgumentException("Unexpected value '" + value + "'");
}
}
private CodeEnum code;
private String message;
private String requestId;
public ErrorErrorDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public ErrorErrorDTO(CodeEnum code, String message, String requestId) {
this.code = code;
this.message = message;
this.requestId = requestId;
}
public ErrorErrorDTO code(CodeEnum code) {
this.code = code;
return this;
}
/**
* Get code
* @return code
*/
@NotNull
@Schema(name = "code", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("code")
public CodeEnum getCode() {
return code;
}
public void setCode(CodeEnum code) {
this.code = code;
}
public ErrorErrorDTO message(String message) {
this.message = message;
return this;
}
/**
* Get message
* @return message
*/
@NotNull @Size(min = 1)
@Schema(name = "message", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("message")
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public ErrorErrorDTO requestId(String requestId) {
this.requestId = requestId;
return this;
}
/**
* Get requestId
* @return requestId
*/
@NotNull @Size(min = 1)
@Schema(name = "request_id", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("request_id")
public String getRequestId() {
return requestId;
}
public void setRequestId(String requestId) {
this.requestId = requestId;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ErrorErrorDTO errorErrorDTO = (ErrorErrorDTO) o;
return Objects.equals(this.code, errorErrorDTO.code) &&
Objects.equals(this.message, errorErrorDTO.message) &&
Objects.equals(this.requestId, errorErrorDTO.requestId);
}
@Override
public int hashCode() {
return Objects.hash(code, message, requestId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ErrorErrorDTO {\n");
sb.append(" code: ").append(toIndentedString(code)).append("\n");
sb.append(" message: ").append(toIndentedString(message)).append("\n");
sb.append(" requestId: ").append(toIndentedString(requestId)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,120 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* HealthDTO
*/
public class HealthDTO {
/**
* Gets or Sets status
*/
public enum StatusEnum {
OK("ok");
private String value;
StatusEnum(String value) {
this.value = value;
}
@JsonValue
public String getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static StatusEnum fromValue(String value) {
for (StatusEnum b : StatusEnum.values()) {
if (b.value.equals(value)) {
return b;
}
}
throw new IllegalArgumentException("Unexpected value '" + value + "'");
}
}
private StatusEnum status;
public HealthDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public HealthDTO(StatusEnum status) {
this.status = status;
}
public HealthDTO status(StatusEnum status) {
this.status = status;
return this;
}
/**
* Get status
* @return status
*/
@NotNull
@Schema(name = "status", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("status")
public StatusEnum getStatus() {
return status;
}
public void setStatus(StatusEnum status) {
this.status = status;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
HealthDTO healthDTO = (HealthDTO) o;
return Objects.equals(this.status, healthDTO.status);
}
@Override
public int hashCode() {
return Objects.hash(status);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class HealthDTO {\n");
sb.append(" status: ").append(toIndentedString(status)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,187 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.Instant;
import java.util.UUID;
/**
* MessageDTO
*/
public class MessageDTO {
private UUID id;
private UUID chatId;
private UUID senderId;
private String text;
private Instant createdAt;
public MessageDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public MessageDTO(UUID id, UUID chatId, UUID senderId, String text, Instant createdAt) {
this.id = id;
this.chatId = chatId;
this.senderId = senderId;
this.text = text;
this.createdAt = createdAt;
}
public MessageDTO id(UUID id) {
this.id = id;
return this;
}
/**
* Get id
* @return id
*/
@NotNull @Valid
@Schema(name = "id", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("id")
public UUID getId() {
return id;
}
public void setId(UUID id) {
this.id = id;
}
public MessageDTO chatId(UUID chatId) {
this.chatId = chatId;
return this;
}
/**
* Get chatId
* @return chatId
*/
@NotNull @Valid
@Schema(name = "chat_id", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("chat_id")
public UUID getChatId() {
return chatId;
}
public void setChatId(UUID chatId) {
this.chatId = chatId;
}
public MessageDTO senderId(UUID senderId) {
this.senderId = senderId;
return this;
}
/**
* Get senderId
* @return senderId
*/
@NotNull @Valid
@Schema(name = "sender_id", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("sender_id")
public UUID getSenderId() {
return senderId;
}
public void setSenderId(UUID senderId) {
this.senderId = senderId;
}
public MessageDTO text(String text) {
this.text = text;
return this;
}
/**
* Get text
* @return text
*/
@NotNull @Size(min = 1, max = 4000)
@Schema(name = "text", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("text")
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public MessageDTO createdAt(Instant createdAt) {
this.createdAt = createdAt;
return this;
}
/**
* Get createdAt
* @return createdAt
*/
@NotNull @Valid
@Schema(name = "created_at", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("created_at")
public Instant getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Instant createdAt) {
this.createdAt = createdAt;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MessageDTO messageDTO = (MessageDTO) o;
return Objects.equals(this.id, messageDTO.id) &&
Objects.equals(this.chatId, messageDTO.chatId) &&
Objects.equals(this.senderId, messageDTO.senderId) &&
Objects.equals(this.text, messageDTO.text) &&
Objects.equals(this.createdAt, messageDTO.createdAt);
}
@Override
public int hashCode() {
return Objects.hash(id, chatId, senderId, text, createdAt);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class MessageDTO {\n");
sb.append(" id: ").append(toIndentedString(id)).append("\n");
sb.append(" chatId: ").append(toIndentedString(chatId)).append("\n");
sb.append(" senderId: ").append(toIndentedString(senderId)).append("\n");
sb.append(" text: ").append(toIndentedString(text)).append("\n");
sb.append(" createdAt: ").append(toIndentedString(createdAt)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,122 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.ArrayList;
import java.util.List;
import ru.mtusi.messenger.dto.MessageDTO;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* MessagePageDTO
*/
public class MessagePageDTO {
@Valid
private List<@Valid MessageDTO> items = new ArrayList<>();
private String nextCursor = null;
public MessagePageDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public MessagePageDTO(List<@Valid MessageDTO> items, String nextCursor) {
this.items = items;
this.nextCursor = nextCursor;
}
public MessagePageDTO items(List<@Valid MessageDTO> items) {
this.items = items;
return this;
}
public MessagePageDTO addItemsItem(MessageDTO itemsItem) {
if (this.items == null) {
this.items = new ArrayList<>();
}
this.items.add(itemsItem);
return this;
}
/**
* Get items
* @return items
*/
@NotNull @Valid
@Schema(name = "items", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("items")
public List<@Valid MessageDTO> getItems() {
return items;
}
public void setItems(List<@Valid MessageDTO> items) {
this.items = items;
}
public MessagePageDTO nextCursor(String nextCursor) {
this.nextCursor = nextCursor;
return this;
}
/**
* Get nextCursor
* @return nextCursor
*/
@Schema(name = "next_cursor", requiredMode = Schema.RequiredMode.NOT_REQUIRED)
@JsonProperty("next_cursor")
public String getNextCursor() {
return nextCursor;
}
public void setNextCursor(String nextCursor) {
this.nextCursor = nextCursor;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MessagePageDTO messagePageDTO = (MessagePageDTO) o;
return Objects.equals(this.items, messagePageDTO.items) &&
Objects.equals(this.nextCursor, messagePageDTO.nextCursor);
}
@Override
public int hashCode() {
return Objects.hash(items, nextCursor);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class MessagePageDTO {\n");
sb.append(" items: ").append(toIndentedString(items)).append("\n");
sb.append(" nextCursor: ").append(toIndentedString(nextCursor)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,198 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import java.time.Instant;
import ru.mtusi.messenger.dto.UserDTO;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* SessionDTO
*/
public class SessionDTO {
private String token;
/**
* Gets or Sets tokenType
*/
public enum TokenTypeEnum {
BEARER("Bearer");
private String value;
TokenTypeEnum(String value) {
this.value = value;
}
@JsonValue
public String getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static TokenTypeEnum fromValue(String value) {
for (TokenTypeEnum b : TokenTypeEnum.values()) {
if (b.value.equals(value)) {
return b;
}
}
throw new IllegalArgumentException("Unexpected value '" + value + "'");
}
}
private TokenTypeEnum tokenType;
private Instant expiresAt;
private UserDTO user;
public SessionDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public SessionDTO(String token, TokenTypeEnum tokenType, Instant expiresAt, UserDTO user) {
this.token = token;
this.tokenType = tokenType;
this.expiresAt = expiresAt;
this.user = user;
}
public SessionDTO token(String token) {
this.token = token;
return this;
}
/**
* Get token
* @return token
*/
@NotNull @Size(min = 32)
@Schema(name = "token", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("token")
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public SessionDTO tokenType(TokenTypeEnum tokenType) {
this.tokenType = tokenType;
return this;
}
/**
* Get tokenType
* @return tokenType
*/
@NotNull
@Schema(name = "token_type", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("token_type")
public TokenTypeEnum getTokenType() {
return tokenType;
}
public void setTokenType(TokenTypeEnum tokenType) {
this.tokenType = tokenType;
}
public SessionDTO expiresAt(Instant expiresAt) {
this.expiresAt = expiresAt;
return this;
}
/**
* Get expiresAt
* @return expiresAt
*/
@NotNull @Valid
@Schema(name = "expires_at", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("expires_at")
public Instant getExpiresAt() {
return expiresAt;
}
public void setExpiresAt(Instant expiresAt) {
this.expiresAt = expiresAt;
}
public SessionDTO user(UserDTO user) {
this.user = user;
return this;
}
/**
* Get user
* @return user
*/
@NotNull @Valid
@Schema(name = "user", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("user")
public UserDTO getUser() {
return user;
}
public void setUser(UserDTO user) {
this.user = user;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SessionDTO sessionDTO = (SessionDTO) o;
return Objects.equals(this.token, sessionDTO.token) &&
Objects.equals(this.tokenType, sessionDTO.tokenType) &&
Objects.equals(this.expiresAt, sessionDTO.expiresAt) &&
Objects.equals(this.user, sessionDTO.user);
}
@Override
public int hashCode() {
return Objects.hash(token, tokenType, expiresAt, user);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class SessionDTO {\n");
sb.append(" token: ").append(toIndentedString(token)).append("\n");
sb.append(" tokenType: ").append(toIndentedString(tokenType)).append("\n");
sb.append(" expiresAt: ").append(toIndentedString(expiresAt)).append("\n");
sb.append(" user: ").append(toIndentedString(user)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,156 @@
package ru.mtusi.messenger.dto;
import java.util.Objects;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.*;
/**
* UserDTO
*/
public class UserDTO {
private UUID id;
private String username;
private String displayName;
private String password;
public UserDTO() {
super();
}
/**
* Constructor with only required parameters
*/
public UserDTO(String username, String displayName, String password) {
this.username = username;
this.displayName = displayName;
this.password = password;
}
public UserDTO username(String username) {
this.username = username;
return this;
}
@Valid
@Schema(name = "id", requiredMode = Schema.RequiredMode.NOT_REQUIRED)
@JsonProperty("id")
public UUID getId() {
return id;
}
public void setId(UUID id) {
this.id = id;
}
public UserDTO id(UUID id) {
this.id = id;
return this;
}
/**
* Get username
* @return username
*/
@NotNull @Pattern(regexp = "^[a-z0-9_]{3,32}$")
@Schema(name = "username", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("username")
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public UserDTO displayName(String displayName) {
this.displayName = displayName;
return this;
}
/**
* Get displayName
* @return displayName
*/
@NotNull @Size(min = 1, max = 100)
@Schema(name = "display_name", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("display_name")
public String getDisplayName() {
return displayName;
}
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
public UserDTO password(String password) {
this.password = password;
return this;
}
/**
* Get password
* @return password
*/
@NotNull @Size(min = 12, max = 128)
@Schema(name = "password", requiredMode = Schema.RequiredMode.REQUIRED)
@JsonProperty("password")
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
UserDTO userDTO = (UserDTO) o;
return Objects.equals(this.id, userDTO.id) &&
Objects.equals(this.username, userDTO.username) &&
Objects.equals(this.displayName, userDTO.displayName) &&
Objects.equals(this.password, userDTO.password);
}
@Override
public int hashCode() {
return Objects.hash(id, username, displayName, password);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class UserDTO {\n");
sb.append(" id: ").append(toIndentedString(id)).append("\n");
sb.append(" username: ").append(toIndentedString(username)).append("\n");
sb.append(" displayName: ").append(toIndentedString(displayName)).append("\n");
sb.append(" password: ").append(toIndentedString(password)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
@@ -0,0 +1,71 @@
package ru.mtusi.messenger.exception;
import tools.jackson.databind.ObjectMapper;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.slf4j.MDC;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import ru.mtusi.messenger.dto.ErrorDTO;
import ru.mtusi.messenger.dto.ErrorErrorDTO;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
@Component
@RequiredArgsConstructor
public class ApiErrorFactory {
private static final String DEFAULT_MESSAGE = "Error";
private static final String REQUEST_ID_ATTR = "requestId";
private static final String REQUEST_ID_MDC = "requestId";
private final ObjectMapper objectMapper;
public ErrorDTO error(ErrorErrorDTO.CodeEnum code, String message, HttpServletRequest request) {
ErrorErrorDTO inner = new ErrorErrorDTO();
inner.setCode(code);
inner.setMessage(normalizeMessage(message));
inner.setRequestId(resolveRequestId(request));
ErrorDTO outer = new ErrorDTO();
outer.setError(inner);
return outer;
}
public void writeError(HttpServletResponse response,
HttpServletRequest request,
HttpStatus status,
String wwwAuthenticate,
ErrorErrorDTO.CodeEnum code,
String message) throws IOException {
String requestId = resolveRequestId(request);
response.setStatus(status.value());
response.setHeader("X-Request-Id", requestId);
if (wwwAuthenticate != null) {
response.setHeader(HttpHeaders.WWW_AUTHENTICATE, wwwAuthenticate);
}
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
objectMapper.writeValue(response.getWriter(), error(code, message, request));
}
public String resolveRequestId(HttpServletRequest request) {
Object attr = request.getAttribute(REQUEST_ID_ATTR);
if (attr instanceof String s && !s.isBlank()) {
return s;
}
String mdc = MDC.get(REQUEST_ID_MDC);
if (mdc != null && !mdc.isBlank()) {
return mdc;
}
return UUID.randomUUID().toString();
}
private String normalizeMessage(String message) {
return (message == null || message.isBlank()) ? DEFAULT_MESSAGE : message;
}
}
@@ -0,0 +1,5 @@
package ru.mtusi.messenger.exception;
public class ConflictException extends RuntimeException {
public ConflictException(String message) { super(message); }
}
@@ -0,0 +1,119 @@
package ru.mtusi.messenger.exception;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.ConstraintViolationException;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.HandlerMethodValidationException;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import ru.mtusi.messenger.config.RateLimitProperties;
import ru.mtusi.messenger.dto.ErrorDTO;
import ru.mtusi.messenger.dto.ErrorErrorDTO;
@RestControllerAdvice
@RequiredArgsConstructor
public class GlobalExceptionHandler {
private final RateLimitProperties limitProperties;
private final ApiErrorFactory errors;
@ExceptionHandler(InvalidRequestException.class)
public ResponseEntity<ErrorDTO> invalidRequest(InvalidRequestException e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST, e.getMessage(), req);
}
@ExceptionHandler(UnauthorizedException.class)
public ResponseEntity<ErrorDTO> unauthorized(UnauthorizedException e, HttpServletRequest req) {
String scheme = req.getRequestURI().equals("/api/v1/auth/sessions")
? "Basic" : "Bearer";
return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
.header("WWW-Authenticate", scheme + " realm=\"messenger\"")
.body(errors.error(ErrorErrorDTO.CodeEnum.UNAUTHORIZED, e.getMessage(), req));
}
@ExceptionHandler(NotFoundException.class)
public ResponseEntity<ErrorDTO> notFound(NotFoundException e, HttpServletRequest req) {
return respond(HttpStatus.NOT_FOUND, ErrorErrorDTO.CodeEnum.NOT_FOUND, e.getMessage(), req);
}
@ExceptionHandler(ConflictException.class)
public ResponseEntity<ErrorDTO> conflict(ConflictException e, HttpServletRequest req) {
return respond(HttpStatus.CONFLICT, ErrorErrorDTO.CodeEnum.CONFLICT, e.getMessage(), req);
}
@ExceptionHandler(PayloadTooLargeException.class)
public ResponseEntity<ErrorDTO> payloadTooLarge(PayloadTooLargeException e, HttpServletRequest req) {
return respond(HttpStatus.PAYLOAD_TOO_LARGE, ErrorErrorDTO.CodeEnum.PAYLOAD_TOO_LARGE, e.getMessage(), req);
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ErrorDTO> validation(MethodArgumentNotValidException e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST, "Validation failed", req);
}
@ExceptionHandler(HttpMessageNotReadableException.class)
public ResponseEntity<ErrorDTO> unreadable(Exception e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST, "Malformed request body", req);
}
@ExceptionHandler(MissingServletRequestParameterException.class)
public ResponseEntity<ErrorDTO> missingParam(Exception e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST, "Missing parameter", req);
}
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
public ResponseEntity<ErrorDTO> typeMismatch(Exception e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST, "Invalid parameter type", req);
}
@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
public ResponseEntity<ErrorDTO> mediaType(Exception e, HttpServletRequest req) {
return respond(HttpStatus.UNSUPPORTED_MEDIA_TYPE, ErrorErrorDTO.CodeEnum.UNSUPPORTED_MEDIA_TYPE,
"Unsupported media type", req);
}
@ExceptionHandler(HandlerMethodValidationException.class)
public ResponseEntity<ErrorDTO> methodValidation(Exception e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST,
"Validation failed", req);
}
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public ResponseEntity<ErrorDTO> methodNotAllowed(Exception e, HttpServletRequest req) {
return respond(HttpStatus.METHOD_NOT_ALLOWED, ErrorErrorDTO.CodeEnum.INVALID_REQUEST,
"Method not allowed", req);
}
@ExceptionHandler(RateLimitedException.class)
public ResponseEntity<ErrorDTO> rateLimited(RateLimitedException e, HttpServletRequest req) {
return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS)
.header("Retry-After", String.valueOf(limitProperties.retryAfterSeconds()))
.body(errors.error(ErrorErrorDTO.CodeEnum.RATE_LIMITED, e.getMessage(), req));
}
@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ErrorDTO> constraint(ConstraintViolationException e, HttpServletRequest req) {
return respond(HttpStatus.BAD_REQUEST, ErrorErrorDTO.CodeEnum.INVALID_REQUEST,
"Validation failed", req);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorDTO> fallback(Exception e, HttpServletRequest req) {
return respond(HttpStatus.INTERNAL_SERVER_ERROR, ErrorErrorDTO.CodeEnum.INTERNAL_ERROR,
"Internal error", req);
}
private ResponseEntity<ErrorDTO> respond(HttpStatus status,
ErrorErrorDTO.CodeEnum code,
String message,
HttpServletRequest req) {
return ResponseEntity.status(status).body(errors.error(code, message, req));
}
}
@@ -0,0 +1,5 @@
package ru.mtusi.messenger.exception;
public class InvalidRequestException extends RuntimeException {
public InvalidRequestException(String message) { super(message); }
}
@@ -0,0 +1,5 @@
package ru.mtusi.messenger.exception;
public class NotFoundException extends RuntimeException {
public NotFoundException(String message) { super(message); }
}
@@ -0,0 +1,5 @@
package ru.mtusi.messenger.exception;
public class PayloadTooLargeException extends RuntimeException {
public PayloadTooLargeException(String message) { super(message); }
}
@@ -0,0 +1,7 @@
package ru.mtusi.messenger.exception;
public class RateLimitedException extends RuntimeException {
public RateLimitedException(String message) {
super(message);
}
}
@@ -0,0 +1,5 @@
package ru.mtusi.messenger.exception;
public class UnauthorizedException extends RuntimeException {
public UnauthorizedException(String message) { super(message); }
}
@@ -0,0 +1,50 @@
package ru.mtusi.messenger.filter;
import io.github.bucket4j.Bucket;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import ru.mtusi.messenger.config.AppProperties;
import ru.mtusi.messenger.config.RateLimitProperties;
import ru.mtusi.messenger.dto.ErrorErrorDTO;
import ru.mtusi.messenger.exception.ApiErrorFactory;
import java.io.IOException;
@Component
@Order(2)
@RequiredArgsConstructor
public class RateLimitFilter extends OncePerRequestFilter {
private final RateLimitProperties limitProperties;
private final Bucket bucket;
private final ApiErrorFactory errors;
@Override
protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res,
FilterChain chain) throws ServletException, IOException {
if (!req.getRequestURI().startsWith("/api/")) {
chain.doFilter(req, res);
return;
}
if (bucket.tryConsume(1)) {
chain.doFilter(req, res);
return;
}
res.setHeader("Retry-After", String.valueOf(limitProperties.retryAfterSeconds()));
errors.writeError(
res,
req,
HttpStatus.TOO_MANY_REQUESTS,
null,
ErrorErrorDTO.CodeEnum.RATE_LIMITED,
"Rate limit exceeded. Try again later.");
}
}
@@ -0,0 +1,35 @@
package ru.mtusi.messenger.filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.MDC;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.UUID;
@Component
@Order(1)
public class RequestIdFilter extends OncePerRequestFilter {
public static final String INSTANCE_ID = UUID.randomUUID().toString();
@Override
protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res,
FilterChain chain) throws ServletException, IOException {
String rid = UUID.randomUUID().toString();
res.setHeader("X-Request-Id", rid);
res.setHeader("X-Instance-Id", INSTANCE_ID);
req.setAttribute("requestId", rid);
MDC.put("requestId", rid);
try {
chain.doFilter(req, res);
} finally {
MDC.clear();
}
}
}
@@ -0,0 +1,34 @@
package ru.mtusi.messenger.mapper;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Named;
import ru.mtusi.messenger.dto.ChatDTO;
import ru.mtusi.messenger.model.Chat;
import ru.mtusi.messenger.model.User;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
@Mapper(componentModel = "spring")
public interface ChatMapper {
@Mapping(target = "id", ignore = true)
@Mapping(target = "createdAt", ignore = true)
@Mapping(target = "members", ignore = true) // ← заполнит ChatService
@Mapping(target = "messages", ignore = true)
Chat toChat(ChatDTO dto);
@Mapping(target = "memberIds", source = "members", qualifiedByName = "usersToIds")
ChatDTO toChatDto(Chat chat);
@Named("usersToIds")
default Set<UUID> usersToIds(Set<User> users) {
if (users == null) return new LinkedHashSet<>();
return users.stream()
.map(User::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
}
}
@@ -0,0 +1,20 @@
package ru.mtusi.messenger.mapper;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import ru.mtusi.messenger.dto.MessageDTO;
import ru.mtusi.messenger.model.Message;
@Mapper(componentModel = "spring")
public interface MessageMapper {
@Mapping(target = "id", ignore = true)
@Mapping(target = "chat", ignore = true)
@Mapping(target = "sender", ignore = true)
@Mapping(target = "createdAt", ignore = true)
Message toMessage(MessageDTO dto);
@Mapping(target = "chatId", source = "chat.id")
@Mapping(target = "senderId", source = "sender.id")
MessageDTO toMessageDTO(Message entity);
}
@@ -0,0 +1,20 @@
package ru.mtusi.messenger.mapper;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import ru.mtusi.messenger.dto.UserDTO;
import ru.mtusi.messenger.model.User;
@Mapper(componentModel = "spring")
public interface UserMapper {
@Mapping(target = "id", ignore = true)
@Mapping(target = "createdAt", ignore = true)
@Mapping(target = "passwordHash", ignore = true)
@Mapping(target = "chats", ignore = true)
@Mapping(target = "messages", ignore = true)
User toUser(UserDTO dto);
@Mapping(target = "password", ignore = true)
UserDTO toUserDto(User user);
}
@@ -0,0 +1,52 @@
package ru.mtusi.messenger.model;
import jakarta.persistence.*;
import lombok.*;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
@Entity
@Table(name = "chats")
@Getter
@Setter
@NoArgsConstructor
public class Chat {
@Id
@Column(nullable = false, updatable = false)
@GeneratedValue(strategy = GenerationType.UUID)
private UUID id;
@Column(nullable = false, length = 100)
private String title;
@Column(name = "created_at", nullable = false, updatable = false)
private Instant createdAt;
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(
name = "chat_members",
joinColumns = @JoinColumn(name = "chat_id"),
inverseJoinColumns = @JoinColumn(name = "user_id")
)
private Set<User> members = new HashSet<>();
@OneToMany(
mappedBy = "chat",
fetch = FetchType.LAZY,
cascade = CascadeType.ALL,
orphanRemoval = true
)
@OrderBy("createdAt ASC, id ASC")
private List<Message> messages = new ArrayList<>();
@PrePersist
private void onCreate() {
this.createdAt = Instant.now();
}
}
@@ -0,0 +1,39 @@
package ru.mtusi.messenger.model;
import jakarta.persistence.*;
import lombok.*;
import java.time.Instant;
import java.util.UUID;
@Entity
@Table(name = "messages")
@Getter
@Setter
@NoArgsConstructor
public class Message {
@Id
@Column(nullable = false, updatable = false)
@GeneratedValue(strategy = GenerationType.UUID)
private UUID id;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "chat_id", nullable = false)
private Chat chat;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "sender_id", nullable = false)
private User sender;
@Column(nullable = false, length = 4000)
private String text;
@Column(name = "created_at", nullable = false, updatable = false)
private Instant createdAt;
@PrePersist
private void onCreate() {
this.createdAt = Instant.now();
}
}
@@ -0,0 +1,41 @@
package ru.mtusi.messenger.model;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.Instant;
import java.util.UUID;
@Entity
@Table(name = "sessions")
@Getter
@Setter
@NoArgsConstructor
public class Session {
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private UUID id;
@Column(name = "user_id", nullable = false)
private UUID userId;
@Column(name = "token_hash", nullable = false, unique = true)
private byte[] tokenHash;
@Column(name = "created_at", nullable = false)
private Instant createdAt;
@Column(name = "expires_at", nullable = false)
private Instant expiresAt;
@Column(name = "revoked_at")
private Instant revokedAt;
@PrePersist
private void onCreate() {
this.createdAt = Instant.now();
}
}
@@ -0,0 +1,47 @@
package ru.mtusi.messenger.model;
import jakarta.persistence.*;
import lombok.*;
import java.time.Instant;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
@Entity
@Table(name = "users")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class User{
@Id()
@Column(nullable = false, updatable = false)
@GeneratedValue(strategy = GenerationType.UUID)
private UUID id;
@Column(nullable = false, unique = true, length = 32)
private String username;
@Column(name = "display_name", nullable = false, length = 100)
private String displayName;
@Column(name = "password_hash", nullable = false, length = 255)
private String passwordHash;
@Column(name = "created_at", nullable = false, updatable = false)
private Instant createdAt;
@ManyToMany(mappedBy = "members", fetch = FetchType.LAZY)
private Set<Chat> chats = new HashSet<>();
@OneToMany(mappedBy = "sender", fetch = FetchType.LAZY)
private Set<Message> messages = new HashSet<>();
@PrePersist
private void onCreate() {
this.createdAt = Instant.now();
}
}
@@ -0,0 +1,30 @@
package ru.mtusi.messenger.repository;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import ru.mtusi.messenger.model.Chat;
import org.springframework.data.domain.Pageable;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
public interface ChatRepository extends JpaRepository<Chat, UUID> {
@EntityGraph(attributePaths = "members")
@Query("""
select distinct c from Chat c
join c.members m
where m.id = :userId
and (:cursorCreated is null
or c.createdAt > :cursorCreated
or (c.createdAt = :cursorCreated and c.id > :cursorId))
order by c.createdAt asc, c.id asc
""")
List<Chat> findPageByMember(@Param("userId") UUID userId,
@Param("cursorCreated") Instant cursorCreated,
@Param("cursorId") UUID cursorId,
Pageable pageable);
}
@@ -0,0 +1,29 @@
package ru.mtusi.messenger.repository;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import ru.mtusi.messenger.model.Message;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
public interface MessageRepository extends JpaRepository<Message, UUID> {
@Query("""
select m from Message m
where m.chat.id = :chatId
and (:cursorCreated is null
or m.createdAt > :cursorCreated
or (m.createdAt = :cursorCreated and m.id > :cursorId))
order by m.createdAt asc, m.id asc
""")
List<Message> findPageByChat(@Param("chatId") UUID chatId,
@Param("cursorCreated") Instant cursorCreated,
@Param("cursorId") UUID cursorId,
Pageable pageable);
long countByChatId(UUID chatId);
}
@@ -0,0 +1,12 @@
package ru.mtusi.messenger.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import ru.mtusi.messenger.model.Session;
import java.util.Optional;
import java.util.UUID;
public interface SessionRepository extends JpaRepository<Session, UUID> {
Optional<Session> findByTokenHash(byte[] tokenHash);
}
@@ -0,0 +1,23 @@
package ru.mtusi.messenger.repository;
import jakarta.persistence.LockModeType;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import ru.mtusi.messenger.model.User;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
public interface UserRepository extends JpaRepository<User, UUID> {
Optional<User> findByUsername(String username);
@Lock(LockModeType.PESSIMISTIC_READ)
@Query("select u from User u where u.id in :ids")
Set<User> findAllByIdForShare(@Param("ids") Set<UUID> ids);
}
@@ -0,0 +1,32 @@
package ru.mtusi.messenger.security;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import ru.mtusi.messenger.dto.ErrorErrorDTO;
import ru.mtusi.messenger.exception.ApiErrorFactory;
import java.io.IOException;
@Component
@RequiredArgsConstructor
public class ApiAuthenticationEntryPoint implements AuthenticationEntryPoint {
private final ApiErrorFactory errors;
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
String scheme = request.getRequestURI().equals("/api/v1/auth/sessions") ? "Basic" : "Bearer";
errors.writeError(
response,
request,
HttpStatus.UNAUTHORIZED,
scheme + " realm=\"messenger\"",
ErrorErrorDTO.CodeEnum.UNAUTHORIZED,
"No valid authentication");
}
}
@@ -0,0 +1,28 @@
package ru.mtusi.messenger.security;
import ru.mtusi.messenger.exception.UnauthorizedException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public record BasicCredentials(String username, String password) {
public static BasicCredentials parse(String header) {
if (header == null || !header.regionMatches(true, 0, "Basic ", 0, 6)) {
throw new UnauthorizedException("Basic authentication required");
}
String decoded;
try {
decoded = new String(
Base64.getDecoder().decode(header.substring(6).trim()),
StandardCharsets.UTF_8);
} catch (IllegalArgumentException e) {
throw new UnauthorizedException("Invalid Basic encoding");
}
int i = decoded.indexOf(':');
if (i < 0) {
throw new UnauthorizedException("Invalid Basic credentials");
}
return new BasicCredentials(decoded.substring(0, i), decoded.substring(i + 1));
}
}
@@ -0,0 +1,39 @@
package ru.mtusi.messenger.security;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.oauth2.server.resource.web.BearerTokenResolver;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
@RequiredArgsConstructor
public class SessionAuthenticationFilter extends OncePerRequestFilter {
private final BearerTokenResolver bearerTokenResolver;
private final AuthenticationManager authenticationManager;
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain) throws ServletException, IOException {
String token = bearerTokenResolver.resolve(request);
if (token != null && !token.isBlank()) {
try {
Authentication auth = authenticationManager.authenticate(
new SessionAuthenticationToken(token));
SecurityContextHolder.getContext().setAuthentication(auth);
} catch (AuthenticationException e) {
SecurityContextHolder.clearContext();
}
}
chain.doFilter(request, response);
}
}
@@ -0,0 +1,33 @@
package ru.mtusi.messenger.security;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.stereotype.Component;
import ru.mtusi.messenger.exception.UnauthorizedException;
import ru.mtusi.messenger.service.SessionService;
@Component
@RequiredArgsConstructor
public class SessionAuthenticationProvider implements AuthenticationProvider {
private final SessionService sessionService;
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
String token = (String) authentication.getCredentials();
try {
var rec = sessionService.requireActive(token);
return new SessionAuthenticationToken(
new SessionPrincipal(rec.userId(), rec.sessionId()));
} catch (UnauthorizedException e) {
throw new BadCredentialsException(e.getMessage(), e);
}
}
@Override
public boolean supports(Class<?> authentication) {
return SessionAuthenticationToken.class.isAssignableFrom(authentication);
}
}
@@ -0,0 +1,34 @@
package ru.mtusi.messenger.security;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import java.util.List;
public class SessionAuthenticationToken extends AbstractAuthenticationToken {
private final String rawToken;
private final SessionPrincipal principal;
public SessionAuthenticationToken(String rawToken) {
super(List.of());
this.rawToken = rawToken;
this.principal = null;
setAuthenticated(false);
}
public SessionAuthenticationToken(SessionPrincipal principal) {
super(List.of());
this.rawToken = null;
this.principal = principal;
setAuthenticated(true);
}
@Override
public Object getCredentials() {
return rawToken;
}
@Override
public Object getPrincipal() {
return principal;
}
}
@@ -0,0 +1,6 @@
package ru.mtusi.messenger.security;
import java.util.UUID;
public record SessionPrincipal(UUID userId, UUID sessionId) {
}
@@ -0,0 +1,32 @@
package ru.mtusi.messenger.service;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import ru.mtusi.messenger.dto.SessionDTO;
import ru.mtusi.messenger.dto.UserDTO;
import ru.mtusi.messenger.exception.UnauthorizedException;
import ru.mtusi.messenger.security.BasicCredentials;
import ru.mtusi.messenger.security.SessionPrincipal;
@Service
@RequiredArgsConstructor
public class AuthService {
private final UserService userService;
private final SessionService sessionService;
public SessionDTO login(String authorizationHeader) {
var creds = BasicCredentials.parse(authorizationHeader);
UserDTO userDTO = userService.authenticate(creds.username(), creds.password());
return sessionService.createSession(userDTO);
}
public void logout() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || !(auth.getPrincipal() instanceof SessionPrincipal sp)) {
throw new UnauthorizedException("No active session");
}
sessionService.revoke(sp.sessionId());
}
}
@@ -0,0 +1,117 @@
package ru.mtusi.messenger.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.mtusi.messenger.dto.ChatDTO;
import ru.mtusi.messenger.dto.ChatPageDTO;
import ru.mtusi.messenger.exception.InvalidRequestException;
import ru.mtusi.messenger.exception.NotFoundException;
import ru.mtusi.messenger.mapper.ChatMapper;
import ru.mtusi.messenger.model.Chat;
import ru.mtusi.messenger.model.User;
import ru.mtusi.messenger.repository.ChatRepository;
import ru.mtusi.messenger.util.CursorCodec;
import java.time.Instant;
import java.util.*;
@Service
@Slf4j
@RequiredArgsConstructor
public class ChatService {
private final ChatMapper chatMapper;
private final UserService userService;
private final ChatRepository chatRepository;
@Transactional
public ChatDTO createChat(UUID caller , ChatDTO chatDTO) {
Set<User> members = validateCreate(caller, chatDTO);
Chat chat = buildChat(chatDTO, members);
try {
chat = chatRepository.saveAndFlush(chat);
} catch (DataIntegrityViolationException e) {
throw new NotFoundException("Cannot create chat: referenced entity is missing");
}
return chatMapper.toChatDto(chat);
}
private Set<User> validateCreate(UUID caller, ChatDTO chatDTO) {
Set<UUID> memberIds = chatDTO.getMemberIds();
if (!memberIds.contains(caller)) {
throw new InvalidRequestException("Вызывающий должен быть участником");
}
return userService.requireUsers(memberIds);
}
private Chat buildChat(ChatDTO chatDTO, Set<User> members) {
Chat chat = chatMapper.toChat(chatDTO);
chat.setMembers(members);
return chat;
}
@Transactional(readOnly = true)
public ChatDTO getChat(UUID caller, UUID chatId) {
Chat chat = chatRepository.findById(chatId)
.orElseThrow(() -> new NotFoundException("Chat not found"));
if (chat.getMembers().stream().noneMatch(m -> m.getId().equals(caller))) {
throw new NotFoundException("Chat not found");
}
return chatMapper.toChatDto(chat);
}
@Transactional(readOnly = true)
public ChatPageDTO listChats(UUID userId, Integer limit, String cursor) {
int size = (limit == null) ? 50 : limit;
CursorCodec.Cursor decoded = parseChatsCursor(cursor);
List<Chat> rows = chatRepository.findPageByMember(userId, boundaryCreatedAt(decoded), boundaryId(decoded), Pageable.ofSize(size + 1));
return buildPage(rows, size);
}
private CursorCodec.Cursor parseChatsCursor(String cursor) {
if (cursor == null || cursor.isBlank()) {
return null;
}
CursorCodec.Cursor decoded = CursorCodec.decode(cursor);
if (decoded.scopeId() != null) {
throw new InvalidRequestException("Invalid cursor");
}
return decoded;
}
private Instant boundaryCreatedAt(CursorCodec.Cursor cursor) {
return cursor == null ? null : cursor.boundary().createdAt();
}
private UUID boundaryId(CursorCodec.Cursor cursor) {
return cursor == null ? null : cursor.boundary().id();
}
private ChatPageDTO buildPage(List<Chat> rows, int size) {
List<ChatDTO> items = rows.stream()
.limit(size)
.map(chatMapper::toChatDto)
.toList();
ChatPageDTO page = new ChatPageDTO();
page.setItems(items);
page.setNextCursor(buildNextCursor(rows, size));
return page;
}
private String buildNextCursor(List<Chat> rows, int size) {
if (rows.size() <= size) {
return null;
}
Chat last = rows.get(size - 1);
return CursorCodec.encode(null, boundaryOf(last));
}
private CursorCodec.PageBoundary boundaryOf(Chat chat) {
return new CursorCodec.PageBoundary(chat.getCreatedAt(), chat.getId());
}
}
@@ -0,0 +1,120 @@
package ru.mtusi.messenger.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.mtusi.messenger.config.AppProperties;
import ru.mtusi.messenger.dto.ChatDTO;
import ru.mtusi.messenger.dto.MessageDTO;
import ru.mtusi.messenger.dto.MessagePageDTO;
import ru.mtusi.messenger.exception.InvalidRequestException;
import ru.mtusi.messenger.exception.NotFoundException;
import ru.mtusi.messenger.exception.PayloadTooLargeException;
import ru.mtusi.messenger.mapper.ChatMapper;
import ru.mtusi.messenger.mapper.MessageMapper;
import ru.mtusi.messenger.model.Chat;
import ru.mtusi.messenger.model.Message;
import ru.mtusi.messenger.model.User;
import ru.mtusi.messenger.repository.MessageRepository;
import ru.mtusi.messenger.repository.UserRepository;
import ru.mtusi.messenger.util.CursorCodec;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
@Service
@Slf4j
@RequiredArgsConstructor
public class MessageService {
private final ChatMapper chatMapper;
private final MessageRepository messageRepository;
private final ChatService chatService;
private final UserService userService;
private final MessageMapper messageMapper;
private final AppProperties appProperties;
@Transactional
public MessageDTO createMessage(UUID senderId, UUID chatId, MessageDTO messageDTO) {
ChatDTO chatDTO = chatService.getChat(senderId, chatId);
validateCreate(chatId, messageDTO);
User sender = userService.getReferenceUserById(senderId);
Message message = buildMessage(messageDTO, sender, chatDTO);
try {
message = messageRepository.saveAndFlush(message);
} catch (DataIntegrityViolationException e) {
throw new NotFoundException("Cannot create message: referenced entity is missing");
}
log.info("Created message id={} in chat={}", message.getId(), chatId);
return messageMapper.toMessageDTO(message);
}
private void validateCreate(UUID chatId, MessageDTO dto) {
if (dto.getText() == null || dto.getText().isBlank()) {
throw new InvalidRequestException("Empty text");
}
if (messageRepository.countByChatId(chatId) >= appProperties.maxMessagesPerChat()) {
throw new PayloadTooLargeException("Chat history limit reached");
}
}
private Message buildMessage(MessageDTO messageDTO, User sender, ChatDTO chatDTO) {
Message message = messageMapper.toMessage(messageDTO);
message.setChat(chatMapper.toChat(chatDTO));
message.setSender(sender);
return message;
}
@Transactional(readOnly = true)
public MessagePageDTO listMessages(UUID userId, UUID chatId, Integer limit, String cursor) {
int size = (limit == null) ? 50 : limit;
chatService.getChat(userId, chatId);
CursorCodec.Cursor decoded = parseMessagesCursor(cursor, chatId);
List<Message> rows = messageRepository.findPageByChat(chatId, boundaryCreatedAt(decoded), boundaryId(decoded), Pageable.ofSize(size + 1));
return buildPage(rows, size, chatId);
}
private CursorCodec.Cursor parseMessagesCursor(String cursor, UUID chatId) {
if (cursor == null || cursor.isBlank()) {
return null;
}
CursorCodec.Cursor decoded = CursorCodec.decode(cursor);
if (decoded.scopeId() == null || !decoded.scopeId().equals(chatId)) {
throw new InvalidRequestException("Cursor from another chat");
}
return decoded;
}
private Instant boundaryCreatedAt(CursorCodec.Cursor cursor) {
return cursor == null ? null : cursor.boundary().createdAt();
}
private UUID boundaryId(CursorCodec.Cursor cursor) {
return cursor == null ? null : cursor.boundary().id();
}
private MessagePageDTO buildPage(List<Message> rows, int size, UUID chatId) {
List<MessageDTO> items = rows.stream()
.limit(size)
.map(messageMapper::toMessageDTO)
.toList();
MessagePageDTO page = new MessagePageDTO();
page.setItems(items);
page.setNextCursor(buildNextCursor(rows, size, chatId));
return page;
}
private String buildNextCursor(List<Message> rows, int size, UUID chatId) {
if (rows.size() <= size) {
return null;
}
Message last = rows.get(size - 1);
return CursorCodec.encode(chatId, new CursorCodec.PageBoundary(
last.getCreatedAt(), last.getId()));
}
}
@@ -0,0 +1,80 @@
package ru.mtusi.messenger.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.mtusi.messenger.config.SessionProperties;
import ru.mtusi.messenger.dto.SessionDTO;
import ru.mtusi.messenger.dto.UserDTO;
import ru.mtusi.messenger.exception.UnauthorizedException;
import ru.mtusi.messenger.model.Session;
import ru.mtusi.messenger.repository.SessionRepository;
import ru.mtusi.messenger.util.TokenGenerator;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.UUID;
@Slf4j
@RequiredArgsConstructor
@Service
public class SessionService {
private final TokenGenerator tokenGenerator;
private final SessionProperties sessionProperties;
private final SessionRepository sessionRepository;
@Transactional
public SessionDTO createSession(UserDTO userDTO) {
String token = tokenGenerator.generate();
Session session = sessionRepository.save(buildSession(userDTO,token));
return toSessionDTO(session, token, userDTO);
}
@Transactional(readOnly = true)
public SessionRecord requireActive(String token) {
Session s = sessionRepository.findByTokenHash(sha256(token))
.filter(x -> x.getRevokedAt() == null)
.filter(x -> x.getExpiresAt().isAfter(Instant.now()))
.orElseThrow(() -> new UnauthorizedException("Invalid or expired session"));
return new SessionRecord(s.getId(), s.getUserId());
}
@Transactional
public void revoke(UUID sessionId) {
sessionRepository.findById(sessionId).ifPresent(s -> {
if (s.getRevokedAt() == null) {
s.setRevokedAt(Instant.now());
}
});
}
private static byte[] sha256(String token) {
try {
return MessageDigest.getInstance("SHA-256")
.digest(token.getBytes(StandardCharsets.UTF_8));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("SHA-256 not available", e);
}
}
private Session buildSession(UserDTO userDTO, String token) {
Session session = new Session();
session.setUserId(userDTO.getId());
session.setTokenHash(sha256(token));
session.setExpiresAt(Instant.now().plus(sessionProperties.ttl()));
return session;
}
private SessionDTO toSessionDTO(Session session, String tokenRaw, UserDTO userDTO) {
return new SessionDTO()
.token(tokenRaw)
.tokenType(SessionDTO.TokenTypeEnum.BEARER)
.expiresAt(session.getExpiresAt())
.user(userDTO);
}
public record SessionRecord(UUID sessionId, UUID userId) {}
}
@@ -0,0 +1,81 @@
package ru.mtusi.messenger.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.mtusi.messenger.dto.UserDTO;
import ru.mtusi.messenger.exception.ConflictException;
import ru.mtusi.messenger.exception.NotFoundException;
import ru.mtusi.messenger.exception.UnauthorizedException;
import ru.mtusi.messenger.mapper.UserMapper;
import ru.mtusi.messenger.model.User;
import ru.mtusi.messenger.repository.UserRepository;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
@Service
@RequiredArgsConstructor
@Slf4j
public class UserService {
private final PasswordEncoder passwordEncoder;
private final UserMapper userMapper;
private final UserRepository userRepository;
@Transactional
public Set<User> requireUsers(Set<UUID> ids) {
Set<User> users = userRepository.findAllByIdForShare(ids);
if (users.size() != ids.size()) {
throw new NotFoundException("Users not found: " + findMissing(ids, users));
}
return users;
}
private Set<UUID> findMissing(Set<UUID> requested, Set<User> found) {
Set<UUID> foundIds = found.stream()
.map(User::getId)
.collect(Collectors.toSet());
Set<UUID> missing = new HashSet<>(requested);
missing.removeAll(foundIds);
return missing;
}
@Transactional(readOnly = true)
public UserDTO authenticate(String username, String password) {
User user = userRepository.findByUsername(username).orElseThrow(() -> new UnauthorizedException("Bad credentials"));
if (!passwordEncoder.matches(password, user.getPasswordHash())) {
throw new UnauthorizedException("Bad credentials");
}
return userMapper.toUserDto(user);
}
@Transactional
public UserDTO registerUser(UserDTO userDTO) {
User user = userMapper.toUser(userDTO);
user.setPasswordHash(passwordEncoder.encode(userDTO.getPassword()));
try {
return userMapper.toUserDto(userRepository.saveAndFlush(user));
} catch (DataIntegrityViolationException exception) {
throw new ConflictException("Username already exists");
}
}
@Transactional(readOnly = true)
public UserDTO currentUser(UUID userId) {
return userMapper.toUserDto(userRepository.findById(userId).orElseThrow(() ->
new NotFoundException("User not found")
));
}
@Transactional
public User getReferenceUserById(UUID senderId) {
return userRepository.getReferenceById(senderId);
}
}
@@ -0,0 +1,37 @@
package ru.mtusi.messenger.util;
import ru.mtusi.messenger.exception.InvalidRequestException;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.Base64;
import java.util.UUID;
public final class CursorCodec {
private CursorCodec() {}
public record PageBoundary(Instant createdAt, UUID id) {}
public record Cursor(UUID scopeId, PageBoundary boundary) {}
public static String encode(UUID scopeId, PageBoundary boundary) {
String raw = (scopeId == null ? "" : scopeId.toString())
+ "|" + boundary.createdAt() + "|" + boundary.id();
return Base64.getUrlEncoder().withoutPadding()
.encodeToString(raw.getBytes(StandardCharsets.UTF_8));
}
public static Cursor decode(String cursor) {
try {
String raw = new String(Base64.getUrlDecoder().decode(cursor), StandardCharsets.UTF_8);
String[] p = raw.split("\\|", -1);
UUID scopeId = p[0].isEmpty() ? null : UUID.fromString(p[0]);
PageBoundary boundary = new PageBoundary(
Instant.parse(p[1]), UUID.fromString(p[2]));
return new Cursor(scopeId, boundary);
} catch (Exception e) {
throw new InvalidRequestException("Invalid cursor");
}
}
}
@@ -0,0 +1,17 @@
package ru.mtusi.messenger.util;
import org.springframework.stereotype.Component;
import java.security.SecureRandom;
import java.util.Base64;
@Component
public class TokenGenerator {
private final SecureRandom rng = new SecureRandom();
public String generate() {
byte[] raw = new byte[32];
rng.nextBytes(raw);
return Base64.getUrlEncoder().withoutPadding().encodeToString(raw);
}
}
+57
View File
@@ -0,0 +1,57 @@
spring:
application:
name: messenger-lab2
config:
import: "optional:configtree:/run/secrets/"
lifecycle:
timeout-per-shutdown-phase: 10s
jackson:
default-property-inclusion: non_null
deserialization:
fail-on-unknown-properties: true
datasource:
driver-class-name: org.postgresql.Driver
url: ${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/messenger}
username: ${SPRING_DATASOURCE_USERNAME:messenger}
password: ${SPRING_DATASOURCE_PASSWORD:change-me-local-only}
jpa:
hibernate:
ddl-auto: validate
open-in-view: false
properties:
hibernate:
jdbc:
time_zone: UTC
dialect: org.hibernate.dialect.PostgreSQLDialect
flyway:
enabled: true
locations: classpath:db/migration
server:
address: ${APP_HOST:0.0.0.0}
port: ${APP_PORT:8080}
shutdown: graceful
management:
endpoints:
web:
exposure:
include: health,metrics
endpoint:
health:
probes:
enabled: true
show-details: always
app:
limits:
max-messages-per-chat: ${MAX_MESSAGES_PER_CHAT:10000}
rate:
rate-per-minute: ${RATE_PER_MINUTE:600}
retry-after-seconds: ${RETRY_AFTER_SECONDS:60}
session:
ttl: ${SESSION_TTL_SECONDS:400}s
logging:
pattern:
console: "%d{ISO8601} %-5level [%X{requestId}] %logger{20} - %msg%n"
@@ -0,0 +1,79 @@
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-- ---------- users ----------
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
username VARCHAR(32) NOT NULL,
display_name VARCHAR(100) NOT NULL,
password_hash VARCHAR(255) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT uq_users_username UNIQUE (username),
CONSTRAINT ck_users_username_format
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT ck_users_display_name_not_blank
CHECK (length(btrim(display_name)) > 0)
);
-- ---------- chats ----------
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT ck_chats_title_not_blank CHECK (length(btrim(title)) > 0)
);
-- ---------- chat_members ----------
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
-- ---------- messages ----------
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT ck_messages_text_not_blank CHECK (length(btrim(text)) > 0)
);
-- ---------- sessions ----------
CREATE TABLE sessions (
id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
token_hash BYTEA NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL,
revoked_at TIMESTAMPTZ,
CONSTRAINT uq_sessions_token_hash UNIQUE (token_hash),
CONSTRAINT ck_sessions_expiry CHECK (expires_at > created_at),
CONSTRAINT ck_sessions_token_len CHECK (octet_length(token_hash) = 32)
);
-- =========================================================
-- Indexes (critical for keyset pagination & EXPLAIN on lab5)
-- =========================================================
-- Keyset pagination: ORDER BY created_at ASC, id ASC (JPQL uses ASC)
CREATE INDEX idx_messages_chat_created_asc_id
ON messages (chat_id, created_at ASC, id ASC);
-- "My chats" list (listChats)
CREATE INDEX idx_chat_members_user
ON chat_members (user_id);
-- For chats list pagination: ORDER BY created_at ASC, id ASC
CREATE INDEX idx_chats_created_asc_id
ON chats (created_at ASC, id ASC);
-- Active sessions per user (logout-all / audit)
CREATE INDEX idx_sessions_user_active
ON sessions (user_id)
WHERE revoked_at IS NULL;
-- Cleanup of expired sessions
CREATE INDEX idx_sessions_expires_active
ON sessions (expires_at)
WHERE revoked_at IS NULL;
@@ -0,0 +1,13 @@
package ru.mtusi.messenger;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class MessengerLab1ApplicationTests {
@Test
void contextLoads() {
}
}