From bd5faa5dc8c8fa6db78850c7e5eac138856e91bb Mon Sep 17 00:00:00 2001 From: Timmy Date: Wed, 21 Feb 2024 16:03:09 +0800 Subject: [PATCH] update: delete subject template group when delete subject (#286) --- pkg/database/dao/group_resource_policy.go | 4 ++ pkg/database/dao/mock/subject_group.go | 24 +++++----- .../dao/mock/subject_template_group.go | 14 ++++++ pkg/database/dao/subject_group.go | 12 ++--- pkg/database/dao/subject_template_group.go | 13 ++++- pkg/service/group.go | 14 +++++- pkg/service/group_test.go | 48 ++++++++++++++++--- 7 files changed, 101 insertions(+), 28 deletions(-) diff --git a/pkg/database/dao/group_resource_policy.go b/pkg/database/dao/group_resource_policy.go index 647c2dba..1f6e44a0 100644 --- a/pkg/database/dao/group_resource_policy.go +++ b/pkg/database/dao/group_resource_policy.go @@ -216,6 +216,10 @@ func (m *groupResourcePolicyManager) BulkDeleteByGroupPKsWithTx( tx *sqlx.Tx, groupPKs []int64, ) error { + if len(groupPKs) == 0 { + return nil + } + sql := `DELETE FROM rbac_group_resource_policy WHERE group_pk IN (?)` return database.SqlxDeleteWithTx(tx, sql, groupPKs) } diff --git a/pkg/database/dao/mock/subject_group.go b/pkg/database/dao/mock/subject_group.go index 25405af0..154d6eac 100644 --- a/pkg/database/dao/mock/subject_group.go +++ b/pkg/database/dao/mock/subject_group.go @@ -64,32 +64,32 @@ func (mr *MockSubjectGroupManagerMockRecorder) BulkDeleteByGroupMembersWithTx(tx return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteByGroupMembersWithTx", reflect.TypeOf((*MockSubjectGroupManager)(nil).BulkDeleteByGroupMembersWithTx), tx, groupPK, subjectPKs) } -// BulkDeleteByGroupPKs mocks base method. -func (m *MockSubjectGroupManager) BulkDeleteByGroupPKs(tx *sqlx.Tx, groupPKs []int64) error { +// BulkDeleteByGroupPKsWithTx mocks base method. +func (m *MockSubjectGroupManager) BulkDeleteByGroupPKsWithTx(tx *sqlx.Tx, groupPKs []int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BulkDeleteByGroupPKs", tx, groupPKs) + ret := m.ctrl.Call(m, "BulkDeleteByGroupPKsWithTx", tx, groupPKs) ret0, _ := ret[0].(error) return ret0 } -// BulkDeleteByGroupPKs indicates an expected call of BulkDeleteByGroupPKs. -func (mr *MockSubjectGroupManagerMockRecorder) BulkDeleteByGroupPKs(tx, groupPKs interface{}) *gomock.Call { +// BulkDeleteByGroupPKsWithTx indicates an expected call of BulkDeleteByGroupPKsWithTx. +func (mr *MockSubjectGroupManagerMockRecorder) BulkDeleteByGroupPKsWithTx(tx, groupPKs interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteByGroupPKs", reflect.TypeOf((*MockSubjectGroupManager)(nil).BulkDeleteByGroupPKs), tx, groupPKs) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteByGroupPKsWithTx", reflect.TypeOf((*MockSubjectGroupManager)(nil).BulkDeleteByGroupPKsWithTx), tx, groupPKs) } -// BulkDeleteBySubjectPKs mocks base method. -func (m *MockSubjectGroupManager) BulkDeleteBySubjectPKs(tx *sqlx.Tx, subjectPKs []int64) error { +// BulkDeleteBySubjectPKsWithTx mocks base method. +func (m *MockSubjectGroupManager) BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BulkDeleteBySubjectPKs", tx, subjectPKs) + ret := m.ctrl.Call(m, "BulkDeleteBySubjectPKsWithTx", tx, subjectPKs) ret0, _ := ret[0].(error) return ret0 } -// BulkDeleteBySubjectPKs indicates an expected call of BulkDeleteBySubjectPKs. -func (mr *MockSubjectGroupManagerMockRecorder) BulkDeleteBySubjectPKs(tx, subjectPKs interface{}) *gomock.Call { +// BulkDeleteBySubjectPKsWithTx indicates an expected call of BulkDeleteBySubjectPKsWithTx. +func (mr *MockSubjectGroupManagerMockRecorder) BulkDeleteBySubjectPKsWithTx(tx, subjectPKs interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteBySubjectPKs", reflect.TypeOf((*MockSubjectGroupManager)(nil).BulkDeleteBySubjectPKs), tx, subjectPKs) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteBySubjectPKsWithTx", reflect.TypeOf((*MockSubjectGroupManager)(nil).BulkDeleteBySubjectPKsWithTx), tx, subjectPKs) } // BulkUpdateExpiredAtWithTx mocks base method. diff --git a/pkg/database/dao/mock/subject_template_group.go b/pkg/database/dao/mock/subject_template_group.go index d9d8ce65..f9ca1159 100644 --- a/pkg/database/dao/mock/subject_template_group.go +++ b/pkg/database/dao/mock/subject_template_group.go @@ -49,6 +49,20 @@ func (mr *MockSubjectTemplateGroupManagerMockRecorder) BulkCreateWithTx(tx, rela return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkCreateWithTx", reflect.TypeOf((*MockSubjectTemplateGroupManager)(nil).BulkCreateWithTx), tx, relations) } +// BulkDeleteBySubjectPKsWithTx mocks base method. +func (m *MockSubjectTemplateGroupManager) BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BulkDeleteBySubjectPKsWithTx", tx, subjectPKs) + ret0, _ := ret[0].(error) + return ret0 +} + +// BulkDeleteBySubjectPKsWithTx indicates an expected call of BulkDeleteBySubjectPKsWithTx. +func (mr *MockSubjectTemplateGroupManagerMockRecorder) BulkDeleteBySubjectPKsWithTx(tx, subjectPKs interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkDeleteBySubjectPKsWithTx", reflect.TypeOf((*MockSubjectTemplateGroupManager)(nil).BulkDeleteBySubjectPKsWithTx), tx, subjectPKs) +} + // BulkDeleteWithTx mocks base method. func (m *MockSubjectTemplateGroupManager) BulkDeleteWithTx(tx *sqlx.Tx, relations []dao.SubjectTemplateGroup) error { m.ctrl.T.Helper() diff --git a/pkg/database/dao/subject_group.go b/pkg/database/dao/subject_group.go index ea8524e1..5efbab4b 100644 --- a/pkg/database/dao/subject_group.go +++ b/pkg/database/dao/subject_group.go @@ -68,8 +68,8 @@ type SubjectGroupManager interface { FilterGroupPKsHasMemberBeforeExpiredAt(groupPKs []int64, expiredAt int64) ([]int64, error) BulkCreateWithTx(tx *sqlx.Tx, relations []SubjectRelation) error - BulkDeleteBySubjectPKs(tx *sqlx.Tx, subjectPKs []int64) error - BulkDeleteByGroupPKs(tx *sqlx.Tx, groupPKs []int64) error + BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error + BulkDeleteByGroupPKsWithTx(tx *sqlx.Tx, groupPKs []int64) error BulkUpdateExpiredAtWithTx(tx *sqlx.Tx, relations []SubjectRelation) error ListGroupMember(groupPK int64) ([]SubjectRelation, error) @@ -352,16 +352,16 @@ func (m *subjectGroupManager) BulkCreateWithTx(tx *sqlx.Tx, relations []SubjectR return m.bulkInsertWithTx(tx, relations) } -// BulkDeleteBySubjectPKs ... -func (m *subjectGroupManager) BulkDeleteBySubjectPKs(tx *sqlx.Tx, subjectPKs []int64) error { +// BulkDeleteBySubjectPKsWithTx ... +func (m *subjectGroupManager) BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error { if len(subjectPKs) == 0 { return nil } return m.bulkDeleteBySubjectPKs(tx, subjectPKs) } -// BulkDeleteByGroupPKs ... -func (m *subjectGroupManager) BulkDeleteByGroupPKs(tx *sqlx.Tx, groupPKs []int64) error { +// BulkDeleteByGroupPKsWithTx ... +func (m *subjectGroupManager) BulkDeleteByGroupPKsWithTx(tx *sqlx.Tx, groupPKs []int64) error { if len(groupPKs) == 0 { return nil } diff --git a/pkg/database/dao/subject_template_group.go b/pkg/database/dao/subject_template_group.go index 6961ccdc..315f9f67 100644 --- a/pkg/database/dao/subject_template_group.go +++ b/pkg/database/dao/subject_template_group.go @@ -34,6 +34,7 @@ type SubjectTemplateGroup struct { type SubjectTemplateGroupManager interface { GetTemplateGroupMemberCount(groupPK, templateID int64) (int64, error) + GetMaxExpiredAtBySubjectGroup(subjectPK, groupPK int64, excludeTemplateID int64) (int64, error) ListPagingTemplateGroupMember( groupPK, templateID int64, limit, offset int64, @@ -46,7 +47,7 @@ type SubjectTemplateGroupManager interface { BulkUpdateExpiredAtWithTx(tx *sqlx.Tx, relations []SubjectTemplateGroup) error BulkUpdateExpiredAtByRelationWithTx(tx *sqlx.Tx, relations []SubjectRelation) error BulkDeleteWithTx(tx *sqlx.Tx, relations []SubjectTemplateGroup) error - GetMaxExpiredAtBySubjectGroup(subjectPK, groupPK int64, excludeTemplateID int64) (int64, error) + BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error } type subjectTemplateGroupManager struct { @@ -235,3 +236,13 @@ func (m *subjectTemplateGroupManager) ListThinRelationWithMaxExpiredAtByGroupPK( return relations, err } + +func (m *subjectTemplateGroupManager) BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []int64) error { + if len(subjectPKs) == 0 { + return nil + } + + sql := `DELETE FROM subject_template_group + WHERE subject_pk in (?)` + return database.SqlxDeleteWithTx(tx, sql, subjectPKs) +} diff --git a/pkg/service/group.go b/pkg/service/group.go index 2eb775c9..dfa3716f 100644 --- a/pkg/service/group.go +++ b/pkg/service/group.go @@ -879,7 +879,7 @@ func (l *groupService) BulkDeleteByGroupPKsWithTx(tx *sqlx.Tx, groupPKs []int64) errorWrapf := errorx.NewLayerFunctionErrorWrapf(GroupSVC, "BulkDeleteByGroupPKsWithTx") // 批量用户组删除成员关系 subjectRelation - err := l.manager.BulkDeleteByGroupPKs(tx, groupPKs) + err := l.manager.BulkDeleteByGroupPKsWithTx(tx, groupPKs) if err != nil { return errorWrapf( err, "manager.BulkDeleteByGroupPKs group_pks=`%+v` fail", groupPKs) @@ -893,12 +893,22 @@ func (l *groupService) BulkDeleteBySubjectPKsWithTx(tx *sqlx.Tx, subjectPKs []in errorWrapf := errorx.NewLayerFunctionErrorWrapf(GroupSVC, "BulkDeleteBySubjectPKsWithTx") // 批量其加入的用户组关系 subjectRelation - err := l.manager.BulkDeleteBySubjectPKs(tx, subjectPKs) + err := l.manager.BulkDeleteBySubjectPKsWithTx(tx, subjectPKs) if err != nil { return errorWrapf( err, "manager.BulkDeleteBySubjectPKs subject_pks=`%+v` fail", subjectPKs) } + // 批量删除subject template group + err = l.subjectTemplateGroupManager.BulkDeleteBySubjectPKsWithTx(tx, subjectPKs) + if err != nil { + return errorWrapf( + err, + "subjectTemplateGroupManager.BulkDeleteBySubjectPKsWithTx subjectPKs=`%+v` fail", + subjectPKs, + ) + } + // 批量删除用户的subject system group err = l.subjectSystemGroupManager.DeleteBySubjectPKsWithTx(tx, subjectPKs) if err != nil { diff --git a/pkg/service/group_test.go b/pkg/service/group_test.go index 77e7e47e..f05a28e7 100644 --- a/pkg/service/group_test.go +++ b/pkg/service/group_test.go @@ -81,7 +81,7 @@ var _ = Describe("GroupService", func() { It("manager.BulkDeleteBySubjectPKs fail", func() { mockSubjectService := mock.NewMockSubjectGroupManager(ctl) - mockSubjectService.EXPECT().BulkDeleteBySubjectPKs(gomock.Any(), []int64{1, 2}).Return( + mockSubjectService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( errors.New("error"), ).AnyTimes() @@ -94,10 +94,37 @@ var _ = Describe("GroupService", func() { assert.Contains(GinkgoT(), err.Error(), "BulkDeleteBySubjectPKs") }) + It("manager.BulkDeleteBySubjectPKs fail", func() { + mockSubjectService := mock.NewMockSubjectGroupManager(ctl) + + mockSubjectService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( + nil, + ).AnyTimes() + + mockSubjectTemplateGroupService := mock.NewMockSubjectTemplateGroupManager(ctl) + mockSubjectTemplateGroupService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( + errors.New("error"), + ).AnyTimes() + + manager := &groupService{ + manager: mockSubjectService, + subjectTemplateGroupManager: mockSubjectTemplateGroupService, + } + + err := manager.BulkDeleteBySubjectPKsWithTx(nil, []int64{1, 2}) + assert.Error(GinkgoT(), err) + assert.Contains(GinkgoT(), err.Error(), "subjectTemplateGroupManager.BulkDeleteBySubjectPKsWithTx") + }) + It("subjectSystemGroupManager.DeleteBySubjectPKsWithTx fail", func() { mockSubjectService := mock.NewMockSubjectGroupManager(ctl) - mockSubjectService.EXPECT().BulkDeleteBySubjectPKs(gomock.Any(), []int64{1, 2}).Return( + mockSubjectService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( + nil, + ).AnyTimes() + + mockSubjectTemplateGroupService := mock.NewMockSubjectTemplateGroupManager(ctl) + mockSubjectTemplateGroupService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( nil, ).AnyTimes() @@ -107,8 +134,9 @@ var _ = Describe("GroupService", func() { ).AnyTimes() manager := &groupService{ - manager: mockSubjectService, - subjectSystemGroupManager: mockSubjectSystemGroupService, + manager: mockSubjectService, + subjectSystemGroupManager: mockSubjectSystemGroupService, + subjectTemplateGroupManager: mockSubjectTemplateGroupService, } err := manager.BulkDeleteBySubjectPKsWithTx(nil, []int64{1, 2}) @@ -119,7 +147,12 @@ var _ = Describe("GroupService", func() { It("ok", func() { mockSubjectService := mock.NewMockSubjectGroupManager(ctl) - mockSubjectService.EXPECT().BulkDeleteBySubjectPKs(gomock.Any(), []int64{1, 2}).Return( + mockSubjectService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( + nil, + ).AnyTimes() + + mockSubjectTemplateGroupService := mock.NewMockSubjectTemplateGroupManager(ctl) + mockSubjectTemplateGroupService.EXPECT().BulkDeleteBySubjectPKsWithTx(gomock.Any(), []int64{1, 2}).Return( nil, ).AnyTimes() @@ -129,8 +162,9 @@ var _ = Describe("GroupService", func() { ).AnyTimes() manager := &groupService{ - manager: mockSubjectService, - subjectSystemGroupManager: mockSubjectSystemGroupService, + manager: mockSubjectService, + subjectSystemGroupManager: mockSubjectSystemGroupService, + subjectTemplateGroupManager: mockSubjectTemplateGroupService, } err := manager.BulkDeleteBySubjectPKsWithTx(nil, []int64{1, 2})