phone

Documentation

Index

• Variables
• type Config
• type Provider
  • func New(config *Config) *Provider
  • func (provider Provider) Callback(context *auth.Context)
  • func (provider Provider) ConfigAuth(auth *auth.Auth)
  • func (Provider) GetName() string
  • func (provider Provider) Login(context *auth.Context)
  • func (provider Provider) Logout(context *auth.Context)
  • func (provider Provider) Register(context *auth.Context)
  • func (provider Provider) ServeHTTP(context *auth.Context)

Variables

var (
	// ErrInvalidToken Auth Token not match
	ErrInvalidToken = errors.New("Token Not Match")
	// ErrTokenExpired Auth Token Expired
	ErrTokenExpired = errors.New("Token Has Expired")
	// ErrInvalidNumber Invalid Phone Number Format
	ErrInvalidNumber = errors.New("Invalid Phone Number")
)

var (
	//DefaultTokenMessage Message for Message
	DefaultTokenMessage = "your code is {token}"
	//ErrPhoneNumberRequired Error Message Phone Number Required
	ErrPhoneNumberRequired = errors.New("Phone Number Required")
	//ErrPhoneNotFound Error Message Phone Number Required
	ErrPhoneNotFound = errors.New("Sorry, it seems your phone number havent registered yet")
)

var DefaultAuthorizeHandler = func(context *auth.Context) (*claims.Claims, error) {
	var (
		authInfo    auth_identity.Basic
		req         = context.Request
		tx          = context.Auth.GetDB(req)
		provider, _ = context.Provider.(*Provider)
	)

	req.ParseForm()
	authInfo.Provider = provider.GetName()
	authInfo.UID = strings.TrimSpace(req.Form.Get("phone_number"))

	if tx.Model(context.Auth.AuthIdentityModel).Where(
		map[string]interface{}{
			"provider": authInfo.Provider,
			"uid":      authInfo.UID,
		}).Scan(&authInfo).RecordNotFound() {
		return nil, ErrPhoneNotFound
	}

	if err := provider.Config.SendTokenHandler(authInfo.UID, context, tx); err != nil {
		return nil, err
	}

	return authInfo.ToClaims(), nil
}

DefaultAuthorizeHandler default authorize handler

var DefaultCheckToken = func(phonenumber string, token string, context *auth.Context, DB *gorm.DB) (*claims.Claims, error) {
	var (
		authInfo      auth_identity.Basic
		tokenIdentity auth_identity.AuthToken
		provider, _   = context.Provider.(*Provider)
	)

	if DB.Model(context.Auth.Config.UserTokenModel).Where(map[string]interface{}{
		"identity": phonenumber,
		"token":    token,
	}).Scan(&tokenIdentity).RecordNotFound() {
		return nil, auth.ErrInvalidAccount
	}

	now := time.Now()
	if now.After(*tokenIdentity.ValidUntil) {
		return nil, ErrTokenExpired
	}

	authInfo.Provider = provider.GetName()
	authInfo.UID = phonenumber

	if DB.Model(context.Auth.AuthIdentityModel).Where(
		map[string]interface{}{
			"provider": authInfo.Provider,
			"uid":      authInfo.UID,
		}).Scan(&authInfo).RecordNotFound() {
		return nil, auth.ErrInvalidAccount
	}

	return authInfo.ToClaims(), nil
}

DefaultCheckToken default confirmation handler

var DefaultConfirmationFormHandler = func(context *auth.Context, confirm func(*auth.Context) (*claims.Claims, error)) {
	var (
		req         = context.Request
		w           = context.Writer
		claims, err = confirm(context)
	)

	if err == nil && claims != nil {
		context.SessionStorer.Flash(w, req, session.Message{Message: "logged"})
		respondAfterLogged(claims, context)
		return
	}

	context.SessionStorer.Flash(w, req, session.Message{Message: template.HTML(err.Error()), Type: "error"})

	responder.With("html", func() {
		context.Auth.Config.Render.Execute("auth/confirmation/providers/phone", context, req, w)
	}).With([]string{"json"}, func() {

	}).Respond(context.Request)
}

DefaultConfirmationFormHandler default login behaviour

var DefaultConfirmationHandler = func(context *auth.Context) (*claims.Claims, error) {
	var (
		req         = context.Request
		tx          = context.Auth.GetDB(req)
		provider, _ = context.Provider.(*Provider)
	)

	req.ParseForm()
	if req.Form.Get("phone_number") == "" {
		return nil, ErrPhoneNumberRequired
	}

	if req.Form.Get("token") == "" {
		return nil, ErrInvalidToken
	}

	return provider.Config.CheckAuthToken(
		req.Form.Get("phone_number"),
		strings.TrimSpace(req.Form.Get("token")),
		context, tx,
	)
}

DefaultConfirmationHandler default authorize handler

var DefaultLoginFormHandler = func(context *auth.Context, authorize func(*auth.Context) (*claims.Claims, error)) {
	var (
		req         = context.Request
		w           = context.Writer
		claims, err = authorize(context)
	)

	if err == nil && claims != nil {
		req.ParseForm()
		context.SessionStorer.Flash(w, req, session.Message{Message: template.HTML(req.Form.Get("phone_number")), Type: "phone_number"})
		respondAfterRequestToken(claims, context)
		return
	}

	context.SessionStorer.Flash(w, req, session.Message{Message: template.HTML(err.Error()), Type: "error"})

	responder.With("html", func() {
		context.Auth.Config.Render.Execute("auth/login/providers/phone", context, req, w)
	}).With([]string{"json"}, func() {

	}).Respond(context.Request)
}

DefaultLoginFormHandler default login behaviour

var DefaultRegisterFormHandler = func(context *auth.Context, register func(*auth.Context) (*claims.Claims, error)) {
	var (
		req         = context.Request
		w           = context.Writer
		claims, err = register(context)
	)

	if err == nil && claims != nil {
		req.ParseForm()
		context.SessionStorer.Flash(w, req, session.Message{Message: template.HTML(req.Form.Get("phone_number")), Type: "phone_number"})
		respondAfterRequestToken(claims, context)
		return
	}

	context.SessionStorer.Flash(w, req, session.Message{Message: template.HTML(err.Error()), Type: "error"})

	responder.With("html", func() {
		context.Auth.Config.Render.Execute("auth/register/providers/phone", context, req, w)
	}).With([]string{"json"}, func() {

	}).Respond(context.Request)
}

DefaultRegisterFormHandler default register behaviour

var DefaultRegisterHandler = func(context *auth.Context) (*claims.Claims, error) {
	var (
		err         error
		schema      auth.Schema
		authInfo    auth_identity.Basic
		req         = context.Request
		tx          = context.Auth.GetDB(req)
		provider, _ = context.Provider.(*Provider)
	)

	req.ParseForm()
	if req.Form.Get("login") == "" {
		return nil, auth.ErrInvalidAccount
	}

	if req.Form.Get("phone_number") == "" {
		return nil, ErrInvalidNumber
	}

	authInfo.Provider = provider.GetName()
	authInfo.UID = strings.TrimSpace(req.Form.Get("phone_number"))

	currentUser := reflect.New(utils.ModelType(context.Auth.Config.UserModel)).Interface()
	if !tx.Model(context.Auth.Config.UserModel).Where(map[string]interface{}{
		"email": strings.TrimSpace(req.Form.Get("login")),
	}).First(currentUser).RecordNotFound() {
		return nil, auth.ErrAlreadyRegistered
	}

	schema.Provider = authInfo.Provider
	schema.UID = authInfo.UID
	schema.Name = strings.TrimSpace(req.Form.Get("name"))
	schema.Email = strings.TrimSpace(req.Form.Get("login"))
	schema.RawInfo = req

	currentUser, authInfo.UserID, err = context.Auth.UserStorer.Save(&schema, context)
	if err != nil {
		return nil, err
	}

	authIdentity := reflect.New(utils.ModelType(context.Auth.Config.AuthIdentityModel)).Interface()
	if err = tx.Where(map[string]interface{}{
		"provider":           authInfo.Provider,
		"uid":                authInfo.UID,
		"encrypted_password": authInfo.EncryptedPassword,
		"user_id":            authInfo.UserID,
	}).FirstOrCreate(authIdentity).Error; err != nil {
		return nil, err
	}

	if err = provider.Config.SendTokenHandler(authInfo.UID, context, tx); err != nil {
		return nil, err
	}

	return authInfo.ToClaims(), err
}

DefaultRegisterHandler default register handler

var DefaultSendTokenHandler = func(phonenumber string, context *auth.Context, tx *gorm.DB) error {
	var (
		err         error
		provider, _ = context.Provider.(*Provider)
	)
	tokenIdentity := reflect.New(utils.ModelType(context.Auth.Config.UserTokenModel)).Interface()
	if err = tx.Where(map[string]interface{}{
		"identity": phonenumber,
	}).FirstOrCreate(tokenIdentity).Error; err != nil {
		return auth.ErrInvalidAccount
	}
	token := generateToken(6)

	tx.Model(tokenIdentity).Where("identity = ?", phonenumber).Update(map[string]interface{}{
		"token":      token,
		"validUntil": time.Now().Add(time.Hour * 3),
	})

	message := strings.NewReplacer(
		"{token}", token,
	).Replace(provider.Config.TokenMessage)

	if err = context.Auth.SMSSender.Send(phonenumber, message); err != nil {
		return err
	}

	return nil
}

DefaultSendTokenHandler default Token Verification Sender

Types

type Config

type Config struct {
	SendTokenHandler func(phonenumber string, context *auth.Context, DB *gorm.DB) error
	CheckAuthToken   func(phonenumber string, token string, context *auth.Context, DB *gorm.DB) (*claims.Claims, error)
	TokenMessage     string

	AuthorizeHandler    func(*auth.Context) (*claims.Claims, error)
	TokenConfirmHandler func(*auth.Context) (*claims.Claims, error)
	RegisterHandler     func(*auth.Context) (*claims.Claims, error)
}

Config phone provider config

type Provider

type Provider struct {
	*Config
}

Provider provide login with phone method

func New

func New(config *Config) *Provider

New initialize phone provider

func (Provider) Callback

func (provider Provider) Callback(context *auth.Context)

Callback implement Callback with password provider

func (Provider) ConfigAuth

func (provider Provider) ConfigAuth(auth *auth.Auth)

ConfigAuth config auth

func (Provider) GetName

func (Provider) GetName() string

GetName return provider name

func (Provider) Login

func (provider Provider) Login(context *auth.Context)

Login implemented login with phone provider

func (Provider) Logout

func (provider Provider) Logout(context *auth.Context)

Logout implemented logout with phone provider

func (Provider) Register

func (provider Provider) Register(context *auth.Context)

Register implemented register with phone provider

func (Provider) ServeHTTP

func (provider Provider) ServeHTTP(context *auth.Context)

ServeHTTP implement ServeHTTP with phone provider