devstack/authorizer
4
0
Fork 0
Code Pull Requests Actions Activity

fix: format logs

Browse Source
This commit is contained in:
Lakhan Samani 2022-05-25 12:30:22 +05:30
parent d886d780b4
commit 714b79e4ab
47 changed files with 266 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
server/db/db.go
View File

@ -1,6 +1,8 @@
package db package db
import ( import (
log "github.com/sirupsen/logrus"
"github.com/authorizerdev/authorizer/server/constants" "github.com/authorizerdev/authorizer/server/constants"
"github.com/authorizerdev/authorizer/server/db/providers" "github.com/authorizerdev/authorizer/server/db/providers"
"github.com/authorizerdev/authorizer/server/db/providers/arangodb" "github.com/authorizerdev/authorizer/server/db/providers/arangodb"
@ -22,29 +24,37 @@ func InitDB() error {
isCassandra := envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeCassandraDB isCassandra := envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyDatabaseType) == constants.DbTypeCassandraDB
if isSQL { if isSQL {
log.Info("Initializing SQL Driver")
Provider, err = sql.NewProvider() Provider, err = sql.NewProvider()
if err != nil { if err != nil {
log.Fatal("Failed to initialize SQL driver: ", err)
return err return err
} }
} }
if isArangoDB { if isArangoDB {
log.Info("Initializing ArangoDB Driver")
Provider, err = arangodb.NewProvider() Provider, err = arangodb.NewProvider()
if err != nil { if err != nil {
log.Fatal("Failed to initialize ArangoDB driver: ", err)
return err return err
} }
} }
if isMongoDB { if isMongoDB {
log.Info("Initializing MongoDB Driver")
Provider, err = mongodb.NewProvider() Provider, err = mongodb.NewProvider()
if err != nil { if err != nil {
log.Fatal("Failed to initialize MongoDB driver: ", err)
return err return err
} }
} }
if isCassandra { if isCassandra {
log.Info("Initializing CassandraDB Driver")
Provider, err = cassandradb.NewProvider() Provider, err = cassandradb.NewProvider()
if err != nil { if err != nil {
log.Fatal("Failed to initialize CassandraDB driver: ", err)
return err return err
} }
} }

4
server/env/env.go vendored
View File

@ -53,6 +53,7 @@ func InitRequiredEnv() error {
} }
if dbType == "" { if dbType == "" {
log.Debug("DATABASE_TYPE is not set")
return errors.New("invalid database type. DATABASE_TYPE is empty") return errors.New("invalid database type. DATABASE_TYPE is empty")
} }
} }
@ -63,6 +64,7 @@ func InitRequiredEnv() error {
} }
if dbURL == "" && dbPort == "" && dbHost == "" && dbUsername == "" && dbPassword == "" { if dbURL == "" && dbPort == "" && dbHost == "" && dbUsername == "" && dbPassword == "" {
log.Debug("DATABASE_URL is not set")
return errors.New("invalid database url. DATABASE_URL is required") return errors.New("invalid database url. DATABASE_URL is required")
} }
} }
@ -180,6 +182,7 @@ func InitAllEnv() error {
} else { } else {
algo = envData.StringEnv[constants.EnvKeyJwtType] algo = envData.StringEnv[constants.EnvKeyJwtType]
if !crypto.IsHMACA(algo) && !crypto.IsRSA(algo) && !crypto.IsECDSA(algo) { if !crypto.IsHMACA(algo) && !crypto.IsRSA(algo) && !crypto.IsECDSA(algo) {
log.Debug("Invalid JWT Algorithm")
return errors.New("invalid JWT_TYPE") return errors.New("invalid JWT_TYPE")
} }
} }
@ -385,6 +388,7 @@ func InitAllEnv() error {
} }
if len(roles) > 0 && len(defaultRoles) == 0 && len(defaultRolesEnv) > 0 { if len(roles) > 0 && len(defaultRoles) == 0 && len(defaultRolesEnv) > 0 {
log.Debug("Default roles not found in roles list. It can be one from ROLES only")
return errors.New(`invalid DEFAULT_ROLE environment variable. It can be one from give ROLES environment variable value`) return errors.New(`invalid DEFAULT_ROLE environment variable. It can be one from give ROLES environment variable value`)
} }

13
server/env/persist_env.go vendored
View File

@ -23,12 +23,14 @@ func GetEnvData() (envstore.Store, error) {
env, err := db.Provider.GetEnv() env, err := db.Provider.GetEnv()
// config not found in db // config not found in db
if err != nil { if err != nil {
log.Debug("Error while getting env data from db: ", err)
return result, err return result, err
} }
encryptionKey := env.Hash encryptionKey := env.Hash
decryptedEncryptionKey, err := crypto.DecryptB64(encryptionKey) decryptedEncryptionKey, err := crypto.DecryptB64(encryptionKey)
if err != nil { if err != nil {
log.Debug("Error while decrypting encryption key: ", err)
return result, err return result, err
} }
@ -36,16 +38,19 @@ func GetEnvData() (envstore.Store, error) {
b64DecryptedConfig, err := crypto.DecryptB64(env.EnvData) b64DecryptedConfig, err := crypto.DecryptB64(env.EnvData)
if err != nil { if err != nil {
log.Debug("Error while decrypting env data from B64: ", err)
return result, err return result, err
} }
decryptedConfigs, err := crypto.DecryptAESEnv([]byte(b64DecryptedConfig)) decryptedConfigs, err := crypto.DecryptAESEnv([]byte(b64DecryptedConfig))
if err != nil { if err != nil {
log.Debug("Error while decrypting env data from AES: ", err)
return result, err return result, err
} }
err = json.Unmarshal(decryptedConfigs, &result) err = json.Unmarshal(decryptedConfigs, &result)
if err != nil { if err != nil {
log.Debug("Error while unmarshalling env data: ", err)
return result, err return result, err
} }
@ -64,6 +69,7 @@ func PersistEnv() error {
encryptedConfig, err := crypto.EncryptEnvData(envstore.EnvStoreObj.GetEnvStoreClone()) encryptedConfig, err := crypto.EncryptEnvData(envstore.EnvStoreObj.GetEnvStoreClone())
if err != nil { if err != nil {
log.Debug("Error while encrypting env data: ", err)
return err return err
} }
@ -74,6 +80,7 @@ func PersistEnv() error {
env, err = db.Provider.AddEnv(env) env, err = db.Provider.AddEnv(env)
if err != nil { if err != nil {
log.Debug("Error while persisting env data to db: ", err)
return err return err
} }
} else { } else {
@ -82,6 +89,7 @@ func PersistEnv() error {
encryptionKey := env.Hash encryptionKey := env.Hash
decryptedEncryptionKey, err := crypto.DecryptB64(encryptionKey) decryptedEncryptionKey, err := crypto.DecryptB64(encryptionKey)
if err != nil { if err != nil {
log.Debug("Error while decrypting encryption key: ", err)
return err return err
} }
@ -89,11 +97,13 @@ func PersistEnv() error {
b64DecryptedConfig, err := crypto.DecryptB64(env.EnvData) b64DecryptedConfig, err := crypto.DecryptB64(env.EnvData)
if err != nil { if err != nil {
log.Debug("Error while decrypting env data from B64: ", err)
return err return err
} }
decryptedConfigs, err := crypto.DecryptAESEnv([]byte(b64DecryptedConfig)) decryptedConfigs, err := crypto.DecryptAESEnv([]byte(b64DecryptedConfig))
if err != nil { if err != nil {
log.Debug("Error while decrypting env data from AES: ", err)
return err return err
} }
@ -102,6 +112,7 @@ func PersistEnv() error {
err = json.Unmarshal(decryptedConfigs, &storeData) err = json.Unmarshal(decryptedConfigs, &storeData)
if err != nil { if err != nil {
log.Debug("Error while unmarshalling env data: ", err)
return err return err
} }
@ -169,6 +180,7 @@ func PersistEnv() error {
envstore.EnvStoreObj.UpdateEnvStore(storeData) envstore.EnvStoreObj.UpdateEnvStore(storeData)
jwk, err := crypto.GenerateJWKBasedOnEnv() jwk, err := crypto.GenerateJWKBasedOnEnv()
if err != nil { if err != nil {
log.Debug("Error while generating JWK: ", err)
return err return err
} }
// updating jwk // updating jwk
@ -177,6 +189,7 @@ func PersistEnv() error {
if hasChanged { if hasChanged {
encryptedConfig, err := crypto.EncryptEnvData(storeData) encryptedConfig, err := crypto.EncryptEnvData(storeData)
if err != nil { if err != nil {
log.Debug("Error while encrypting env data: ", err)
return err return err
} }

2
server/envstore/store.go
View File

@ -13,6 +13,8 @@ var (
ARG_DB_TYPE *string ARG_DB_TYPE *string
// ARG_ENV_FILE is the cli arg variable for the env file // ARG_ENV_FILE is the cli arg variable for the env file
ARG_ENV_FILE *string ARG_ENV_FILE *string
// ARG_LOG_LEVEL is the cli arg variable for the log level
ARG_LOG_LEVEL *string
) )
// Store data structure // Store data structure

2
server/handlers/app.go
View File

@ -55,7 +55,7 @@ func AppHandler() gin.HandlerFunc {
if pusher := c.Writer.Pusher(); pusher != nil { if pusher := c.Writer.Pusher(); pusher != nil {
// use pusher.Push() to do server push // use pusher.Push() to do server push
if err := pusher.Push("/app/build/bundle.js", nil); err != nil { if err := pusher.Push("/app/build/bundle.js", nil); err != nil {
log.Debug("Failed to push file path", err) log.Debug("Failed to push file path: ", err)
} }
} }
c.HTML(http.StatusOK, "app.tmpl", gin.H{ c.HTML(http.StatusOK, "app.tmpl", gin.H{

12
server/handlers/authorize.go
View File

@ -50,7 +50,7 @@ func AuthorizeHandler() gin.HandlerFunc {
} }
if responseMode != "query" && responseMode != "web_message" { if responseMode != "query" && responseMode != "web_message" {
log.Debug("Invalid response_mode") log.Debug("Invalid response_mode: ", responseMode)
gc.JSON(400, gin.H{"error": "invalid response mode"}) gc.JSON(400, gin.H{"error": "invalid response mode"})
} }
@ -66,7 +66,7 @@ func AuthorizeHandler() gin.HandlerFunc {
if isQuery { if isQuery {
gc.Redirect(http.StatusFound, loginURL) gc.Redirect(http.StatusFound, loginURL)
} else { } else {
log.Debug("Failed to get client_id") log.Debug("Failed to get client_id: ", clientID)
gc.HTML(http.StatusOK, template, gin.H{ gc.HTML(http.StatusOK, template, gin.H{
"target_origin": redirectURI, "target_origin": redirectURI,
"authorization_response": map[string]interface{}{ "authorization_response": map[string]interface{}{
@ -84,7 +84,7 @@ func AuthorizeHandler() gin.HandlerFunc {
if isQuery { if isQuery {
gc.Redirect(http.StatusFound, loginURL) gc.Redirect(http.StatusFound, loginURL)
} else { } else {
log.Debug("Invalid client_id") log.Debug("Invalid client_id: ", clientID)
gc.HTML(http.StatusOK, template, gin.H{ gc.HTML(http.StatusOK, template, gin.H{
"target_origin": redirectURI, "target_origin": redirectURI,
"authorization_response": map[string]interface{}{ "authorization_response": map[string]interface{}{
@ -102,7 +102,7 @@ func AuthorizeHandler() gin.HandlerFunc {
if isQuery { if isQuery {
gc.Redirect(http.StatusFound, loginURL) gc.Redirect(http.StatusFound, loginURL)
} else { } else {
log.Debug("Failed to get state") log.Debug("Failed to get state: ", state)
gc.HTML(http.StatusOK, template, gin.H{ gc.HTML(http.StatusOK, template, gin.H{
"target_origin": redirectURI, "target_origin": redirectURI,
"authorization_response": map[string]interface{}{ "authorization_response": map[string]interface{}{
@ -127,7 +127,7 @@ func AuthorizeHandler() gin.HandlerFunc {
if isQuery { if isQuery {
gc.Redirect(http.StatusFound, loginURL) gc.Redirect(http.StatusFound, loginURL)
} else { } else {
log.Debug("Invalid response_type") log.Debug("Invalid response_type: ", responseType)
gc.HTML(http.StatusOK, template, gin.H{ gc.HTML(http.StatusOK, template, gin.H{
"target_origin": redirectURI, "target_origin": redirectURI,
"authorization_response": map[string]interface{}{ "authorization_response": map[string]interface{}{
@ -146,7 +146,7 @@ func AuthorizeHandler() gin.HandlerFunc {
if isQuery { if isQuery {
gc.Redirect(http.StatusFound, loginURL) gc.Redirect(http.StatusFound, loginURL)
} else { } else {
log.Debug("Failed to get code_challenge") log.Debug("Failed to get code_challenge: ", codeChallenge)
gc.HTML(http.StatusBadRequest, template, gin.H{ gc.HTML(http.StatusBadRequest, template, gin.H{
"target_origin": redirectURI, "target_origin": redirectURI,
"authorization_response": map[string]interface{}{ "authorization_response": map[string]interface{}{

2
server/handlers/jwks.go
View File

@ -16,7 +16,7 @@ func JWKsHandler() gin.HandlerFunc {
jwk := envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyJWK) jwk := envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyJWK)
err := json.Unmarshal([]byte(jwk), &data) err := json.Unmarshal([]byte(jwk), &data)
if err != nil { if err != nil {
log.Debug("Failed to parse JWK", err) log.Debug("Failed to parse JWK: ", err)
c.JSON(500, gin.H{ c.JSON(500, gin.H{
"error": err.Error(), "error": err.Error(),
}) })

4
server/handlers/logout.go
View File

@ -19,7 +19,7 @@ func LogoutHandler() gin.HandlerFunc {
// get fingerprint hash // get fingerprint hash
fingerprintHash, err := cookie.GetSession(gc) fingerprintHash, err := cookie.GetSession(gc)
if err != nil { if err != nil {
log.Debug("Failed to get session", err) log.Debug("Failed to get session: ", err)
gc.JSON(http.StatusUnauthorized, gin.H{ gc.JSON(http.StatusUnauthorized, gin.H{
"error": err.Error(), "error": err.Error(),
}) })
@ -28,7 +28,7 @@ func LogoutHandler() gin.HandlerFunc {
decryptedFingerPrint, err := crypto.DecryptAES(fingerprintHash) decryptedFingerPrint, err := crypto.DecryptAES(fingerprintHash)
if err != nil { if err != nil {
log.Debug("Failed to decrypt fingerprint", err) log.Debug("Failed to decrypt fingerprint: ", err)
gc.JSON(http.StatusUnauthorized, gin.H{ gc.JSON(http.StatusUnauthorized, gin.H{
"error": err.Error(), "error": err.Error(),
}) })

10
server/handlers/oauth_callback.go
View File

@ -34,7 +34,7 @@ func OAuthCallbackHandler() gin.HandlerFunc {
sessionState := sessionstore.GetState(state) sessionState := sessionstore.GetState(state)
if sessionState == "" { if sessionState == "" {
log.Debug("Invalid oauth state") log.Debug("Invalid oauth state: ", state)
c.JSON(400, gin.H{"error": "invalid oauth state"}) c.JSON(400, gin.H{"error": "invalid oauth state"})
} }
sessionstore.GetState(state) sessionstore.GetState(state)
@ -42,7 +42,7 @@ func OAuthCallbackHandler() gin.HandlerFunc {
sessionSplit := strings.Split(state, "___") sessionSplit := strings.Split(state, "___")
if len(sessionSplit) < 3 { if len(sessionSplit) < 3 {
log.Debug("Invalid redirect url") log.Debug("Unable to get redirect url from state: ", state)
c.JSON(400, gin.H{"error": "invalid redirect url"}) c.JSON(400, gin.H{"error": "invalid redirect url"})
return return
} }
@ -93,7 +93,7 @@ func OAuthCallbackHandler() gin.HandlerFunc {
} }
if hasProtectedRole { if hasProtectedRole {
log.Debug("Invalid role") log.Debug("Signup is not allowed with protected roles:", inputRoles)
c.JSON(400, gin.H{"error": "invalid role"}) c.JSON(400, gin.H{"error": "invalid role"})
return return
} }
@ -104,7 +104,7 @@ func OAuthCallbackHandler() gin.HandlerFunc {
user, _ = db.Provider.AddUser(user) user, _ = db.Provider.AddUser(user)
} else { } else {
if user.RevokedTimestamp != nil { if user.RevokedTimestamp != nil {
log.Debug("User access revoked") log.Debug("User access revoked at: ", user.RevokedTimestamp)
c.JSON(400, gin.H{"error": "user access has been revoked"}) c.JSON(400, gin.H{"error": "user access has been revoked"})
} }
@ -215,7 +215,7 @@ func processGoogleUserInfo(code string) (models.User, error) {
// Extract the ID Token from OAuth2 token. // Extract the ID Token from OAuth2 token.
rawIDToken, ok := oauth2Token.Extra("id_token").(string) rawIDToken, ok := oauth2Token.Extra("id_token").(string)
if !ok { if !ok {
log.Debug("Failed to extract ID Token from OAuth2 token.") log.Debug("Failed to extract ID Token from OAuth2 token")
return user, fmt.Errorf("unable to extract id_token") return user, fmt.Errorf("unable to extract id_token")
} }

1
server/handlers/oauth_login.go
View File

@ -57,6 +57,7 @@ func OAuthLoginHandler() gin.HandlerFunc {
// use protected roles verification for admin login only. // use protected roles verification for admin login only.
// though if not associated with user, it will be rejected from oauth_callback // though if not associated with user, it will be rejected from oauth_callback
if !utils.IsValidRoles(rolesSplit, append([]string{}, append(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyProtectedRoles)...)...)) { if !utils.IsValidRoles(rolesSplit, append([]string{}, append(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyProtectedRoles)...)...)) {
log.Debug("Invalid roles: ", roles)
c.JSON(400, gin.H{ c.JSON(400, gin.H{
"error": "invalid role", "error": "invalid role",
}) })

2
server/handlers/revoke.go
View File

@ -38,7 +38,7 @@ func RevokeHandler() gin.HandlerFunc {
} }
if clientID != envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyClientID) { if clientID != envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyClientID) {
log.Debug("Client ID is invalid") log.Debug("Client ID is invalid: ", clientID)
gc.JSON(http.StatusBadRequest, gin.H{ gc.JSON(http.StatusBadRequest, gin.H{
"error": "invalid_client_id", "error": "invalid_client_id",
"error_description": "The client id is invalid", "error_description": "The client id is invalid",

6
server/handlers/token.go
View File

@ -46,7 +46,7 @@ func TokenHandler() gin.HandlerFunc {
isAuthorizationCodeGrant := grantType == "authorization_code" isAuthorizationCodeGrant := grantType == "authorization_code"
if !isRefreshTokenGrant && !isAuthorizationCodeGrant { if !isRefreshTokenGrant && !isAuthorizationCodeGrant {
log.Debug("Invalid grant type") log.Debug("Invalid grant type: ", grantType)
gc.JSON(http.StatusBadRequest, gin.H{ gc.JSON(http.StatusBadRequest, gin.H{
"error": "invalid_grant_type", "error": "invalid_grant_type",
"error_description": "grant_type is invalid", "error_description": "grant_type is invalid",
@ -63,7 +63,7 @@ func TokenHandler() gin.HandlerFunc {
} }
if clientID != envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyClientID) { if clientID != envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyClientID) {
log.Debug("Client ID is invalid") log.Debug("Client ID is invalid: ", clientID)
gc.JSON(http.StatusBadRequest, gin.H{ gc.JSON(http.StatusBadRequest, gin.H{
"error": "invalid_client_id", "error": "invalid_client_id",
"error_description": "The client id is invalid", "error_description": "The client id is invalid",
@ -100,7 +100,7 @@ func TokenHandler() gin.HandlerFunc {
encryptedCode = strings.ReplaceAll(encryptedCode, "=", "") encryptedCode = strings.ReplaceAll(encryptedCode, "=", "")
sessionData := sessionstore.GetState(encryptedCode) sessionData := sessionstore.GetState(encryptedCode)
if sessionData == "" { if sessionData == "" {
log.Debug("Invalid code verifier") log.Debug("Session data is empty")
gc.JSON(http.StatusBadRequest, gin.H{ gc.JSON(http.StatusBadRequest, gin.H{
"error": "invalid_code_verifier", "error": "invalid_code_verifier",
"error_description": "The code verifier is invalid", "error_description": "The code verifier is invalid",

31
server/main.go
View File

@ -16,14 +16,41 @@ import (
var VERSION string var VERSION string
type UTCFormatter struct {
log.Formatter
}
func (u UTCFormatter) Format(e *log.Entry) ([]byte, error) {
e.Time = e.Time.UTC()
return u.Formatter.Format(e)
}
func main() { func main() {
envstore.ARG_DB_URL = flag.String("database_url", "", "Database connection string") envstore.ARG_DB_URL = flag.String("database_url", "", "Database connection string")
envstore.ARG_DB_TYPE = flag.String("database_type", "", "Database type, possible values are postgres,mysql,sqlite") envstore.ARG_DB_TYPE = flag.String("database_type", "", "Database type, possible values are postgres,mysql,sqlite")
envstore.ARG_ENV_FILE = flag.String("env_file", "", "Env file path") envstore.ARG_ENV_FILE = flag.String("env_file", "", "Env file path")
flag.Parse() // envstore.ARG_LOG_LEVEL = flag.String("log_level", "", "Log level, possible values are debug,info,warn,error,fatal,panic")
log.SetFormatter(&log.JSONFormatter{}) log.SetFormatter(UTCFormatter{&log.JSONFormatter{}})
log.SetReportCaller(true) log.SetReportCaller(true)
log.SetLevel(log.DebugLevel)
// switch *envstore.ARG_LOG_LEVEL {
// case "debug":
// log.SetLevel(log.DebugLevel)
// case "info":
// log.SetLevel(log.InfoLevel)
// case "warn":
// log.SetLevel(log.WarnLevel)
// case "error":
// log.SetLevel(log.ErrorLevel)
// case "fatal":
// log.SetLevel(log.FatalLevel)
// case "panic":
// log.SetLevel(log.PanicLevel)
// default:
// log.SetLevel(log.InfoLevel)
// }
constants.VERSION = VERSION constants.VERSION = VERSION

2
server/middlewares/log.go
View File

@ -23,7 +23,7 @@ func (fn GinLogWriteFunc) Write(data []byte) (int, error) {
// NewGinLogrusWrite logrus writer for gin // NewGinLogrusWrite logrus writer for gin
func NewGinLogrusWrite() io.Writer { func NewGinLogrusWrite() io.Writer {
return GinLogWriteFunc(func(data []byte) (int, error) { return GinLogWriteFunc(func(data []byte) (int, error) {
log.Info("%s", data) log.Info("%v", data)
return 0, nil return 0, nil
}) })
} }

2
server/resolvers/admin_login.go
View File

@ -20,7 +20,7 @@ func AdminLoginResolver(ctx context.Context, params model.AdminLoginInput) (*mod
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

2
server/resolvers/admin_logout.go
View File

@ -18,7 +18,7 @@ func AdminLogoutResolver(ctx context.Context) (*model.Response, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

4
server/resolvers/admin_session.go
View File

@ -21,12 +21,12 @@ func AdminSessionResolver(ctx context.Context) (*model.Response, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return res, fmt.Errorf("unauthorized") return res, fmt.Errorf("unauthorized")
} }

4
server/resolvers/delete_user.go
View File

@ -19,12 +19,12 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return res, fmt.Errorf("unauthorized") return res, fmt.Errorf("unauthorized")
} }

2
server/resolvers/enable_access.go
View File

@ -18,7 +18,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

2
server/resolvers/env.go
View File

@ -20,7 +20,7 @@ func EnvResolver(ctx context.Context) (*model.Env, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

8
server/resolvers/forgot_password.go
View File

@ -24,18 +24,18 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) { if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
log.Debug("Basic authentication is disabled.") log.Debug("Basic authentication is disabled")
return res, fmt.Errorf(`basic authentication is disabled for this instance`) return res, fmt.Errorf(`basic authentication is disabled for this instance`)
} }
params.Email = strings.ToLower(params.Email) params.Email = strings.ToLower(params.Email)
if !utils.IsValidEmail(params.Email) { if !utils.IsValidEmail(params.Email) {
log.Debug("Invalid email address.") log.Debug("Invalid email address: ", params.Email)
return res, fmt.Errorf("invalid email") return res, fmt.Errorf("invalid email")
} }
@ -44,12 +44,14 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu
}) })
_, err = db.Provider.GetUserByEmail(params.Email) _, err = db.Provider.GetUserByEmail(params.Email)
if err != nil { if err != nil {
log.Debug("User not found: ", err)
return res, fmt.Errorf(`user with this email not found`) return res, fmt.Errorf(`user with this email not found`)
} }
hostname := utils.GetHost(gc) hostname := utils.GetHost(gc)
_, nonceHash, err := utils.GenerateNonce() _, nonceHash, err := utils.GenerateNonce()
if err != nil { if err != nil {
log.Debug("Failed to generate nonce: ", err)
return res, err return res, err
} }
redirectURL := utils.GetAppURL(gc) + "/reset-password" redirectURL := utils.GetAppURL(gc) + "/reset-password"

4
server/resolvers/generate_jwt_keys.go
View File

@ -17,12 +17,12 @@ import (
func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysInput) (*model.GenerateJWTKeysResponse, error) { func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysInput) (*model.GenerateJWTKeysResponse, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return nil, err return nil, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return nil, fmt.Errorf("unauthorized") return nil, fmt.Errorf("unauthorized")
} }

16
server/resolvers/invite_members.go
View File

@ -23,7 +23,7 @@ import (
func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput) (*model.Response, error) { func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput) (*model.Response, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return nil, err return nil, err
} }
@ -34,7 +34,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
// this feature is only allowed if email server is configured // this feature is only allowed if email server is configured
if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableEmailVerification) { if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableEmailVerification) {
log.Debug("Email server is not configured.") log.Debug("Email server is not configured")
return nil, errors.New("email sending is disabled") return nil, errors.New("email sending is disabled")
} }
@ -52,7 +52,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
} }
if len(emails) == 0 { if len(emails) == 0 {
log.Debug("No valid email addresses.") log.Debug("No valid email addresses")
return nil, errors.New("no valid emails found") return nil, errors.New("no valid emails found")
} }
@ -62,10 +62,10 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
for _, email := range emails { for _, email := range emails {
_, err := db.Provider.GetUserByEmail(email) _, err := db.Provider.GetUserByEmail(email)
if err != nil { if err != nil {
log.Info("User with this email not found, so inviting...") log.Debugf("User with %s email not found, so inviting user", email)
newEmails = append(newEmails, email) newEmails = append(newEmails, email)
} else { } else {
log.Info("User with this email already exists, so not inviting...") log.Debugf("User with %s email already exists, so not inviting user", email)
} }
} }
@ -97,7 +97,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
verificationToken, err := token.CreateVerificationToken(email, constants.VerificationTypeForgotPassword, hostname, nonceHash, redirectURL) verificationToken, err := token.CreateVerificationToken(email, constants.VerificationTypeForgotPassword, hostname, nonceHash, redirectURL)
if err != nil { if err != nil {
log.Debug("Failed to create verification token.", err) log.Debug("Failed to create verification token: ", err)
} }
verificationRequest := models.VerificationRequest{ verificationRequest := models.VerificationRequest{
@ -123,13 +123,13 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
user, err = db.Provider.AddUser(user) user, err = db.Provider.AddUser(user)
if err != nil { if err != nil {
log.Debug("Error adding user: %s, err: %v", email, err) log.Debugf("Error adding user: %s, err: %v", email, err)
return nil, err return nil, err
} }
_, err = db.Provider.AddVerificationRequest(verificationRequest) _, err = db.Provider.AddVerificationRequest(verificationRequest)
if err != nil { if err != nil {
log.Debug("Error adding verification request: %s, err: %v", email, err) log.Debugf("Error adding verification request: %s, err: %v", email, err)
return nil, err return nil, err
} }

8
server/resolvers/login.go
View File

@ -26,7 +26,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
@ -41,7 +41,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
params.Email = strings.ToLower(params.Email) params.Email = strings.ToLower(params.Email)
user, err := db.Provider.GetUserByEmail(params.Email) user, err := db.Provider.GetUserByEmail(params.Email)
if err != nil { if err != nil {
log.Debug("Failed to get user by email", err) log.Debug("Failed to get user by email: ", err)
return res, fmt.Errorf(`user with this email not found`) return res, fmt.Errorf(`user with this email not found`)
} }
@ -63,14 +63,14 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(params.Password)) err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(params.Password))
if err != nil { if err != nil {
log.Debug("Failed to compare password", err) log.Debug("Failed to compare password: ", err)
return res, fmt.Errorf(`invalid password`) return res, fmt.Errorf(`invalid password`)
} }
roles := envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyDefaultRoles) roles := envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyDefaultRoles)
currentRoles := strings.Split(user.Roles, ",") currentRoles := strings.Split(user.Roles, ",")
if len(params.Roles) > 0 { if len(params.Roles) > 0 {
if !utils.IsValidRoles(params.Roles, currentRoles) { if !utils.IsValidRoles(params.Roles, currentRoles) {
log.Debug("Invalid roles") log.Debug("Invalid roles: ", params.Roles)
return res, fmt.Errorf(`invalid roles`) return res, fmt.Errorf(`invalid roles`)
} }

2
server/resolvers/logout.go
View File

@ -18,7 +18,7 @@ func LogoutResolver(ctx context.Context) (*model.Response, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

12
server/resolvers/magic_link_login.go
View File

@ -24,7 +24,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
@ -63,7 +63,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
if len(params.Roles) > 0 { if len(params.Roles) > 0 {
// check if roles exists // check if roles exists
if !utils.IsValidRoles(params.Roles, envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles)) { if !utils.IsValidRoles(params.Roles, envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles)) {
log.Debug("Invalid roles") log.Debug("Invalid roles: ", params.Roles)
return res, fmt.Errorf(`invalid roles`) return res, fmt.Errorf(`invalid roles`)
} else { } else {
inputRoles = params.Roles inputRoles = params.Roles
@ -82,7 +82,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
// Need to modify roles in this case // Need to modify roles in this case
if user.RevokedTimestamp != nil { if user.RevokedTimestamp != nil {
log.Debug("User access is revoked") log.Debug("User access is revoked at: ", user.RevokedTimestamp)
return res, fmt.Errorf(`user access has been revoked`) return res, fmt.Errorf(`user access has been revoked`)
} }
@ -125,7 +125,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
user.SignupMethods = signupMethod user.SignupMethods = signupMethod
user, _ = db.Provider.UpdateUser(user) user, _ = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
} }
} }
@ -134,7 +134,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
// insert verification request // insert verification request
_, nonceHash, err := utils.GenerateNonce() _, nonceHash, err := utils.GenerateNonce()
if err != nil { if err != nil {
log.Debug("Failed to generate nonce", err) log.Debug("Failed to generate nonce: ", err)
return res, err return res, err
} }
redirectURLParams := "&roles=" + strings.Join(inputRoles, ",") redirectURLParams := "&roles=" + strings.Join(inputRoles, ",")
@ -158,7 +158,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
verificationType := constants.VerificationTypeMagicLinkLogin verificationType := constants.VerificationTypeMagicLinkLogin
verificationToken, err := token.CreateVerificationToken(params.Email, verificationType, hostname, nonceHash, redirectURL) verificationToken, err := token.CreateVerificationToken(params.Email, verificationType, hostname, nonceHash, redirectURL)
if err != nil { if err != nil {
log.Debug("Failed to create verification token", err) log.Debug("Failed to create verification token: ", err)
} }
_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{ _, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
Token: verificationToken, Token: verificationToken,

2
server/resolvers/profile.go
View File

@ -17,7 +17,7 @@ func ProfileResolver(ctx context.Context) (*model.User, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }

16
server/resolvers/resend_verify_email.go
View File

@ -22,43 +22,43 @@ func ResendVerifyEmailResolver(ctx context.Context, params model.ResendVerifyEma
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
params.Email = strings.ToLower(params.Email) params.Email = strings.ToLower(params.Email)
if !utils.IsValidEmail(params.Email) { if !utils.IsValidEmail(params.Email) {
log.Debug("Invalid email", params.Email) log.Debug("Invalid email: ", params.Email)
return res, fmt.Errorf("invalid email") return res, fmt.Errorf("invalid email")
} }
if !utils.IsValidVerificationIdentifier(params.Identifier) { if !utils.IsValidVerificationIdentifier(params.Identifier) {
log.Debug("Invalid verification identifier", params.Identifier) log.Debug("Invalid verification identifier: ", params.Identifier)
return res, fmt.Errorf("invalid identifier") return res, fmt.Errorf("invalid identifier")
} }
verificationRequest, err := db.Provider.GetVerificationRequestByEmail(params.Email, params.Identifier) verificationRequest, err := db.Provider.GetVerificationRequestByEmail(params.Email, params.Identifier)
if err != nil { if err != nil {
log.Debug("Failed to get verification request", err) log.Debug("Failed to get verification request: ", err)
return res, fmt.Errorf(`verification request not found`) return res, fmt.Errorf(`verification request not found`)
} }
// delete current verification and create new one // delete current verification and create new one
err = db.Provider.DeleteVerificationRequest(verificationRequest) err = db.Provider.DeleteVerificationRequest(verificationRequest)
if err != nil { if err != nil {
log.Debug("Failed to delete verification request", err) log.Debug("Failed to delete verification request: ", err)
} }
hostname := utils.GetHost(gc) hostname := utils.GetHost(gc)
_, nonceHash, err := utils.GenerateNonce() _, nonceHash, err := utils.GenerateNonce()
if err != nil { if err != nil {
log.Debug("Failed to generate nonce", err) log.Debug("Failed to generate nonce: ", err)
return res, err return res, err
} }
verificationToken, err := token.CreateVerificationToken(params.Email, params.Identifier, hostname, nonceHash, verificationRequest.RedirectURI) verificationToken, err := token.CreateVerificationToken(params.Email, params.Identifier, hostname, nonceHash, verificationRequest.RedirectURI)
if err != nil { if err != nil {
log.Debug("Failed to create verification token", err) log.Debug("Failed to create verification token: ", err)
} }
_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{ _, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
Token: verificationToken, Token: verificationToken,
@ -69,7 +69,7 @@ func ResendVerifyEmailResolver(ctx context.Context, params model.ResendVerifyEma
RedirectURI: verificationRequest.RedirectURI, RedirectURI: verificationRequest.RedirectURI,
}) })
if err != nil { if err != nil {
log.Debug("Failed to add verification request", err) log.Debug("Failed to add verification request: ", err)
} }
// exec it as go routin so that we can reduce the api latency // exec it as go routin so that we can reduce the api latency

12
server/resolvers/reset_password.go
View File

@ -23,7 +23,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) { if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
@ -33,7 +33,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token) verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token)
if err != nil { if err != nil {
log.Debug("Failed to get verification request", err) log.Debug("Failed to get verification request: ", err)
return res, fmt.Errorf(`invalid token`) return res, fmt.Errorf(`invalid token`)
} }
@ -51,7 +51,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
hostname := utils.GetHost(gc) hostname := utils.GetHost(gc)
claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email) claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email)
if err != nil { if err != nil {
log.Debug("Failed to parse token", err) log.Debug("Failed to parse token: ", err)
return res, fmt.Errorf(`invalid token`) return res, fmt.Errorf(`invalid token`)
} }
@ -61,7 +61,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
}) })
user, err := db.Provider.GetUserByEmail(email) user, err := db.Provider.GetUserByEmail(email)
if err != nil { if err != nil {
log.Debug("Failed to get user", err) log.Debug("Failed to get user: ", err)
return res, err return res, err
} }
@ -83,13 +83,13 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
// delete from verification table // delete from verification table
err = db.Provider.DeleteVerificationRequest(verificationRequest) err = db.Provider.DeleteVerificationRequest(verificationRequest)
if err != nil { if err != nil {
log.Debug("Failed to delete verification request", err) log.Debug("Failed to delete verification request: ", err)
return res, err return res, err
} }
_, err = db.Provider.UpdateUser(user) _, err = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
return res, err return res, err
} }

8
server/resolvers/revoke_access.go
View File

@ -20,12 +20,12 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return res, fmt.Errorf("unauthorized") return res, fmt.Errorf("unauthorized")
} }
@ -34,7 +34,7 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
}) })
user, err := db.Provider.GetUserByID(params.UserID) user, err := db.Provider.GetUserByID(params.UserID)
if err != nil { if err != nil {
log.Debug("Failed to get user by ID", err) log.Debug("Failed to get user by ID: ", err)
return res, err return res, err
} }
@ -43,7 +43,7 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
user, err = db.Provider.UpdateUser(user) user, err = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
return res, err return res, err
} }

4
server/resolvers/session.go
View File

@ -23,7 +23,7 @@ func SessionResolver(ctx context.Context, params *model.SessionQueryInput) (*mod
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
@ -71,7 +71,7 @@ func SessionResolver(ctx context.Context, params *model.SessionQueryInput) (*mod
authToken, err := token.CreateAuthToken(gc, user, claimRoles, scope) authToken, err := token.CreateAuthToken(gc, user, claimRoles, scope)
if err != nil { if err != nil {
log.Debug("Failed to create auth token", err) log.Debug("Failed to create auth token: ", err)
return res, err return res, err
} }

10
server/resolvers/signup.go
View File

@ -27,22 +27,22 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableSignUp) { if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableSignUp) {
log.Debug("Signup is disabled.") log.Debug("Signup is disabled")
return res, fmt.Errorf(`signup is disabled for this instance`) return res, fmt.Errorf(`signup is disabled for this instance`)
} }
if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) { if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
log.Debug("Basic authentication is disabled.") log.Debug("Basic authentication is disabled")
return res, fmt.Errorf(`basic authentication is disabled for this instance`) return res, fmt.Errorf(`basic authentication is disabled for this instance`)
} }
if params.ConfirmPassword != params.Password { if params.ConfirmPassword != params.Password {
log.Debug("Passwords do not match.") log.Debug("Passwords do not match")
return res, fmt.Errorf(`password and confirm password does not match`) return res, fmt.Errorf(`password and confirm password does not match`)
} }
@ -81,7 +81,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
if len(params.Roles) > 0 { if len(params.Roles) > 0 {
// check if roles exists // check if roles exists
if !utils.IsValidRoles(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), params.Roles) { if !utils.IsValidRoles(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), params.Roles) {
log.Debug("Invalid roles", params.Roles) log.Debug("Invalid roles: ", params.Roles)
return res, fmt.Errorf(`invalid roles`) return res, fmt.Errorf(`invalid roles`)
} else { } else {
inputRoles = params.Roles inputRoles = params.Roles

34
server/resolvers/update_env.go
View File

@ -28,12 +28,12 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return res, fmt.Errorf("unauthorized") return res, fmt.Errorf("unauthorized")
} }
@ -44,7 +44,7 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
if params.JwtType != nil { if params.JwtType != nil {
algo = *params.JwtType algo = *params.JwtType
if !crypto.IsHMACA(algo) && !crypto.IsECDSA(algo) && !crypto.IsRSA(algo) { if !crypto.IsHMACA(algo) && !crypto.IsECDSA(algo) && !crypto.IsRSA(algo) {
log.Debug("Invalid JWT type", algo) log.Debug("Invalid JWT type: ", algo)
return res, fmt.Errorf("invalid jwt type") return res, fmt.Errorf("invalid jwt type")
} }
@ -75,7 +75,7 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
if crypto.IsRSA(algo) { if crypto.IsRSA(algo) {
if params.JwtPrivateKey == nil || params.JwtPublicKey == nil { if params.JwtPrivateKey == nil || params.JwtPublicKey == nil {
log.Debug("JWT private key and public key are required for RSA", params.JwtPrivateKey, params.JwtPublicKey) log.Debug("JWT private key and public key are required for RSA: ", *params.JwtPrivateKey, *params.JwtPublicKey)
return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm") return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm")
} }
@ -83,20 +83,20 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
params.JwtSecret = &defaultSecret params.JwtSecret = &defaultSecret
_, err = crypto.ParseRsaPrivateKeyFromPemStr(*params.JwtPrivateKey) _, err = crypto.ParseRsaPrivateKeyFromPemStr(*params.JwtPrivateKey)
if err != nil { if err != nil {
log.Debug("Invalid JWT private key", err) log.Debug("Invalid JWT private key: ", err)
return res, err return res, err
} }
_, err := crypto.ParseRsaPublicKeyFromPemStr(*params.JwtPublicKey) _, err := crypto.ParseRsaPublicKeyFromPemStr(*params.JwtPublicKey)
if err != nil { if err != nil {
log.Debug("Invalid JWT public key", err) log.Debug("Invalid JWT public key: ", err)
return res, err return res, err
} }
} }
if crypto.IsECDSA(algo) { if crypto.IsECDSA(algo) {
if params.JwtPrivateKey == nil || params.JwtPublicKey == nil { if params.JwtPrivateKey == nil || params.JwtPublicKey == nil {
log.Debug("JWT private key and public key are required for ECDSA", params.JwtPrivateKey, params.JwtPublicKey) log.Debug("JWT private key and public key are required for ECDSA: ", *params.JwtPrivateKey, *params.JwtPublicKey)
return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm") return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm")
} }
@ -104,13 +104,13 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
params.JwtSecret = &defaultSecret params.JwtSecret = &defaultSecret
_, err = crypto.ParseEcdsaPrivateKeyFromPemStr(*params.JwtPrivateKey) _, err = crypto.ParseEcdsaPrivateKeyFromPemStr(*params.JwtPrivateKey)
if err != nil { if err != nil {
log.Debug("Invalid JWT private key", err) log.Debug("Invalid JWT private key: ", err)
return res, err return res, err
} }
_, err := crypto.ParseEcdsaPublicKeyFromPemStr(*params.JwtPublicKey) _, err := crypto.ParseEcdsaPublicKeyFromPemStr(*params.JwtPublicKey)
if err != nil { if err != nil {
log.Debug("Invalid JWT public key", err) log.Debug("Invalid JWT public key: ", err)
return res, err return res, err
} }
} }
@ -120,13 +120,13 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
var data map[string]interface{} var data map[string]interface{}
byteData, err := json.Marshal(params) byteData, err := json.Marshal(params)
if err != nil { if err != nil {
log.Debug("Failed to marshal update env input", err) log.Debug("Failed to marshal update env input: ", err)
return res, fmt.Errorf("error marshalling params: %t", err) return res, fmt.Errorf("error marshalling params: %t", err)
} }
err = json.Unmarshal(byteData, &data) err = json.Unmarshal(byteData, &data)
if err != nil { if err != nil {
log.Debug("Failed to unmarshal update env input", err) log.Debug("Failed to unmarshal update env input: ", err)
return res, fmt.Errorf("error un-marshalling params: %t", err) return res, fmt.Errorf("error un-marshalling params: %t", err)
} }
@ -209,14 +209,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
envstore.EnvStoreObj.UpdateEnvStore(updatedData) envstore.EnvStoreObj.UpdateEnvStore(updatedData)
jwk, err := crypto.GenerateJWKBasedOnEnv() jwk, err := crypto.GenerateJWKBasedOnEnv()
if err != nil { if err != nil {
log.Debug("Failed to generate JWK", err) log.Debug("Failed to generate JWK: ", err)
return res, err return res, err
} }
// updating jwk // updating jwk
envstore.EnvStoreObj.UpdateEnvVariable(constants.StringStoreIdentifier, constants.EnvKeyJWK, jwk) envstore.EnvStoreObj.UpdateEnvVariable(constants.StringStoreIdentifier, constants.EnvKeyJWK, jwk)
err = sessionstore.InitSession() err = sessionstore.InitSession()
if err != nil { if err != nil {
log.Debug("Failed to init session store", err) log.Debug("Failed to init session store: ", err)
return res, err return res, err
} }
err = oauth.InitOAuth() err = oauth.InitOAuth()
@ -227,14 +227,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
// Fetch the current db store and update it // Fetch the current db store and update it
env, err := db.Provider.GetEnv() env, err := db.Provider.GetEnv()
if err != nil { if err != nil {
log.Debug("Failed to get env", err) log.Debug("Failed to get env: ", err)
return res, err return res, err
} }
if params.AdminSecret != nil { if params.AdminSecret != nil {
hashedKey, err := crypto.EncryptPassword(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)) hashedKey, err := crypto.EncryptPassword(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret))
if err != nil { if err != nil {
log.Debug("Failed to encrypt admin secret", err) log.Debug("Failed to encrypt admin secret: ", err)
return res, err return res, err
} }
cookie.SetAdminCookie(gc, hashedKey) cookie.SetAdminCookie(gc, hashedKey)
@ -242,14 +242,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
encryptedConfig, err := crypto.EncryptEnvData(updatedData) encryptedConfig, err := crypto.EncryptEnvData(updatedData)
if err != nil { if err != nil {
log.Debug("Failed to encrypt env data", err) log.Debug("Failed to encrypt env data: ", err)
return res, err return res, err
} }
env.EnvData = encryptedConfig env.EnvData = encryptedConfig
_, err = db.Provider.UpdateEnv(env) _, err = db.Provider.UpdateEnv(env)
if err != nil { if err != nil {
log.Debug("Failed to update env", err) log.Debug("Failed to update env: ", err)
return res, err return res, err
} }

33
server/resolvers/update_profile.go
View File

@ -28,23 +28,24 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
accessToken, err := token.GetAccessToken(gc) accessToken, err := token.GetAccessToken(gc)
if err != nil { if err != nil {
log.Debug("Failed to get access token", err) log.Debug("Failed to get access token: ", err)
return res, err return res, err
} }
claims, err := token.ValidateAccessToken(gc, accessToken) claims, err := token.ValidateAccessToken(gc, accessToken)
if err != nil { if err != nil {
log.Debug("Failed to validate access token", err) log.Debug("Failed to validate access token: ", err)
return res, err return res, err
} }
// validate if all params are not empty // validate if all params are not empty
if params.GivenName == nil && params.FamilyName == nil && params.Picture == nil && params.MiddleName == nil && params.Nickname == nil && params.OldPassword == nil && params.Email == nil && params.Birthdate == nil && params.Gender == nil && params.PhoneNumber == nil { if params.GivenName == nil && params.FamilyName == nil && params.Picture == nil && params.MiddleName == nil && params.Nickname == nil && params.OldPassword == nil && params.Email == nil && params.Birthdate == nil && params.Gender == nil && params.PhoneNumber == nil {
log.Debug("All params are empty")
return res, fmt.Errorf("please enter at least one param to update") return res, fmt.Errorf("please enter at least one param to update")
} }
@ -55,7 +56,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
user, err := db.Provider.GetUserByID(userID) user, err := db.Provider.GetUserByID(userID)
if err != nil { if err != nil {
log.Debug("Failed to get user by id", err) log.Debug("Failed to get user by id: ", err)
return res, err return res, err
} }
@ -93,17 +94,17 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
if params.OldPassword != nil { if params.OldPassword != nil {
if err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(*params.OldPassword)); err != nil { if err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(*params.OldPassword)); err != nil {
log.Debug("Failed to compare hash and old password", err) log.Debug("Failed to compare hash and old password: ", err)
return res, fmt.Errorf("incorrect old password") return res, fmt.Errorf("incorrect old password")
} }
if params.NewPassword == nil { if params.NewPassword == nil {
log.Debug("Failed to get new password") log.Debug("Failed to get new password: ")
return res, fmt.Errorf("new password is required") return res, fmt.Errorf("new password is required")
} }
if params.ConfirmNewPassword == nil { if params.ConfirmNewPassword == nil {
log.Debug("Failed to get confirm new password") log.Debug("Failed to get confirm new password: ")
return res, fmt.Errorf("confirm password is required") return res, fmt.Errorf("confirm password is required")
} }
@ -122,15 +123,21 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
if params.Email != nil && user.Email != *params.Email { if params.Email != nil && user.Email != *params.Email {
// check if valid email // check if valid email
if !utils.IsValidEmail(*params.Email) { if !utils.IsValidEmail(*params.Email) {
log.Debug("Failed to validate email", *params.Email) log.Debug("Failed to validate email: ", *params.Email)
return res, fmt.Errorf("invalid email address") return res, fmt.Errorf("invalid email address")
} }
newEmail := strings.ToLower(*params.Email) newEmail := strings.ToLower(*params.Email)
// check if valid email
if !utils.IsValidEmail(newEmail) {
log.Debug("Failed to validate new email: ", newEmail)
return res, fmt.Errorf("invalid new email address")
}
// check if user with new email exists // check if user with new email exists
_, err := db.Provider.GetUserByEmail(newEmail) _, err := db.Provider.GetUserByEmail(newEmail)
// err = nil means user exists // err = nil means user exists
if err == nil { if err == nil {
log.Debug("Failed to get user by email", newEmail) log.Debug("Failed to get user by email: ", newEmail)
return res, fmt.Errorf("user with this email address already exists") return res, fmt.Errorf("user with this email address already exists")
} }
@ -145,14 +152,14 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
// insert verification request // insert verification request
_, nonceHash, err := utils.GenerateNonce() _, nonceHash, err := utils.GenerateNonce()
if err != nil { if err != nil {
log.Debug("Failed to generate nonce", err) log.Debug("Failed to generate nonce: ", err)
return res, err return res, err
} }
verificationType := constants.VerificationTypeUpdateEmail verificationType := constants.VerificationTypeUpdateEmail
redirectURL := utils.GetAppURL(gc) redirectURL := utils.GetAppURL(gc)
verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL) verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL)
if err != nil { if err != nil {
log.Debug("Failed to create verification token", err) log.Debug("Failed to create verification token: ", err)
return res, err return res, err
} }
_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{ _, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
@ -164,7 +171,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
RedirectURI: redirectURL, RedirectURI: redirectURL,
}) })
if err != nil { if err != nil {
log.Debug("Failed to add verification request", err) log.Debug("Failed to add verification request: ", err)
return res, err return res, err
} }
@ -175,7 +182,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
} }
_, err = db.Provider.UpdateUser(user) _, err = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
return res, err return res, err
} }
message := `Profile details updated successfully.` message := `Profile details updated successfully.`

22
server/resolvers/update_user.go
View File

@ -26,17 +26,17 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return res, fmt.Errorf("unauthorized") return res, fmt.Errorf("unauthorized")
} }
if params.ID == "" { if params.ID == "" {
log.Debug("Invalid user id") log.Debug("UserID is empty")
return res, fmt.Errorf("User ID is required") return res, fmt.Errorf("User ID is required")
} }
@ -51,7 +51,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
user, err := db.Provider.GetUserByID(params.ID) user, err := db.Provider.GetUserByID(params.ID)
if err != nil { if err != nil {
log.Debug("Failed to get user by id", err) log.Debug("Failed to get user by id: ", err)
return res, fmt.Errorf(`User not found`) return res, fmt.Errorf(`User not found`)
} }
@ -99,7 +99,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
if params.Email != nil && user.Email != *params.Email { if params.Email != nil && user.Email != *params.Email {
// check if valid email // check if valid email
if !utils.IsValidEmail(*params.Email) { if !utils.IsValidEmail(*params.Email) {
log.Debug("Invalid email", *params.Email) log.Debug("Invalid email: ", *params.Email)
return res, fmt.Errorf("invalid email address") return res, fmt.Errorf("invalid email address")
} }
newEmail := strings.ToLower(*params.Email) newEmail := strings.ToLower(*params.Email)
@ -107,7 +107,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
_, err = db.Provider.GetUserByEmail(newEmail) _, err = db.Provider.GetUserByEmail(newEmail)
// err = nil means user exists // err = nil means user exists
if err == nil { if err == nil {
log.Debug("User with email already exists", newEmail) log.Debug("User with email already exists: ", newEmail)
return res, fmt.Errorf("user with this email address already exists") return res, fmt.Errorf("user with this email address already exists")
} }
@ -120,14 +120,14 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
// insert verification request // insert verification request
_, nonceHash, err := utils.GenerateNonce() _, nonceHash, err := utils.GenerateNonce()
if err != nil { if err != nil {
log.Debug("Failed to generate nonce", err) log.Debug("Failed to generate nonce: ", err)
return res, err return res, err
} }
verificationType := constants.VerificationTypeUpdateEmail verificationType := constants.VerificationTypeUpdateEmail
redirectURL := utils.GetAppURL(gc) redirectURL := utils.GetAppURL(gc)
verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL) verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL)
if err != nil { if err != nil {
log.Debug("Failed to create verification token", err) log.Debug("Failed to create verification token: ", err)
} }
_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{ _, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
Token: verificationToken, Token: verificationToken,
@ -138,7 +138,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
RedirectURI: redirectURL, RedirectURI: redirectURL,
}) })
if err != nil { if err != nil {
log.Debug("Failed to add verification request", err) log.Debug("Failed to add verification request: ", err)
return res, err return res, err
} }
@ -156,7 +156,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
} }
if !utils.IsValidRoles(inputRoles, append([]string{}, append(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyProtectedRoles)...)...)) { if !utils.IsValidRoles(inputRoles, append([]string{}, append(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyProtectedRoles)...)...)) {
log.Debug("Invalid roles", params.Roles) log.Debug("Invalid roles: ", params.Roles)
return res, fmt.Errorf("invalid list of roles") return res, fmt.Errorf("invalid list of roles")
} }
@ -173,7 +173,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
user, err = db.Provider.UpdateUser(user) user, err = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
return res, err return res, err
} }

4
server/resolvers/users.go
View File

@ -17,7 +17,7 @@ import (
func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Users, error) { func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Users, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return nil, err return nil, err
} }
@ -30,7 +30,7 @@ func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Us
res, err := db.Provider.ListUsers(pagination) res, err := db.Provider.ListUsers(pagination)
if err != nil { if err != nil {
log.Debug("Failed to get users", err) log.Debug("Failed to get users: ", err)
return nil, err return nil, err
} }

6
server/resolvers/validate_jwt_token.go
View File

@ -24,7 +24,7 @@ import (
func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTTokenInput) (*model.ValidateJWTTokenResponse, error) { func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTTokenInput) (*model.ValidateJWTTokenResponse, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return nil, err return nil, err
} }
@ -57,7 +57,7 @@ func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTToken
if userID != "" && nonce != "" { if userID != "" && nonce != "" {
claims, err = token.ParseJWTToken(params.Token, hostname, nonce, userID) claims, err = token.ParseJWTToken(params.Token, hostname, nonce, userID)
if err != nil { if err != nil {
log.Debug("Failed to parse jwt token", err) log.Debug("Failed to parse jwt token: ", err)
return &model.ValidateJWTTokenResponse{ return &model.ValidateJWTTokenResponse{
IsValid: false, IsValid: false,
}, nil }, nil
@ -65,7 +65,7 @@ func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTToken
} else { } else {
claims, err = token.ParseJWTTokenWithoutNonce(params.Token, hostname) claims, err = token.ParseJWTTokenWithoutNonce(params.Token, hostname)
if err != nil { if err != nil {
log.Debug("Failed to parse jwt token without nonce", err) log.Debug("Failed to parse jwt token without nonce: ", err)
return &model.ValidateJWTTokenResponse{ return &model.ValidateJWTTokenResponse{
IsValid: false, IsValid: false,
}, nil }, nil

6
server/resolvers/verification_requests.go
View File

@ -17,12 +17,12 @@ import (
func VerificationRequestsResolver(ctx context.Context, params *model.PaginatedInput) (*model.VerificationRequests, error) { func VerificationRequestsResolver(ctx context.Context, params *model.PaginatedInput) (*model.VerificationRequests, error) {
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return nil, err return nil, err
} }
if !token.IsSuperAdmin(gc) { if !token.IsSuperAdmin(gc) {
log.Debug("Not logged in as super admin.") log.Debug("Not logged in as super admin")
return nil, fmt.Errorf("unauthorized") return nil, fmt.Errorf("unauthorized")
} }
@ -30,7 +30,7 @@ func VerificationRequestsResolver(ctx context.Context, params *model.PaginatedIn
res, err := db.Provider.ListVerificationRequests(pagination) res, err := db.Provider.ListVerificationRequests(pagination)
if err != nil { if err != nil {
log.Debug("Failed to get verification requests", err) log.Debug("Failed to get verification requests: ", err)
return nil, err return nil, err
} }

14
server/resolvers/verify_email.go
View File

@ -23,13 +23,13 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
gc, err := utils.GinContextFromContext(ctx) gc, err := utils.GinContextFromContext(ctx)
if err != nil { if err != nil {
log.Debug("Failed to get GinContext", err) log.Debug("Failed to get GinContext: ", err)
return res, err return res, err
} }
verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token) verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token)
if err != nil { if err != nil {
log.Debug("Failed to get verification request by token", err) log.Debug("Failed to get verification request by token: ", err)
return res, fmt.Errorf(`invalid token: %s`, err.Error()) return res, fmt.Errorf(`invalid token: %s`, err.Error())
} }
@ -37,7 +37,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
hostname := utils.GetHost(gc) hostname := utils.GetHost(gc)
claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email) claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email)
if err != nil { if err != nil {
log.Debug("Failed to parse token", err) log.Debug("Failed to parse token: ", err)
return res, fmt.Errorf(`invalid token: %s`, err.Error()) return res, fmt.Errorf(`invalid token: %s`, err.Error())
} }
@ -47,7 +47,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
}) })
user, err := db.Provider.GetUserByEmail(email) user, err := db.Provider.GetUserByEmail(email)
if err != nil { if err != nil {
log.Debug("Failed to get user by email", err) log.Debug("Failed to get user by email: ", err)
return res, err return res, err
} }
@ -56,13 +56,13 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
user.EmailVerifiedAt = &now user.EmailVerifiedAt = &now
user, err = db.Provider.UpdateUser(user) user, err = db.Provider.UpdateUser(user)
if err != nil { if err != nil {
log.Debug("Failed to update user", err) log.Debug("Failed to update user: ", err)
return res, err return res, err
} }
// delete from verification table // delete from verification table
err = db.Provider.DeleteVerificationRequest(verificationRequest) err = db.Provider.DeleteVerificationRequest(verificationRequest)
if err != nil { if err != nil {
log.Debug("Failed to delete verification request", err) log.Debug("Failed to delete verification request: ", err)
return res, err return res, err
} }
@ -70,7 +70,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
scope := []string{"openid", "email", "profile"} scope := []string{"openid", "email", "profile"}
authToken, err := token.CreateAuthToken(gc, user, roles, scope) authToken, err := token.CreateAuthToken(gc, user, roles, scope)
if err != nil { if err != nil {
log.Debug("Failed to create auth token", err) log.Debug("Failed to create auth token: ", err)
return res, err return res, err
} }

5
server/routes/routes.go
View File

@ -9,9 +9,8 @@ import (
// InitRouter initializes gin router // InitRouter initializes gin router
func InitRouter() *gin.Engine { func InitRouter() *gin.Engine {
router := gin.Default() router := gin.New()
gin.DefaultWriter = middlewares.NewGinLogrusWrite() router.Use(gin.Recovery())
router.Use(middlewares.JSONLogMiddleware())
router.Use(middlewares.GinContextToContextMiddleware()) router.Use(middlewares.GinContextToContextMiddleware())
router.Use(middlewares.CORSMiddleware()) router.Use(middlewares.CORSMiddleware())

4
server/sessionstore/session.go
View File

@ -98,6 +98,7 @@ func InitSession() error {
if len(redisURLHostPortsList) > 1 { if len(redisURLHostPortsList) > 1 {
opt, err := redis.ParseURL(redisURLHostPortsList[0]) opt, err := redis.ParseURL(redisURLHostPortsList[0])
if err != nil { if err != nil {
log.Debug("error parsing redis url: ", err)
return err return err
} }
urls := []string{opt.Addr} urls := []string{opt.Addr}
@ -109,6 +110,7 @@ func InitSession() error {
ctx := context.Background() ctx := context.Background()
_, err = rdb.Ping(ctx).Result() _, err = rdb.Ping(ctx).Result()
if err != nil { if err != nil {
log.Debug("error connecting to redis: ", err)
return err return err
} }
SessionStoreObj.RedisMemoryStoreObj = &RedisStore{ SessionStoreObj.RedisMemoryStoreObj = &RedisStore{
@ -122,6 +124,7 @@ func InitSession() error {
opt, err := redis.ParseURL(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyRedisURL)) opt, err := redis.ParseURL(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyRedisURL))
if err != nil { if err != nil {
log.Debug("error parsing redis url: ", err)
return err return err
} }
@ -129,6 +132,7 @@ func InitSession() error {
ctx := context.Background() ctx := context.Background()
_, err = rdb.Ping(ctx).Result() _, err = rdb.Ping(ctx).Result()
if err != nil { if err != nil {
log.Debug("error connecting to redis: ", err)
return err return err
} }