Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

6.3 KB
Raw Blame
package actions

import (
	"context"

	"github.com/getfider/fider/app"

	"github.com/getfider/fider/app/models/entity"
	"github.com/getfider/fider/app/models/enum"
	"github.com/getfider/fider/app/models/query"
	"github.com/getfider/fider/app/pkg/bus"
	"github.com/getfider/fider/app/pkg/validate"
)

// SignInByEmail happens when user request to sign in by email
type SignInByEmail struct {
	Email            string `json:"email" format:"lower"`
	VerificationCode string `json:"-"`
	LinkKey          string `json:"-"`
}

func NewSignInByEmail() *SignInByEmail {
	return &SignInByEmail{
		VerificationCode: entity.GenerateEmailVerificationCode(),
		LinkKey:          entity.GenerateEmailVerificationKey(),
	}
}

// IsAuthorized returns true if current user is authorized to perform this action
func (action *SignInByEmail) IsAuthorized(ctx context.Context, user *entity.User) bool {
	tenant := ctx.Value(app.TenantCtxKey).(*entity.Tenant)
	if tenant.IsEmailAuthAllowed {
		return true
	}
	getUser := &query.GetUserByEmail{
		Email: action.Email,
	}
	if err := bus.Dispatch(ctx, getUser); err != nil {
		return false
	}
	return getUser.Result != nil && getUser.Result.IsAdministrator()
}

// Validate if current model is valid
func (action *SignInByEmail) Validate(ctx context.Context, user *entity.User) *validate.Result {
	result := validate.Success()

	if action.Email == "" {
		result.AddFieldFailure("email", propertyIsRequired(ctx, "email"))
		return result
	}

	messages := validate.Email(ctx, action.Email)
	result.AddFieldFailure("email", messages...)

	return result
}

// GetEmail returns the email being verified
func (action *SignInByEmail) GetEmail() string {
	return action.Email
}

// GetName returns empty for this kind of process
func (action *SignInByEmail) GetName() string {
	return ""
}

// GetUser returns the current user performing this action
func (action *SignInByEmail) GetUser() *entity.User {
	return nil
}

// GetKind returns EmailVerificationKindSignIn
func (action *SignInByEmail) GetKind() enum.EmailVerificationKind {
	return enum.EmailVerificationKindSignIn
}

// VerifySignInCode happens when user enters the verification code received via email
type VerifySignInCode struct {
	Email string `json:"email" format:"lower"`
	Code  string `json:"code"`
}

// IsAuthorized returns true if current user is authorized to perform this action
func (action *VerifySignInCode) IsAuthorized(ctx context.Context, user *entity.User) bool {
	return true
}

// Validate if current model is valid
func (action *VerifySignInCode) Validate(ctx context.Context, user *entity.User) *validate.Result {
	result := validate.Success()

	if action.Email == "" {
		result.AddFieldFailure("email", propertyIsRequired(ctx, "email"))
	} else {
		messages := validate.Email(ctx, action.Email)
		result.AddFieldFailure("email", messages...)
	}

	if action.Code == "" {
		result.AddFieldFailure("code", propertyIsRequired(ctx, "code"))
	} else if len(action.Code) != 6 {
		result.AddFieldFailure("code", "Verification code must be 6 digits")
	} else {
		// Validate that code contains only digits
		for _, char := range action.Code {
			if char < '0' || char > '9' {
				result.AddFieldFailure("code", "Verification code must contain only digits")
				break
			}
		}
	}

	return result
}

// SignInByEmailWithName happens when a new user (without account) requests to sign in by email
type SignInByEmailWithName struct {
	Email            string `json:"email" format:"lower"`
	Name             string `json:"name"`
	VerificationCode string `json:"-"`
	LinkKey          string `json:"-"`
}

func NewSignInByEmailWithName() *SignInByEmailWithName {
	return &SignInByEmailWithName{
		VerificationCode: entity.GenerateEmailVerificationCode(),
		LinkKey:          entity.GenerateEmailVerificationKey(),
	}
}

// IsAuthorized returns true if current user is authorized to perform this action
func (action *SignInByEmailWithName) IsAuthorized(ctx context.Context, user *entity.User) bool {
	tenant := ctx.Value(app.TenantCtxKey).(*entity.Tenant)
	// Reject new-user requests before the handler looks up the user
	return tenant.CanCreateAccountByEmail(action.GetKind())
}

// Validate if current model is valid
func (action *SignInByEmailWithName) Validate(ctx context.Context, user *entity.User) *validate.Result {
	result := validate.Success()

	if action.Email == "" {
		result.AddFieldFailure("email", propertyIsRequired(ctx, "email"))
	} else {
		messages := validate.Email(ctx, action.Email)
		result.AddFieldFailure("email", messages...)
	}

	if action.Name == "" {
		result.AddFieldFailure("name", propertyIsRequired(ctx, "name"))
	} else if len(action.Name) > 100 {
		result.AddFieldFailure("name", propertyMaxStringLen(ctx, "name", 100))
	}

	return result
}

// GetEmail returns the email being verified
func (action *SignInByEmailWithName) GetEmail() string {
	return action.Email
}

// GetName returns the name provided by the user
func (action *SignInByEmailWithName) GetName() string {
	return action.Name
}

// GetUser returns the current user performing this action
func (action *SignInByEmailWithName) GetUser() *entity.User {
	return nil
}

// GetKind returns EmailVerificationKindSignIn
func (action *SignInByEmailWithName) GetKind() enum.EmailVerificationKind {
	return enum.EmailVerificationKindSignIn
}

// CompleteProfile happens when users completes their profile during first time sign in
type CompleteProfile struct {
	Kind enum.EmailVerificationKind `json:"kind"`
	Key  string                     `json:"key"`
	Name string                     `json:"name"`
}

// IsAuthorized returns true if current user is authorized to perform this action
func (action *CompleteProfile) IsAuthorized(ctx context.Context, user *entity.User) bool {
	return true
}

// Validate if current model is valid
func (action *CompleteProfile) Validate(ctx context.Context, user *entity.User) *validate.Result {
	result := validate.Success()

	if action.Name == "" {
		result.AddFieldFailure("name", propertyIsRequired(ctx, "name"))
	} else if len(action.Name) > 50 {
		result.AddFieldFailure("name", propertyMaxStringLen(ctx, "name", 50))
	}

	if action.Key == "" {
		result.AddFieldFailure("key", propertyIsRequired(ctx, "key"))
	}

	// Only sign in and invitation keys can be used to create a new account
	if action.Kind != enum.EmailVerificationKindSignIn && action.Kind != enum.EmailVerificationKindUserInvitation {
		result.AddFieldFailure("kind", "Invalid verification kind")
	}

	return result
}