-
Notifications
You must be signed in to change notification settings - Fork 0
/
signup.go
109 lines (92 loc) · 3.08 KB
/
signup.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package usersvc
import (
"context"
"strings"
"github.com/sisukasco/commons/http_utils"
"github.com/sisukasco/commons/stringid"
"github.com/sisukasco/commons/utils"
"github.com/sisukasco/henki/pkg/db"
"github.com/sisukasco/henki/pkg/external"
)
// SignupParams are the parameters the Signup endpoint accepts
type SignupParams struct {
Email string `json:"email"`
Password string `json:"password"`
Data map[string]interface{} `json:"data"`
Provider string `json:"-"`
}
func (this *UserService) SignupNewUser(ctx context.Context, params *SignupParams) (*db.User, error) {
email := utils.CleanupString(params.Email)
passwd := strings.TrimSpace(params.Password)
if passwd == "" {
return nil, http_utils.UnprocessableEntityError("Signup requires a valid password")
}
if len(passwd) > 250 {
return nil, http_utils.UnprocessableEntityError("Too long password ")
}
if len(email) > 250 {
return nil, http_utils.UnprocessableEntityError("Too long email address ")
}
err := utils.ValidateEmail(email)
if err != nil {
return nil, http_utils.UnprocessableEntityError("%v", err)
}
exists, err := DoesUserExist(ctx, this.svc.DB.Q, email)
if err != nil {
return nil, http_utils.InternalServerError("Couldn' Process Request").WithInternalError(err)
}
if exists {
return nil, http_utils.BadRequestError("A user with this email address has already been registered")
}
user, err := NewUser(ctx, this.svc.DB.Q, email, passwd, params.Data)
if err != nil {
return nil, http_utils.InternalServerError("Couldn't create new user").WithInternalError(err)
}
this.PostConfirmationEmail(user.ID)
return user, nil
}
func (usvc *UserService) AuthenticateExternalUser(ctx context.Context,
userInfo *external.UserProvidedData) (*AccessTokenResponse, error) {
email := utils.CleanupString(userInfo.Email)
exists, err := DoesUserExist(ctx, usvc.svc.DB.Q, email)
if err != nil {
return nil, http_utils.InternalServerError("Couldn't check for User").WithInternalError(err)
}
if exists {
user, err := GetUserByEmail(ctx, usvc.svc.DB.Q, email)
if err != nil {
return nil, http_utils.InternalServerError("Couldn't get User Rec").WithInternalError(err)
}
if user.BannedAt.Valid {
return nil, http_utils.OauthError("access_denied", "user is blocked")
}
return usvc.createAccessTokenForUser(ctx, user)
} else {
passwd := stringid.RandString(32)
var params SignupParams
params.Email = email
params.Password = passwd
params.Provider = userInfo.Provider
user, err := usvc.SignupNewUser(ctx, ¶ms)
if err != nil {
return nil, err
}
uparams := db.UpdateUserProfileParams{
ID: user.ID,
FirstName: userInfo.FirstName,
LastName: userInfo.LastName,
AvatarUrl: userInfo.AvatarURL,
}
if len(uparams.FirstName) <= 0 && len(userInfo.Name) > 0 {
uparams.FirstName = userInfo.Name
}
err = usvc.svc.DB.Q.UpdateUserProfile(ctx, uparams)
if err != nil {
return nil, err
}
if userInfo.Verified {
usvc.svc.DB.Q.ConfirmUserEmailByID(ctx, user.ID)
}
return usvc.createAccessTokenForUser(ctx, user)
}
}