paricafe/packages/backend/src/core/UserBlockingService.ts

197 lines
6.9 KiB
TypeScript
Raw Normal View History

/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
2022-09-17 13:27:08 -05:00
2023-04-04 23:57:22 -05:00
import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
2022-09-17 13:27:08 -05:00
import { IdService } from '@/core/IdService.js';
import type { MiUser } from '@/models/User.js';
import type { MiBlocking } from '@/models/Blocking.js';
2022-09-17 13:27:08 -05:00
import { QueueService } from '@/core/QueueService.js';
import { GlobalEventService } from '@/core/GlobalEventService.js';
import { DI } from '@/di-symbols.js';
import type { FollowRequestsRepository, BlockingsRepository, UserListsRepository, UserListMembershipsRepository } from '@/models/_.js';
2022-09-23 17:12:11 -05:00
import Logger from '@/logger.js';
2022-12-03 19:16:03 -06:00
import { UserEntityService } from '@/core/entities/UserEntityService.js';
import { ApRendererService } from '@/core/activitypub/ApRendererService.js';
import { LoggerService } from '@/core/LoggerService.js';
import { WebhookService } from '@/core/WebhookService.js';
import { bindThis } from '@/decorators.js';
2023-04-04 20:21:10 -05:00
import { CacheService } from '@/core/CacheService.js';
import { UserFollowingService } from '@/core/UserFollowingService.js';
2022-09-17 13:27:08 -05:00
@Injectable()
2023-04-04 23:57:22 -05:00
export class UserBlockingService implements OnModuleInit {
2022-09-23 17:12:11 -05:00
private logger: Logger;
2023-04-04 23:57:22 -05:00
private userFollowingService: UserFollowingService;
2022-09-23 17:12:11 -05:00
2022-09-17 13:27:08 -05:00
constructor(
2023-04-04 23:57:22 -05:00
private moduleRef: ModuleRef,
2022-09-17 13:27:08 -05:00
@Inject(DI.followRequestsRepository)
private followRequestsRepository: FollowRequestsRepository,
@Inject(DI.blockingsRepository)
private blockingsRepository: BlockingsRepository,
@Inject(DI.userListsRepository)
private userListsRepository: UserListsRepository,
@Inject(DI.userListMembershipsRepository)
private userListMembershipsRepository: UserListMembershipsRepository,
2022-09-17 13:27:08 -05:00
2023-04-04 20:21:10 -05:00
private cacheService: CacheService,
2022-09-17 13:27:08 -05:00
private userEntityService: UserEntityService,
private idService: IdService,
private queueService: QueueService,
2023-02-03 19:02:03 -06:00
private globalEventService: GlobalEventService,
2022-09-17 13:27:08 -05:00
private webhookService: WebhookService,
private apRendererService: ApRendererService,
2022-09-23 17:12:11 -05:00
private loggerService: LoggerService,
2022-09-17 13:27:08 -05:00
) {
2022-09-23 17:12:11 -05:00
this.logger = this.loggerService.getLogger('user-block');
2022-09-17 13:27:08 -05:00
}
2023-04-04 23:57:22 -05:00
onModuleInit() {
this.userFollowingService = this.moduleRef.get('UserFollowingService');
}
@bindThis
public async block(blocker: MiUser, blockee: MiUser, silent = false) {
2022-09-17 13:27:08 -05:00
await Promise.all([
this.cancelRequest(blocker, blockee, silent),
this.cancelRequest(blockee, blocker, silent),
this.userFollowingService.unfollow(blocker, blockee, silent),
this.userFollowingService.unfollow(blockee, blocker, silent),
2022-09-18 13:11:50 -05:00
this.removeFromList(blockee, blocker),
2022-09-17 13:27:08 -05:00
]);
const blocking = {
id: this.idService.gen(),
2022-09-17 13:27:08 -05:00
blocker,
blockerId: blocker.id,
blockee,
blockeeId: blockee.id,
} as MiBlocking;
2022-09-17 13:27:08 -05:00
await this.blockingsRepository.insert(blocking);
2023-04-04 20:21:10 -05:00
this.cacheService.userBlockingCache.refresh(blocker.id);
this.cacheService.userBlockedCache.refresh(blockee.id);
2023-02-03 21:40:40 -06:00
this.globalEventService.publishInternalEvent('blockingCreated', {
blockerId: blocker.id,
blockeeId: blockee.id,
});
2022-09-17 13:27:08 -05:00
if (this.userEntityService.isLocalUser(blocker) && this.userEntityService.isRemoteUser(blockee)) {
2023-02-12 03:47:30 -06:00
const content = this.apRendererService.addContext(this.apRendererService.renderBlock(blocking));
this.queueService.deliver(blocker, content, blockee.inbox, false);
2022-09-17 13:27:08 -05:00
}
}
@bindThis
private async cancelRequest(follower: MiUser, followee: MiUser, silent = false) {
2022-09-17 13:27:08 -05:00
const request = await this.followRequestsRepository.findOneBy({
followeeId: followee.id,
followerId: follower.id,
});
if (request == null) {
return;
}
await this.followRequestsRepository.delete({
followeeId: followee.id,
followerId: follower.id,
});
if (this.userEntityService.isLocalUser(followee)) {
this.userEntityService.pack(followee, followee, {
schema: 'MeDetailed',
2023-02-03 19:02:03 -06:00
}).then(packed => this.globalEventService.publishMainStream(followee.id, 'meUpdated', packed));
2022-09-17 13:27:08 -05:00
}
if (this.userEntityService.isLocalUser(follower) && !silent) {
2022-09-17 13:27:08 -05:00
this.userEntityService.pack(followee, follower, {
schema: 'UserDetailedNotMe',
2022-09-17 13:27:08 -05:00
}).then(async packed => {
2023-02-03 19:02:03 -06:00
this.globalEventService.publishMainStream(follower.id, 'unfollow', packed);
2022-09-17 13:27:08 -05:00
const webhooks = (await this.webhookService.getActiveWebhooks()).filter(x => x.userId === follower.id && x.on.includes('unfollow'));
for (const webhook of webhooks) {
this.queueService.webhookDeliver(webhook, 'unfollow', {
user: packed,
});
}
});
}
// リモートにフォローリクエストをしていたらUndoFollow送信
if (this.userEntityService.isLocalUser(follower) && this.userEntityService.isRemoteUser(followee)) {
2023-02-12 03:47:30 -06:00
const content = this.apRendererService.addContext(this.apRendererService.renderUndo(this.apRendererService.renderFollow(follower, followee), follower));
this.queueService.deliver(follower, content, followee.inbox, false);
2022-09-17 13:27:08 -05:00
}
// リモートからフォローリクエストを受けていたらReject送信
if (this.userEntityService.isRemoteUser(follower) && this.userEntityService.isLocalUser(followee)) {
2023-02-12 03:47:30 -06:00
const content = this.apRendererService.addContext(this.apRendererService.renderReject(this.apRendererService.renderFollow(follower, followee, request.requestId!), followee));
this.queueService.deliver(followee, content, follower.inbox, false);
2022-09-17 13:27:08 -05:00
}
}
@bindThis
private async removeFromList(listOwner: MiUser, user: MiUser) {
2022-09-17 13:27:08 -05:00
const userLists = await this.userListsRepository.findBy({
userId: listOwner.id,
});
for (const userList of userLists) {
await this.userListMembershipsRepository.delete({
2022-09-17 13:27:08 -05:00
userListId: userList.id,
userId: user.id,
});
}
}
@bindThis
public async unblock(blocker: MiUser, blockee: MiUser) {
2022-09-17 13:27:08 -05:00
const blocking = await this.blockingsRepository.findOneBy({
blockerId: blocker.id,
blockeeId: blockee.id,
});
2022-09-17 13:27:08 -05:00
if (blocking == null) {
2022-09-23 17:12:11 -05:00
this.logger.warn('ブロック解除がリクエストされましたがブロックしていませんでした');
2022-09-17 13:27:08 -05:00
return;
}
2022-09-17 13:27:08 -05:00
// Since we already have the blocker and blockee, we do not need to fetch
// them in the query above and can just manually insert them here.
blocking.blocker = blocker;
blocking.blockee = blockee;
2022-09-17 13:27:08 -05:00
await this.blockingsRepository.delete(blocking.id);
2023-04-04 20:21:10 -05:00
this.cacheService.userBlockingCache.refresh(blocker.id);
this.cacheService.userBlockedCache.refresh(blockee.id);
2023-02-03 21:40:40 -06:00
this.globalEventService.publishInternalEvent('blockingDeleted', {
blockerId: blocker.id,
blockeeId: blockee.id,
});
2022-09-17 13:27:08 -05:00
// deliver if remote bloking
if (this.userEntityService.isLocalUser(blocker) && this.userEntityService.isRemoteUser(blockee)) {
2023-02-12 03:47:30 -06:00
const content = this.apRendererService.addContext(this.apRendererService.renderUndo(this.apRendererService.renderBlock(blocking), blocker));
this.queueService.deliver(blocker, content, blockee.inbox, false);
2022-09-17 13:27:08 -05:00
}
}
2023-02-03 21:40:40 -06:00
@bindThis
public async checkBlocked(blockerId: MiUser['id'], blockeeId: MiUser['id']): Promise<boolean> {
2023-04-04 20:21:10 -05:00
return (await this.cacheService.userBlockingCache.fetch(blockerId)).has(blockeeId);
2023-02-03 21:40:40 -06:00
}
2022-09-17 13:27:08 -05:00
}