836 lines
25 KiB
TypeScript
836 lines
25 KiB
TypeScript
import { Injectable, BadRequestException, NotFoundException, ForbiddenException } from '@nestjs/common';
|
|
import { UserStatus, UserRole, Prisma, VerificationStatus } from '@prisma/client';
|
|
import { PrismaService } from '../prisma/prisma.service';
|
|
import { EventEmitter2 } from '@nestjs/event-emitter';
|
|
import * as argon2 from 'argon2';
|
|
|
|
type UserWithProfiles = Prisma.UserGetPayload<{
|
|
include: { userProfile: true; agentProfile: { include: { agentType: true } } };
|
|
}>;
|
|
|
|
@Injectable()
|
|
export class UsersService {
|
|
constructor(
|
|
private readonly prisma: PrismaService,
|
|
private readonly eventEmitter: EventEmitter2,
|
|
) {}
|
|
|
|
// =============================================
|
|
// USER PROFILE METHODS (for regular users)
|
|
// =============================================
|
|
|
|
async getMyUserProfile(userId: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { userProfile: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.USER) {
|
|
throw new BadRequestException('This endpoint is for regular users only');
|
|
}
|
|
|
|
// Create user profile if it doesn't exist
|
|
let profile = user.userProfile;
|
|
if (!profile) {
|
|
profile = await this.prisma.userProfile.create({
|
|
data: {
|
|
userId: user.id,
|
|
},
|
|
});
|
|
}
|
|
|
|
return {
|
|
id: profile.id,
|
|
userId: user.id,
|
|
email: user.email,
|
|
firstName: profile.firstName,
|
|
lastName: profile.lastName,
|
|
phone: profile.phone,
|
|
avatar: profile.avatar,
|
|
city: profile.city,
|
|
state: profile.state,
|
|
country: profile.country,
|
|
createdAt: profile.createdAt,
|
|
updatedAt: profile.updatedAt,
|
|
};
|
|
}
|
|
|
|
async updateMyUserProfile(
|
|
userId: string,
|
|
data: {
|
|
firstName?: string;
|
|
lastName?: string;
|
|
phone?: string;
|
|
avatar?: string | null;
|
|
city?: string;
|
|
state?: string;
|
|
country?: string;
|
|
},
|
|
) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { userProfile: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.USER) {
|
|
throw new BadRequestException('This endpoint is for regular users only');
|
|
}
|
|
|
|
// Create or update user profile
|
|
const profile = await this.prisma.userProfile.upsert({
|
|
where: { userId },
|
|
create: {
|
|
userId,
|
|
...data,
|
|
},
|
|
update: data,
|
|
});
|
|
|
|
return {
|
|
id: profile.id,
|
|
userId: user.id,
|
|
email: user.email,
|
|
firstName: profile.firstName,
|
|
lastName: profile.lastName,
|
|
phone: profile.phone,
|
|
avatar: profile.avatar,
|
|
city: profile.city,
|
|
state: profile.state,
|
|
country: profile.country,
|
|
createdAt: profile.createdAt,
|
|
updatedAt: profile.updatedAt,
|
|
};
|
|
}
|
|
|
|
// =============================================
|
|
// ADMIN METHODS
|
|
// =============================================
|
|
|
|
async findAll(page = 1, limit = 10, role?: UserRole, search?: string, verificationStatus?: string) {
|
|
const skip = (page - 1) * limit;
|
|
|
|
// Build where clause
|
|
const where: Prisma.UserWhereInput = {};
|
|
if (role) where.role = role;
|
|
if (search) {
|
|
const searchParts = search.trim().split(/\s+/).filter(Boolean);
|
|
|
|
if (searchParts.length > 1) {
|
|
// Multi-word search (e.g. "Sophie Brown") — match across firstName + lastName
|
|
where.OR = [
|
|
// Match all parts across firstName/lastName for userProfile
|
|
{
|
|
userProfile: {
|
|
AND: searchParts.map((part) => ({
|
|
OR: [
|
|
{ firstName: { contains: part, mode: 'insensitive' as const } },
|
|
{ lastName: { contains: part, mode: 'insensitive' as const } },
|
|
],
|
|
})),
|
|
},
|
|
},
|
|
// Match all parts across firstName/lastName for agentProfile
|
|
{
|
|
agentProfile: {
|
|
AND: searchParts.map((part) => ({
|
|
OR: [
|
|
{ firstName: { contains: part, mode: 'insensitive' as const } },
|
|
{ lastName: { contains: part, mode: 'insensitive' as const } },
|
|
],
|
|
})),
|
|
},
|
|
},
|
|
// Also match the full search string against email
|
|
{ email: { contains: search, mode: 'insensitive' } },
|
|
];
|
|
} else {
|
|
// Single word — match against any field
|
|
where.OR = [
|
|
{ email: { contains: search, mode: 'insensitive' } },
|
|
{ userProfile: { firstName: { contains: search, mode: 'insensitive' } } },
|
|
{ userProfile: { lastName: { contains: search, mode: 'insensitive' } } },
|
|
{ agentProfile: { firstName: { contains: search, mode: 'insensitive' } } },
|
|
{ agentProfile: { lastName: { contains: search, mode: 'insensitive' } } },
|
|
];
|
|
}
|
|
}
|
|
if (verificationStatus) {
|
|
where.agentProfile = { ...((where.agentProfile as object) || {}), verificationStatus: verificationStatus as any };
|
|
}
|
|
|
|
const [users, total] = await Promise.all([
|
|
this.prisma.user.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { createdAt: 'desc' },
|
|
include: {
|
|
userProfile: true,
|
|
agentProfile: {
|
|
include: {
|
|
agentType: true,
|
|
},
|
|
},
|
|
},
|
|
}) as Promise<UserWithProfiles[]>,
|
|
this.prisma.user.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
users: users.map((user) => {
|
|
// Get the appropriate profile based on role
|
|
const profile = user.role === UserRole.AGENT ? user.agentProfile : user.userProfile;
|
|
|
|
return {
|
|
id: user.id,
|
|
email: user.email,
|
|
role: user.role,
|
|
status: user.status,
|
|
emailVerified: user.emailVerified,
|
|
authProvider: user.authProvider,
|
|
createdAt: user.createdAt,
|
|
lastLoginAt: user.lastLoginAt,
|
|
profile: profile
|
|
? {
|
|
firstName: profile.firstName,
|
|
lastName: profile.lastName,
|
|
avatar: profile.avatar,
|
|
phone: profile.phone,
|
|
city: profile.city,
|
|
state: profile.state,
|
|
country: profile.country,
|
|
}
|
|
: null,
|
|
agentProfile: user.agentProfile
|
|
? {
|
|
id: user.agentProfile.id,
|
|
slug: user.agentProfile.slug,
|
|
headline: user.agentProfile.headline,
|
|
bio: user.agentProfile.bio,
|
|
companyName: user.agentProfile.companyName,
|
|
licenseNumber: user.agentProfile.licenseNumber,
|
|
yearsOfExperience: user.agentProfile.yearsOfExperience,
|
|
isProfileComplete: user.agentProfile.isProfileComplete,
|
|
profileCompleteness: user.agentProfile.profileCompleteness,
|
|
agentTypeId: user.agentProfile.agentTypeId,
|
|
agentType: user.agentProfile.agentType,
|
|
isVerified: user.agentProfile.isVerified,
|
|
verificationStatus: user.agentProfile.verificationStatus,
|
|
verificationNote: user.agentProfile.verificationNote,
|
|
averageRating: user.agentProfile.averageRating,
|
|
totalReviews: user.agentProfile.totalReviews,
|
|
}
|
|
: null,
|
|
};
|
|
}),
|
|
total,
|
|
page,
|
|
limit,
|
|
totalPages: Math.ceil(total / limit),
|
|
};
|
|
}
|
|
|
|
async findOne(id: string) {
|
|
const user = (await this.prisma.user.findUnique({
|
|
where: { id },
|
|
include: {
|
|
userProfile: true,
|
|
agentProfile: {
|
|
include: {
|
|
agentType: true,
|
|
},
|
|
},
|
|
},
|
|
})) as UserWithProfiles | null;
|
|
|
|
if (!user) {
|
|
return null;
|
|
}
|
|
|
|
// Base user data
|
|
const baseData = {
|
|
id: user.id,
|
|
email: user.email,
|
|
role: user.role,
|
|
status: user.status,
|
|
emailVerified: user.emailVerified,
|
|
emailVerifiedAt: user.emailVerifiedAt,
|
|
authProvider: user.authProvider,
|
|
createdAt: user.createdAt,
|
|
lastLoginAt: user.lastLoginAt,
|
|
};
|
|
|
|
// For agents, return full agent profile
|
|
if (user.role === UserRole.AGENT && user.agentProfile) {
|
|
return {
|
|
...baseData,
|
|
profile: {
|
|
firstName: user.agentProfile.firstName,
|
|
lastName: user.agentProfile.lastName,
|
|
avatar: user.agentProfile.avatar,
|
|
phone: user.agentProfile.phone,
|
|
city: user.agentProfile.city,
|
|
state: user.agentProfile.state,
|
|
country: user.agentProfile.country,
|
|
},
|
|
agentProfile: {
|
|
id: user.agentProfile.id,
|
|
slug: user.agentProfile.slug,
|
|
bio: user.agentProfile.bio,
|
|
headline: user.agentProfile.headline,
|
|
companyName: user.agentProfile.companyName,
|
|
licenseNumber: user.agentProfile.licenseNumber,
|
|
yearsOfExperience: user.agentProfile.yearsOfExperience,
|
|
isProfileComplete: user.agentProfile.isProfileComplete,
|
|
profileCompleteness: user.agentProfile.profileCompleteness,
|
|
agentTypeId: user.agentProfile.agentTypeId,
|
|
agentType: user.agentProfile.agentType,
|
|
// Verification fields
|
|
isVerified: user.agentProfile.isVerified,
|
|
verificationStatus: user.agentProfile.verificationStatus,
|
|
verificationNote: user.agentProfile.verificationNote,
|
|
verifiedAt: user.agentProfile.verifiedAt,
|
|
verifiedBy: user.agentProfile.verifiedBy,
|
|
},
|
|
};
|
|
}
|
|
|
|
// For regular users
|
|
return {
|
|
...baseData,
|
|
profile: user.userProfile
|
|
? {
|
|
firstName: user.userProfile.firstName,
|
|
lastName: user.userProfile.lastName,
|
|
avatar: user.userProfile.avatar,
|
|
phone: user.userProfile.phone,
|
|
city: user.userProfile.city,
|
|
state: user.userProfile.state,
|
|
country: user.userProfile.country,
|
|
}
|
|
: null,
|
|
};
|
|
}
|
|
|
|
async updateStatus(id: string, status: UserStatus) {
|
|
return this.prisma.user.update({
|
|
where: { id },
|
|
data: { status },
|
|
});
|
|
}
|
|
|
|
async updateAgentType(userId: string, agentTypeId: string) {
|
|
// Get user to verify they are an agent
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { agentProfile: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.AGENT) {
|
|
throw new BadRequestException('User is not an agent');
|
|
}
|
|
|
|
if (!user.agentProfile) {
|
|
throw new NotFoundException('Agent profile not found');
|
|
}
|
|
|
|
// Verify agent type exists
|
|
const agentType = await this.prisma.agentType.findUnique({
|
|
where: { id: agentTypeId },
|
|
});
|
|
|
|
if (!agentType) {
|
|
throw new BadRequestException('Invalid agent type');
|
|
}
|
|
|
|
// Update agent profile with new agent type
|
|
const updatedProfile = await this.prisma.agentProfile.update({
|
|
where: { id: user.agentProfile.id },
|
|
data: { agentTypeId },
|
|
include: { agentType: true },
|
|
});
|
|
|
|
return {
|
|
id: user.id,
|
|
agentTypeId: updatedProfile.agentTypeId,
|
|
agentType: updatedProfile.agentType,
|
|
message: 'Agent type updated successfully',
|
|
};
|
|
}
|
|
|
|
async getVerificationDocuments(userId: string) {
|
|
// Get user to verify they are an agent
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { agentProfile: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.AGENT) {
|
|
throw new BadRequestException('User is not an agent');
|
|
}
|
|
|
|
if (!user.agentProfile) {
|
|
throw new NotFoundException('Agent profile not found');
|
|
}
|
|
|
|
// Find the upload-documents section field
|
|
const field = await this.prisma.profileField.findFirst({
|
|
where: {
|
|
section: { slug: 'upload-documents' },
|
|
slug: 'documents',
|
|
},
|
|
});
|
|
|
|
if (!field) return [];
|
|
|
|
const fieldValue = await this.prisma.agentProfileFieldValue.findUnique({
|
|
where: {
|
|
agentProfileId_fieldId: {
|
|
agentProfileId: user.agentProfile.id,
|
|
fieldId: field.id,
|
|
},
|
|
},
|
|
});
|
|
|
|
return fieldValue?.jsonValue || [];
|
|
}
|
|
|
|
async updateVerification(
|
|
userId: string,
|
|
data: {
|
|
status: VerificationStatus;
|
|
note?: string;
|
|
},
|
|
adminId: string,
|
|
) {
|
|
// Get user to verify they are an agent
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { agentProfile: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.AGENT) {
|
|
throw new BadRequestException('User is not an agent');
|
|
}
|
|
|
|
if (!user.agentProfile) {
|
|
throw new NotFoundException('Agent profile not found');
|
|
}
|
|
|
|
const updateData: Prisma.AgentProfileUpdateInput = {
|
|
verificationStatus: data.status,
|
|
verificationNote: data.note || null,
|
|
};
|
|
|
|
if (data.status === VerificationStatus.APPROVED) {
|
|
updateData.isVerified = true;
|
|
updateData.verifiedAt = new Date();
|
|
updateData.verifiedBy = adminId;
|
|
} else if (data.status === VerificationStatus.REJECTED) {
|
|
updateData.isVerified = false;
|
|
updateData.verifiedAt = null;
|
|
updateData.verifiedBy = null;
|
|
}
|
|
|
|
const updatedProfile = await this.prisma.agentProfile.update({
|
|
where: { id: user.agentProfile.id },
|
|
data: updateData,
|
|
include: {
|
|
agentType: true,
|
|
},
|
|
});
|
|
|
|
// Save verification history with profile snapshot
|
|
const profileSnapshot = await this.captureProfileSnapshot(user.agentProfile.id);
|
|
await this.prisma.verificationHistory.create({
|
|
data: {
|
|
agentProfileId: user.agentProfile.id,
|
|
status: data.status,
|
|
note: data.note || null,
|
|
adminId,
|
|
submittedData: profileSnapshot ?? undefined,
|
|
},
|
|
});
|
|
|
|
// Emit notification to the agent
|
|
this.eventEmitter.emit('notification.verification', {
|
|
recipientUserId: userId,
|
|
status: data.status,
|
|
note: data.note,
|
|
agentName: `${updatedProfile.firstName || ''} ${updatedProfile.lastName || ''}`.trim(),
|
|
});
|
|
|
|
return {
|
|
id: user.id,
|
|
agentProfileId: updatedProfile.id,
|
|
isVerified: updatedProfile.isVerified,
|
|
verificationStatus: updatedProfile.verificationStatus,
|
|
verificationNote: updatedProfile.verificationNote,
|
|
verifiedAt: updatedProfile.verifiedAt,
|
|
verifiedBy: updatedProfile.verifiedBy,
|
|
message: `Verification ${data.status.toLowerCase()} successfully`,
|
|
};
|
|
}
|
|
|
|
// Get verification history for an agent
|
|
async getVerificationHistory(agentProfileId: string) {
|
|
return this.prisma.verificationHistory.findMany({
|
|
where: { agentProfileId },
|
|
include: {
|
|
admin: { select: { id: true, email: true } },
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
}
|
|
|
|
// Submit or resubmit for verification (agent-facing)
|
|
async submitForVerification(userId: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
include: { agentProfile: true },
|
|
});
|
|
|
|
if (!user) throw new NotFoundException('User not found');
|
|
if (user.role !== UserRole.AGENT) throw new BadRequestException('User is not an agent');
|
|
if (!user.agentProfile) throw new NotFoundException('Agent profile not found');
|
|
|
|
const currentStatus = user.agentProfile.verificationStatus;
|
|
if (currentStatus === VerificationStatus.PENDING_REVIEW) {
|
|
throw new BadRequestException('Verification is already pending review');
|
|
}
|
|
if (currentStatus === VerificationStatus.APPROVED) {
|
|
throw new BadRequestException('Profile is already verified');
|
|
}
|
|
|
|
// Capture snapshot of current profile data + documents
|
|
const profileSnapshot = await this.captureProfileSnapshot(user.agentProfile.id);
|
|
|
|
// Update status to PENDING_REVIEW
|
|
await this.prisma.agentProfile.update({
|
|
where: { id: user.agentProfile.id },
|
|
data: {
|
|
verificationStatus: VerificationStatus.PENDING_REVIEW,
|
|
verificationNote: null,
|
|
},
|
|
});
|
|
|
|
// Create history entry with submitted data snapshot
|
|
await this.prisma.verificationHistory.create({
|
|
data: {
|
|
agentProfileId: user.agentProfile.id,
|
|
status: VerificationStatus.PENDING_REVIEW,
|
|
note: currentStatus === VerificationStatus.REJECTED ? 'Resubmitted after rejection' : 'Initial submission',
|
|
submittedData: profileSnapshot ?? undefined,
|
|
},
|
|
});
|
|
|
|
return { message: 'Verification submitted successfully', status: 'PENDING_REVIEW' };
|
|
}
|
|
|
|
// Capture a snapshot of agent's profile data and documents for history
|
|
private async captureProfileSnapshot(agentProfileId: string) {
|
|
const profile = await this.prisma.agentProfile.findUnique({
|
|
where: { id: agentProfileId },
|
|
include: {
|
|
user: { select: { email: true } },
|
|
agentType: { select: { id: true, name: true } },
|
|
fieldValues: {
|
|
include: {
|
|
field: {
|
|
select: { slug: true, name: true, fieldType: true, section: { select: { slug: true, name: true } } },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!profile) return null;
|
|
|
|
// Organize field values by section
|
|
const sections: Record<string, Record<string, any>> = {};
|
|
for (const fv of profile.fieldValues) {
|
|
const sectionSlug = fv.field.section.slug;
|
|
if (!sections[sectionSlug]) {
|
|
sections[sectionSlug] = { _name: fv.field.section.name };
|
|
}
|
|
const value = fv.textValue ?? fv.numberValue ?? fv.booleanValue ?? fv.jsonValue ?? fv.dateValue;
|
|
sections[sectionSlug][fv.field.slug] = {
|
|
name: fv.field.name,
|
|
type: fv.field.fieldType,
|
|
value,
|
|
};
|
|
}
|
|
|
|
return {
|
|
firstName: profile.firstName,
|
|
lastName: profile.lastName,
|
|
email: profile.user?.email,
|
|
phone: profile.phone,
|
|
avatar: profile.avatar,
|
|
bio: profile.bio,
|
|
agentType: profile.agentType?.name,
|
|
sections,
|
|
capturedAt: new Date().toISOString(),
|
|
};
|
|
}
|
|
|
|
// Check which required fields are missing for an agent
|
|
private async getRequiredFieldsMissing(agentProfileId: string, agentTypeId: string | null) {
|
|
// Get all sections for this agent type (or global sections)
|
|
const sectionFilter: any = { isActive: true };
|
|
if (agentTypeId) {
|
|
sectionFilter.OR = [
|
|
{ isGlobal: true },
|
|
{ agentTypeSections: { some: { agentTypeId } } },
|
|
];
|
|
} else {
|
|
sectionFilter.isGlobal = true;
|
|
}
|
|
|
|
// Get all required fields from applicable sections
|
|
const requiredFields = await this.prisma.profileField.findMany({
|
|
where: {
|
|
isRequired: true,
|
|
isActive: true,
|
|
section: sectionFilter,
|
|
},
|
|
select: { id: true, name: true, slug: true, section: { select: { name: true, slug: true } } },
|
|
});
|
|
|
|
if (requiredFields.length === 0) return [];
|
|
|
|
// Get agent's filled field values
|
|
const filledValues = await this.prisma.agentProfileFieldValue.findMany({
|
|
where: {
|
|
agentProfileId,
|
|
fieldId: { in: requiredFields.map((f) => f.id) },
|
|
},
|
|
select: { fieldId: true, textValue: true, numberValue: true, booleanValue: true, jsonValue: true, dateValue: true },
|
|
});
|
|
|
|
const filledMap = new Map(filledValues.map((fv) => [fv.fieldId, fv]));
|
|
|
|
// Find missing or empty required fields
|
|
const missing: { fieldName: string; sectionName: string }[] = [];
|
|
for (const field of requiredFields) {
|
|
const value = filledMap.get(field.id);
|
|
if (!value) {
|
|
missing.push({ fieldName: field.name, sectionName: field.section.name });
|
|
continue;
|
|
}
|
|
// Check if value is actually empty
|
|
const hasValue = value.textValue || value.numberValue !== null || value.booleanValue !== null ||
|
|
(value.jsonValue && (Array.isArray(value.jsonValue) ? (value.jsonValue as any[]).length > 0 : true)) ||
|
|
value.dateValue;
|
|
if (!hasValue) {
|
|
missing.push({ fieldName: field.name, sectionName: field.section.name });
|
|
}
|
|
}
|
|
|
|
return missing;
|
|
}
|
|
|
|
// =============================================
|
|
// NOTIFICATION PREFERENCES
|
|
// =============================================
|
|
|
|
async getNotificationPreferences(userId: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
select: { notificationPreferences: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
// Return preferences or default empty object
|
|
return user.notificationPreferences || { email: {}, push: {} };
|
|
}
|
|
|
|
async updateNotificationPreferences(
|
|
userId: string,
|
|
preferences: { email?: Record<string, boolean>; push?: Record<string, boolean> },
|
|
) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
const updatedUser = await this.prisma.user.update({
|
|
where: { id: userId },
|
|
data: {
|
|
notificationPreferences: preferences,
|
|
},
|
|
select: { notificationPreferences: true },
|
|
});
|
|
|
|
return updatedUser.notificationPreferences;
|
|
}
|
|
|
|
// =============================================
|
|
// PRIVACY PREFERENCES
|
|
// =============================================
|
|
|
|
async getPrivacyPreferences(userId: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
select: { privacyPreferences: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
// Return preferences or default empty object
|
|
return user.privacyPreferences || { privacySettings: {}, dataSettings: {} };
|
|
}
|
|
|
|
async updatePrivacyPreferences(
|
|
userId: string,
|
|
preferences: {
|
|
privacySettings?: Record<string, string>;
|
|
dataSettings?: Record<string, boolean>;
|
|
},
|
|
) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
const updatedUser = await this.prisma.user.update({
|
|
where: { id: userId },
|
|
data: {
|
|
privacyPreferences: preferences,
|
|
},
|
|
select: { privacyPreferences: true },
|
|
});
|
|
|
|
return updatedUser.privacyPreferences;
|
|
}
|
|
|
|
// =============================================
|
|
// DELETE ACCOUNT
|
|
// =============================================
|
|
|
|
async deleteAccount(userId: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: userId },
|
|
select: { id: true, role: true },
|
|
});
|
|
|
|
if (!user) {
|
|
throw new NotFoundException('User not found');
|
|
}
|
|
|
|
if (user.role !== UserRole.USER) {
|
|
throw new BadRequestException('This endpoint is for regular users only');
|
|
}
|
|
|
|
// Delete in a transaction to ensure data consistency
|
|
await this.prisma.$transaction(async (tx) => {
|
|
// Delete user profile if it exists
|
|
await tx.userProfile.deleteMany({
|
|
where: { userId },
|
|
});
|
|
|
|
// Delete the user account
|
|
await tx.user.delete({
|
|
where: { id: userId },
|
|
});
|
|
});
|
|
|
|
return { message: 'Account deleted successfully' };
|
|
}
|
|
|
|
// =============================================
|
|
// ADMIN MANAGEMENT (SUPER_ADMIN only)
|
|
// =============================================
|
|
|
|
async getAdminUsers() {
|
|
return this.prisma.user.findMany({
|
|
where: { role: { in: ['ADMIN', 'SUPER_ADMIN'] } },
|
|
select: {
|
|
id: true,
|
|
email: true,
|
|
role: true,
|
|
status: true,
|
|
createdAt: true,
|
|
lastLoginAt: true,
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
}
|
|
|
|
async createAdminUser(email: string, password: string) {
|
|
const existing = await this.prisma.user.findUnique({ where: { email } });
|
|
if (existing) {
|
|
throw new BadRequestException('A user with this email already exists');
|
|
}
|
|
|
|
const hashedPassword = await argon2.hash(password);
|
|
return this.prisma.user.create({
|
|
data: {
|
|
email,
|
|
password: hashedPassword,
|
|
role: 'ADMIN',
|
|
status: 'ACTIVE',
|
|
emailVerified: true,
|
|
emailVerifiedAt: new Date(),
|
|
authProvider: 'LOCAL',
|
|
},
|
|
select: {
|
|
id: true,
|
|
email: true,
|
|
role: true,
|
|
status: true,
|
|
createdAt: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
async deleteAdminUser(id: string, requesterId: string) {
|
|
if (id === requesterId) {
|
|
throw new BadRequestException('You cannot delete your own account');
|
|
}
|
|
|
|
const user = await this.prisma.user.findUnique({ where: { id } });
|
|
if (!user) throw new NotFoundException('User not found');
|
|
if (user.role === 'SUPER_ADMIN') {
|
|
throw new ForbiddenException('Cannot delete a super admin');
|
|
}
|
|
if (user.role !== 'ADMIN') {
|
|
throw new BadRequestException('This user is not an admin');
|
|
}
|
|
|
|
await this.prisma.user.delete({ where: { id } });
|
|
return null;
|
|
}
|
|
}
|