SQLStore: extend `user.SearchUsers` method (#17514)

* SQLStore: extend `user.SearchUsers` method

Allow `user.SearchUsers` to search users based on their auth type

pkg/models/user.go

@@ -140,10 +140,11 @@ type GetUserProfileQuery struct {
 }
 
 type SearchUsersQuery struct {
-	OrgId int64
-	Query string
-	Page  int
-	Limit int
+	OrgId      int64
+	Query      string
+	Page       int
+	Limit      int
+	AuthModule string
 
 	Result SearchUserQueryResult
 }

pkg/services/sqlstore/user.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/grafana/grafana/pkg/bus"
 	"github.com/grafana/grafana/pkg/events"
-	m "github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/util"
 )
@@ -35,12 +35,12 @@ func (ss *SqlStore) addUserQueryAndCommandHandlers() {
 	bus.AddHandlerCtx("sql", CreateUser)
 }
 
-func getOrgIdForNewUser(cmd *m.CreateUserCommand, sess *DBSession) (int64, error) {
+func getOrgIdForNewUser(cmd *models.CreateUserCommand, sess *DBSession) (int64, error) {
 	if cmd.SkipOrgSetup {
 		return -1, nil
 	}
 
-	var org m.Org
+	var org models.Org
 
 	if setting.AutoAssignOrg {
 		has, err := sess.Where("id=?", setting.AutoAssignOrgId).Get(&org)
@@ -88,7 +88,7 @@ func getOrgIdForNewUser(cmd *m.CreateUserCommand, sess *DBSession) (int64, error
 	return org.Id, nil
 }
 
-func CreateUser(ctx context.Context, cmd *m.CreateUserCommand) error {
+func CreateUser(ctx context.Context, cmd *models.CreateUserCommand) error {
 	return inTransactionCtx(ctx, func(sess *DBSession) error {
 		orgId, err := getOrgIdForNewUser(cmd, sess)
 		if err != nil {
@@ -100,7 +100,7 @@ func CreateUser(ctx context.Context, cmd *m.CreateUserCommand) error {
 		}
 
 		// create user
-		user := m.User{
+		user := models.User{
 			Email:         cmd.Email,
 			Name:          cmd.Name,
 			Login:         cmd.Login,
@@ -138,19 +138,19 @@ func CreateUser(ctx context.Context, cmd *m.CreateUserCommand) error {
 
 		// create org user link
 		if !cmd.SkipOrgSetup {
-			orgUser := m.OrgUser{
+			orgUser := models.OrgUser{
 				OrgId:   orgId,
 				UserId:  user.Id,
-				Role:    m.ROLE_ADMIN,
+				Role:    models.ROLE_ADMIN,
 				Created: time.Now(),
 				Updated: time.Now(),
 			}
 
 			if setting.AutoAssignOrg && !user.IsAdmin {
 				if len(cmd.DefaultOrgRole) > 0 {
-					orgUser.Role = m.RoleType(cmd.DefaultOrgRole)
+					orgUser.Role = models.RoleType(cmd.DefaultOrgRole)
 				} else {
-					orgUser.Role = m.RoleType(setting.AutoAssignOrgRole)
+					orgUser.Role = models.RoleType(setting.AutoAssignOrgRole)
 				}
 			}
 
@@ -163,14 +163,14 @@ func CreateUser(ctx context.Context, cmd *m.CreateUserCommand) error {
 	})
 }
 
-func GetUserById(query *m.GetUserByIdQuery) error {
-	user := new(m.User)
+func GetUserById(query *models.GetUserByIdQuery) error {
+	user := new(models.User)
 	has, err := x.Id(query.Id).Get(user)
 
 	if err != nil {
 		return err
 	} else if !has {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
 	query.Result = user
@@ -178,14 +178,14 @@ func GetUserById(query *m.GetUserByIdQuery) error {
 	return nil
 }
 
-func GetUserByLogin(query *m.GetUserByLoginQuery) error {
+func GetUserByLogin(query *models.GetUserByLoginQuery) error {
 	if query.LoginOrEmail == "" {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
 	// Try and find the user by login first.
 	// It's not sufficient to assume that a LoginOrEmail with an "@" is an email.
-	user := &m.User{Login: query.LoginOrEmail}
+	user := &models.User{Login: query.LoginOrEmail}
 	has, err := x.Get(user)
 
 	if err != nil {
@@ -195,14 +195,14 @@ func GetUserByLogin(query *m.GetUserByLoginQuery) error {
 	if !has && strings.Contains(query.LoginOrEmail, "@") {
 		// If the user wasn't found, and it contains an "@" fallback to finding the
 		// user by email.
-		user = &m.User{Email: query.LoginOrEmail}
+		user = &models.User{Email: query.LoginOrEmail}
 		has, err = x.Get(user)
 	}
 
 	if err != nil {
 		return err
 	} else if !has {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
 	query.Result = user
@@ -210,18 +210,18 @@ func GetUserByLogin(query *m.GetUserByLoginQuery) error {
 	return nil
 }
 
-func GetUserByEmail(query *m.GetUserByEmailQuery) error {
+func GetUserByEmail(query *models.GetUserByEmailQuery) error {
 	if query.Email == "" {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
-	user := &m.User{Email: query.Email}
+	user := &models.User{Email: query.Email}
 	has, err := x.Get(user)
 
 	if err != nil {
 		return err
 	} else if !has {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
 	query.Result = user
@@ -229,10 +229,10 @@ func GetUserByEmail(query *m.GetUserByEmailQuery) error {
 	return nil
 }
 
-func UpdateUser(cmd *m.UpdateUserCommand) error {
+func UpdateUser(cmd *models.UpdateUserCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 
-		user := m.User{
+		user := models.User{
 			Name:    cmd.Name,
 			Email:   cmd.Email,
 			Login:   cmd.Login,
@@ -256,10 +256,10 @@ func UpdateUser(cmd *m.UpdateUserCommand) error {
 	})
 }
 
-func ChangeUserPassword(cmd *m.ChangeUserPasswordCommand) error {
+func ChangeUserPassword(cmd *models.ChangeUserPasswordCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 
-		user := m.User{
+		user := models.User{
 			Password: cmd.NewPassword,
 			Updated:  time.Now(),
 		}
@@ -269,9 +269,9 @@ func ChangeUserPassword(cmd *m.ChangeUserPasswordCommand) error {
 	})
 }
 
-func UpdateUserLastSeenAt(cmd *m.UpdateUserLastSeenAtCommand) error {
+func UpdateUserLastSeenAt(cmd *models.UpdateUserLastSeenAtCommand) error {
 	return inTransaction(func(sess *DBSession) error {
-		user := m.User{
+		user := models.User{
 			Id:         cmd.UserId,
 			LastSeenAt: time.Now(),
 		}
@@ -281,8 +281,8 @@ func UpdateUserLastSeenAt(cmd *m.UpdateUserLastSeenAtCommand) error {
 	})
 }
 
-func SetUsingOrg(cmd *m.SetUsingOrgCommand) error {
-	getOrgsForUserCmd := &m.GetUserOrgListQuery{UserId: cmd.UserId}
+func SetUsingOrg(cmd *models.SetUsingOrgCommand) error {
+	getOrgsForUserCmd := &models.GetUserOrgListQuery{UserId: cmd.UserId}
 	GetUserOrgList(getOrgsForUserCmd)
 
 	valid := false
@@ -302,7 +302,7 @@ func SetUsingOrg(cmd *m.SetUsingOrgCommand) error {
 }
 
 func setUsingOrgInTransaction(sess *DBSession, userID int64, orgID int64) error {
-	user := m.User{
+	user := models.User{
 		Id:    userID,
 		OrgId: orgID,
 	}
@@ -311,17 +311,17 @@ func setUsingOrgInTransaction(sess *DBSession, userID int64, orgID int64) error
 	return err
 }
 
-func GetUserProfile(query *m.GetUserProfileQuery) error {
-	var user m.User
+func GetUserProfile(query *models.GetUserProfileQuery) error {
+	var user models.User
 	has, err := x.Id(query.UserId).Get(&user)
 
 	if err != nil {
 		return err
 	} else if !has {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
-	query.Result = m.UserProfileDTO{
+	query.Result = models.UserProfileDTO{
 		Id:             user.Id,
 		Name:           user.Name,
 		Email:          user.Email,
@@ -335,8 +335,8 @@ func GetUserProfile(query *m.GetUserProfileQuery) error {
 	return err
 }
 
-func GetUserOrgList(query *m.GetUserOrgListQuery) error {
-	query.Result = make([]*m.UserOrgDTO, 0)
+func GetUserOrgList(query *models.GetUserOrgListQuery) error {
+	query.Result = make([]*models.UserOrgDTO, 0)
 	sess := x.Table("org_user")
 	sess.Join("INNER", "org", "org_user.org_id=org.id")
 	sess.Where("org_user.user_id=?", query.UserId)
@@ -350,10 +350,10 @@ func newSignedInUserCacheKey(orgID, userID int64) string {
 	return fmt.Sprintf("signed-in-user-%d-%d", userID, orgID)
 }
 
-func (ss *SqlStore) GetSignedInUserWithCache(query *m.GetSignedInUserQuery) error {
+func (ss *SqlStore) GetSignedInUserWithCache(query *models.GetSignedInUserQuery) error {
 	cacheKey := newSignedInUserCacheKey(query.OrgId, query.UserId)
 	if cached, found := ss.CacheService.Get(cacheKey); found {
-		query.Result = cached.(*m.SignedInUser)
+		query.Result = cached.(*models.SignedInUser)
 		return nil
 	}
 
@@ -367,7 +367,7 @@ func (ss *SqlStore) GetSignedInUserWithCache(query *m.GetSignedInUserQuery) erro
 	return nil
 }
 
-func GetSignedInUser(query *m.GetSignedInUserQuery) error {
+func GetSignedInUser(query *models.GetSignedInUserQuery) error {
 	orgId := "u.org_id"
 	if query.OrgId > 0 {
 		orgId = strconv.FormatInt(query.OrgId, 10)
@@ -398,12 +398,12 @@ func GetSignedInUser(query *m.GetSignedInUserQuery) error {
 		sess.SQL(rawSql+"WHERE u.email=?", query.Email)
 	}
 
-	var user m.SignedInUser
+	var user models.SignedInUser
 	has, err := sess.Get(&user)
 	if err != nil {
 		return err
 	} else if !has {
-		return m.ErrUserNotFound
+		return models.ErrUserNotFound
 	}
 
 	if user.OrgRole == "" {
@@ -411,7 +411,7 @@ func GetSignedInUser(query *m.GetSignedInUserQuery) error {
 		user.OrgName = "Org missing"
 	}
 
-	getTeamsByUserQuery := &m.GetTeamsByUserQuery{OrgId: user.OrgId, UserId: user.UserId}
+	getTeamsByUserQuery := &models.GetTeamsByUserQuery{OrgId: user.OrgId, UserId: user.UserId}
 	err = GetTeamsByUser(getTeamsByUserQuery)
 	if err != nil {
 		return err
@@ -426,9 +426,9 @@ func GetSignedInUser(query *m.GetSignedInUserQuery) error {
 	return err
 }
 
-func SearchUsers(query *m.SearchUsersQuery) error {
-	query.Result = m.SearchUserQueryResult{
-		Users: make([]*m.UserSearchHitDTO, 0),
+func SearchUsers(query *models.SearchUsersQuery) error {
+	query.Result = models.SearchUserQueryResult{
+		Users: make([]*models.UserSearchHitDTO, 0),
 	}
 
 	queryWithWildcards := "%" + query.Query + "%"
@@ -447,6 +447,17 @@ func SearchUsers(query *m.SearchUsersQuery) error {
 		whereParams = append(whereParams, queryWithWildcards, queryWithWildcards, queryWithWildcards)
 	}
 
+	if query.AuthModule != "" {
+		whereConditions = append(
+			whereConditions,
+			`id IN (SELECT user_id
+			FROM user_auth
+			WHERE auth_module=?)`,
+		)
+
+		whereParams = append(whereParams, query.AuthModule)
+	}
+
 	if len(whereConditions) > 0 {
 		sess.Where(strings.Join(whereConditions, " AND "), whereParams...)
 	}
@@ -459,7 +470,7 @@ func SearchUsers(query *m.SearchUsersQuery) error {
 	}
 
 	// get total
-	user := m.User{}
+	user := models.User{}
 	countSess := x.Table("user")
 
 	if len(whereConditions) > 0 {
@@ -476,8 +487,8 @@ func SearchUsers(query *m.SearchUsersQuery) error {
 	return err
 }
 
-func DisableUser(cmd *m.DisableUserCommand) error {
-	user := m.User{}
+func DisableUser(cmd *models.DisableUserCommand) error {
+	user := models.User{}
 	sess := x.Table("user")
 	sess.ID(cmd.UserId).Get(&user)
 
@@ -488,7 +499,7 @@ func DisableUser(cmd *m.DisableUserCommand) error {
 	return err
 }
 
-func BatchDisableUsers(cmd *m.BatchDisableUsersCommand) error {
+func BatchDisableUsers(cmd *models.BatchDisableUsersCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 		userIds := cmd.UserIds
 
@@ -513,13 +524,13 @@ func BatchDisableUsers(cmd *m.BatchDisableUsersCommand) error {
 	})
 }
 
-func DeleteUser(cmd *m.DeleteUserCommand) error {
+func DeleteUser(cmd *models.DeleteUserCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 		return deleteUserInTransaction(sess, cmd)
 	})
 }
 
-func deleteUserInTransaction(sess *DBSession, cmd *m.DeleteUserCommand) error {
+func deleteUserInTransaction(sess *DBSession, cmd *models.DeleteUserCommand) error {
 	deletes := []string{
 		"DELETE FROM star WHERE user_id = ?",
 		"DELETE FROM " + dialect.Quote("user") + " WHERE id = ?",
@@ -542,9 +553,9 @@ func deleteUserInTransaction(sess *DBSession, cmd *m.DeleteUserCommand) error {
 	return nil
 }
 
-func UpdateUserPermissions(cmd *m.UpdateUserPermissionsCommand) error {
+func UpdateUserPermissions(cmd *models.UpdateUserPermissionsCommand) error {
 	return inTransaction(func(sess *DBSession) error {
-		user := m.User{}
+		user := models.User{}
 		sess.ID(cmd.UserId).Get(&user)
 
 		user.IsAdmin = cmd.IsGrafanaAdmin
@@ -564,10 +575,10 @@ func UpdateUserPermissions(cmd *m.UpdateUserPermissionsCommand) error {
 	})
 }
 
-func SetUserHelpFlag(cmd *m.SetUserHelpFlagCommand) error {
+func SetUserHelpFlag(cmd *models.SetUserHelpFlagCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 
-		user := m.User{
+		user := models.User{
 			Id:         cmd.UserId,
 			HelpFlags1: cmd.HelpFlags1,
 			Updated:    time.Now(),
@@ -580,13 +591,13 @@ func SetUserHelpFlag(cmd *m.SetUserHelpFlagCommand) error {
 
 func validateOneAdminLeft(sess *DBSession) error {
 	// validate that there is an admin user left
-	count, err := sess.Where("is_admin=?", true).Count(&m.User{})
+	count, err := sess.Where("is_admin=?", true).Count(&models.User{})
 	if err != nil {
 		return err
 	}
 
 	if count == 0 {
-		return m.ErrLastGrafanaAdmin
+		return models.ErrLastGrafanaAdmin
 	}
 
 	return nil

pkg/services/sqlstore/user_test.go

@@ -7,7 +7,7 @@ import (
 
 	. "github.com/smartystreets/goconvey/convey"
 
-	m "github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/models"
 )
 
 func TestUserDataAccess(t *testing.T) {
@@ -16,7 +16,7 @@ func TestUserDataAccess(t *testing.T) {
 		ss := InitTestDB(t)
 
 		Convey("Creating a user", func() {
-			cmd := &m.CreateUserCommand{
+			cmd := &models.CreateUserCommand{
 				Email: "usertest@test.com",
 				Name:  "user name",
 				Login: "user_test_login",
@@ -26,7 +26,7 @@ func TestUserDataAccess(t *testing.T) {
 			So(err, ShouldBeNil)
 
 			Convey("Loading a user", func() {
-				query := m.GetUserByIdQuery{Id: cmd.Result.Id}
+				query := models.GetUserByIdQuery{Id: cmd.Result.Id}
 				err := GetUserById(&query)
 				So(err, ShouldBeNil)
 
@@ -39,10 +39,10 @@ func TestUserDataAccess(t *testing.T) {
 
 		Convey("Given 5 users", func() {
 			var err error
-			var cmd *m.CreateUserCommand
-			users := []m.User{}
+			var cmd *models.CreateUserCommand
+			users := []models.User{}
 			for i := 0; i < 5; i++ {
-				cmd = &m.CreateUserCommand{
+				cmd = &models.CreateUserCommand{
 					Email: fmt.Sprint("user", i, "@test.com"),
 					Name:  fmt.Sprint("user", i),
 					Login: fmt.Sprint("loginuser", i),
@@ -53,7 +53,7 @@ func TestUserDataAccess(t *testing.T) {
 			}
 
 			Convey("Can return the first page of users and a total count", func() {
-				query := m.SearchUsersQuery{Query: "", Page: 1, Limit: 3}
+				query := models.SearchUsersQuery{Query: "", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
@@ -62,7 +62,7 @@ func TestUserDataAccess(t *testing.T) {
 			})
 
 			Convey("Can return the second page of users and a total count", func() {
-				query := m.SearchUsersQuery{Query: "", Page: 2, Limit: 3}
+				query := models.SearchUsersQuery{Query: "", Page: 2, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
@@ -71,28 +71,28 @@ func TestUserDataAccess(t *testing.T) {
 			})
 
 			Convey("Can return list of users matching query on user name", func() {
-				query := m.SearchUsersQuery{Query: "use", Page: 1, Limit: 3}
+				query := models.SearchUsersQuery{Query: "use", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
 				So(len(query.Result.Users), ShouldEqual, 3)
 				So(query.Result.TotalCount, ShouldEqual, 5)
 
-				query = m.SearchUsersQuery{Query: "ser1", Page: 1, Limit: 3}
+				query = models.SearchUsersQuery{Query: "ser1", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
 				So(len(query.Result.Users), ShouldEqual, 1)
 				So(query.Result.TotalCount, ShouldEqual, 1)
 
-				query = m.SearchUsersQuery{Query: "USER1", Page: 1, Limit: 3}
+				query = models.SearchUsersQuery{Query: "USER1", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
 				So(len(query.Result.Users), ShouldEqual, 1)
 				So(query.Result.TotalCount, ShouldEqual, 1)
 
-				query = m.SearchUsersQuery{Query: "idontexist", Page: 1, Limit: 3}
+				query = models.SearchUsersQuery{Query: "idontexist", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
@@ -101,7 +101,7 @@ func TestUserDataAccess(t *testing.T) {
 			})
 
 			Convey("Can return list of users matching query on email", func() {
-				query := m.SearchUsersQuery{Query: "ser1@test.com", Page: 1, Limit: 3}
+				query := models.SearchUsersQuery{Query: "ser1@test.com", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
@@ -110,7 +110,7 @@ func TestUserDataAccess(t *testing.T) {
 			})
 
 			Convey("Can return list of users matching query on login name", func() {
-				query := m.SearchUsersQuery{Query: "loginuser1", Page: 1, Limit: 3}
+				query := models.SearchUsersQuery{Query: "loginuser1", Page: 1, Limit: 3}
 				err = SearchUsers(&query)
 
 				So(err, ShouldBeNil)
@@ -118,34 +118,78 @@ func TestUserDataAccess(t *testing.T) {
 				So(query.Result.TotalCount, ShouldEqual, 1)
 			})
 
+			Convey("can return list users based on their auth type", func() {
+				// add users to auth table
+				for index, user := range users {
+					authModule := "killa"
+
+					// define every second user as ldap
+					if index%2 == 0 {
+						authModule = "ldap"
+					}
+
+					cmd2 := &models.SetAuthInfoCommand{
+						UserId:     user.Id,
+						AuthModule: authModule,
+						AuthId:     "gorilla",
+					}
+					err = SetAuthInfo(cmd2)
+					So(err, ShouldBeNil)
+				}
+				query := models.SearchUsersQuery{AuthModule: "ldap"}
+				err = SearchUsers(&query)
+				So(err, ShouldBeNil)
+
+				So(query.Result.Users, ShouldHaveLength, 3)
+
+				zero, second, fourth := false, false, false
+				for _, user := range query.Result.Users {
+					if user.Name == "user0" {
+						zero = true
+					}
+
+					if user.Name == "user2" {
+						second = true
+					}
+
+					if user.Name == "user4" {
+						fourth = true
+					}
+				}
+
+				So(zero, ShouldBeTrue)
+				So(second, ShouldBeTrue)
+				So(fourth, ShouldBeTrue)
+			})
+
 			Convey("when a user is an org member and has been assigned permissions", func() {
-				err = AddOrgUser(&m.AddOrgUserCommand{LoginOrEmail: users[1].Login, Role: m.ROLE_VIEWER, OrgId: users[0].OrgId, UserId: users[1].Id})
+				err = AddOrgUser(&models.AddOrgUserCommand{LoginOrEmail: users[1].Login, Role: models.ROLE_VIEWER, OrgId: users[0].OrgId, UserId: users[1].Id})
 				So(err, ShouldBeNil)
 
-				testHelperUpdateDashboardAcl(1, m.DashboardAcl{DashboardId: 1, OrgId: users[0].OrgId, UserId: users[1].Id, Permission: m.PERMISSION_EDIT})
+				testHelperUpdateDashboardAcl(1, models.DashboardAcl{DashboardId: 1, OrgId: users[0].OrgId, UserId: users[1].Id, Permission: models.PERMISSION_EDIT})
 				So(err, ShouldBeNil)
 
-				err = SavePreferences(&m.SavePreferencesCommand{UserId: users[1].Id, OrgId: users[0].OrgId, HomeDashboardId: 1, Theme: "dark"})
+				err = SavePreferences(&models.SavePreferencesCommand{UserId: users[1].Id, OrgId: users[0].OrgId, HomeDashboardId: 1, Theme: "dark"})
 				So(err, ShouldBeNil)
 
 				Convey("when the user is deleted", func() {
-					err = DeleteUser(&m.DeleteUserCommand{UserId: users[1].Id})
+					err = DeleteUser(&models.DeleteUserCommand{UserId: users[1].Id})
 					So(err, ShouldBeNil)
 
 					Convey("Should delete connected org users and permissions", func() {
-						query := &m.GetOrgUsersQuery{OrgId: users[0].OrgId}
+						query := &models.GetOrgUsersQuery{OrgId: users[0].OrgId}
 						err = GetOrgUsersForTest(query)
 						So(err, ShouldBeNil)
 
 						So(len(query.Result), ShouldEqual, 1)
 
-						permQuery := &m.GetDashboardAclInfoListQuery{DashboardId: 1, OrgId: users[0].OrgId}
+						permQuery := &models.GetDashboardAclInfoListQuery{DashboardId: 1, OrgId: users[0].OrgId}
 						err = GetDashboardAclInfoList(permQuery)
 						So(err, ShouldBeNil)
 
 						So(len(permQuery.Result), ShouldEqual, 0)
 
-						prefsQuery := &m.GetPreferencesQuery{OrgId: users[0].OrgId, UserId: users[1].Id}
+						prefsQuery := &models.GetPreferencesQuery{OrgId: users[0].OrgId, UserId: users[1].Id}
 						err = GetPreferences(prefsQuery)
 						So(err, ShouldBeNil)
 
@@ -157,14 +201,14 @@ func TestUserDataAccess(t *testing.T) {
 				Convey("when retreiving signed in user for orgId=0 result should return active org id", func() {
 					ss.CacheService.Flush()
 
-					query := &m.GetSignedInUserQuery{OrgId: users[1].OrgId, UserId: users[1].Id}
+					query := &models.GetSignedInUserQuery{OrgId: users[1].OrgId, UserId: users[1].Id}
 					err := ss.GetSignedInUserWithCache(query)
 					So(err, ShouldBeNil)
 					So(query.Result, ShouldNotBeNil)
 					So(query.OrgId, ShouldEqual, users[1].OrgId)
-					err = SetUsingOrg(&m.SetUsingOrgCommand{UserId: users[1].Id, OrgId: users[0].OrgId})
+					err = SetUsingOrg(&models.SetUsingOrgCommand{UserId: users[1].Id, OrgId: users[0].OrgId})
 					So(err, ShouldBeNil)
-					query = &m.GetSignedInUserQuery{OrgId: 0, UserId: users[1].Id}
+					query = &models.GetSignedInUserQuery{OrgId: 0, UserId: users[1].Id}
 					err = ss.GetSignedInUserWithCache(query)
 					So(err, ShouldBeNil)
 					So(query.Result, ShouldNotBeNil)
@@ -181,13 +225,13 @@ func TestUserDataAccess(t *testing.T) {
 				for i := 0; i < 3; i++ {
 					userIdsToDisable = append(userIdsToDisable, users[i].Id)
 				}
-				disableCmd := m.BatchDisableUsersCommand{UserIds: userIdsToDisable, IsDisabled: true}
+				disableCmd := models.BatchDisableUsersCommand{UserIds: userIdsToDisable, IsDisabled: true}
 
 				err = BatchDisableUsers(&disableCmd)
 				So(err, ShouldBeNil)
 
 				Convey("Should disable all provided users", func() {
-					query := m.SearchUsersQuery{}
+					query := models.SearchUsersQuery{}
 					err = SearchUsers(&query)
 
 					So(query.Result.TotalCount, ShouldEqual, 5)
@@ -213,7 +257,7 @@ func TestUserDataAccess(t *testing.T) {
 
 		Convey("Given one grafana admin user", func() {
 			var err error
-			createUserCmd := &m.CreateUserCommand{
+			createUserCmd := &models.CreateUserCommand{
 				Email:   fmt.Sprint("admin", "@test.com"),
 				Name:    fmt.Sprint("admin"),
 				Login:   fmt.Sprint("admin"),
@@ -223,12 +267,12 @@ func TestUserDataAccess(t *testing.T) {
 			So(err, ShouldBeNil)
 
 			Convey("Cannot make themselves a non-admin", func() {
-				updateUserPermsCmd := m.UpdateUserPermissionsCommand{IsGrafanaAdmin: false, UserId: 1}
+				updateUserPermsCmd := models.UpdateUserPermissionsCommand{IsGrafanaAdmin: false, UserId: 1}
 				updatePermsError := UpdateUserPermissions(&updateUserPermsCmd)
 
-				So(updatePermsError, ShouldEqual, m.ErrLastGrafanaAdmin)
+				So(updatePermsError, ShouldEqual, models.ErrLastGrafanaAdmin)
 
-				query := m.GetUserByIdQuery{Id: createUserCmd.Result.Id}
+				query := models.GetUserByIdQuery{Id: createUserCmd.Result.Id}
 				getUserError := GetUserById(&query)
 
 				So(getUserError, ShouldBeNil)
@@ -239,8 +283,8 @@ func TestUserDataAccess(t *testing.T) {
 	})
 }
 
-func GetOrgUsersForTest(query *m.GetOrgUsersQuery) error {
-	query.Result = make([]*m.OrgUserDTO, 0)
+func GetOrgUsersForTest(query *models.GetOrgUsersQuery) error {
+	query.Result = make([]*models.OrgUserDTO, 0)
 	sess := x.Table("org_user")
 	sess.Join("LEFT ", x.Dialect().Quote("user"), fmt.Sprintf("org_user.user_id=%s.id", x.Dialect().Quote("user")))
 	sess.Where("org_user.org_id=?", query.OrgId)