feat(login): show profile (#485)

* profile data

* fix scripts

* fix image paths

* feat: show profile (with image) when possible

* fix profile image width

internal/ui/login/handler/change_password_handler.go

@@ -24,7 +24,6 @@ func (l *Login) handleChangePassword(w http.ResponseWriter, r *http.Request) {
 		l.renderError(w, r, authReq, err)
 		return
 	}
-
 	err = l.authRepo.ChangePassword(setContext(r.Context(), authReq.UserOrgID), authReq.UserID, data.OldPassword, data.NewPassword)
 	if err != nil {
 		l.renderChangePassword(w, r, authReq, err)
@@ -39,8 +38,8 @@ func (l *Login) renderChangePassword(w http.ResponseWriter, r *http.Request, aut
 		errMessage = l.getErrorMessage(r, err)
 	}
 	data := passwordData{
-		baseData:  l.getBaseData(r, authReq, "Change Password", errType, errMessage),
-		LoginName: authReq.LoginName,
+		baseData:    l.getBaseData(r, authReq, "Change Password", errType, errMessage),
+		profileData: l.getProfileData(authReq),
 	}
 	policy, description, _ := l.getPasswordComplexityPolicy(r, authReq.UserOrgID)
 	if policy != nil {
@@ -64,9 +63,6 @@ func (l *Login) renderChangePassword(w http.ResponseWriter, r *http.Request, aut
 
 func (l *Login) renderChangePasswordDone(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest) {
 	var errType, errMessage string
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Password Change Done", errType, errMessage),
-		LoginName: authReq.LoginName,
-	}
+	data := l.getUserData(r, authReq, "Password Change Done", errType, errMessage)
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplChangePasswordDone], data, nil)
 }

internal/ui/login/handler/init_password_handler.go

@@ -25,6 +25,7 @@ type initPasswordFormData struct {
 
 type initPasswordData struct {
 	baseData
+	profileData
 	Code                      string
 	UserID                    string
 	PasswordPolicyDescription string
@@ -93,9 +94,10 @@ func (l *Login) renderInitPassword(w http.ResponseWriter, r *http.Request, authR
 	}
 
 	data := initPasswordData{
-		baseData: l.getBaseData(r, authReq, "Init Password", errType, errMessage),
-		UserID:   userID,
-		Code:     code,
+		baseData:    l.getBaseData(r, authReq, "Init Password", errType, errMessage),
+		profileData: l.getProfileData(authReq),
+		UserID:      userID,
+		Code:        code,
 	}
 	policy, description, _ := l.getPasswordComplexityPolicyByUserID(r, userID)
 	if policy != nil {
@@ -118,13 +120,6 @@ func (l *Login) renderInitPassword(w http.ResponseWriter, r *http.Request, authR
 }
 
 func (l *Login) renderInitPasswordDone(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest) {
-	loginName := ""
-	if authReq != nil {
-		loginName = authReq.LoginName
-	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Password Init Done", "", ""),
-		LoginName: loginName,
-	}
+	data := l.getUserData(r, authReq, "Password Init Done", "", "")
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplInitPasswordDone], data, nil)
 }

internal/ui/login/handler/init_user_handler.go

@@ -28,6 +28,7 @@ type initUserFormData struct {
 
 type initUserData struct {
 	baseData
+	profileData
 	Code                      string
 	UserID                    string
 	PasswordSet               bool
@@ -73,10 +74,10 @@ func (l *Login) checkUserInitCode(w http.ResponseWriter, r *http.Request, authRe
 	}
 	err = l.authRepo.VerifyInitCode(setContext(r.Context(), userOrgID), data.UserID, data.Code, data.Password)
 	if err != nil {
-		l.renderInitUser(w, r, nil, data.UserID, "", data.PasswordSet, err)
+		l.renderInitUser(w, r, authReq, data.UserID, "", data.PasswordSet, err)
 		return
 	}
-	l.renderInitUserDone(w, r, nil)
+	l.renderInitUserDone(w, r, authReq)
 }
 
 func (l *Login) resendUserInit(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest, userID string, showPassword bool) {
@@ -97,7 +98,8 @@ func (l *Login) renderInitUser(w http.ResponseWriter, r *http.Request, authReq *
 		userID = authReq.UserID
 	}
 	data := initUserData{
-		baseData:    l.getBaseData(r, nil, "Init User", errType, errMessage),
+		baseData:    l.getBaseData(r, authReq, "Init User", errType, errMessage),
+		profileData: l.getProfileData(authReq),
 		UserID:      userID,
 		Code:        code,
 		PasswordSet: passwordSet,
@@ -123,13 +125,6 @@ func (l *Login) renderInitUser(w http.ResponseWriter, r *http.Request, authReq *
 }
 
 func (l *Login) renderInitUserDone(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest) {
-	var loginName string
-	if authReq != nil {
-		loginName = authReq.LoginName
-	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "User Init Done", "", ""),
-		LoginName: loginName,
-	}
+	data := l.getUserData(r, authReq, "User Init Done", "", "")
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplInitUserDone], data, nil)
 }

internal/ui/login/handler/login_handler.go

@@ -61,13 +61,6 @@ func (l *Login) renderLogin(w http.ResponseWriter, r *http.Request, authReq *mod
 	if err != nil {
 		errMessage = l.getErrorMessage(r, err)
 	}
-	loginName := ""
-	if authReq != nil {
-		loginName = authReq.LoginName
-	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Login", errType, errMessage),
-		LoginName: loginName,
-	}
+	data := l.getUserData(r, authReq, "Login", errType, errMessage)
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplLogin], data, nil)
 }

internal/ui/login/handler/logout_handler.go

@@ -13,8 +13,6 @@ func (l *Login) handleLogoutDone(w http.ResponseWriter, r *http.Request) {
 }
 
 func (l *Login) renderLogoutDone(w http.ResponseWriter, r *http.Request) {
-	data := userData{
-		baseData: l.getBaseData(r, nil, "Logout Done", "", ""),
-	}
+	data := l.getUserData(r, nil, "Logout Done", "", "")
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplLogoutDone], data, nil)
 }

internal/ui/login/handler/mail_verify_handler.go

@@ -22,6 +22,7 @@ type mailVerificationFormData struct {
 
 type mailVerificationData struct {
 	baseData
+	profileData
 	UserID string
 }
 
@@ -77,15 +78,17 @@ func (l *Login) renderMailVerification(w http.ResponseWriter, r *http.Request, a
 		userID = authReq.UserID
 	}
 	data := mailVerificationData{
-		baseData: l.getBaseData(r, authReq, "Mail Verification", errType, errMessage),
-		UserID:   userID,
+		baseData:    l.getBaseData(r, authReq, "Mail Verification", errType, errMessage),
+		UserID:      userID,
+		profileData: l.getProfileData(authReq),
 	}
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplMailVerification], data, nil)
 }
 
 func (l *Login) renderMailVerified(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest) {
 	data := mailVerificationData{
-		baseData: l.getBaseData(r, authReq, "Mail Verified", "", ""),
+		baseData:    l.getBaseData(r, authReq, "Mail Verified", "", ""),
+		profileData: l.getProfileData(authReq),
 	}
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplMailVerified], data, nil)
 }

internal/ui/login/handler/mfa_init_done_handler.go

@@ -16,6 +16,6 @@ type mfaInitDoneData struct {
 func (l *Login) renderMfaInitDone(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest, data *mfaDoneData) {
 	var errType, errMessage string
 	data.baseData = l.getBaseData(r, authReq, "Mfa Init Done", errType, errMessage)
-	data.LoginName = authReq.LoginName
+	data.profileData = l.getProfileData(authReq)
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplMfaInitDone], data, nil)
 }

internal/ui/login/handler/mfa_init_verify_handler.go

@@ -68,7 +68,7 @@ func (l *Login) renderMfaInitVerify(w http.ResponseWriter, r *http.Request, auth
 		errMessage = l.getErrorMessage(r, err)
 	}
 	data.baseData = l.getBaseData(r, authReq, "Mfa Init Verify", errType, errMessage)
-	data.LoginName = authReq.LoginName
+	data.profileData = l.getProfileData(authReq)
 	if data.MfaType == model.MfaTypeOTP {
 		code, err := generateQrCode(data.otpData.Url)
 		if err == nil {

internal/ui/login/handler/mfa_prompt_handler.go

@@ -18,37 +18,37 @@ type mfaPromptData struct {
 
 func (l *Login) handleMfaPrompt(w http.ResponseWriter, r *http.Request) {
 	data := new(mfaPromptData)
-	authSession, err := l.getAuthRequestAndParseData(r, data)
+	authReq, err := l.getAuthRequestAndParseData(r, data)
 	if err != nil {
-		l.renderError(w, r, authSession, err)
+		l.renderError(w, r, authReq, err)
 		return
 	}
 	if !data.Skip {
 		mfaVerifyData := new(mfaVerifyData)
 		mfaVerifyData.MfaType = data.MfaProvider
-		l.handleMfaCreation(w, r, authSession, mfaVerifyData)
+		l.handleMfaCreation(w, r, authReq, mfaVerifyData)
 		return
 	}
-	err = l.authRepo.SkipMfaInit(setContext(r.Context(), authSession.UserOrgID), authSession.UserID)
+	err = l.authRepo.SkipMfaInit(setContext(r.Context(), authReq.UserOrgID), authReq.UserID)
 	if err != nil {
-		l.renderError(w, r, authSession, err)
+		l.renderError(w, r, authReq, err)
 		return
 	}
 	l.handleLogin(w, r)
 }
 
-func (l *Login) renderMfaPrompt(w http.ResponseWriter, r *http.Request, authSession *model.AuthRequest, mfaPromptData *model.MfaPromptStep, err error) {
+func (l *Login) renderMfaPrompt(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest, mfaPromptData *model.MfaPromptStep, err error) {
 	var errType, errMessage string
 	if err != nil {
 		errMessage = l.getErrorMessage(r, err)
 	}
 	data := mfaData{
-		baseData:  l.getBaseData(r, authSession, "Mfa Prompt", errType, errMessage),
-		LoginName: authSession.LoginName,
+		baseData:    l.getBaseData(r, authReq, "Mfa Prompt", errType, errMessage),
+		profileData: l.getProfileData(authReq),
 	}
 
 	if mfaPromptData == nil {
-		l.renderError(w, r, authSession, caos_errs.ThrowPreconditionFailed(nil, "APP-XU0tj", "Errors.User.Mfa.NoProviders"))
+		l.renderError(w, r, authReq, caos_errs.ThrowPreconditionFailed(nil, "APP-XU0tj", "Errors.User.Mfa.NoProviders"))
 		return
 	}
 
@@ -59,19 +59,19 @@ func (l *Login) renderMfaPrompt(w http.ResponseWriter, r *http.Request, authSess
 		data := &mfaVerifyData{
 			MfaType: mfaPromptData.MfaProviders[0],
 		}
-		l.handleMfaCreation(w, r, authSession, data)
+		l.handleMfaCreation(w, r, authReq, data)
 		return
 	}
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplMfaPrompt], data, nil)
 }
 
-func (l *Login) handleMfaCreation(w http.ResponseWriter, r *http.Request, authSession *model.AuthRequest, data *mfaVerifyData) {
+func (l *Login) handleMfaCreation(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest, data *mfaVerifyData) {
 	switch data.MfaType {
 	case model.MfaTypeOTP:
-		l.handleOtpCreation(w, r, authSession, data)
+		l.handleOtpCreation(w, r, authReq, data)
 		return
 	}
-	l.renderError(w, r, authSession, caos_errs.ThrowPreconditionFailed(nil, "APP-Or3HO", "Errors.User.Mfa.NoProviders"))
+	l.renderError(w, r, authReq, caos_errs.ThrowPreconditionFailed(nil, "APP-Or3HO", "Errors.User.Mfa.NoProviders"))
 }
 
 func (l *Login) handleOtpCreation(w http.ResponseWriter, r *http.Request, authReq *model.AuthRequest, data *mfaVerifyData) {

internal/ui/login/handler/mfa_verify_handler.go

@@ -37,10 +37,7 @@ func (l *Login) renderMfaVerify(w http.ResponseWriter, r *http.Request, authReq
 	if err != nil {
 		errMessage = l.getErrorMessage(r, err)
 	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Mfa Verify", errType, errMessage),
-		LoginName: authReq.LoginName,
-	}
+	data := l.getUserData(r, authReq, "Mfa Verify", errType, errMessage)
 	if verificationStep != nil {
 		data.MfaProviders = verificationStep.MfaProviders
 		data.SelectedMfaProvider = verificationStep.MfaProviders[0]

internal/ui/login/handler/password_handler.go

@@ -19,10 +19,7 @@ func (l *Login) renderPassword(w http.ResponseWriter, r *http.Request, authReq *
 	if err != nil {
 		errMessage = l.getErrorMessage(r, err)
 	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Password", errType, errMessage),
-		LoginName: authReq.LoginName,
-	}
+	data := l.getUserData(r, authReq, "Password", errType, errMessage)
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplPassword], data, nil)
 }
 

internal/ui/login/handler/password_reset_handler.go

@@ -25,9 +25,6 @@ func (l *Login) renderPasswordResetDone(w http.ResponseWriter, r *http.Request,
 	if err != nil {
 		errMessage = l.getErrorMessage(r, err)
 	}
-	data := userData{
-		baseData:  l.getBaseData(r, authReq, "Password Reset Done", errType, errMessage),
-		LoginName: authReq.LoginName,
-	}
+	data := l.getUserData(r, authReq, "Password Reset Done", errType, errMessage)
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplPasswordResetDone], data, nil)
 }

internal/ui/login/handler/renderer.go

@@ -3,11 +3,12 @@ package handler
 import (
 	"errors"
 	"fmt"
-	"github.com/gorilla/csrf"
 	"html/template"
 	"net/http"
 	"path"
 
+	"github.com/gorilla/csrf"
+
 	"github.com/caos/zitadel/internal/api/http/middleware"
 	"github.com/caos/zitadel/internal/auth_request/model"
 	caos_errs "github.com/caos/zitadel/internal/errors"
@@ -185,6 +186,13 @@ func (l *Login) renderInternalError(w http.ResponseWriter, r *http.Request, auth
 	l.renderer.RenderTemplate(w, r, l.renderer.Templates[tmplError], data, nil)
 }
 
+func (l *Login) getUserData(r *http.Request, authReq *model.AuthRequest, title string, errType, errMessage string) userData {
+	return userData{
+		baseData:    l.getBaseData(r, authReq, title, errType, errMessage),
+		profileData: l.getProfileData(authReq),
+	}
+}
+
 func (l *Login) getBaseData(r *http.Request, authReq *model.AuthRequest, title string, errType, errMessage string) baseData {
 	return baseData{
 		errorData: errorData{
@@ -201,6 +209,18 @@ func (l *Login) getBaseData(r *http.Request, authReq *model.AuthRequest, title s
 	}
 }
 
+func (l *Login) getProfileData(authReq *model.AuthRequest) profileData {
+	var loginName, displayName string
+	if authReq != nil {
+		loginName = authReq.LoginName
+		displayName = authReq.DisplayName
+	}
+	return profileData{
+		LoginName:   loginName,
+		DisplayName: displayName,
+	}
+}
+
 func (l *Login) getErrorMessage(r *http.Request, err error) (errMsg string) {
 	caosErr := new(caos_errs.CaosError)
 	if errors.As(err, &caosErr) {
@@ -257,15 +277,20 @@ type errorData struct {
 
 type userData struct {
 	baseData
-	LoginName           string
+	profileData
 	PasswordChecked     string
 	MfaProviders        []model.MfaType
 	SelectedMfaProvider model.MfaType
 }
 
+type profileData struct {
+	LoginName   string
+	DisplayName string
+}
+
 type passwordData struct {
 	baseData
-	LoginName                 string
+	profileData
 	PasswordPolicyDescription string
 	MinLength                 uint64
 	HasUppercase              string
@@ -281,22 +306,22 @@ type userSelectionData struct {
 
 type mfaData struct {
 	baseData
-	LoginName    string
+	profileData
 	MfaProviders []model.MfaType
 	MfaRequired  bool
 }
 
 type mfaVerifyData struct {
 	baseData
-	LoginName string
-	MfaType   model.MfaType
+	profileData
+	MfaType model.MfaType
 	otpData
 }
 
 type mfaDoneData struct {
 	baseData
-	LoginName string
-	MfaType   model.MfaType
+	profileData
+	MfaType model.MfaType
 }
 
 type otpData struct {