mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

Migrate Roles Layered store to Sync by default (#10790)

Просмотр исходного кода 
* Migrate Roles Layered store to Sync by default

* Fixing govet

* Addressing PR review comments
Этот коммит содержится в:
Jesús Espino
2019-05-17 17:03:05 +02:00
коммит произвёл Jesse Hallam
родитель fb01d37846
Коммит 6d1ac00330
18 изменённых файлов: 645 добавлений и 639 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

87
app/import_functions_test.go
Просмотреть файл

@@ -105,55 +105,49 @@ func TestImportImportScheme(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -177,55 +171,49 @@ func TestImportImportScheme(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -330,55 +318,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -402,55 +384,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -489,7 +465,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have failed to import.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported.")
}
@@ -500,7 +476,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported as we are in dry run mode.")
}
@@ -511,7 +487,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have failed to import.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported.")
}
@@ -524,10 +500,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.Name, role.Name)
assert.Equal(t, *data.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)
@@ -545,10 +520,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded. %v", err)
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.Name, role.Name)
assert.Equal(t, *data.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)
@@ -567,10 +541,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data2.Name, role.Name)
assert.Equal(t, *data2.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)

116
app/migrations.go
Просмотреть файл

@@ -30,27 +30,29 @@ func (a *App) DoAdvancedPermissionsMigration() {
allSucceeded := true
for _, role := range roles {
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
// If this failed for reasons other than the role already existing, don't mark the migration as done.
if result2 := <-a.Srv.Store.Role().GetByName(role.Name); result2.Err != nil {
mlog.Critical("Failed to migrate role to database.")
mlog.Critical(fmt.Sprint(result.Err))
_, err := a.Srv.Store.Role().Save(role)
if err == nil {
continue
}
// If this failed for reasons other than the role already existing, don't mark the migration as done.
fetchedRole, err := a.Srv.Store.Role().GetByName(role.Name)
if err != nil {
mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
allSucceeded = false
continue
}
// If the role already existed, check it is the same and update if not.
if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
fetchedRole.DisplayName != role.DisplayName ||
fetchedRole.Description != role.Description ||
fetchedRole.SchemeManaged != role.SchemeManaged {
role.Id = fetchedRole.Id
if _, err = a.Srv.Store.Role().Save(role); err != nil {
// Role is not the same, but failed to update.
mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
allSucceeded = false
} else {
// If the role already existed, check it is the same and update if not.
fetchedRole := result.Data.(*model.Role)
if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
fetchedRole.DisplayName != role.DisplayName ||
fetchedRole.Description != role.Description ||
fetchedRole.SchemeManaged != role.SchemeManaged {
role.Id = fetchedRole.Id
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
// Role is not the same, but failed to update.
mlog.Critical("Failed to migrate role to database.")
mlog.Critical(fmt.Sprint(result.Err))
allSucceeded = false
}
}
}
}
}
@@ -63,7 +65,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
if *config.ServiceSettings.DEPRECATED_DO_NOT_USE_AllowEditPost == model.ALLOW_EDIT_POST_ALWAYS {
*config.ServiceSettings.PostEditTimeLimit = -1
if err := a.SaveConfig(config, true); err != nil {
mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.String("error", err.Error()))
mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.Err(err))
}
}
@@ -73,8 +75,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark advanced permissions migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark advanced permissions migration as completed.", mlog.Err(result.Err))
}
}
@@ -104,46 +105,40 @@ func (a *App) DoEmojisPermissionsMigration() {
case model.RESTRICT_EMOJI_CREATION_ALL:
role, err = a.GetRoleByName(model.SYSTEM_USER_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
case model.RESTRICT_EMOJI_CREATION_ADMIN:
role, err = a.GetRoleByName(model.TEAM_ADMIN_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
case model.RESTRICT_EMOJI_CREATION_SYSTEM_ADMIN:
role = nil
default:
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical("Invalid restrict emoji creation setting")
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config. Invalid restrict emoji creation setting")
return
}
if role != nil {
role.Permissions = append(role.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(result.Err.Error())
if _, err = a.Srv.Store.Role().Save(role); err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
}
systemAdminRole, err = a.GetRoleByName(model.SYSTEM_ADMIN_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_DELETE_OTHERS_EMOJIS.Id)
if result := <-a.Srv.Store.Role().Save(systemAdminRole); result.Err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(result.Err.Error())
if _, err := a.Srv.Store.Role().Save(systemAdminRole); err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
@@ -153,8 +148,7 @@ func (a *App) DoEmojisPermissionsMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark emojis permissions migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark emojis permissions migration as completed.", mlog.Err(result.Err))
}
}
@@ -167,32 +161,28 @@ func (a *App) DoGuestRolesCreationMigration() {
roles := model.MakeDefaultRoles()
allSucceeded := true
if result := <-a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
if result := <-a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
if result := <-a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
resultSchemes := <-a.Srv.Store.Scheme().GetAllPage("", 0, 1000000)
if resultSchemes.Err != nil {
mlog.Critical("Failed to get all schemes.")
mlog.Critical(fmt.Sprint(resultSchemes.Err))
mlog.Critical("Failed to get all schemes.", mlog.Err(resultSchemes.Err))
allSucceeded = false
}
schemes := resultSchemes.Data.([]*model.Scheme)
@@ -206,12 +196,11 @@ func (a *App) DoGuestRolesCreationMigration() {
SchemeManaged: true,
}
if saveRoleResult := <-a.Srv.Store.Role().Save(teamGuestRole); saveRoleResult.Err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.")
mlog.Critical(fmt.Sprint(saveRoleResult.Err))
if savedRole, err := a.Srv.Store.Role().Save(teamGuestRole); err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
allSucceeded = false
} else {
scheme.DefaultTeamGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultTeamGuestRole = savedRole.Name
}
// Channel Guest Role
@@ -222,18 +211,16 @@ func (a *App) DoGuestRolesCreationMigration() {
SchemeManaged: true,
}
if saveRoleResult := <-a.Srv.Store.Role().Save(channelGuestRole); saveRoleResult.Err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.")
mlog.Critical(fmt.Sprint(saveRoleResult.Err))
if savedRole, err := a.Srv.Store.Role().Save(channelGuestRole); err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
allSucceeded = false
} else {
scheme.DefaultChannelGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultChannelGuestRole = savedRole.Name
}
result := <-a.Srv.Store.Scheme().Save(scheme)
if result.Err != nil {
mlog.Critical("Failed to update custom scheme.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to update custom scheme.", mlog.Err(result.Err))
allSucceeded = false
}
}
@@ -249,8 +236,7 @@ func (a *App) DoGuestRolesCreationMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark guest roles creation migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark guest roles creation migration as completed.", mlog.Err(result.Err))
}
}

4
app/permissions.go
Просмотреть файл

@@ -48,8 +48,8 @@ func (a *App) ResetPermissionsSystem() *model.AppError {
}
// Purge all roles from the database.
if result := <-a.Srv.Store.Role().PermanentDeleteAll(); result.Err != nil {
return result.Err
if err := a.Srv.Store.Role().PermanentDeleteAll(); err != nil {
return err
}
// Remove the "System" table entry that marks the advanced permissions migration as done.

4
app/permissions_migrations.go
Просмотреть файл

@@ -143,8 +143,8 @@ func (a *App) doPermissionsMigration(key string, migrationMap permissionsMap) *m
for _, role := range roles {
role.Permissions = applyPermissionsMap(role.Name, roleMap, migrationMap)
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
return result.Err
if _, err := a.Srv.Store.Role().Save(role); err != nil {
return err
}
}

40
app/role.go
Просмотреть файл

@@ -12,35 +12,19 @@ import (
)
func (a *App) GetRole(id string) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().Get(id)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().Get(id)
}
func (a *App) GetAllRoles() ([]*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetAll()
if result.Err != nil {
return nil, result.Err
}
return result.Data.([]*model.Role), nil
return a.Srv.Store.Role().GetAll()
}
func (a *App) GetRoleByName(name string) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetByName(name)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().GetByName(name)
}
func (a *App) GetRolesByNames(names []string) ([]*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetByNames(names)
if result.Err != nil {
return nil, result.Err
}
return result.Data.([]*model.Role), nil
return a.Srv.Store.Role().GetByNames(names)
}
func (a *App) PatchRole(role *model.Role, patch *model.RolePatch) (*model.Role, *model.AppError) {
@@ -66,22 +50,18 @@ func (a *App) CreateRole(role *model.Role) (*model.Role, *model.AppError) {
role.BuiltIn = false
role.SchemeManaged = false
result := <-a.Srv.Store.Role().Save(role)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().Save(role)
}
func (a *App) UpdateRole(role *model.Role) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().Save(role)
if result.Err != nil {
return nil, result.Err
savedRole, err := a.Srv.Store.Role().Save(role)
if err != nil {
return nil, err
}
a.sendUpdatedRoleEvent(role)
a.sendUpdatedRoleEvent(savedRole)
return role, nil
return savedRole, nil
}