319 lines
9.8 KiB
Go
319 lines
9.8 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
type captureAuthService struct {
|
|
resolvedAuthKeyID [8]byte
|
|
hasResolved bool
|
|
resolveCount int
|
|
userID int64
|
|
userIDCount int
|
|
signInUser domain.User
|
|
signUpPhone string
|
|
signUpHash string
|
|
signUpFirstName string
|
|
signUpLastName string
|
|
signUpAuth domain.Authorization
|
|
signUpUser domain.User
|
|
acceptedAuth domain.Authorization
|
|
acceptedUserID int64
|
|
authorizations []domain.Authorization
|
|
authorizationLookups int
|
|
authorizationLists int
|
|
layerUpdates int
|
|
authKeyClientInfos map[[8]byte]domain.AuthKeyClientInfo
|
|
authKeyInfoLookups int
|
|
loggedOutAuthKeyID [8]byte
|
|
pendingPasswordUserID int64
|
|
pendingPassword bool
|
|
completedPasswordKey [8]byte
|
|
completePasswordCount int
|
|
codeDelivery domain.AuthCodeDelivery
|
|
signInWithEmailCount int
|
|
}
|
|
|
|
type blockingUserAuthService struct {
|
|
userID int64
|
|
started chan struct{}
|
|
release chan struct{}
|
|
once sync.Once
|
|
mu sync.Mutex
|
|
count int
|
|
}
|
|
|
|
func (s *blockingUserAuthService) UserIDCount() int {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.count
|
|
}
|
|
|
|
func (s *blockingUserAuthService) BindTempAuthKey(context.Context, int64, domain.TempAuthKeyBinding) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) ResolveAuthKey(context.Context, [8]byte) ([8]byte, bool, error) {
|
|
return [8]byte{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) UserID(ctx context.Context, _ [8]byte) (int64, bool, error) {
|
|
s.mu.Lock()
|
|
s.count++
|
|
s.mu.Unlock()
|
|
s.once.Do(func() { close(s.started) })
|
|
select {
|
|
case <-s.release:
|
|
return s.userID, s.userID != 0, nil
|
|
case <-ctx.Done():
|
|
return 0, false, ctx.Err()
|
|
}
|
|
}
|
|
|
|
func (s *blockingUserAuthService) SendCode(context.Context, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) CodeDelivery(context.Context, string) (domain.AuthCodeDelivery, bool, error) {
|
|
return domain.AuthCodeDelivery{Kind: domain.AuthCodeDeliveryPhone, Length: devCodeLength}, true, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) ResendCode(context.Context, string, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) CancelCode(context.Context, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) SignIn(context.Context, domain.Authorization, string, string, string) (domain.User, domain.Message, bool, error) {
|
|
return domain.User{}, domain.Message{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) SignInWithEmail(context.Context, domain.Authorization, string, string, string) (domain.User, domain.Message, bool, error) {
|
|
return domain.User{}, domain.Message{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) BindVerifiedLogin(_ context.Context, _ domain.Authorization, userID int64) (domain.User, error) {
|
|
return domain.User{ID: userID}, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) SignUp(context.Context, domain.Authorization, string, string, string, string) (domain.User, domain.Message, error) {
|
|
return domain.User{}, domain.Message{}, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) AcceptLoginToken(context.Context, domain.Authorization, int64) (domain.Authorization, error) {
|
|
return domain.Authorization{}, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) SignInBot(context.Context, domain.Authorization, string) (domain.User, error) {
|
|
return domain.User{}, domain.ErrBotTokenInvalid
|
|
}
|
|
|
|
func (s *blockingUserAuthService) LogOut(context.Context, [8]byte) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) Authorization(context.Context, [8]byte) (domain.Authorization, bool, error) {
|
|
return domain.Authorization{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) UpdateAuthorizationLayer(context.Context, [8]byte, int) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) AuthKeyClientInfo(context.Context, [8]byte) (domain.AuthKeyClientInfo, bool, error) {
|
|
return domain.AuthKeyClientInfo{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) UpdateAuthKeyClientInfo(context.Context, [8]byte, domain.AuthKeyClientInfo) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) ListAuthorizations(context.Context, int64) ([]domain.Authorization, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) ResetAuthorization(context.Context, int64, int64) (domain.Authorization, bool, error) {
|
|
return domain.Authorization{}, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) ResetAuthorizations(context.Context, int64, [8]byte) ([]domain.Authorization, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) PendingPasswordUserID(context.Context, [8]byte) (int64, bool, error) {
|
|
return 0, false, nil
|
|
}
|
|
|
|
func (s *blockingUserAuthService) CompletePasswordSignIn(context.Context, [8]byte) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) BindTempAuthKey(context.Context, int64, domain.TempAuthKeyBinding) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) ResolveAuthKey(context.Context, [8]byte) ([8]byte, bool, error) {
|
|
s.resolveCount++
|
|
return s.resolvedAuthKeyID, s.hasResolved, nil
|
|
}
|
|
|
|
func (s *captureAuthService) UserID(context.Context, [8]byte) (int64, bool, error) {
|
|
s.userIDCount++
|
|
return s.userID, s.userID != 0, nil
|
|
}
|
|
|
|
func (s *captureAuthService) SendCode(context.Context, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (s *captureAuthService) CodeDelivery(context.Context, string) (domain.AuthCodeDelivery, bool, error) {
|
|
if s.codeDelivery.Kind != "" {
|
|
return s.codeDelivery, true, nil
|
|
}
|
|
return domain.AuthCodeDelivery{Kind: domain.AuthCodeDeliveryPhone, Length: devCodeLength}, true, nil
|
|
}
|
|
|
|
func (s *captureAuthService) ResendCode(context.Context, string, string) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (s *captureAuthService) CancelCode(context.Context, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) SignIn(context.Context, domain.Authorization, string, string, string) (domain.User, domain.Message, bool, error) {
|
|
if s.signInUser.ID != 0 {
|
|
return s.signInUser, domain.Message{}, false, nil
|
|
}
|
|
return domain.User{}, domain.Message{}, false, nil
|
|
}
|
|
|
|
func (s *captureAuthService) SignInWithEmail(context.Context, domain.Authorization, string, string, string) (domain.User, domain.Message, bool, error) {
|
|
s.signInWithEmailCount++
|
|
if s.signInUser.ID != 0 {
|
|
return s.signInUser, domain.Message{}, false, nil
|
|
}
|
|
return domain.User{}, domain.Message{}, false, nil
|
|
}
|
|
|
|
func (s *captureAuthService) BindVerifiedLogin(_ context.Context, _ domain.Authorization, userID int64) (domain.User, error) {
|
|
if s.signInUser.ID != 0 {
|
|
return s.signInUser, nil
|
|
}
|
|
return domain.User{ID: userID}, nil
|
|
}
|
|
|
|
func (s *captureAuthService) SignUp(_ context.Context, a domain.Authorization, phone, hash, first, last string) (domain.User, domain.Message, error) {
|
|
s.signUpAuth = a
|
|
s.signUpPhone = phone
|
|
s.signUpHash = hash
|
|
s.signUpFirstName = first
|
|
s.signUpLastName = last
|
|
if s.signUpUser.ID != 0 {
|
|
return s.signUpUser, domain.Message{}, nil
|
|
}
|
|
return domain.User{}, domain.Message{}, nil
|
|
}
|
|
|
|
func (s *captureAuthService) AcceptLoginToken(_ context.Context, a domain.Authorization, userID int64) (domain.Authorization, error) {
|
|
a.UserID = userID
|
|
if a.Hash == 0 {
|
|
a.Hash = 77
|
|
}
|
|
s.acceptedAuth = a
|
|
s.acceptedUserID = userID
|
|
return a, nil
|
|
}
|
|
|
|
func (s *captureAuthService) SignInBot(context.Context, domain.Authorization, string) (domain.User, error) {
|
|
if s.signInUser.ID != 0 {
|
|
return s.signInUser, nil
|
|
}
|
|
return domain.User{}, domain.ErrBotTokenInvalid
|
|
}
|
|
|
|
func (s *captureAuthService) LogOut(_ context.Context, authKeyID [8]byte) error {
|
|
s.loggedOutAuthKeyID = authKeyID
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) Authorization(_ context.Context, authKeyID [8]byte) (domain.Authorization, bool, error) {
|
|
s.authorizationLookups++
|
|
for _, item := range s.authorizations {
|
|
if item.AuthKeyID == authKeyID {
|
|
return item, true, nil
|
|
}
|
|
}
|
|
return domain.Authorization{}, false, nil
|
|
}
|
|
|
|
func (s *captureAuthService) UpdateAuthorizationLayer(_ context.Context, authKeyID [8]byte, layer int) error {
|
|
s.layerUpdates++
|
|
for i := range s.authorizations {
|
|
if s.authorizations[i].AuthKeyID == authKeyID {
|
|
s.authorizations[i].Layer = layer
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) AuthKeyClientInfo(_ context.Context, authKeyID [8]byte) (domain.AuthKeyClientInfo, bool, error) {
|
|
s.authKeyInfoLookups++
|
|
info, ok := s.authKeyClientInfos[authKeyID]
|
|
return info, ok, nil
|
|
}
|
|
|
|
func (s *captureAuthService) UpdateAuthKeyClientInfo(_ context.Context, authKeyID [8]byte, info domain.AuthKeyClientInfo) error {
|
|
if s.authKeyClientInfos == nil {
|
|
s.authKeyClientInfos = make(map[[8]byte]domain.AuthKeyClientInfo)
|
|
}
|
|
current := s.authKeyClientInfos[authKeyID]
|
|
if info.Layer > 0 {
|
|
current.Layer = info.Layer
|
|
}
|
|
if info.DeviceModel != "" {
|
|
current.DeviceModel = info.DeviceModel
|
|
}
|
|
if info.Platform != "" {
|
|
current.Platform = info.Platform
|
|
}
|
|
if info.SystemVersion != "" {
|
|
current.SystemVersion = info.SystemVersion
|
|
}
|
|
if info.APIID != 0 {
|
|
current.APIID = info.APIID
|
|
}
|
|
if info.AppVersion != "" {
|
|
current.AppVersion = info.AppVersion
|
|
}
|
|
s.authKeyClientInfos[authKeyID] = current
|
|
return nil
|
|
}
|
|
|
|
func (s *captureAuthService) ListAuthorizations(context.Context, int64) ([]domain.Authorization, error) {
|
|
s.authorizationLists++
|
|
return append([]domain.Authorization(nil), s.authorizations...), nil
|
|
}
|
|
|
|
func (s *captureAuthService) ResetAuthorization(context.Context, int64, int64) (domain.Authorization, bool, error) {
|
|
return domain.Authorization{}, false, nil
|
|
}
|
|
|
|
func (s *captureAuthService) ResetAuthorizations(context.Context, int64, [8]byte) ([]domain.Authorization, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *captureAuthService) PendingPasswordUserID(context.Context, [8]byte) (int64, bool, error) {
|
|
return s.pendingPasswordUserID, s.pendingPassword, nil
|
|
}
|
|
|
|
func (s *captureAuthService) CompletePasswordSignIn(_ context.Context, authKeyID [8]byte) error {
|
|
s.completedPasswordKey = authKeyID
|
|
s.completePasswordCount++
|
|
return nil
|
|
}
|