Auth: Adds validation and ingestion of conflict file (#53014)

* add users-manager command * add users-manager command * rename files * refactor: imports and renaming * Command: add conflict merge user command - MergeUser will - replace all user_ids from conflicting users to the chosen userId - delete users whose user_ids are not the chosen user - SameIdentification will - update chosen user with chosen email,login details - delete users whose user_ids are not the chosen user * refactor: clean up * refactor: create structure for read, validate, ingest * feat: ls and generate-file for conflicting users * remove usagestats * added back pkg/services/login/authinfoservice/database/stats.go * Revert "added back pkg/services/login/authinfoservice/database/stats.go" This reverts commit 2ba6e3c4d6. * Revert "remove usagestats" This reverts commit 1e3fa97810. * cherry pick * Revert "cherry pick" This reverts commit 461626c306. * validation of picked merge user * fix test * make lint * make test run * tests for ingest working * clean up and refactored to align with downstream refactoring * formatting * refactor: name list instead of ls * fix: static lint error use trimprefix * WIP: permissions for validation * fix: remove unused functions in sqlstore * fix: remove unused function * handling of multiple users and resolve discarded users * fix tests * fix: bug that did not exclude the blocks * ioutil is blacklisted * WIP: validation * tests for merging a user working * add latest changes to output print * refactor: removed conflictEmail and conflictLogin that was not used * refactor: code clean up, showChanges working * test and linting fixes * test and linting fixes * refactor: removed logging of config and added more info for vlidation command * refactor: fix order of code * fix time now * refactor: no longer need for check casesensitive login/email * removed unnessecary loop * refactor: move functions around * test: working * docs: add docuemntationf for file * Add failing test for generating the conflict login block * Fix regex * Fix some stuff/tests Co-authored-by: eleijonmarck <eric.leijonmarck@gmail.com> * add: docs for conflict file * add: conflict_email, conflict_login fields * add: conflict_email, conflict_login fields * WIP * fix: tests working as intended * Update pkg/cmd/grafana-cli/commands/conflict_user_command.go Co-authored-by: linoman <2051016+linoman@users.noreply.github.com> * review comments * Update pkg/cmd/grafana-cli/commands/conflict_user_command.go Co-authored-by: Misi <mgyongyosi@users.noreply.github.com> * Update pkg/cmd/grafana-cli/commands/conflict_user_command.go Co-authored-by: Misi <mgyongyosi@users.noreply.github.com> * missspelling * trailing new line * update to use userimpl store * remove newline * remove newline * refactor: initializing of resolver for conflicts * fix: test sqlStore * refactor: removed lines * refactor: remove TODOs Co-authored-by: Mihaly Gyongyosi <mgyongyosi@users.noreply.github.com> Co-authored-by: linoman <2051016+linoman@users.noreply.github.com>
2022-09-29 14:26:24 +02:00
parent 9a68f8704f
commit 1e8f8dff4b
6 changed files with 937 additions and 198 deletions
@@ -1,8 +1,13 @@
 package commands

 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
 	"strings"

 	"github.com/fatih/color"
@@ -10,19 +15,49 @@ import (
 	"github.com/grafana/grafana/pkg/cmd/grafana-cli/logger"
 	"github.com/grafana/grafana/pkg/cmd/grafana-cli/utils"
 	"github.com/grafana/grafana/pkg/infra/tracing"
+	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/sqlstore/db"
 	"github.com/grafana/grafana/pkg/services/sqlstore/migrations"
+	"github.com/grafana/grafana/pkg/services/user"
+	"github.com/grafana/grafana/pkg/services/user/userimpl"
+	"github.com/grafana/grafana/pkg/setting"
 	"github.com/urfave/cli/v2"
 )

-func getSqlStore(context *cli.Context) (*sqlstore.SQLStore, error) {
-	cmd := &utils.ContextCommandLine{Context: context}
-	cfg, err := initCfg(cmd)
-	cfg.Logger = nil
+func initConflictCfg(cmd *utils.ContextCommandLine) (*setting.Cfg, error) {
+	configOptions := strings.Split(cmd.String("configOverrides"), " ")
+	configOptions = append(configOptions, cmd.Args().Slice()...)
+	cfg, err := setting.NewCfgFromArgs(setting.CommandLineArgs{
+		Config:   cmd.ConfigFile(),
+		HomePath: cmd.HomePath(),
+		Args:     append(configOptions, "cfg:log.level=error"), // tailing arguments have precedence over the options string
+	})
+	if err != nil {
+		return nil, err
+	}
+	return cfg, nil
+}
+
+func initializeConflictResolver(cmd *utils.ContextCommandLine, f Formatter, ctx *cli.Context) (*ConflictResolver, error) {
+	cfg, err := initConflictCfg(cmd)
 	if err != nil {
 		return nil, fmt.Errorf("%v: %w", "failed to load configuration", err)
 	}
+	s, err := getSqlStore(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("%v: %w", "failed to get to sql", err)
+	}
+	conflicts, err := GetUsersWithConflictingEmailsOrLogins(ctx, s)
+	if err != nil {
+		return nil, fmt.Errorf("%v: %w", "failed to get users with conflicting logins", err)
+	}
+	resolver := ConflictResolver{Users: conflicts}
+	resolver.BuildConflictBlocks(conflicts, f)
+	return &resolver, nil
+}
+
+func getSqlStore(cfg *setting.Cfg) (*sqlstore.SQLStore, error) {
 	tracer, err := tracing.ProvideService(cfg)
 	if err != nil {
 		return nil, fmt.Errorf("%v: %w", "failed to initialize tracer service", err)
@@ -33,28 +68,21 @@ func getSqlStore(context *cli.Context) (*sqlstore.SQLStore, error) {

 func runListConflictUsers() func(context *cli.Context) error {
 	return func(context *cli.Context) error {
-		s, err := getSqlStore(context)
+		cmd := &utils.ContextCommandLine{Context: context}
+		whiteBold := color.New(color.FgWhite).Add(color.Bold)
+		r, err := initializeConflictResolver(cmd, whiteBold.Sprintf, context)
 		if err != nil {
-			return fmt.Errorf("%v: %w", "failed to get to sql", err)
+			return fmt.Errorf("%v: %w", "failed to initialize conflict resolver", err)
 		}
-		conflicts, err := GetUsersWithConflictingEmailsOrLogins(context, s)
-		if err != nil {
-			return fmt.Errorf("%v: %w", "failed to get users with conflicting logins", err)
-		}
-		if len(conflicts) < 1 {
+		if len(r.Users) < 1 {
 			logger.Info(color.GreenString("No Conflicting users found.\n\n"))
 			return nil
 		}
-		whiteBold := color.New(color.FgWhite).Add(color.Bold)
-		resolver := ConflictResolver{Users: conflicts}
-		resolver.BuildConflictBlocks(whiteBold.Sprintf)
-		logger.Infof("\n\nShowing Conflicts\n\n")
-		logger.Infof(resolver.ToStringPresentation())
+		logger.Infof("\n\nShowing conflicts\n\n")
+		logger.Infof(r.ToStringPresentation())
 		logger.Infof("\n")
-		// TODO: remove line when finished
-		// this is only for debugging
-		if len(resolver.DiscardedBlocks) != 0 {
-			resolver.logDiscardedUsers()
+		if len(r.DiscardedBlocks) != 0 {
+			r.logDiscardedUsers()
 		}
 		return nil
 	}
@@ -62,74 +90,324 @@ func runListConflictUsers() func(context *cli.Context) error {

 func runGenerateConflictUsersFile() func(context *cli.Context) error {
 	return func(context *cli.Context) error {
-		s, err := getSqlStore(context)
+		cmd := &utils.ContextCommandLine{Context: context}
+		r, err := initializeConflictResolver(cmd, fmt.Sprintf, context)
 		if err != nil {
-			return fmt.Errorf("%v: %w", "failed to get to sql", err)
+			return fmt.Errorf("%v: %w", "failed to initialize conflict resolver", err)
 		}
-		conflicts, err := GetUsersWithConflictingEmailsOrLogins(context, s)
-		if err != nil {
-			return fmt.Errorf("%v: %w", "failed to get users with conflicting logins", err)
-		}
-		if len(conflicts) < 1 {
+		if len(r.Users) < 1 {
 			logger.Info(color.GreenString("No Conflicting users found.\n\n"))
 			return nil
 		}
-		resolver := ConflictResolver{Users: conflicts}
-		resolver.BuildConflictBlocks(fmt.Sprintf)
-		tmpFile, err := generateConflictUsersFile(&resolver)
+		tmpFile, err := generateConflictUsersFile(r)
 		if err != nil {
 			return fmt.Errorf("generating file return error: %w", err)
 		}
 		logger.Infof("\n\ngenerated file\n")
 		logger.Infof("%s\n\n", tmpFile.Name())
 		logger.Infof("once the file is edited and resolved conflicts, you can either validate or ingest the file\n\n")
-		if len(resolver.DiscardedBlocks) != 0 {
-			resolver.logDiscardedUsers()
+		if len(r.DiscardedBlocks) != 0 {
+			r.logDiscardedUsers()
 		}
 		return nil
 	}
 }

+func runValidateConflictUsersFile() func(context *cli.Context) error {
+	return func(context *cli.Context) error {
+		cmd := &utils.ContextCommandLine{Context: context}
+		r, err := initializeConflictResolver(cmd, fmt.Sprintf, context)
+		if err != nil {
+			return fmt.Errorf("%v: %w", "failed to initialize conflict resolver", err)
+		}
+
+		// read in the file to validate
+		// read in the file to ingest
+		arg := cmd.Args().First()
+		if arg == "" {
+			return errors.New("please specify a absolute path to file to read from")
+		}
+		b, err := os.ReadFile(filepath.Clean(arg))
+		if err != nil {
+			return fmt.Errorf("could not read file with error %e", err)
+		}
+		validErr := getValidConflictUsers(r, b)
+		if validErr != nil {
+			return fmt.Errorf("could not validate file with error %s", err)
+		}
+		logger.Info("File validation complete without errors.\n\n File can be used with ingesting command `ingest-file`.\n\n")
+		return nil
+	}
+}
+
+func runIngestConflictUsersFile() func(context *cli.Context) error {
+	return func(context *cli.Context) error {
+		cmd := &utils.ContextCommandLine{Context: context}
+		r, err := initializeConflictResolver(cmd, fmt.Sprintf, context)
+		if err != nil {
+			return fmt.Errorf("%v: %w", "failed to initialize conflict resolver", err)
+		}
+
+		// read in the file to ingest
+		arg := cmd.Args().First()
+		if arg == "" {
+			return errors.New("please specify a absolute path to file to read from")
+		}
+		b, err := os.ReadFile(filepath.Clean(arg))
+		if err != nil {
+			return fmt.Errorf("could not read file with error %e", err)
+		}
+		validErr := getValidConflictUsers(r, b)
+		if validErr != nil {
+			return fmt.Errorf("could not validate file with error %s", validErr)
+		}
+		// should we rebuild blocks here?
+		// kind of a weird thing maybe?
+		if len(r.ValidUsers) == 0 {
+			return fmt.Errorf("no users")
+		}
+		r.showChanges()
+		if !confirm("\n\nWe encourage users to create a db backup before running this command. \n Proceed with operation?") {
+			return fmt.Errorf("user cancelled")
+		}
+		err = r.MergeConflictingUsers(context.Context)
+		if err != nil {
+			return fmt.Errorf("not able to merge with %e", err)
+		}
+		logger.Info("\n\nconflicts resolved.\n")
+		return nil
+	}
+}
+
+func getDocumentationForFile() string {
+	return `# Conflicts File
+# This file is generated by the grafana-cli command ` + color.CyanString("grafana-cli admin user-manager conflicts generate-file") + `.
+#
+# Commands:
+# +, keep <user> = keep user
+# -, delete <user> = delete user
+#
+# The fields conflict_email and conflict_login
+# indicate that we see a conflict in email and/or login with another user.
+# Both these fields can be true.
+#
+# There needs to be exactly one picked user per conflict block.
+#
+# The lines can be re-ordered.
+#
+# If you feel like you want to wait with a specific block,
+# delete all lines regarding that conflict block.
+#
+`
+}
+
 func generateConflictUsersFile(r *ConflictResolver) (*os.File, error) {
 	tmpFile, err := os.CreateTemp(os.TempDir(), "conflicting_user_*.diff")
 	if err != nil {
 		return nil, err
 	}
+	if _, err := tmpFile.Write([]byte(getDocumentationForFile())); err != nil {
+		return nil, err
+	}
 	if _, err := tmpFile.Write([]byte(r.ToStringPresentation())); err != nil {
 		return nil, err
 	}
 	return tmpFile, nil
 }

+func getValidConflictUsers(r *ConflictResolver, b []byte) error {
+	newConflicts := make(ConflictingUsers, 0)
+	// need to verify that id or email exists
+	previouslySeenIds := map[string]bool{}
+	previouslySeenEmails := map[string]bool{}
+	for _, users := range r.Blocks {
+		for _, u := range users {
+			previouslySeenIds[strings.ToLower(u.ID)] = true
+			previouslySeenEmails[strings.ToLower(u.Email)] = true
+		}
+	}
+
+	// tested in https://regex101.com/r/una3zC/1
+	diffPattern := `^[+-]`
+	// compiling since in a loop
+	matchingExpression, err := regexp.Compile(diffPattern)
+	if err != nil {
+		return fmt.Errorf("unable to compile regex %s: %w", diffPattern, err)
+	}
+	for _, row := range strings.Split(string(b), "\n") {
+		if row == "" {
+			// end of file
+			break
+		}
+		// if the row starts with a #, it is a comment
+		if row[0] == '#' {
+			// comment
+			continue
+		}
+		entryRow := matchingExpression.Match([]byte(row))
+		if !entryRow {
+			// block row
+			// conflict: hej
+			continue
+		}
+
+		newUser := &ConflictingUser{}
+		err := newUser.Marshal(row)
+		if err != nil {
+			return fmt.Errorf("could not parse the content of the file with error %e", err)
+		}
+		if !previouslySeenEmails[strings.ToLower(newUser.Email)] {
+			return fmt.Errorf("not valid email: %s, email not in previous conflicts seen", newUser.Email)
+		}
+		// valid entry
+		newConflicts = append(newConflicts, *newUser)
+	}
+	r.ValidUsers = newConflicts
+	r.BuildConflictBlocks(newConflicts, fmt.Sprintf)
+	return nil
+}
+
+func (r *ConflictResolver) MergeConflictingUsers(ctx context.Context) error {
+	for block, users := range r.Blocks {
+		if len(users) < 2 {
+			return fmt.Errorf("not enough users to perform merge, found %d for id %s, should be at least 2", len(users), block)
+		}
+		var intoUser user.User
+		var intoUserId int64
+		var fromUserIds []int64
+
+		// creating a session for each block of users
+		// we want to rollback incase something happens during update / delete
+		sess := r.Store.NewSession(ctx)
+		defer sess.Close()
+		err := sess.Begin()
+		if err != nil {
+			return fmt.Errorf("could not open a db session: %w", err)
+		}
+		for _, u := range users {
+			if u.Direction == "+" {
+				id, err := strconv.ParseInt(u.ID, 10, 64)
+				if err != nil {
+					return fmt.Errorf("could not convert id in +")
+				}
+				intoUserId = id
+			} else if u.Direction == "-" {
+				id, err := strconv.ParseInt(u.ID, 10, 64)
+				if err != nil {
+					return fmt.Errorf("could not convert id in -")
+				}
+				fromUserIds = append(fromUserIds, id)
+			}
+		}
+		if _, err := sess.ID(intoUserId).Where(sqlstore.NotServiceAccountFilter(r.Store)).Get(&intoUser); err != nil {
+			return fmt.Errorf("could not find intoUser: %w", err)
+		}
+
+		for _, fromUserId := range fromUserIds {
+			var fromUser user.User
+			exists, err := sess.ID(fromUserId).Where(sqlstore.NotServiceAccountFilter(r.Store)).Get(&fromUser)
+			if err != nil {
+				return fmt.Errorf("could not find fromUser: %w", err)
+			}
+			if !exists {
+				fmt.Printf("user with id %d does not exist, skipping\n", fromUserId)
+			}
+			// // delete the user
+			delErr := r.Store.DeleteUserInSession(ctx, sess, &models.DeleteUserCommand{UserId: fromUserId})
+			if delErr != nil {
+				return fmt.Errorf("error during deletion of user: %w", delErr)
+			}
+		}
+		commitErr := sess.Commit()
+		if commitErr != nil {
+			return fmt.Errorf("could not commit operation for useridentification %s: %w", block, commitErr)
+		}
+		userStore := userimpl.ProvideStore(r.Store, setting.NewCfg())
+		updateMainCommand := &user.UpdateUserCommand{
+			UserID: intoUser.ID,
+			Login:  strings.ToLower(intoUser.Login),
+			Email:  strings.ToLower(intoUser.Email),
+		}
+		updateErr := userStore.Update(ctx, updateMainCommand)
+		if updateErr != nil {
+			return fmt.Errorf("could not update user: %w", updateErr)
+		}
+	}
+	return nil
+}
+
+/*
+hej@test.com+hej@test.com
+all of the permissions, roles and ownership will be transferred to the user.
+ id: 1, email: hej@test.com, login: hej@test.com
+these user(s) will be deleted and their permissions transferred.
+- id: 2, email: HEJ@TEST.COM, login: HEJ@TEST.COM
+- id: 3, email: hej@TEST.com, login: hej@TEST.com
+*/
+func (r *ConflictResolver) showChanges() {
+	if len(r.ValidUsers) == 0 {
+		fmt.Println("no changes will take place as we have no valid users.")
+		return
+	}
+
+	var b strings.Builder
+	for block, users := range r.Blocks {
+		if _, ok := r.DiscardedBlocks[block]; ok {
+			// skip block
+			continue
+		}
+
+		// looping as we want to can get these out of order (meaning the + and -)
+		var mainUser ConflictingUser
+		for _, u := range users {
+			if u.Direction == "+" {
+				mainUser = u
+				break
+			}
+		}
+		b.WriteString("Keep the following user.\n")
+		b.WriteString(fmt.Sprintf("%s\n", block))
+		b.WriteString(fmt.Sprintf("id: %s, email: %s, login: %s\n", mainUser.ID, mainUser.Email, mainUser.Login))
+		b.WriteString("\n\n")
+		b.WriteString("The following user(s) will be deleted.\n")
+		for _, user := range users {
+			if user.ID == mainUser.ID {
+				continue
+			}
+			// mergeable users
+			b.WriteString(fmt.Sprintf("id: %s, email: %s, login: %s\n", user.ID, user.Email, user.Login))
+		}
+		b.WriteString("\n\n")
+	}
+	logger.Info("\n\nChanges that will take place\n\n")
+	logger.Infof(b.String())
+}
+
 // Formatter make it possible for us to write to terminal and to a file
 // with different formats depending on the usecase
 type Formatter func(format string, a ...interface{}) string

-func BoldFormatter(format string, a ...interface{}) string {
-	white := color.New(color.FgWhite)
-	whiteBold := white.Add(color.Bold)
-	return whiteBold.Sprintf(format, a...)
-}
-
 func shouldDiscardBlock(seenUsersInBlock map[string]string, block string, user ConflictingUser) bool {
 	// loop through users to see if we should skip this block
 	// we have some more tricky scenarios where we have more than two users that can have conflicts with each other
 	// we have made the approach to discard any users that we have seen
-	if _, ok := seenUsersInBlock[user.Id]; ok {
+	if _, ok := seenUsersInBlock[user.ID]; ok {
 		// we have seen the user in different block than the current block
-		if seenUsersInBlock[user.Id] != block {
+		if seenUsersInBlock[user.ID] != block {
 			return true
 		}
 	}
-	seenUsersInBlock[user.Id] = block
+	seenUsersInBlock[user.ID] = block
 	return false
 }

-func (r *ConflictResolver) BuildConflictBlocks(f Formatter) {
+// BuildConflictBlocks builds blocks of users where each block is a unique email/login
+// NOTE: currently this function assumes that the users are in order of grouping already
+func (r *ConflictResolver) BuildConflictBlocks(users ConflictingUsers, f Formatter) {
 	discardedBlocks := make(map[string]bool)
 	seenUsersToBlock := make(map[string]string)
 	blocks := make(map[string]ConflictingUsers)
-	for _, user := range r.Users {
+	for _, user := range users {
 		// conflict blocks is how we identify a conflict in the user base.
 		var conflictBlock string
 		if user.ConflictEmail != "" {
@@ -165,7 +443,7 @@ func (r *ConflictResolver) BuildConflictBlocks(f Formatter) {

 func contains(cu ConflictingUsers, target ConflictingUser) bool {
 	for _, u := range cu {
-		if u.Id == target.Id {
+		if u.ID == target.ID {
 			return true
 		}
 	}
@@ -176,7 +454,7 @@ func (r *ConflictResolver) logDiscardedUsers() {
 	keys := make([]string, 0, len(r.DiscardedBlocks))
 	for block := range r.DiscardedBlocks {
 		for _, u := range r.Blocks[block] {
-			keys = append(keys, u.Id)
+			keys = append(keys, u.ID)
 		}
 	}
 	warn := color.YellowString("Note: We discarded some conflicts that have multiple conflicting types involved.")
@@ -208,7 +486,7 @@ func (r *ConflictResolver) ToStringPresentation() string {
 		- id: 3, email: hej@TEST.com, login: hej@TEST.com
 	*/
 	startOfBlock := make(map[string]bool)
-	fileString := ""
+	var b strings.Builder
 	for block, users := range r.Blocks {
 		if _, ok := r.DiscardedBlocks[block]; ok {
 			// skip block
@@ -216,76 +494,105 @@ func (r *ConflictResolver) ToStringPresentation() string {
 		}
 		for _, user := range users {
 			if !startOfBlock[block] {
-				fileString += fmt.Sprintf("%s\n", block)
+				b.WriteString(fmt.Sprintf("%s\n", block))
 				startOfBlock[block] = true
-				fileString += fmt.Sprintf("+ id: %s, email: %s, login: %s\n", user.Id, user.Email, user.Login)
+				b.WriteString(fmt.Sprintf("+ id: %s, email: %s, login: %s, last_seen_at: %s, auth_module: %s, conflict_email: %s, conflict_login: %s\n",
+					user.ID,
+					user.Email,
+					user.Login,
+					user.LastSeenAt,
+					user.AuthModule,
+					user.ConflictEmail,
+					user.ConflictLogin,
+				))
 				continue
 			}
-			// mergable users
-			fileString += fmt.Sprintf("- id: %s, email: %s, login: %s\n", user.Id, user.Email, user.Login)
+			// mergeable users
+			b.WriteString(fmt.Sprintf("- id: %s, email: %s, login: %s, last_seen_at: %s, auth_module: %s, conflict_email: %s, conflict_login: %s\n",
+				user.ID,
+				user.Email,
+				user.Login,
+				user.LastSeenAt,
+				user.AuthModule,
+				user.ConflictEmail,
+				user.ConflictLogin,
+			))
 		}
 	}
-	return fileString
+	return b.String()
 }

 type ConflictResolver struct {
+	Store           *sqlstore.SQLStore
+	Config          *setting.Cfg
 	Users           ConflictingUsers
+	ValidUsers      ConflictingUsers
 	Blocks          map[string]ConflictingUsers
 	DiscardedBlocks map[string]bool
 }

 type ConflictingUser struct {
-	// IDENTIFIER
-	// TODO: should have conflict block in sql for performance and stability
-	Direction string `xorm:"direction"`
-	// FIXME: refactor change to correct type int64
-	Id    string `xorm:"id"`
-	Email string `xorm:"email"`
-	Login string `xorm:"login"`
-	// FIXME: refactor change to correct type <>
-	LastSeenAt string `xorm:"last_seen_at"`
-	AuthModule string `xorm:"auth_module"`
-	// currently not really used for anything
+	// direction is the +/- which indicates if we should keep or delete the user
+	Direction     string `xorm:"direction"`
+	ID            string `xorm:"id"`
+	Email         string `xorm:"email"`
+	Login         string `xorm:"login"`
+	LastSeenAt    string `xorm:"last_seen_at"`
+	AuthModule    string `xorm:"auth_module"`
 	ConflictEmail string `xorm:"conflict_email"`
 	ConflictLogin string `xorm:"conflict_login"`
 }

-// always better to have a slice of the object
-// not a pointer for slice type ConflictingUsers []*ConflictingUser
 type ConflictingUsers []ConflictingUser

 func (c *ConflictingUser) Marshal(filerow string) error {
-	// +/- id: 1, email: hej,
+	// example view of the file to ingest
+	// +/- id: 1, email: hej, auth_module: LDAP
 	trimmedSpaces := strings.ReplaceAll(filerow, " ", "")
 	if trimmedSpaces[0] == '+' {
 		c.Direction = "+"
 	} else if trimmedSpaces[0] == '-' {
 		c.Direction = "-"
 	} else {
-		return fmt.Errorf("unable to get which operation the user would receive")
+		return fmt.Errorf("unable to get which operation was chosen")
 	}
 	trimmed := strings.TrimLeft(trimmedSpaces, "+-")
 	values := strings.Split(trimmed, ",")
-	if len(values) != 5 {
-		// fmt errror
-		return fmt.Errorf("expected 5 values in entryrow")
+
+	if len(values) < 3 {
+		return fmt.Errorf("expected at least 3 values in entry row")
 	}
+	// expected fields
 	id := strings.Split(values[0], ":")
 	email := strings.Split(values[1], ":")
 	login := strings.Split(values[2], ":")
+	c.ID = id[1]
+	c.Email = email[1]
+	c.Login = login[1]
+
+	// why trim values, 2022-08-20:19:17:12
 	lastSeenAt := strings.TrimPrefix(values[3], "last_seen_at:")
 	authModule := strings.Split(values[4], ":")
-	// optional field
 	if len(authModule) < 2 {
 		c.AuthModule = ""
 	} else {
 		c.AuthModule = authModule[1]
 	}
-	// expected fields
-	c.Id = id[1]
-	c.Email = email[1]
-	c.Login = login[1]
 	c.LastSeenAt = lastSeenAt
+
+	// which conflict
+	conflictEmail := strings.Split(values[5], ":")
+	conflictLogin := strings.Split(values[6], ":")
+	if len(conflictEmail) < 2 {
+		c.ConflictEmail = ""
+	} else {
+		c.ConflictEmail = conflictEmail[1]
+	}
+	if len(conflictLogin) < 2 {
+		c.ConflictLogin = ""
+	} else {
+		c.ConflictLogin = conflictLogin[1]
+	}
 	return nil
 }

@@ -306,6 +613,7 @@ func GetUsersWithConflictingEmailsOrLogins(ctx *cli.Context, s *sqlstore.SQLStor
 // sorts the users by their useridentification and ids
 func conflictingUserEntriesSQL(s *sqlstore.SQLStore) string {
 	userDialect := db.DB.GetDialect(s).Quote("user")
+
 	sqlQuery := `
 	SELECT DISTINCT
 	u1.id,
@@ -314,12 +622,12 @@ func conflictingUserEntriesSQL(s *sqlstore.SQLStore) string {
 	u1.last_seen_at,
 	user_auth.auth_module,
 		( SELECT
-			'conflict_email'
+			'true'
 		FROM
 			` + userDialect + `
 		WHERE (LOWER(u1.email) = LOWER(u2.email)) AND(u1.email != u2.email)) AS conflict_email,
 		( SELECT
-			'conflict_login'
+			'true'
 		FROM
 			` + userDialect + `
 		WHERE (LOWER(u1.login) = LOWER(u2.login) AND(u1.login != u2.login))) AS conflict_login
@@ -337,3 +645,21 @@ func notServiceAccount(ss *sqlstore.SQLStore) string {
 	return fmt.Sprintf("is_service_account = %s",
 		ss.Dialect.BooleanStr(false))
 }
+
+// confirm function asks for user input
+// returns bool
+func confirm(confirmPrompt string) bool {
+	var input string
+	logger.Infof("%s? [y|n]: ", confirmPrompt)
+
+	_, err := fmt.Scanln(&input)
+	if err != nil {
+		logger.Infof("could not parse input from user for confirmation")
+		return false
+	}
+	input = strings.ToLower(input)
+	if input == "y" || input == "yes" {
+		return true
+	}
+	return false
+}