197 lines
5.9 KiB
TypeScript
197 lines
5.9 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
Injectable,
|
|
InternalServerErrorException,
|
|
NotFoundException,
|
|
} from '@nestjs/common';
|
|
import mongoose from 'mongoose';
|
|
import { ConnectionService } from '../global/database/connection.service';
|
|
import {
|
|
CommunityDocument,
|
|
UserDocument,
|
|
} from '../global/database/schema';
|
|
|
|
export interface CreateCommunityInput {
|
|
name: string;
|
|
description?: string;
|
|
identityId?: mongoose.Types.ObjectId;
|
|
owner?: {
|
|
kakaoTalkId?: string;
|
|
kakaoTalkNickname?: string;
|
|
discordId?: string;
|
|
discordNickname?: string;
|
|
};
|
|
}
|
|
|
|
@Injectable()
|
|
export class CommunityService {
|
|
constructor(private readonly connectionService: ConnectionService) {}
|
|
|
|
public async getById(
|
|
communityId: mongoose.Types.ObjectId,
|
|
): Promise<CommunityDocument> {
|
|
const CommunityModel = await this.connectionService.getModel('community');
|
|
const community = await CommunityModel.findById(communityId).exec();
|
|
if (!community) throw new NotFoundException('Community not found.');
|
|
return community;
|
|
}
|
|
|
|
public async createCommunityWithOwner(input: CreateCommunityInput): Promise<{
|
|
community: CommunityDocument;
|
|
owner: UserDocument;
|
|
}> {
|
|
const CommunityModel = await this.connectionService.getModel('community');
|
|
const UserModel = await this.connectionService.getModel('user');
|
|
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const ownerUserId = new mongoose.Types.ObjectId();
|
|
|
|
const session = await this.connectionService.createSession();
|
|
if (!session) {
|
|
throw new InternalServerErrorException('Failed to start DB session.');
|
|
}
|
|
|
|
try {
|
|
session.startTransaction();
|
|
|
|
const [community] = await CommunityModel.create(
|
|
[
|
|
{
|
|
_id: communityId,
|
|
name: input.name,
|
|
description: input.description ?? '',
|
|
ownerUserId,
|
|
},
|
|
],
|
|
{ session },
|
|
);
|
|
|
|
const [owner] = await UserModel.create(
|
|
[
|
|
{
|
|
_id: ownerUserId,
|
|
communityId,
|
|
identityId: input.identityId,
|
|
role: 'owner',
|
|
kakaoTalkId: input.owner?.kakaoTalkId,
|
|
kakaoTalkNickname: input.owner?.kakaoTalkNickname,
|
|
discordId: input.owner?.discordId,
|
|
discordNickname: input.owner?.discordNickname,
|
|
},
|
|
],
|
|
{ session },
|
|
);
|
|
|
|
await session.commitTransaction();
|
|
return { community, owner };
|
|
} catch (err) {
|
|
await session.abortTransaction();
|
|
throw err;
|
|
} finally {
|
|
await session.endSession();
|
|
}
|
|
}
|
|
|
|
public async promoteToAdmin(params: {
|
|
communityId: mongoose.Types.ObjectId;
|
|
targetUserId: mongoose.Types.ObjectId;
|
|
}): Promise<UserDocument> {
|
|
return this.changeNonOwnerRole({ ...params, nextRole: 'admin' });
|
|
}
|
|
|
|
public async demoteToMember(params: {
|
|
communityId: mongoose.Types.ObjectId;
|
|
targetUserId: mongoose.Types.ObjectId;
|
|
}): Promise<UserDocument> {
|
|
return this.changeNonOwnerRole({ ...params, nextRole: 'member' });
|
|
}
|
|
|
|
public async transferOwnership(params: {
|
|
communityId: mongoose.Types.ObjectId;
|
|
currentOwnerUserId: mongoose.Types.ObjectId;
|
|
newOwnerUserId: mongoose.Types.ObjectId;
|
|
}): Promise<{
|
|
community: CommunityDocument;
|
|
previousOwner: UserDocument;
|
|
newOwner: UserDocument;
|
|
}> {
|
|
if (params.currentOwnerUserId.equals(params.newOwnerUserId)) {
|
|
throw new BadRequestException('New owner is already the current owner.');
|
|
}
|
|
|
|
const CommunityModel = await this.connectionService.getModel('community');
|
|
const UserModel = await this.connectionService.getModel('user');
|
|
|
|
const session = await this.connectionService.createSession();
|
|
if (!session) {
|
|
throw new InternalServerErrorException('Failed to start DB session.');
|
|
}
|
|
|
|
try {
|
|
session.startTransaction();
|
|
|
|
const community = await CommunityModel.findById(
|
|
params.communityId,
|
|
).session(session);
|
|
if (!community) throw new NotFoundException('Community not found.');
|
|
if (!community.ownerUserId.equals(params.currentOwnerUserId)) {
|
|
throw new BadRequestException('Acting user is not the current owner.');
|
|
}
|
|
|
|
const [previousOwner, newOwner] = await Promise.all([
|
|
UserModel.findById(params.currentOwnerUserId).session(session),
|
|
UserModel.findById(params.newOwnerUserId).session(session),
|
|
]);
|
|
if (!previousOwner)
|
|
throw new NotFoundException('Previous owner user not found.');
|
|
if (!newOwner) throw new NotFoundException('New owner user not found.');
|
|
if (!newOwner.communityId.equals(params.communityId)) {
|
|
throw new BadRequestException(
|
|
'New owner does not belong to this community.',
|
|
);
|
|
}
|
|
|
|
community.ownerUserId = newOwner._id;
|
|
previousOwner.role = 'admin';
|
|
newOwner.role = 'owner';
|
|
|
|
await Promise.all([
|
|
community.save({ session }),
|
|
previousOwner.save({ session }),
|
|
newOwner.save({ session }),
|
|
]);
|
|
|
|
await session.commitTransaction();
|
|
return { community, previousOwner, newOwner };
|
|
} catch (err) {
|
|
await session.abortTransaction();
|
|
throw err;
|
|
} finally {
|
|
await session.endSession();
|
|
}
|
|
}
|
|
|
|
private async changeNonOwnerRole(params: {
|
|
communityId: mongoose.Types.ObjectId;
|
|
targetUserId: mongoose.Types.ObjectId;
|
|
nextRole: 'admin' | 'member';
|
|
}): Promise<UserDocument> {
|
|
const UserModel = await this.connectionService.getModel('user');
|
|
const user = await UserModel.findById(params.targetUserId);
|
|
if (!user) throw new NotFoundException('Target user not found.');
|
|
if (!user.communityId.equals(params.communityId)) {
|
|
throw new BadRequestException(
|
|
'Target user does not belong to this community.',
|
|
);
|
|
}
|
|
if (user.role === 'owner') {
|
|
throw new BadRequestException(
|
|
'Owner role must be changed via transferOwnership.',
|
|
);
|
|
}
|
|
user.role = params.nextRole;
|
|
await user.save();
|
|
return user;
|
|
}
|
|
}
|