324 lines
11 KiB
TypeScript
324 lines
11 KiB
TypeScript
import { Inject, Injectable } from '@nestjs/common';
|
|
import {
|
|
Pothos,
|
|
PothosRef,
|
|
PothosSchema,
|
|
SchemaBuilderToken,
|
|
} from '@smatch-corp/nestjs-pothos';
|
|
import { Builder } from '../Graphql/graphql.builder';
|
|
import { PrismaService } from '../Prisma/prisma.service';
|
|
import { MailService } from '../Mail/mail.service';
|
|
import { JwtUtils } from '../common/utils/jwt.utils';
|
|
@Injectable()
|
|
export class CenterMentorSchema extends PothosSchema {
|
|
constructor(
|
|
@Inject(SchemaBuilderToken) private readonly builder: Builder,
|
|
private readonly prisma: PrismaService,
|
|
private readonly mailService: MailService,
|
|
private readonly jwtUtils: JwtUtils,
|
|
) {
|
|
super();
|
|
}
|
|
|
|
@PothosRef()
|
|
centerMentor() {
|
|
return this.builder.prismaObject('CenterMentor', {
|
|
description: 'A mentor of a center.',
|
|
fields: (t) => ({
|
|
mentorId: t.exposeID('mentorId', {
|
|
description: 'The ID of the mentor.',
|
|
}),
|
|
centerId: t.exposeID('centerId', {
|
|
description: 'The ID of the center.',
|
|
}),
|
|
isCenterOwner: t.exposeBoolean('isCenterOwner', {
|
|
description: 'Whether the mentor is the center owner.',
|
|
}),
|
|
mentor: t.relation('mentor', {
|
|
description: 'The mentor.',
|
|
}),
|
|
center: t.relation('center', {
|
|
description: 'The center.',
|
|
}),
|
|
createdWorkshop: t.relation('createdWorkshop', {
|
|
description: 'The workshops created by the center mentor.',
|
|
}),
|
|
managedService: t.relation('managedService', {
|
|
description: 'The managed services of the center mentor.',
|
|
}),
|
|
adminNote: t.relation('adminNote', {
|
|
description: 'The admin note of the center mentor.',
|
|
}),
|
|
}),
|
|
});
|
|
}
|
|
|
|
@Pothos()
|
|
init(): void {
|
|
this.builder.queryFields((t) => ({
|
|
centerMentor: t.prismaField({
|
|
description:
|
|
'Retrieve a list of center mentors with optional filtering, ordering, and pagination.',
|
|
type: [this.centerMentor()],
|
|
args: this.builder.generator.findManyArgs('CenterMentor'),
|
|
resolve: async (query, root, args) => {
|
|
return await this.prisma.centerMentor.findMany({
|
|
...query,
|
|
skip: args.skip ?? undefined,
|
|
take: args.take ?? undefined,
|
|
orderBy: args.orderBy ?? undefined,
|
|
where: args.filter ?? undefined,
|
|
});
|
|
},
|
|
}),
|
|
}));
|
|
|
|
// mutations
|
|
this.builder.mutationFields((t) => ({
|
|
createCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
description: 'Create a new center mentor.',
|
|
args: {
|
|
data: t.arg({
|
|
type: this.builder.generator.getCreateInput('CenterMentor'),
|
|
required: true,
|
|
}),
|
|
},
|
|
resolve: async (query, root, args) => {
|
|
return await this.prisma.centerMentor.create({
|
|
...query,
|
|
data: args.data,
|
|
});
|
|
},
|
|
}),
|
|
|
|
updateCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
description: 'Update an existing center mentor.',
|
|
args: {
|
|
where: t.arg({
|
|
type: this.builder.generator.getWhereUnique('CenterMentor'),
|
|
required: true,
|
|
}),
|
|
data: t.arg({
|
|
type: this.builder.generator.getUpdateInput('CenterMentor'),
|
|
required: true,
|
|
}),
|
|
},
|
|
resolve: async (query, root, args) => {
|
|
return await this.prisma.centerMentor.update({
|
|
...query,
|
|
where: args.where,
|
|
data: args.data,
|
|
});
|
|
},
|
|
}),
|
|
|
|
deleteCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
description: 'Delete an existing center mentor.',
|
|
args: {
|
|
where: t.arg({
|
|
type: this.builder.generator.getWhereUnique('CenterMentor'),
|
|
required: true,
|
|
}),
|
|
},
|
|
resolve: async (query, root, args) => {
|
|
return await this.prisma.centerMentor.delete({
|
|
...query,
|
|
where: args.where,
|
|
});
|
|
},
|
|
}),
|
|
inviteCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
description: 'Invite a new center mentor.',
|
|
args: {
|
|
email: t.arg({ type: 'String', required: true }),
|
|
},
|
|
resolve: async (query, root, args, ctx) => {
|
|
return this.prisma.$transaction(async (prisma) => {
|
|
// get centerId by user id from context
|
|
const userId = ctx.me.id;
|
|
if (!userId) {
|
|
throw new Error('User ID is required');
|
|
}
|
|
// get centerId by user id
|
|
const center = await prisma.center.findUnique({
|
|
where: { centerOwnerId: userId },
|
|
});
|
|
if (!center) {
|
|
throw new Error('Center not found');
|
|
}
|
|
// build signature
|
|
const token = this.jwtUtils.signTokenRS256(
|
|
{ centerId: center.id, email: args.email },
|
|
'1d',
|
|
);
|
|
// build invite url
|
|
const inviteUrl = `${process.env.CENTER_BASE_URL}/invite?token=${token}`;
|
|
// mail to user with params centerId, email
|
|
await this.mailService.sendTemplateEmail(
|
|
args.email,
|
|
'Invite to center',
|
|
'MentorInvitation',
|
|
{
|
|
center_name: center.name,
|
|
invite_url: inviteUrl,
|
|
},
|
|
);
|
|
return null;
|
|
});
|
|
},
|
|
}),
|
|
testInviteCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
args: {
|
|
email: t.arg({ type: 'String', required: true }),
|
|
centerId: t.arg({ type: 'String', required: true }),
|
|
},
|
|
description: 'Test invite center mentor.',
|
|
resolve: async (query, root, args) => {
|
|
return this.prisma.$transaction(async () => {
|
|
// sign token
|
|
const token = this.jwtUtils.signTokenRS256(
|
|
{ centerId: args.centerId, email: args.email },
|
|
'1d',
|
|
);
|
|
// build invite url
|
|
const inviteUrl = `${process.env.CENTER_BASE_URL}/invite?token=${token}`;
|
|
// mail to user with params centerId, email
|
|
await this.mailService.sendTemplateEmail(
|
|
args.email,
|
|
'Invite to center',
|
|
'MentorInvitation',
|
|
{
|
|
center_name: args.centerId,
|
|
invite_url: inviteUrl,
|
|
},
|
|
);
|
|
return null;
|
|
});
|
|
},
|
|
}),
|
|
approveOrRejectCenterMentor: t.prismaField({
|
|
type: this.centerMentor(),
|
|
description: 'Approve or reject a center mentor.',
|
|
args: {
|
|
where: t.arg({
|
|
type: this.builder.generator.getWhereUnique('User'),
|
|
required: true,
|
|
}),
|
|
approved: t.arg({ type: 'Boolean', required: true }),
|
|
adminNote: t.arg({ type: 'String', required: false }),
|
|
},
|
|
resolve: async (query, root, args, ctx, info) => {
|
|
return this.prisma.$transaction(async (prisma) => {
|
|
// validate input
|
|
if (args.approved && !args.adminNote) {
|
|
throw new Error('Admin note is required');
|
|
}
|
|
// get mentor info
|
|
const mentor = await prisma.user.findUnique({
|
|
where: args.where,
|
|
});
|
|
if (!mentor) {
|
|
throw new Error('Mentor not found');
|
|
}
|
|
// get centerMentor
|
|
const centerMentor = await prisma.centerMentor.findUnique({
|
|
where: { mentorId: mentor.id },
|
|
});
|
|
if (!centerMentor) {
|
|
throw new Error('Center mentor not found');
|
|
}
|
|
// get center
|
|
const center = await prisma.center.findUnique({
|
|
where: { id: centerMentor.centerId },
|
|
});
|
|
if (!center) {
|
|
throw new Error('Center not found');
|
|
}
|
|
// get email
|
|
const email = await prisma.user.findUnique({
|
|
where: args.where,
|
|
select: { email: true },
|
|
});
|
|
if (!email) {
|
|
throw new Error('Email is required');
|
|
}
|
|
// if approved, update role to mentor
|
|
if (args.approved) {
|
|
// send mail to user
|
|
await this.mailService.sendTemplateEmail(
|
|
email.email,
|
|
'Thông báo về việc được chấp nhận làm mentor',
|
|
'MentorApproved',
|
|
{
|
|
CENTER_NAME: center.name,
|
|
USER_NAME: mentor.name,
|
|
},
|
|
);
|
|
// create adminNote
|
|
const adminNote = await prisma.adminNote.create({
|
|
data: {
|
|
content: args.adminNote ?? '',
|
|
mentorId: mentor.id,
|
|
notedByUserId: ctx.me.id,
|
|
},
|
|
});
|
|
const updatedUser = await prisma.user.update({
|
|
where: args.where,
|
|
data: {
|
|
role: 'CENTER_MENTOR',
|
|
updatedAt: new Date(),
|
|
},
|
|
});
|
|
// update centerMentor
|
|
const updatedCenterMentor = await prisma.centerMentor.update({
|
|
where: {
|
|
mentorId_centerId: {
|
|
mentorId: mentor.id,
|
|
centerId: centerMentor.centerId,
|
|
},
|
|
},
|
|
data: {
|
|
adminNote: { connect: { id: adminNote.id } },
|
|
},
|
|
});
|
|
return updatedCenterMentor;
|
|
}
|
|
// if rejected, update adminNote
|
|
await this.mailService.sendTemplateEmail(
|
|
email.email,
|
|
'Thông báo về việc không được chấp nhận làm mentor',
|
|
'MentorRejected',
|
|
{
|
|
CENTER_NAME: center.name,
|
|
USER_NAME: mentor.name,
|
|
},
|
|
);
|
|
return await prisma.centerMentor.update({
|
|
where: {
|
|
mentorId_centerId: {
|
|
mentorId: mentor.id,
|
|
centerId: centerMentor.centerId,
|
|
},
|
|
},
|
|
data: {
|
|
adminNote: {
|
|
create: {
|
|
content: args.adminNote ?? '',
|
|
notedByUserId: ctx.me.id,
|
|
updatedAt: new Date(),
|
|
},
|
|
},
|
|
},
|
|
});
|
|
});
|
|
},
|
|
}),
|
|
}));
|
|
}
|
|
}
|