256 lines
6.9 KiB
Go
256 lines
6.9 KiB
Go
package rpc
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
|
||
"github.com/gotd/td/tg"
|
||
|
||
"telesrv/internal/app/users"
|
||
"telesrv/internal/compat/tdesktop"
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
const maxSavedMusicLimit = 100
|
||
|
||
// registerUsers 注册 users.* RPC handler。
|
||
func (r *Router) registerUsers(d *tg.ServerDispatcher) {
|
||
d.OnUsersGetUsers(r.onUsersGetUsers)
|
||
d.OnUsersGetFullUser(r.onUsersGetFullUser)
|
||
d.OnUsersGetSavedMusic(r.onUsersGetSavedMusic)
|
||
d.OnUsersGetSavedMusicByID(r.onUsersGetSavedMusicByID)
|
||
}
|
||
|
||
// onUsersGetUsers 处理 users.getUsers：支持 self 和已知 user peer（含 777000 官方账号）。
|
||
func (r *Router) onUsersGetUsers(ctx context.Context, ids []tg.InputUserClass) ([]tg.UserClass, error) {
|
||
currentUserID, authorized, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
out := make([]tg.UserClass, 0, len(ids))
|
||
for _, in := range ids {
|
||
if r.deps.Users == nil {
|
||
continue
|
||
}
|
||
switch v := in.(type) {
|
||
case *tg.InputUserSelf:
|
||
if !authorized {
|
||
continue
|
||
}
|
||
u, err := r.deps.Users.Self(ctx, currentUserID)
|
||
if err != nil {
|
||
if errors.Is(err, users.ErrNotAuthorized) {
|
||
continue // 未登录：getUsers 尽力而为，跳过 self
|
||
}
|
||
return nil, internalErr()
|
||
}
|
||
out = append(out, r.tgSelfUser(u))
|
||
case *tg.InputUser:
|
||
if !authorized {
|
||
continue
|
||
}
|
||
u, found, err := r.deps.Users.ByID(ctx, currentUserID, v.UserID)
|
||
if err != nil {
|
||
if errors.Is(err, users.ErrNotAuthorized) {
|
||
continue
|
||
}
|
||
return nil, internalErr()
|
||
}
|
||
if !found || (v.AccessHash != 0 && v.AccessHash != u.AccessHash) {
|
||
continue
|
||
}
|
||
out = append(out, r.tgUser(u))
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (r *Router) onUsersGetFullUser(ctx context.Context, id tg.InputUserClass) (*tg.UsersUserFull, error) {
|
||
if r.deps.Users == nil {
|
||
return emptyUserFull(), nil
|
||
}
|
||
currentUserID, _, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
u, found, err := r.userFromInput(ctx, currentUserID, id)
|
||
if err != nil {
|
||
if errors.Is(err, users.ErrNotAuthorized) {
|
||
return emptyUserFull(), nil
|
||
}
|
||
return nil, internalErr()
|
||
}
|
||
if !found {
|
||
return emptyUserFull(), nil
|
||
}
|
||
user := r.tgUser(u)
|
||
if _, ok := id.(*tg.InputUserSelf); ok {
|
||
user = r.tgSelfUser(u)
|
||
}
|
||
about := u.About
|
||
if r.deps.Privacy != nil && u.ID != currentUserID {
|
||
allowed, err := r.deps.Privacy.CanSee(ctx, u.ID, currentUserID, domain.PrivacyKeyAbout)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
if !allowed {
|
||
about = ""
|
||
}
|
||
}
|
||
full := tg.UserFull{
|
||
ID: u.ID,
|
||
About: about,
|
||
Settings: tg.PeerSettings{},
|
||
NotifySettings: *tdesktop.NotifySettings(),
|
||
}
|
||
if err := r.fillUserFullPhotos(ctx, currentUserID, u.ID, &full); err != nil {
|
||
return nil, err
|
||
}
|
||
if r.deps.Channels != nil && u.ID != currentUserID {
|
||
common, err := r.deps.Channels.CommonChannels(ctx, currentUserID, domain.CommonChannelsRequest{
|
||
UserID: currentUserID,
|
||
TargetUserID: u.ID,
|
||
Limit: 1,
|
||
CountOnly: true,
|
||
})
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
full.CommonChatsCount = common.Count
|
||
}
|
||
return &tg.UsersUserFull{
|
||
FullUser: full,
|
||
Users: []tg.UserClass{user},
|
||
}, nil
|
||
}
|
||
|
||
func (r *Router) onUsersGetSavedMusic(ctx context.Context, req *tg.UsersGetSavedMusicRequest) (tg.UsersSavedMusicClass, error) {
|
||
if req == nil || req.Offset < 0 || req.Limit < 0 || req.Limit > maxSavedMusicLimit {
|
||
return nil, limitInvalidErr()
|
||
}
|
||
if err := r.validateInputUser(ctx, req.ID); err != nil {
|
||
return nil, err
|
||
}
|
||
return &tg.UsersSavedMusic{
|
||
Count: 0,
|
||
Documents: []tg.DocumentClass{},
|
||
}, nil
|
||
}
|
||
|
||
func (r *Router) onUsersGetSavedMusicByID(ctx context.Context, req *tg.UsersGetSavedMusicByIDRequest) (tg.UsersSavedMusicClass, error) {
|
||
if req == nil || len(req.Documents) > maxSavedMusicLimit {
|
||
return nil, limitInvalidErr()
|
||
}
|
||
if err := r.validateInputUser(ctx, req.ID); err != nil {
|
||
return nil, err
|
||
}
|
||
return &tg.UsersSavedMusic{
|
||
Count: 0,
|
||
Documents: []tg.DocumentClass{},
|
||
}, nil
|
||
}
|
||
|
||
func (r *Router) fillUserFullPhotos(ctx context.Context, viewerUserID, ownerUserID int64, full *tg.UserFull) error {
|
||
if r.deps.Files == nil || full == nil || ownerUserID == 0 {
|
||
return nil
|
||
}
|
||
if viewerUserID == ownerUserID {
|
||
if photo, found, err := r.deps.Files.CurrentProfilePhotoKind(ctx, domain.PeerTypeUser, ownerUserID, domain.ProfilePhotoKindProfile); err != nil {
|
||
return internalErr()
|
||
} else if found {
|
||
full.SetProfilePhoto(tgPhoto(photo))
|
||
}
|
||
if photo, found, err := r.deps.Files.CurrentProfilePhotoKind(ctx, domain.PeerTypeUser, ownerUserID, domain.ProfilePhotoKindFallback); err != nil {
|
||
return internalErr()
|
||
} else if found {
|
||
full.SetFallbackPhoto(tgPhoto(photo))
|
||
}
|
||
return nil
|
||
}
|
||
if r.deps.Contacts != nil {
|
||
refs, err := r.deps.Contacts.PersonalPhotos(ctx, viewerUserID, []int64{ownerUserID})
|
||
if err != nil {
|
||
return internalErr()
|
||
}
|
||
if ref, ok := refs[ownerUserID]; ok && ref.PhotoID != 0 {
|
||
photo, found, err := r.deps.Files.GetPhoto(ctx, ref.PhotoID)
|
||
if err != nil {
|
||
return internalErr()
|
||
}
|
||
if found {
|
||
full.SetPersonalPhoto(tgPhoto(photo))
|
||
}
|
||
}
|
||
}
|
||
profileAllowed := true
|
||
if r.deps.Privacy != nil {
|
||
var err error
|
||
profileAllowed, err = r.deps.Privacy.CanSee(ctx, ownerUserID, viewerUserID, domain.PrivacyKeyProfilePhoto)
|
||
if err != nil {
|
||
return internalErr()
|
||
}
|
||
}
|
||
if profileAllowed {
|
||
if photo, found, err := r.deps.Files.CurrentProfilePhotoKind(ctx, domain.PeerTypeUser, ownerUserID, domain.ProfilePhotoKindProfile); err != nil {
|
||
return internalErr()
|
||
} else if found {
|
||
full.SetProfilePhoto(tgPhoto(photo))
|
||
}
|
||
return nil
|
||
}
|
||
if photo, found, err := r.deps.Files.CurrentProfilePhotoKind(ctx, domain.PeerTypeUser, ownerUserID, domain.ProfilePhotoKindFallback); err != nil {
|
||
return internalErr()
|
||
} else if found {
|
||
full.SetFallbackPhoto(tgPhoto(photo))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func emptyUserFull() *tg.UsersUserFull {
|
||
return &tg.UsersUserFull{
|
||
FullUser: tg.UserFull{
|
||
Settings: tg.PeerSettings{},
|
||
NotifySettings: *tdesktop.NotifySettings(),
|
||
},
|
||
}
|
||
}
|
||
|
||
func (r *Router) userFromInput(ctx context.Context, currentUserID int64, id tg.InputUserClass) (domain.User, bool, error) {
|
||
switch v := id.(type) {
|
||
case *tg.InputUserSelf:
|
||
u, err := r.deps.Users.Self(ctx, currentUserID)
|
||
return u, err == nil, err
|
||
case *tg.InputUser:
|
||
u, found, err := r.deps.Users.ByID(ctx, currentUserID, v.UserID)
|
||
if err != nil || !found {
|
||
return domain.User{}, found, err
|
||
}
|
||
if v.AccessHash != 0 && v.AccessHash != u.AccessHash {
|
||
return domain.User{}, false, nil
|
||
}
|
||
return u, true, nil
|
||
default:
|
||
return domain.User{}, false, nil
|
||
}
|
||
}
|
||
|
||
func (r *Router) validateInputUser(ctx context.Context, id tg.InputUserClass) error {
|
||
if r.deps.Users == nil {
|
||
return nil
|
||
}
|
||
currentUserID, _, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return internalErr()
|
||
}
|
||
_, found, err := r.userFromInput(ctx, currentUserID, id)
|
||
if err != nil {
|
||
if errors.Is(err, users.ErrNotAuthorized) {
|
||
return userIDInvalidErr()
|
||
}
|
||
return internalErr()
|
||
}
|
||
if !found {
|
||
return userIDInvalidErr()
|
||
}
|
||
return nil
|
||
}
|