Skip to content

Commit 0deba7d

Browse files
JamesChenXJamesChenX
committed
Implement the missing feature: Delete a relationship from a specific relationship group #1365 
1 parent 4cd2b1f commit 0deba7d

4 files changed

Lines changed: 199 additions & 33 deletions

File tree

‎turms-service/src/main/java/im/turms/service/domain/user/access/servicerequest/controller/UserRelationshipServiceController.java‎

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -291,14 +291,21 @@ public ClientRequestHandler handleDeleteRelationshipRequest() {
291291
return clientRequest -> {
292292
DeleteRelationshipRequest request = clientRequest.turmsRequest()
293293
.getDeleteRelationshipRequest();
294-
Mono<Void> deleteMono;
294+
Mono<?> deleteMono;
295295
if (deleteTwoSidedRelationships) {
296-
deleteMono = userRelationshipService
297-
.deleteTwoSidedRelationships(clientRequest.userId(), request.getUserId());
296+
deleteMono = userRelationshipService.tryDeleteTwoSidedRelationships(
297+
clientRequest.userId(),
298+
request.getUserId(),
299+
request.hasGroupIndex()
300+
? request.getGroupIndex()
301+
: null);
298302
} else {
299303
deleteMono =
300304
userRelationshipService.deleteOneSidedRelationship(clientRequest.userId(),
301305
request.getUserId(),
306+
request.hasGroupIndex()
307+
? request.getGroupIndex()
308+
: null,
302309
null);
303310
}
304311
return deleteMono.then(Mono.fromCallable(

‎turms-service/src/main/java/im/turms/service/domain/user/repository/UserRelationshipGroupMemberRepository.java‎

Lines changed: 22 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,18 @@ public UserRelationshipGroupMemberRepository(
4646
super(mongoClient, UserRelationshipGroupMember.class);
4747
}
4848

49+
public Mono<DeleteResult> deleteRelatedUserFromRelationshipGroup(
50+
Long ownerId,
51+
Long relatedUserId,
52+
Integer groupIndex,
53+
@Nullable ClientSession session) {
54+
Filter filter = Filter.newBuilder(3)
55+
.eq(UserRelationshipGroupMember.Fields.ID_OWNER_ID, ownerId)
56+
.eq(UserRelationshipGroupMember.Fields.ID_RELATED_USER_ID, relatedUserId)
57+
.eq(UserRelationshipGroupMember.Fields.ID_GROUP_INDEX, groupIndex);
58+
return mongoClient.deleteOne(session, entityClass, filter);
59+
}
60+
4961
public Mono<DeleteResult> deleteRelatedUsersFromAllRelationshipGroups(
5062
Long ownerId,
5163
Collection<Long> relatedUserIds,
@@ -56,6 +68,15 @@ public Mono<DeleteResult> deleteRelatedUsersFromAllRelationshipGroups(
5668
return mongoClient.deleteMany(session, entityClass, filter);
5769
}
5870

71+
public Mono<Long> countGroups(
72+
@Nullable Collection<Long> ownerIds,
73+
@Nullable Collection<Long> relatedUserIds) {
74+
Filter filter = Filter.newBuilder(2)
75+
.inIfNotNull(UserRelationshipGroupMember.Fields.ID_OWNER_ID, ownerIds)
76+
.inIfNotNull(UserRelationshipGroupMember.Fields.ID_RELATED_USER_ID, relatedUserIds);
77+
return mongoClient.count(entityClass, filter);
78+
}
79+
5980
public Mono<Long> countMembers(
6081
@Nullable Set<Long> ownerIds,
6182
@Nullable Set<Integer> groupIndexes) {
@@ -112,4 +133,4 @@ public Flux<UserRelationshipGroupMember> findRelationshipGroupMembers(
112133
return mongoClient.findMany(entityClass, filterMember);
113134
}
114135

115-
}
136+
}

‎turms-service/src/main/java/im/turms/service/domain/user/service/UserRelationshipGroupService.java‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -394,6 +394,45 @@ public Mono<DeleteResult> deleteAllRelationshipGroups(
394394
return deleteMono;
395395
}
396396

397+
public Mono<DeleteResult> deleteRelatedUserFromRelationshipGroup(
398+
@NotNull Long ownerId,
399+
@NotNull Long relatedUserId,
400+
@NotNull Integer groupIndex,
401+
@Nullable ClientSession session,
402+
boolean updateRelationshipGroupsMembersVersion) {
403+
try {
404+
Validator.notNull(ownerId, "ownerId");
405+
Validator.notNull(relatedUserId, "relatedUserId");
406+
Validator.notNull(groupIndex, "groupIndex");
407+
} catch (ResponseException e) {
408+
return Mono.error(e);
409+
}
410+
Mono<DeleteResult> deleteMono = userRelationshipGroupMemberRepository
411+
.deleteRelatedUserFromRelationshipGroup(ownerId,
412+
relatedUserId,
413+
groupIndex,
414+
session);
415+
if (updateRelationshipGroupsMembersVersion) {
416+
return deleteMono.flatMap(result -> {
417+
if (result.getDeletedCount() == 0) {
418+
return Mono.empty();
419+
}
420+
return userVersionService.updateRelationshipGroupsMembersVersion(ownerId)
421+
.onErrorResume(t -> {
422+
LOGGER.error(
423+
"Caught an error while updating the relationship groups members version of the owner ({}) after deleting the user ({}) from the group ({})",
424+
ownerId,
425+
relatedUserId,
426+
groupIndex,
427+
t);
428+
return Mono.empty();
429+
})
430+
.thenReturn(result);
431+
});
432+
}
433+
return deleteMono;
434+
}
435+
397436
public Mono<DeleteResult> deleteRelatedUserFromAllRelationshipGroups(
398437
@NotNull Long ownerId,
399438
@NotNull Long relatedUserId,
@@ -557,6 +596,12 @@ public Mono<Long> countRelationshipGroups(
557596
.countRelationshipGroups(ownerIds, indexes, names, creationDateRange);
558597
}
559598

599+
public Mono<Long> countRelationshipGroups(
600+
@Nullable Set<Long> ownerIds,
601+
@Nullable Set<Long> relatedUserIds) {
602+
return userRelationshipGroupMemberRepository.countGroups(ownerIds, relatedUserIds);
603+
}
604+
560605
public Mono<Long> countRelationshipGroupMembers(
561606
@Nullable Set<Long> ownerIds,
562607
@Nullable Set<Integer> groupIndexes) {

‎turms-service/src/main/java/im/turms/service/domain/user/service/UserRelationshipService.java‎

Lines changed: 122 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -176,9 +176,16 @@ public Mono<DeleteResult> deleteOneSidedRelationships(
176176
.retryWhen(TRANSACTION_RETRY);
177177
}
178178

179-
public Mono<Void> deleteOneSidedRelationship(
179+
/**
180+
* @return true if the relationship existed and has been deleted;
181+
* <p>
182+
* false if the relationship does not exist, or still exists and has been deleted from a
183+
* relationship group.
184+
*/
185+
public Mono<Boolean> deleteOneSidedRelationship(
180186
@NotNull Long ownerId,
181187
@NotNull Long relatedUserId,
188+
@Nullable Integer groupIndex,
182189
@Nullable ClientSession session) {
183190
try {
184191
Validator.notNull(ownerId, "ownerId");
@@ -187,45 +194,131 @@ public Mono<Void> deleteOneSidedRelationship(
187194
return Mono.error(e);
188195
}
189196
if (session == null) {
190-
return userRelationshipRepository.inTransaction(
191-
newSession -> deleteOneSidedRelationship(ownerId, relatedUserId, newSession))
197+
return userRelationshipRepository
198+
.inTransaction(newSession -> deleteOneSidedRelationship(ownerId,
199+
relatedUserId,
200+
groupIndex,
201+
newSession))
192202
.retryWhen(TRANSACTION_RETRY);
193203
}
194204
UserRelationship.Key key = new UserRelationship.Key(ownerId, relatedUserId);
195-
return userRelationshipRepository.deleteById(key)
196-
.then(userRelationshipGroupService.deleteRelatedUserFromAllRelationshipGroups(
197-
ownerId,
205+
if (groupIndex == null) {
206+
return userRelationshipGroupService
207+
.deleteRelatedUserFromAllRelationshipGroups(ownerId,
208+
relatedUserId,
209+
session,
210+
false)
211+
.flatMap(deleteResult -> {
212+
// because every relationship should exist in a relationship group at least,
213+
// return immediately if no relationship found in any group.
214+
if (deleteResult.getDeletedCount() == 0) {
215+
return PublisherPool.FALSE;
216+
}
217+
return userRelationshipRepository.deleteById(key, session)
218+
.then(userVersionService
219+
.updateSpecificVersion(ownerId,
220+
null,
221+
UserVersion.Fields.RELATIONSHIP_GROUP_MEMBERS,
222+
UserVersion.Fields.RELATIONSHIPS)
223+
.onErrorResume(t -> {
224+
LOGGER.error(
225+
"Caught an error while updating the relationships version and relationship groups members version of "
226+
+ "the owner ({}) after deleting the relationship with the user ({})",
227+
ownerId,
228+
relatedUserId,
229+
t);
230+
return Mono.empty();
231+
}))
232+
.then(Mono.fromCallable(() -> {
233+
invalidateRelationshipCache(ownerId, relatedUserId);
234+
return true;
235+
}));
236+
});
237+
}
238+
return userRelationshipGroupService
239+
.deleteRelatedUserFromRelationshipGroup(ownerId,
198240
relatedUserId,
241+
groupIndex,
199242
session,
200-
false))
201-
.then(userVersionService
202-
.updateSpecificVersion(ownerId,
203-
session,
204-
UserVersion.Fields.RELATIONSHIP_GROUP_MEMBERS,
205-
UserVersion.Fields.RELATIONSHIPS)
206-
.onErrorResume(t -> {
207-
LOGGER.error(
208-
"Caught an error while updating the relationships version and relationships group members version of the owner ({}) after deleting a relationship",
209-
ownerId,
210-
t);
211-
return Mono.empty();
212-
}))
213-
.doOnSuccess(unused -> invalidateRelationshipCache(ownerId, relatedUserId))
214-
.then();
243+
false)
244+
.flatMap(deleteResult -> {
245+
if (deleteResult.getDeletedCount() == 0) {
246+
return PublisherPool.FALSE;
247+
}
248+
return userRelationshipGroupService
249+
.countRelationshipGroups(Set.of(ownerId), Set.of(relatedUserId))
250+
.flatMap(relationshipGroupCount -> {
251+
if (relationshipGroupCount > 0) {
252+
return userVersionService
253+
.updateSpecificVersion(ownerId,
254+
null,
255+
UserVersion.Fields.RELATIONSHIP_GROUP_MEMBERS)
256+
.onErrorResume(t -> {
257+
LOGGER.error(
258+
"Caught an error while updating the relationship groups members version of "
259+
+ "the owner ({}) after deleting the relationship with the user ({}) from the group ({})",
260+
ownerId,
261+
relatedUserId,
262+
groupIndex,
263+
t);
264+
return Mono.empty();
265+
})
266+
.thenReturn(false);
267+
}
268+
return userRelationshipRepository.deleteById(key, session)
269+
.then(Mono.defer(() -> {
270+
invalidateRelationshipCache(ownerId, relatedUserId);
271+
return userVersionService.updateSpecificVersion(ownerId,
272+
null,
273+
UserVersion.Fields.RELATIONSHIP_GROUP_MEMBERS,
274+
UserVersion.Fields.RELATIONSHIPS)
275+
.onErrorResume(t -> {
276+
LOGGER.error(
277+
"Caught an error while updating the relationships version and relationship group members version of "
278+
+ "the owner ({}) after deleting the relationship with the user ({}) from the group ({})",
279+
ownerId,
280+
relatedUserId,
281+
groupIndex,
282+
t);
283+
return Mono.empty();
284+
});
285+
}))
286+
.thenReturn(true);
287+
});
288+
});
215289
}
216290

217-
public Mono<Void> deleteTwoSidedRelationships(
218-
@NotNull Long userOneId,
219-
@NotNull Long userTwoId) {
291+
public Mono<Void> tryDeleteTwoSidedRelationships(
292+
@NotNull Long requesterId,
293+
@NotNull Long relatedUserId,
294+
@Nullable Integer groupId) {
220295
try {
221-
Validator.notNull(userOneId, "userOneId");
222-
Validator.notNull(userTwoId, "userTwoId");
296+
Validator.notNull(requesterId, "requesterId");
297+
Validator.notNull(relatedUserId, "relatedUserId");
223298
} catch (ResponseException e) {
224299
return Mono.error(e);
225300
}
226-
return userRelationshipRepository
227-
.inTransaction(session -> deleteOneSidedRelationship(userOneId, userTwoId, session)
228-
.then(deleteOneSidedRelationship(userTwoId, userOneId, session))
301+
return userRelationshipRepository.inTransaction(
302+
session -> deleteOneSidedRelationship(requesterId, relatedUserId, groupId, session)
303+
.flatMap(deleted -> {
304+
if (!deleted) {
305+
// If not deleted, meaning the relationship between the requester,
306+
// and the related user didn't exist, or still exists,
307+
// we don't delete the relationship between
308+
// the related user and the requester for these cases.
309+
return Mono.empty();
310+
}
311+
return isBlocked(relatedUserId, requesterId, false)
312+
.flatMap(isBlocked -> {
313+
if (isBlocked) {
314+
return Mono.empty();
315+
}
316+
return deleteOneSidedRelationship(relatedUserId,
317+
requesterId,
318+
groupId,
319+
session);
320+
});
321+
})
229322
.then())
230323
.retryWhen(TRANSACTION_RETRY);
231324
}

0 commit comments

Comments
 (0)