forked from mtusi2026/mtusi2026lab4
216 lines
12 KiB
Java
216 lines
12 KiB
Java
package ru.mtusi.messenger;
|
|
|
|
import org.springframework.dao.EmptyResultDataAccessException;
|
|
import org.springframework.dao.DuplicateKeyException;
|
|
import org.springframework.jdbc.core.JdbcTemplate;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.security.MessageDigest;
|
|
import java.sql.Timestamp;
|
|
import java.time.Instant;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import static ru.mtusi.messenger.Models.*;
|
|
|
|
@Service
|
|
public class MessengerStore {
|
|
private final JdbcTemplate jdbc;
|
|
private final CursorCodec cursors;
|
|
|
|
public MessengerStore(JdbcTemplate jdbc, CursorCodec cursors) { this.jdbc = jdbc; this.cursors = cursors; }
|
|
|
|
@Transactional
|
|
public User createUser(String username, String displayName, String passwordHash) {
|
|
UUID id = UUID.randomUUID();
|
|
Instant created = Instant.now();
|
|
try {
|
|
jdbc.update("INSERT INTO users(id, username, display_name, password_hash, created_at) VALUES (?, ?, ?, ?, ?)",
|
|
id, username, displayName, passwordHash, Timestamp.from(created));
|
|
} catch (DuplicateKeyException exception) {
|
|
throw new ApiException(409, "conflict", "username уже занят");
|
|
}
|
|
return findUser(id);
|
|
}
|
|
|
|
public Credentials credentials(String username) {
|
|
try {
|
|
return jdbc.queryForObject("SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = ?",
|
|
(rs, row) -> new Credentials(new User(rs.getObject("id", UUID.class), rs.getString("username"),
|
|
rs.getString("display_name"), rs.getTimestamp("created_at").toInstant()),
|
|
rs.getString("password_hash")), username);
|
|
} catch (EmptyResultDataAccessException exception) { return null; }
|
|
}
|
|
|
|
public User findUser(UUID id) {
|
|
try {
|
|
return jdbc.queryForObject("SELECT id, username, display_name, created_at FROM users WHERE id = ?",
|
|
(rs, row) -> user(rs), id);
|
|
} catch (EmptyResultDataAccessException exception) { return null; }
|
|
}
|
|
|
|
@Transactional
|
|
public Chat createChat(UUID actor, String title, List<UUID> memberIds) {
|
|
if (!memberIds.contains(actor)) throw ApiException.invalid("Участники должны существовать и включать создателя");
|
|
for (UUID member : memberIds) {
|
|
if (findUser(member) == null) throw ApiException.invalid("Участники должны существовать и включать создателя");
|
|
}
|
|
UUID id = UUID.randomUUID();
|
|
Instant created = Instant.now();
|
|
jdbc.update("INSERT INTO chats(id, title, created_at) VALUES (?, ?, ?)", id, title, Timestamp.from(created));
|
|
for (UUID member : memberIds) jdbc.update("INSERT INTO chat_members(chat_id, user_id) VALUES (?, ?)", id, member);
|
|
return chat(actor, id);
|
|
}
|
|
|
|
public Chat chat(UUID actor, UUID id) {
|
|
try {
|
|
Chat chat = jdbc.queryForObject("SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=? AND m.user_id=?",
|
|
(rs, row) -> new Chat(rs.getObject("id", UUID.class), rs.getString("title"),
|
|
loadMembers(rs.getObject("id", UUID.class)), rs.getTimestamp("created_at").toInstant()), id, actor);
|
|
if (chat == null) throw ApiException.notFound();
|
|
return chat;
|
|
} catch (EmptyResultDataAccessException exception) { throw ApiException.notFound(); }
|
|
}
|
|
|
|
@Transactional
|
|
public Message send(UUID actor, UUID chatId, String text) {
|
|
chat(actor, chatId);
|
|
UUID id = UUID.randomUUID();
|
|
Instant created = Instant.now();
|
|
jdbc.update("INSERT INTO messages(id, chat_id, sender_id, text, created_at) VALUES (?, ?, ?, ?, ?)",
|
|
id, chatId, actor, text, Timestamp.from(created));
|
|
return findMessage(id);
|
|
}
|
|
|
|
@Transactional
|
|
public Message sendIdempotent(UUID actor, UUID chatId, String text,
|
|
List<UUID> attachmentIds,
|
|
String method, String requestPath, String idempotencyKey) {
|
|
chat(actor, chatId);
|
|
verifyAttachments(actor, chatId, attachmentIds);
|
|
String requestHash = hashRequest(text, attachmentIds);
|
|
Instant created = Instant.now();
|
|
int inserted = jdbc.update("""
|
|
INSERT INTO message_idempotency(actor_id, method, request_path, idempotency_key,
|
|
request_hash, message_id, created_at)
|
|
VALUES (?, ?, ?, ?, ?, NULL, ?)
|
|
ON CONFLICT (actor_id, method, request_path, idempotency_key) DO NOTHING
|
|
""", actor, method, requestPath, idempotencyKey, requestHash, Timestamp.from(created));
|
|
|
|
if (inserted == 0) {
|
|
IdempotencyRecord previous = jdbc.queryForObject("""
|
|
SELECT request_hash, message_id
|
|
FROM message_idempotency
|
|
WHERE actor_id=? AND method=? AND request_path=? AND idempotency_key=?
|
|
""", (rs, row) -> new IdempotencyRecord(rs.getString("request_hash"),
|
|
rs.getObject("message_id", UUID.class)), actor, method, requestPath, idempotencyKey);
|
|
if (!MessageDigest.isEqual(previous.requestHash().getBytes(StandardCharsets.US_ASCII),
|
|
requestHash.getBytes(StandardCharsets.US_ASCII))) {
|
|
throw new ApiException(409, "conflict", "Idempotency-Key уже использован для другого сообщения");
|
|
}
|
|
if (previous.messageId() == null) {
|
|
throw new ApiException(503, "unavailable", "Результат идемпотентного запроса ещё не готов");
|
|
}
|
|
return findMessage(previous.messageId());
|
|
}
|
|
|
|
UUID id = UUID.randomUUID();
|
|
jdbc.update("INSERT INTO messages(id, chat_id, sender_id, text, created_at) VALUES (?, ?, ?, ?, ?)",
|
|
id, chatId, actor, text, Timestamp.from(created));
|
|
for (UUID attachmentId : attachmentIds) {
|
|
jdbc.update("INSERT INTO message_attachments(message_id, attachment_id) VALUES (?, ?)", id, attachmentId);
|
|
}
|
|
jdbc.update("""
|
|
UPDATE message_idempotency
|
|
SET message_id=?
|
|
WHERE actor_id=? AND method=? AND request_path=? AND idempotency_key=?
|
|
""", id, actor, method, requestPath, idempotencyKey);
|
|
return findMessage(id);
|
|
}
|
|
|
|
public Page<Chat> chats(UUID actor, int limit, String cursor) {
|
|
CursorCodec.Position after = cursors.decode(cursor, "chats:" + actor);
|
|
String sql = "SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=?";
|
|
List<Object> args = new ArrayList<>(List.of(actor));
|
|
if (after != null) { sql += " AND (c.created_at, c.id) > (?, ?)"; args.add(Timestamp.from(after.createdAt())); args.add(after.id()); }
|
|
sql += " ORDER BY c.created_at, c.id LIMIT ?";
|
|
args.add(limit + 1);
|
|
List<Chat> rows = jdbc.query(sql, (rs, row) -> {
|
|
UUID id = rs.getObject("id", UUID.class);
|
|
return new Chat(id, rs.getString("title"), loadMembers(id), rs.getTimestamp("created_at").toInstant());
|
|
}, args.toArray());
|
|
return page(rows, limit, "chats:" + actor, c -> new CursorCodec.Position(c.createdAt(), c.id()));
|
|
}
|
|
|
|
public Page<Message> history(UUID actor, UUID chatId, int limit, String cursor) {
|
|
chat(actor, chatId);
|
|
CursorCodec.Position after = cursors.decode(cursor, "messages:" + chatId);
|
|
String sql = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=?";
|
|
List<Object> args = new ArrayList<>(List.of(chatId));
|
|
if (after != null) { sql += " AND (created_at, id) > (?, ?)"; args.add(Timestamp.from(after.createdAt())); args.add(after.id()); }
|
|
sql += " ORDER BY created_at, id LIMIT ?";
|
|
args.add(limit + 1);
|
|
List<Message> rows = jdbc.query(sql, (rs, row) -> new Message(rs.getObject("id", UUID.class),
|
|
rs.getObject("chat_id", UUID.class), rs.getObject("sender_id", UUID.class), rs.getString("text"),
|
|
rs.getTimestamp("created_at").toInstant(), loadAttachmentIds(rs.getObject("id", UUID.class))), args.toArray());
|
|
return page(rows, limit, "messages:" + chatId, m -> new CursorCodec.Position(m.createdAt(), m.id()));
|
|
}
|
|
|
|
private List<UUID> loadMembers(UUID chatId) {
|
|
return jdbc.query("SELECT user_id FROM chat_members WHERE chat_id=? ORDER BY user_id",
|
|
(rs, row) -> rs.getObject("user_id", UUID.class), chatId);
|
|
}
|
|
|
|
private Message findMessage(UUID id) {
|
|
try {
|
|
return jdbc.queryForObject("SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id=?",
|
|
(rs, row) -> new Message(rs.getObject("id", UUID.class), rs.getObject("chat_id", UUID.class),
|
|
rs.getObject("sender_id", UUID.class), rs.getString("text"), rs.getTimestamp("created_at").toInstant(),
|
|
loadAttachmentIds(rs.getObject("id", UUID.class))), id);
|
|
} catch (EmptyResultDataAccessException exception) {
|
|
throw new ApiException(500, "internal_error", "Созданное сообщение не найдено");
|
|
}
|
|
}
|
|
|
|
private String hashRequest(String text, List<UUID> attachmentIds) {
|
|
try {
|
|
byte[] digest = MessageDigest.getInstance("SHA-256")
|
|
.digest((text + "|" + attachmentIds.stream().map(UUID::toString).sorted().toList()).getBytes(StandardCharsets.UTF_8));
|
|
StringBuilder result = new StringBuilder(digest.length * 2);
|
|
for (byte value : digest) result.append(String.format("%02x", value));
|
|
return result.toString();
|
|
} catch (java.security.NoSuchAlgorithmException exception) {
|
|
throw new IllegalStateException("SHA-256 is unavailable", exception);
|
|
}
|
|
}
|
|
|
|
private void verifyAttachments(UUID actor, UUID chatId, List<UUID> ids) {
|
|
for (UUID id : ids) {
|
|
Integer count = jdbc.queryForObject("SELECT count(*) FROM attachments a JOIN chat_members m ON m.chat_id=a.chat_id WHERE a.id=? AND a.chat_id=? AND m.user_id=? AND a.status='ready'", Integer.class, id, chatId, actor);
|
|
if (count == null || count != 1) throw ApiException.notFound();
|
|
}
|
|
}
|
|
|
|
private List<UUID> loadAttachmentIds(UUID messageId) {
|
|
return jdbc.query("SELECT attachment_id FROM message_attachments WHERE message_id=? ORDER BY attachment_id",
|
|
(rs, row) -> rs.getObject("attachment_id", UUID.class), messageId);
|
|
}
|
|
|
|
private record IdempotencyRecord(String requestHash, UUID messageId) {}
|
|
|
|
private User user(java.sql.ResultSet rs) throws java.sql.SQLException {
|
|
return new User(rs.getObject("id", UUID.class), rs.getString("username"), rs.getString("display_name"),
|
|
rs.getTimestamp("created_at").toInstant());
|
|
}
|
|
|
|
private <T> Page<T> page(List<T> rows, int limit, String scope, java.util.function.Function<T, CursorCodec.Position> position) {
|
|
boolean more = rows.size() > limit;
|
|
List<T> result = more ? rows.subList(0, limit) : rows;
|
|
String next = more ? cursors.encode(scope, position.apply(result.getLast())) : null;
|
|
return new Page<>(result, next);
|
|
}
|
|
}
|