Ilia Denisov
81b9e1529e
CI / changes (pull_request) Successful in 2s
CI / unit (pull_request) Successful in 9s
CI / integration (pull_request) Successful in 15s
CI / ui (pull_request) Successful in 51s
CI / gate (pull_request) Successful in 0s
CI / deploy (pull_request) Successful in 1m19s
Make a per-user block one-directional and non-destructive: the blocker stops
receiving everything from the blocked user (chat, nudge, friend requests,
invitations) and the matchmaker never pairs them, while the blocked user
notices nothing — their sends still persist by the normal rules but are never
delivered or surfaced (born-read). A block no longer deletes the friendship
(an unblock cleanly restores it) and instant-reads any unread the blocked user
had left for the blocker.
- backend: a directional blockExists guard across chat/nudge/friends/invitations
(store-but-hide for the blocked->blocker direction, refuse blocker->blocked);
the matchmaker excludes a block-related pair (both directions) from auto-match;
user_blocked/user_unblocked notifications to the blocker only (in-app only).
- ui: the opponent score card gains a block ✖️ control mirroring add-friend
(red "Block?" confirm, mutual-hide while confirming, struck name, hidden chat
composer when blocked); optimistic apply + event confirm + rollback for both.
- admin: the user card gains cross-linked blocks / blocked-by / friends lists.
- docs: FUNCTIONAL(+ru), ARCHITECTURE §10 + decision record, UI_DESIGN, PRERELEASE.
78 lines
2.0 KiB
Go
78 lines
2.0 KiB
Go
package server
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// The /api/v1/user/blocks/* handlers wire the per-user block list. A block is asymmetric:
|
|
// the blocker stops seeing everything from the blocked user (chat, nudge, requests,
|
|
// invitations, matchmaking) while the blocked user notices nothing; it overrides — but does
|
|
// not delete — any friendship (an unblock restores it). They reuse the friend handlers'
|
|
// targetIDRequest and account-ref resolution.
|
|
|
|
// blockListDTO is the accounts the caller has blocked.
|
|
type blockListDTO struct {
|
|
Blocked []accountRefDTO `json:"blocked"`
|
|
}
|
|
|
|
// handleBlock blocks the body-supplied account.
|
|
func (s *Server) handleBlock(c *gin.Context) {
|
|
uid, ok := userID(c)
|
|
if !ok {
|
|
abortBadRequest(c, "missing identity")
|
|
return
|
|
}
|
|
var req targetIDRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
abortBadRequest(c, "invalid request body")
|
|
return
|
|
}
|
|
target, ok := parseUUIDField(req.AccountID)
|
|
if !ok {
|
|
abortBadRequest(c, "invalid account id")
|
|
return
|
|
}
|
|
if err := s.social.Block(c.Request.Context(), uid, target); err != nil {
|
|
s.abortErr(c, err)
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, okResponse{OK: true})
|
|
}
|
|
|
|
// handleUnblock removes the caller's block on the :id account.
|
|
func (s *Server) handleUnblock(c *gin.Context) {
|
|
uid, ok := userID(c)
|
|
if !ok {
|
|
abortBadRequest(c, "missing identity")
|
|
return
|
|
}
|
|
target, err := uuid.Parse(c.Param("id"))
|
|
if err != nil {
|
|
abortBadRequest(c, "invalid account id")
|
|
return
|
|
}
|
|
if err := s.social.Unblock(c.Request.Context(), uid, target); err != nil {
|
|
s.abortErr(c, err)
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, okResponse{OK: true})
|
|
}
|
|
|
|
// handleListBlocks returns the accounts the caller has blocked.
|
|
func (s *Server) handleListBlocks(c *gin.Context) {
|
|
uid, ok := userID(c)
|
|
if !ok {
|
|
abortBadRequest(c, "missing identity")
|
|
return
|
|
}
|
|
ids, err := s.social.ListBlocks(c.Request.Context(), uid)
|
|
if err != nil {
|
|
s.abortErr(c, err)
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, blockListDTO{Blocked: s.accountRefs(c.Request.Context(), ids)})
|
|
}
|