146 lines
3.6 KiB
Go
146 lines
3.6 KiB
Go
package model
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"spark-server/internal/module/friend/entity"
|
|
"spark-server/internal/pkg/errs"
|
|
)
|
|
|
|
func (m *MemoryRepo) SetRemark(_ context.Context, userID, friendID int64, remark string) error {
|
|
return m.updateFriendEdge(userID, friendID, func(rel *entity.Relation) {
|
|
rel.Remark = remark
|
|
rel.UpdatedAt = time.Now()
|
|
})
|
|
}
|
|
|
|
func (m *MemoryRepo) SetPinned(_ context.Context, userID, friendID int64, pinned bool) error {
|
|
return m.updateFriendEdge(userID, friendID, func(rel *entity.Relation) {
|
|
rel.Pinned = pinned
|
|
rel.UpdatedAt = time.Now()
|
|
})
|
|
}
|
|
|
|
func (m *MemoryRepo) updateFriendEdge(userID, friendID int64, fn func(*entity.Relation)) error {
|
|
if userID <= 0 || friendID <= 0 {
|
|
return errs.ErrInvalidArgument
|
|
}
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
rel, ok := m.relations[edgeKey{UserID: userID, FriendID: friendID}]
|
|
if !ok || rel.Status != entity.StatusFriend {
|
|
return errs.ErrNotFound
|
|
}
|
|
fn(rel)
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryRepo) IsBlocked(_ context.Context, userID, targetID int64) (bool, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
rel, ok := m.relations[edgeKey{UserID: userID, FriendID: targetID}]
|
|
return ok && rel.Blocked, nil
|
|
}
|
|
|
|
func (m *MemoryRepo) BlockedEither(_ context.Context, a, b int64) (bool, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
ab := m.relations[edgeKey{UserID: a, FriendID: b}]
|
|
ba := m.relations[edgeKey{UserID: b, FriendID: a}]
|
|
return (ab != nil && ab.Blocked) || (ba != nil && ba.Blocked), nil
|
|
}
|
|
|
|
func (m *MemoryRepo) SetBlocked(_ context.Context, userID, friendID int64, blocked bool) error {
|
|
if userID <= 0 || friendID <= 0 {
|
|
return errs.ErrInvalidArgument
|
|
}
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
now := time.Now()
|
|
key := edgeKey{UserID: userID, FriendID: friendID}
|
|
rel, ok := m.relations[key]
|
|
if !ok {
|
|
if !blocked {
|
|
return nil
|
|
}
|
|
m.relations[key] = &entity.Relation{
|
|
UserID: userID, FriendID: friendID, Status: entity.StatusNone,
|
|
Blocked: true, CreatedAt: now, UpdatedAt: now,
|
|
}
|
|
m.rejectPendingLocked(userID, friendID, now)
|
|
return nil
|
|
}
|
|
rel.Blocked = blocked
|
|
rel.UpdatedAt = now
|
|
if blocked {
|
|
m.rejectPendingLocked(userID, friendID, now)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryRepo) CreateReport(_ context.Context, r *entity.Report) error {
|
|
if r == nil || r.UserID <= 0 || r.TargetID <= 0 {
|
|
return errs.ErrInvalidArgument
|
|
}
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *r
|
|
m.reports = append(m.reports, &cp)
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryRepo) AcceptFriend(_ context.Context, in entity.AcceptParams) error {
|
|
if len(in.Edges) == 0 {
|
|
return errs.ErrInvalidArgument
|
|
}
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
now := time.Now()
|
|
for _, e := range in.Edges {
|
|
if e == nil || e.UserID <= 0 || e.FriendID <= 0 {
|
|
return errs.ErrInvalidArgument
|
|
}
|
|
if e.CreatedAt.IsZero() {
|
|
e.CreatedAt = now
|
|
}
|
|
if e.UpdatedAt.IsZero() {
|
|
e.UpdatedAt = e.CreatedAt
|
|
}
|
|
key := edgeKey{UserID: e.UserID, FriendID: e.FriendID}
|
|
if cur, ok := m.relations[key]; ok {
|
|
cur.Status = entity.StatusFriend
|
|
cur.UpdatedAt = e.UpdatedAt
|
|
if e.Remark != "" {
|
|
cur.Remark = e.Remark
|
|
}
|
|
if e.Source != 0 {
|
|
cur.Source = e.Source
|
|
}
|
|
continue
|
|
}
|
|
cp := *e
|
|
m.relations[key] = &cp
|
|
}
|
|
for _, id := range in.Requests {
|
|
if req := m.requests[id]; req != nil {
|
|
req.Status = entity.RequestAccepted
|
|
req.UpdatedAt = now
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryRepo) DeleteFriend(_ context.Context, a, b int64) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
_, ab := m.relations[edgeKey{UserID: a, FriendID: b}]
|
|
_, ba := m.relations[edgeKey{UserID: b, FriendID: a}]
|
|
if !ab && !ba {
|
|
return errs.ErrNotFound
|
|
}
|
|
delete(m.relations, edgeKey{UserID: a, FriendID: b})
|
|
delete(m.relations, edgeKey{UserID: b, FriendID: a})
|
|
return nil
|
|
}
|