Skip to content

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Apache Answer.

feat(plugin): The third-party login send binding email

LinkinStar06db2bd091dd
diff --git a/cmd/answer/wire_gen.go b/cmd/answer/wire_gen.go
index 6070af38..3134d0d4 100644
--- a/cmd/answer/wire_gen.go
+++ b/cmd/answer/wire_gen.go
@@ -213,8 +213,8 @@ func initApplication(debug bool, serverConf *conf.Server, dbConf *data.Database,
templateController := controller.NewTemplateController(templateRenderController, siteInfoCommonService)
templateRouter := router.NewTemplateRouter(templateController, templateRenderController, siteInfoController)
userExternalLoginRepo := user_external_login.NewUserExternalLoginRepo(dataData)
- userExternalLoginService := user_external_login2.NewUserExternalLoginService(userRepo, userCommon, userExternalLoginRepo)
- connectorController := controller.NewConnectorController(siteInfoCommonService, userExternalLoginService)
+ userExternalLoginService := user_external_login2.NewUserExternalLoginService(userRepo, userCommon, userExternalLoginRepo, emailService, siteInfoCommonService, userActiveActivityRepo)
+ connectorController := controller.NewConnectorController(siteInfoCommonService, emailService, userExternalLoginService)
pluginAPIRouter := router.NewPluginAPIRouter(connectorController)
ginEngine := server.NewHTTPServer(debug, staticRouter, answerAPIRouter, swaggerRouter, uiRouter, authUserMiddleware, avatarMiddleware, templateRouter, pluginAPIRouter)
scheduledTaskManager := cron.NewScheduledTaskManager(siteInfoCommonService, questionService)
diff --git a/internal/base/constant/connector.go b/internal/base/constant/connector.go
index bb14aef0..fcf181f4 100644
--- a/internal/base/constant/connector.go
+++ b/internal/base/constant/connector.go
@@ -4,5 +4,5 @@ import "time"
const (
ConnectorUserExternalInfoCacheKey = "answer:connector:"
- ConnectorUserExternalInfoCacheTime = 24 * time.Hour
+ ConnectorUserExternalInfoCacheTime = 10 * time.Minute
)
diff --git a/internal/controller/connector_controller.go b/internal/controller/connector_controller.go
index 148e2ad4..47b9ba51 100644
--- a/internal/controller/connector_controller.go
+++ b/internal/controller/connector_controller.go
@@ -5,46 +5,53 @@ import (
"net/http"
"github.com/answerdev/answer/internal/base/handler"
+ "github.com/answerdev/answer/internal/base/reason"
"github.com/answerdev/answer/internal/plugin"
_ "github.com/answerdev/answer/internal/plugin/connector"
"github.com/answerdev/answer/internal/schema"
+ "github.com/answerdev/answer/internal/service/export"
"github.com/answerdev/answer/internal/service/siteinfo_common"
"github.com/answerdev/answer/internal/service/user_external_login"
"github.com/gin-gonic/gin"
+ "github.com/segmentfault/pacman/errors"
"github.com/segmentfault/pacman/log"
)
const (
- ConnectorRedirectRouterPrefix = "/answer/api/v1/connector/redirect/"
ConnectorLoginRouterPrefix = "/answer/api/v1/connector/login/"
+ ConnectorRedirectRouterPrefix = "/answer/api/v1/connector/redirect/"
)
// ConnectorController comment controller
type ConnectorController struct {
siteInfoService *siteinfo_common.SiteInfoCommonService
userExternalService *user_external_login.UserExternalLoginService
+ emailService *export.EmailService
}
// NewConnectorController new controller
func NewConnectorController(
siteInfoService *siteinfo_common.SiteInfoCommonService,
+ emailService *export.EmailService,
userExternalService *user_external_login.UserExternalLoginService,
) *ConnectorController {
return &ConnectorController{
siteInfoService: siteInfoService,
userExternalService: userExternalService,
+ emailService: emailService,
}
}
-func (cc *ConnectorController) ConnectorRedirect(connector plugin.Connector) (fn func(ctx *gin.Context)) {
+func (cc *ConnectorController) ConnectorLogin(connector plugin.Connector) (fn func(ctx *gin.Context)) {
return func(ctx *gin.Context) {
general, err := cc.siteInfoService.GetSiteGeneral(ctx)
if err != nil {
+ log.Error(err)
ctx.Redirect(http.StatusFound, "/50x")
return
}
- receiverURL := fmt.Sprintf("%s%s%s", general.SiteUrl, ConnectorLoginRouterPrefix, connector.ConnectorSlugName())
+ receiverURL := fmt.Sprintf("%s%s%s", general.SiteUrl, ConnectorRedirectRouterPrefix, connector.ConnectorSlugName())
redirectURL := connector.ConnectorSender(ctx, receiverURL)
if len(redirectURL) > 0 {
ctx.Redirect(http.StatusFound, redirectURL)
@@ -53,17 +60,24 @@ func (cc *ConnectorController) ConnectorRedirect(connector plugin.Connector) (fn
}
}
-func (cc *ConnectorController) ConnectorLogin(connector plugin.Connector) (fn func(ctx *gin.Context)) {
+func (cc *ConnectorController) ConnectorRedirect(connector plugin.Connector) (fn func(ctx *gin.Context)) {
return func(ctx *gin.Context) {
userInfo, err := connector.ConnectorReceiver(ctx)
if err != nil {
+ log.Errorf("connector received failed: %v", err)
ctx.Redirect(http.StatusFound, "/50x")
return
}
- userInfo.Provider = connector.ConnectorSlugName()
- resp, err := cc.userExternalService.ExternalLogin(ctx, userInfo)
+ u := &schema.ExternalLoginUserInfoCache{
+ Provider: connector.ConnectorSlugName(),
+ ExternalID: userInfo.ExternalID,
+ Name: userInfo.Name,
+ Email: userInfo.Email,
+ MetaInfo: userInfo.MetaInfo,
+ }
+ resp, err := cc.userExternalService.ExternalLogin(ctx, u)
if err != nil {
- log.Error(err)
+ log.Errorf("external login failed: %v", err)
ctx.Redirect(http.StatusFound, "/50x")
return
}
@@ -103,6 +117,7 @@ func (cc *ConnectorController) ExternalLoginBindingUserSendEmail(ctx *gin.Contex
if handler.BindAndCheck(ctx, req) {
return
}
+
resp, err := cc.userExternalService.ExternalLoginBindingUserSendEmail(ctx, req)
handler.HandleResponse(ctx, err, resp)
}
@@ -112,6 +127,14 @@ func (cc *ConnectorController) ExternalLoginBindingUser(ctx *gin.Context) {
if handler.BindAndCheck(ctx, req) {
return
}
+
+ req.Content = cc.emailService.VerifyUrlExpired(ctx, req.Code)
+ if len(req.Content) == 0 {
+ handler.HandleResponse(ctx, errors.Forbidden(reason.EmailVerifyURLExpired),
+ &schema.ForbiddenResp{Type: schema.ForbiddenReasonTypeURLExpired})
+ return
+ }
+
resp, err := cc.userExternalService.ExternalLoginBindingUser(ctx, req)
handler.HandleResponse(ctx, err, resp)
}
diff --git a/internal/plugin/connector.go b/internal/plugin/connector.go
index 821aa3a6..762b7f0a 100644
--- a/internal/plugin/connector.go
+++ b/internal/plugin/connector.go
@@ -31,9 +31,6 @@ type Connector interface {
// ExternalLoginUserInfo external login user info
type ExternalLoginUserInfo struct {
- // Third party identification
- // e.g. facebook, twitter, instagram
- Provider string
// required. The unique user ID provided by the third-party login
ExternalID string
// optional. This name is used preferentially during registration
diff --git a/internal/repo/user/user_repo.go b/internal/repo/user/user_repo.go
index e5a33314..7c47ae91 100644
--- a/internal/repo/user/user_repo.go
+++ b/internal/repo/user/user_repo.go
@@ -10,6 +10,7 @@ import (
"github.com/answerdev/answer/internal/service/config"
usercommon "github.com/answerdev/answer/internal/service/user_common"
"github.com/segmentfault/pacman/errors"
+ "xorm.io/xorm"
)
// userRepo user repository
@@ -28,10 +29,21 @@ func NewUserRepo(data *data.Data, configRepo config.ConfigRepo) usercommon.UserR
// AddUser add user
func (ur *userRepo) AddUser(ctx context.Context, user *entity.User) (err error) {
- _, err = ur.data.DB.Insert(user)
- if err != nil {
- err = errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
- }
+ _, err = ur.data.DB.Transaction(func(session *xorm.Session) (interface{}, error) {
+ userInfo := &entity.User{}
+ exist, err := session.Where("username = ?", user.Username).Get(userInfo)
+ if err != nil {
+ return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
+ }
+ if exist {
+ return nil, errors.InternalServer(reason.UsernameDuplicate)
+ }
+ _, err = session.Insert(user)
+ if err != nil {
+ return nil, errors.InternalServer(reason.DatabaseError).WithError(err).WithStack()
+ }
+ return nil, nil
+ })
return
}
diff --git a/internal/repo/user_external_login/user_external_login_repo.go b/internal/repo/user_external_login/user_external_login_repo.go
index ce54f414..78b1d474 100644
--- a/internal/repo/user_external_login/user_external_login_repo.go
+++ b/internal/repo/user_external_login/user_external_login_repo.go
@@ -8,7 +8,7 @@ import (
"github.com/answerdev/answer/internal/base/data"
"github.com/answerdev/answer/internal/base/reason"
"github.com/answerdev/answer/internal/entity"
- "github.com/answerdev/answer/internal/plugin"
+ "github.com/answerdev/answer/internal/schema"
"github.com/answerdev/answer/internal/service/user_external_login"
"github.com/segmentfault/pacman/errors"
)
@@ -55,15 +55,15 @@ func (ur *userExternalLoginRepo) GetByExternalID(ctx context.Context, externalID
// SetCacheUserExternalLoginInfo cache user info for external login
func (ur *userExternalLoginRepo) SetCacheUserExternalLoginInfo(
- ctx context.Context, key string, info plugin.ExternalLoginUserInfo) (err error) {
+ ctx context.Context, key string, info *schema.ExternalLoginUserInfoCache) (err error) {
cacheData, _ := json.Marshal(info)
- return ur.data.Cache.SetString(ctx, constant.ConnectorUserExternalInfoCacheKey+info.ExternalID,
+ return ur.data.Cache.SetString(ctx, constant.ConnectorUserExternalInfoCacheKey+key,
string(cacheData), constant.ConnectorUserExternalInfoCacheTime)
}
// GetCacheUserExternalLoginInfo cache user info for external login
func (ur *userExternalLoginRepo) GetCacheUserExternalLoginInfo(
- ctx context.Context, key string) (info plugin.ExternalLoginUserInfo, err error) {
+ ctx context.Context, key string) (info *schema.ExternalLoginUserInfoCache, err error) {
res, err := ur.data.Cache.GetString(ctx, constant.ConnectorUserExternalInfoCacheKey+key)
if err != nil {
return info, err
diff --git a/internal/router/plugin_api_router.go b/internal/router/plugin_api_router.go
index f5b8cb3f..b22f5028 100644
--- a/internal/router/plugin_api_router.go
+++ b/internal/router/plugin_api_router.go
@@ -22,8 +22,8 @@ func (pr *PluginAPIRouter) RegisterConnector(r *gin.Engine) {
connectorController := pr.connectorController
_ = plugin.CallConnector(func(connector plugin.Connector) error {
connectorSlugName := connector.ConnectorSlugName()
- r.GET(controller.ConnectorLoginRouterPrefix+connectorSlugName, connectorController.ConnectorRedirect(connector))
- r.GET(controller.ConnectorRedirectRouterPrefix+connectorSlugName, connectorController.ConnectorLogin(connector))
+ r.GET(controller.ConnectorLoginRouterPrefix+connectorSlugName, connectorController.ConnectorLogin(connector))
+ r.GET(controller.ConnectorRedirectRouterPrefix+connectorSlugName, connectorController.ConnectorRedirect(connector))
return nil
})
r.GET("/answer/api/v1/connector/info", connectorController.ConnectorsInfo)
diff --git a/internal/schema/email_template.go b/internal/schema/email_template.go
index 16e438c8..94918331 100644
--- a/internal/schema/email_template.go
+++ b/internal/schema/email_template.go
@@ -3,18 +3,21 @@ package schema
import "encoding/json"
const (
- AccountActivationSourceType SourceType = "account-activation"
- PasswordResetSourceType SourceType = "password-reset"
- ConfirmNewEmailSourceType SourceType = "password-reset"
- UnsubscribeSourceType SourceType = "unsubscribe"
+ AccountActivationSourceType EmailSourceType = "account-activation"
+ PasswordResetSourceType EmailSourceType = "password-reset"
+ ConfirmNewEmailSourceType EmailSourceType = "password-reset"
+ UnsubscribeSourceType EmailSourceType = "unsubscribe"
+ BindingSourceType EmailSourceType = "binding"
)
-type SourceType string
+type EmailSourceType string
type EmailCodeContent struct {
- SourceType SourceType `json:"source_type"`
- Email string `json:"e_mail"`
- UserID string `json:"user_id"`
+ SourceType EmailSourceType `json:"source_type"`
+ Email string `json:"e_mail"`
+ UserID string `json:"user_id"`
+ // Used for third-party login account binding
+ BindingKey string `json:"binding_key"`
}
func (r *EmailCodeContent) ToJSONString() string {
diff --git a/internal/schema/user_external_login_schema.go b/internal/schema/user_external_login_schema.go
index 5a317e22..aa02700a 100644
--- a/internal/schema/user_external_login_schema.go
+++ b/internal/schema/user_external_login_schema.go
@@ -22,10 +22,26 @@ type ExternalLoginBindingUserSendEmailResp struct {
// ExternalLoginBindingUserReq external login binding user request
type ExternalLoginBindingUserReq struct {
- Code string `validate:"required,gt=0,lte=500" json:"code"`
+ Code string `validate:"required,gt=0,lte=500" json:"code"`
+ Content string `json:"-"`
}
// ExternalLoginBindingUserResp external login binding user response
type ExternalLoginBindingUserResp struct {
AccessToken string `json:"access_token"`
}
+
+// ExternalLoginUserInfoCache external login user info
+type ExternalLoginUserInfoCache struct {
+ // Third party identification
+ // e.g. facebook, twitter, instagram
+ Provider string
+ // required. The unique user ID provided by the third-party login
+ ExternalID string
+ // optional. This name is used preferentially during registration
+ Name string
+ // optional. If email exist will bind the existing user
+ Email string
+ // optional. The original user information provided by the third-party login platform
+ MetaInfo string
+}
diff --git a/internal/service/export/email_service.go b/internal/service/export/email_service.go
index 4ae086e9..4fc9a2fa 100644
--- a/internal/service/export/email_service.go
+++ b/internal/service/export/email_service.go
@@ -162,39 +162,30 @@ func (es *EmailService) GetSiteGeneral(ctx context.Context) (resp schema.SiteGen
}
func (es *EmailService) RegisterTemplate(ctx context.Context, registerUrl string) (title, body string, err error) {
- ec, err := es.GetEmailConfig()
+ emailConfig, err := es.GetEmailConfig()
if err != nil {
return
}
- siteinfo, err := es.GetSiteGeneral(ctx)
+
+ siteInfo, err := es.GetSiteGeneral(ctx)
if err != nil {
return
}
-
templateData := RegisterTemplateData{
- SiteName: siteinfo.Name, RegisterUrl: registerUrl,
- }
- tmpl, err := template.New("register_title").Parse(ec.RegisterTitle)
- if err != nil {
- return "", "", err
- }
- titleBuf := &bytes.Buffer{}
- bodyBuf := &bytes.Buffer{}
- err = tmpl.Execute(titleBuf, templateData)
- if err != nil {
- return "", "", err
+ SiteName: siteInfo.Name,
+ RegisterUrl: registerUrl,
}
- tmpl, err = template.New("register_body").Parse(ec.RegisterBody)
+ title, err = es.parseTemplateData(emailConfig.RegisterTitle, templateData)
if err != nil {
- return "", "", err
+ return "", "", fmt.Errorf("email template parse error: %s", err)
}
- err = tmpl.Execute(bodyBuf, templateData)
+
+ body, err = es.parseTemplateData(emailConfig.RegisterBody, templateData)
if err != nil {
- return "", "", err
+ return "", "", fmt.Errorf("email template parse error: %s", err)
}
-
- return titleBuf.String(), bodyBuf.String(), nil
+ return title, body, nil
}
func (es *EmailService) PassResetTemplate(ctx context.Context, passResetUrl string) (title, body string, err error) {
diff --git a/internal/service/user_common/user.go b/internal/service/user_common/user.go
index 872ed7ae..8d84f288 100644
--- a/internal/service/user_common/user.go
+++ b/internal/service/user_common/user.go
@@ -2,8 +2,6 @@ package usercommon
import (
"context"
- "encoding/hex"
- "math/rand"
"regexp"
"strings"
@@ -14,6 +12,7 @@ import (
"github.com/answerdev/answer/internal/service/auth"
"github.com/answerdev/answer/internal/service/role"
"github.com/answerdev/answer/pkg/checker"
+ "github.com/answerdev/answer/pkg/random"
"github.com/segmentfault/pacman/errors"
"github.com/segmentfault/pacman/log"
)
@@ -149,9 +148,7 @@ func (us *UserCommon) MakeUsername(ctx context.Context, displayName string) (use
if !has {
break
}
- bytes := make([]byte, 2)
- _, _ = rand.Read(bytes)
- suffix = hex.EncodeToString(bytes)
+ suffix = random.UsernameSuffix()
}
return username + suffix, nil
}
diff --git a/internal/service/user_external_login/user_external_login_service.go b/internal/service/user_external_login/user_external_login_service.go
index 6e073e3b..b351653c 100644
--- a/internal/service/user_external_login/user_external_login_service.go
+++ b/internal/service/user_external_login/user_external_login_service.go
@@ -2,25 +2,29 @@ package user_external_login
import (
"context"
+ "fmt"
"time"
"github.com/answerdev/answer/internal/base/reason"
"github.com/answerdev/answer/internal/entity"
- "github.com/answerdev/answer/internal/plugin"
"github.com/answerdev/answer/internal/schema"
+ "github.com/answerdev/answer/internal/service/activity"
+ "github.com/answerdev/answer/internal/service/export"
+ "github.com/answerdev/answer/internal/service/siteinfo_common"
usercommon "github.com/answerdev/answer/internal/service/user_common"
+ "github.com/answerdev/answer/pkg/random"
"github.com/answerdev/answer/pkg/token"
+ "github.com/google/uuid"
"github.com/segmentfault/pacman/errors"
+ "github.com/segmentfault/pacman/log"
)
type UserExternalLoginRepo interface {
AddUserExternalLogin(ctx context.Context, user *entity.UserExternalLogin) (err error)
UpdateInfo(ctx context.Context, userInfo *entity.UserExternalLogin) (err error)
GetByExternalID(ctx context.Context, externalID string) (userInfo *entity.UserExternalLogin, exist bool, err error)
- SetCacheUserExternalLoginInfo(
- ctx context.Context, key string, info plugin.ExternalLoginUserInfo) (err error)
- GetCacheUserExternalLoginInfo(
- ctx context.Context, key string) (info plugin.ExternalLoginUserInfo, err error)
+ SetCacheUserExternalLoginInfo(ctx context.Context, key string, info *schema.ExternalLoginUserInfoCache) (err error)
+ GetCacheUserExternalLoginInfo(ctx context.Context, key string) (info *schema.ExternalLoginUserInfoCache, err error)
}
// UserExternalLoginService user external login service
@@ -28,6 +32,9 @@ type UserExternalLoginService struct {
userRepo usercommon.UserRepo
userExternalLoginRepo UserExternalLoginRepo
userCommonService *usercommon.UserCommon
+ emailService *export.EmailService
+ siteInfoCommonService *siteinfo_common.SiteInfoCommonService
+ userActivity activity.UserActiveActivityRepo
}
// NewUserExternalLoginService new user external login service
@@ -35,18 +42,40 @@ func NewUserExternalLoginService(
userRepo usercommon.UserRepo,
userCommonService *usercommon.UserCommon,
userExternalLoginRepo UserExternalLoginRepo,
+ emailService *export.EmailService,
+ siteInfoCommonService *siteinfo_common.SiteInfoCommonService,
+ userActivity activity.UserActiveActivityRepo,
) *UserExternalLoginService {
return &UserExternalLoginService{
userRepo: userRepo,
userCommonService: userCommonService,
userExternalLoginRepo: userExternalLoginRepo,
+ emailService: emailService,
+ siteInfoCommonService: siteInfoCommonService,
+ userActivity: userActivity,
}
}
// ExternalLogin if user is already a member logged in
func (us *UserExternalLoginService) ExternalLogin(
- ctx context.Context, externalUserInfo plugin.ExternalLoginUserInfo) (
+ ctx context.Context, externalUserInfo *schema.ExternalLoginUserInfoCache) (
resp *schema.UserExternalLoginResp, err error) {
+ oldExternalLoginUserInfo, exist, err := us.userExternalLoginRepo.GetByExternalID(ctx, externalUserInfo.ExternalID)
+ if err != nil {
+ return nil, err
+ }
+ if exist {
+ oldUserInfo, exist, err := us.userRepo.GetByUserID(ctx, oldExternalLoginUserInfo.UserID)
+ if err != nil {
+ return nil, err
+ }
+ if exist {
+ accessToken, _, err := us.userCommonService.CacheLoginUserInfo(
+ ctx, oldUserInfo.ID, oldUserInfo.MailStatus, oldUserInfo.Status)
+ return &schema.UserExternalLoginResp{AccessToken: accessToken}, err
+ }
+ }
+
// cache external user info, waiting for user enter email address.
if len(externalUserInfo.Email) == 0 {
bindingKey := token.GenerateToken()
@@ -62,12 +91,12 @@ func (us *UserExternalLoginService) ExternalLogin(
return nil, err
}
if !exist {
- oldUserInfo, err = us.RegisterNewUser(ctx, externalUserInfo)
+ oldUserInfo, err = us.registerNewUser(ctx, externalUserInfo)
if err != nil {
return nil, err
}
}
- err = us.BindOldUser(ctx, externalUserInfo, oldUserInfo)
+ err = us.bindOldUser(ctx, externalUserInfo, oldUserInfo)
if err != nil {
return nil, err
}
@@ -77,14 +106,14 @@ func (us *UserExternalLoginService) ExternalLogin(
return &schema.UserExternalLoginResp{AccessToken: accessToken}, err
}
-func (us *UserExternalLoginService) RegisterNewUser(ctx context.Context,
- externalUserInfo plugin.ExternalLoginUserInfo) (userInfo *entity.User, err error) {
+func (us *UserExternalLoginService) registerNewUser(ctx context.Context,
+ externalUserInfo *schema.ExternalLoginUserInfoCache) (userInfo *entity.User, err error) {
userInfo = &entity.User{}
userInfo.EMail = externalUserInfo.Email
userInfo.DisplayName = externalUserInfo.Name
userInfo.Username, err = us.userCommonService.MakeUsername(ctx, externalUserInfo.Name)
if err != nil {
- userInfo.Username = "" // TODO random
+ userInfo.Username = random.Username()
}
userInfo.MailStatus = entity.EmailStatusToBeVerified
userInfo.Status = entity.UserStatusAvailable
@@ -96,8 +125,8 @@ func (us *UserExternalLoginService) RegisterNewUser(ctx context.Context,
return userInfo, nil
}
-func (us *UserExternalLoginService) BindOldUser(ctx context.Context,
- externalUserInfo plugin.ExternalLoginUserInfo, oldUserInfo *entity.User) (err error) {
+func (us *UserExternalLoginService) bindOldUser(ctx context.Context,
+ externalUserInfo *schema.ExternalLoginUserInfoCache, oldUserInfo *entity.User) (err error) {
oldExternalUserInfo, exist, err := us.userExternalLoginRepo.GetByExternalID(ctx, externalUserInfo.ExternalID)
if err != nil {
return err
@@ -118,16 +147,25 @@ func (us *UserExternalLoginService) BindOldUser(ctx context.Context,
return err
}
+// ExternalLoginBindingUserSendEmail Send an email for third-party account login for binding user
func (us *UserExternalLoginService) ExternalLoginBindingUserSendEmail(
ctx context.Context, req *schema.ExternalLoginBindingUserSendEmailReq) (
resp *schema.ExternalLoginBindingUserSendEmailResp, err error) {
+ siteGeneral, err := us.siteInfoCommonService.GetSiteGeneral(ctx)
+ if err != nil {
+ return nil, err
+ }
resp = &schema.ExternalLoginBindingUserSendEmailResp{}
externalLoginInfo, err := us.userExternalLoginRepo.GetCacheUserExternalLoginInfo(ctx, req.BindingKey)
if err != nil || len(externalLoginInfo.ExternalID) == 0 {
return nil, errors.BadRequest(reason.UserNotFound)
}
+ if len(externalLoginInfo.Email) > 0 {
+ log.Warnf("the binding email has been sent %s", req.BindingKey)
+ return &schema.ExternalLoginBindingUserSendEmailResp{}, nil
+ }
- _, exist, err := us.userRepo.GetByEmail(ctx, req.Email)
+ userInfo, exist, err := us.userRepo.GetByEmail(ctx, req.Email)
if err != nil {
return nil, err
}
@@ -138,18 +176,79 @@ func (us *UserExternalLoginService) ExternalLoginBindingUserSendEmail(
if !exist {
externalLoginInfo.Email = req.Email
- _, err = us.RegisterNewUser(ctx, externalLoginInfo)
+ userInfo, err = us.registerNewUser(ctx, externalLoginInfo)
if err != nil {
return nil, err
}
}
+ err = us.userExternalLoginRepo.SetCacheUserExternalLoginInfo(ctx, req.BindingKey, externalLoginInfo)
+ if err != nil {
+ return nil, err
+ }
- // TODO send bind confirmation email
+ // send bind confirmation email
+ data := &schema.EmailCodeContent{
+ SourceType: schema.BindingSourceType,
+ Email: req.Email,
+ UserID: userInfo.ID,
+ BindingKey: req.BindingKey,
+ }
+ code := uuid.NewString()
+ verifyEmailURL := fmt.Sprintf("%s/users/account-activation?code=%s", siteGeneral.SiteUrl, code)
+ title, body, err := us.emailService.RegisterTemplate(ctx, verifyEmailURL)
+ if err != nil {
+ return nil, err
+ }
+ go us.emailService.SendAndSaveCode(ctx, userInfo.EMail, title, body, code, data.ToJSONString())
return resp, nil
}
+// ExternalLoginBindingUser
+// The user clicks on the email link of the bound account and requests the API to bind the user officially
func (us *UserExternalLoginService) ExternalLoginBindingUser(
ctx context.Context, req *schema.ExternalLoginBindingUserReq) (
resp *schema.ExternalLoginBindingUserResp, err error) {
- return
+ data := &schema.EmailCodeContent{}
+ err = data.FromJSONString(req.Content)
+ if err != nil {
+ return nil, errors.BadRequest(reason.EmailVerifyURLExpired)
+ }
+ if data.SourceType != schema.BindingSourceType {
+ log.Warnf("invalid email source type %s", data.BindingKey)
+ return nil, errors.BadRequest(reason.EmailVerifyURLExpired)
+ }
+
+ oldUserInfo, exist, err := us.userRepo.GetByUserID(ctx, data.UserID)
+ if err != nil {
+ return nil, err
+ }
+ if !exist {
+ return nil, errors.BadRequest(reason.UserNotFound)
+ }
+
+ // If the user's email is not already authenticated, update the email status.
+ if oldUserInfo.MailStatus == entity.EmailStatusToBeVerified {
+ err = us.userRepo.UpdateEmailStatus(ctx, data.UserID, entity.EmailStatusAvailable)
+ if err != nil {
+ return nil, err
+ }
+ if err = us.userActivity.UserActive(ctx, data.UserID); err != nil {
+ log.Error(err)
+ }
+ oldUserInfo.MailStatus = entity.EmailStatusAvailable
+ }
+
+ externalLoginInfo, err := us.userExternalLoginRepo.GetCacheUserExternalLoginInfo(ctx, data.BindingKey)
+ if err != nil || len(externalLoginInfo.ExternalID) == 0 {
+ return nil, errors.BadRequest(reason.UserNotFound)
+ }
+ err = us.bindOldUser(ctx, externalLoginInfo, oldUserInfo)
+ if err != nil {
+ return nil, err
+ }
+
+ accessToken, _, err := us.userCommonService.CacheLoginUserInfo(
+ ctx, oldUserInfo.ID, oldUserInfo.MailStatus, oldUserInfo.Status)
+ resp = &schema.ExternalLoginBindingUserResp{AccessToken: accessToken}
+ return resp, err
}
diff --git a/pkg/random/random_username.go b/pkg/random/random_username.go
new file mode 100644
index 00000000..3c8cb1de
--- /dev/null
+++ b/pkg/random/random_username.go
@@ -0,0 +1,18 @@
+package random
+
+import (
+ "encoding/hex"
+ "math/rand"
+)
+
+func UsernameSuffix() string {
+ bytes := make([]byte, 2)
+ _, _ = rand.Read(bytes)
+ return hex.EncodeToString(bytes)
+}
+
+func Username() string {
+ bytes := make([]byte, 6)
+ _, _ = rand.Read(bytes)
+ return hex.EncodeToString(bytes)
+}