504 lines
17 KiB
TypeScript
504 lines
17 KiB
TypeScript
import { getErrorMessage } from "@bff/core/utils/error.util";
|
|
import { normalizeAndValidateEmail, validateUuidV4OrThrow } from "@bff/core/utils/validation.util";
|
|
import type { UpdateAddressRequest } from "@customer-portal/domain";
|
|
import { Injectable, Inject, NotFoundException, BadRequestException } from "@nestjs/common";
|
|
import { Logger } from "nestjs-pino";
|
|
import { PrismaService } from "@bff/infra/database/prisma.service";
|
|
import { User, Activity, Address, type AuthenticatedUser } from "@customer-portal/domain";
|
|
import type { Subscription, Invoice } from "@customer-portal/domain";
|
|
import type { User as PrismaUser } from "@prisma/client";
|
|
import { WhmcsService } from "@bff/integrations/whmcs/whmcs.service";
|
|
import { SalesforceService } from "@bff/integrations/salesforce/salesforce.service";
|
|
|
|
import { MappingsService } from "@bff/modules/id-mappings/mappings.service";
|
|
import { mapPrismaUserToUserProfile } from "@bff/infra/utils/user-mapper.util";
|
|
|
|
// Use a subset of PrismaUser for updates
|
|
type UserUpdateData = Partial<
|
|
Pick<
|
|
PrismaUser,
|
|
| "firstName"
|
|
| "lastName"
|
|
| "company"
|
|
| "phone"
|
|
| "passwordHash"
|
|
| "failedLoginAttempts"
|
|
| "lastLoginAt"
|
|
| "lockedUntil"
|
|
>
|
|
>;
|
|
|
|
@Injectable()
|
|
export class UsersService {
|
|
constructor(
|
|
private prisma: PrismaService,
|
|
private whmcsService: WhmcsService,
|
|
private salesforceService: SalesforceService,
|
|
private mappingsService: MappingsService,
|
|
@Inject(Logger) private readonly logger: Logger
|
|
) {}
|
|
|
|
// Helper function to convert Prisma user to domain User type
|
|
private toDomainUser(user: PrismaUser): User {
|
|
return {
|
|
id: user.id,
|
|
email: user.email,
|
|
firstName: user.firstName || undefined,
|
|
lastName: user.lastName || undefined,
|
|
company: user.company || undefined,
|
|
phone: user.phone || undefined,
|
|
mfaEnabled: user.mfaSecret !== null,
|
|
emailVerified: user.emailVerified,
|
|
createdAt: user.createdAt.toISOString(),
|
|
updatedAt: user.updatedAt.toISOString(),
|
|
};
|
|
}
|
|
|
|
private validateEmail(email: string): string {
|
|
return normalizeAndValidateEmail(email);
|
|
}
|
|
|
|
private validateUserId(id: string): string {
|
|
return validateUuidV4OrThrow(id);
|
|
}
|
|
|
|
async findByEmail(email: string): Promise<User | null> {
|
|
const validEmail = this.validateEmail(email);
|
|
|
|
try {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { email: validEmail },
|
|
});
|
|
return user ? this.toDomainUser(user) : null;
|
|
} catch (error) {
|
|
this.logger.error("Failed to find user by email", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to find user");
|
|
}
|
|
}
|
|
|
|
// Internal method for auth service - returns raw user with sensitive fields
|
|
async findByEmailInternal(email: string): Promise<PrismaUser | null> {
|
|
const validEmail = this.validateEmail(email);
|
|
|
|
try {
|
|
return await this.prisma.user.findUnique({
|
|
where: { email: validEmail },
|
|
});
|
|
} catch (error) {
|
|
this.logger.error("Failed to find user by email (internal)", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to find user");
|
|
}
|
|
}
|
|
|
|
// Internal method for auth service - returns raw user by ID with sensitive fields
|
|
async findByIdInternal(id: string): Promise<PrismaUser | null> {
|
|
const validId = this.validateUserId(id);
|
|
|
|
try {
|
|
return await this.prisma.user.findUnique({ where: { id: validId } });
|
|
} catch (error) {
|
|
this.logger.error("Failed to find user by ID (internal)", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to find user");
|
|
}
|
|
}
|
|
|
|
async findById(id: string): Promise<AuthenticatedUser | null> {
|
|
const validId = this.validateUserId(id);
|
|
|
|
try {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: validId },
|
|
});
|
|
if (!user) return null;
|
|
|
|
// Enhance profile (prefer WHMCS values), fallback to basic user data
|
|
try {
|
|
return await this.getEnhancedProfile(validId);
|
|
} catch (error) {
|
|
this.logger.warn("Failed to enhance profile, returning basic user data", {
|
|
error: getErrorMessage(error),
|
|
userId: validId,
|
|
});
|
|
return mapPrismaUserToUserProfile(user);
|
|
}
|
|
} catch (error) {
|
|
this.logger.error("Failed to find user by ID", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to find user");
|
|
}
|
|
}
|
|
|
|
async getEnhancedProfile(userId: string): Promise<AuthenticatedUser> {
|
|
const user = await this.prisma.user.findUnique({ where: { id: userId } });
|
|
if (!user) throw new Error("User not found");
|
|
|
|
const mapping = await this.mappingsService.findByUserId(userId);
|
|
|
|
// Start with portal DB values
|
|
let firstName: string | undefined = user.firstName || undefined;
|
|
let lastName: string | undefined = user.lastName || undefined;
|
|
let company: string | undefined = user.company || undefined;
|
|
let phone: string | undefined = user.phone || undefined;
|
|
let email: string = user.email;
|
|
|
|
// Prefer WHMCS client details for profile (including email)
|
|
if (mapping?.whmcsClientId) {
|
|
try {
|
|
const client = await this.whmcsService.getClientDetails(mapping.whmcsClientId);
|
|
if (client) {
|
|
firstName = client.firstname || firstName;
|
|
lastName = client.lastname || lastName;
|
|
company = client.companyname || company;
|
|
phone = client.phonenumber || phone;
|
|
email = client.email || email;
|
|
}
|
|
} catch (err) {
|
|
this.logger.warn("WHMCS client details unavailable for profile enrichment", {
|
|
error: getErrorMessage(err),
|
|
userId,
|
|
whmcsClientId: mapping.whmcsClientId,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Check Salesforce health flag (do not override fields)
|
|
if (mapping?.sfAccountId) {
|
|
try {
|
|
await this.salesforceService.getAccount(mapping.sfAccountId);
|
|
} catch (error) {
|
|
this.logger.error("Failed to fetch Salesforce account data", {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
sfAccountId: mapping.sfAccountId,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Create enhanced user object with Salesforce data
|
|
const enhancedUser: PrismaUser = {
|
|
...user,
|
|
firstName: firstName || user.firstName,
|
|
lastName: lastName || user.lastName,
|
|
company: company || user.company,
|
|
phone: phone || user.phone,
|
|
email: email || user.email,
|
|
};
|
|
|
|
return mapPrismaUserToUserProfile(enhancedUser);
|
|
}
|
|
|
|
async create(userData: Partial<PrismaUser>): Promise<User> {
|
|
const validEmail = this.validateEmail(userData.email!);
|
|
|
|
try {
|
|
const normalizedData = { ...userData, email: validEmail };
|
|
const createdUser = await this.prisma.user.create({
|
|
data: normalizedData,
|
|
});
|
|
return this.toDomainUser(createdUser);
|
|
} catch (error) {
|
|
this.logger.error("Failed to create user", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to create user");
|
|
}
|
|
}
|
|
|
|
async update(id: string, userData: UserUpdateData): Promise<User> {
|
|
const validId = this.validateUserId(id);
|
|
const sanitizedData = this.sanitizeUserData(userData);
|
|
|
|
try {
|
|
const updatedUser = await this.prisma.user.update({
|
|
where: { id: validId },
|
|
data: sanitizedData,
|
|
});
|
|
|
|
// Do not mutate Salesforce Account from the portal. Salesforce remains authoritative.
|
|
|
|
return this.toDomainUser(updatedUser);
|
|
} catch (error) {
|
|
this.logger.error("Failed to update user", {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error("Failed to update user");
|
|
}
|
|
}
|
|
|
|
private sanitizeUserData(userData: UserUpdateData): Partial<PrismaUser> {
|
|
const sanitized: Partial<PrismaUser> = {};
|
|
if (userData.firstName !== undefined)
|
|
sanitized.firstName = userData.firstName?.trim().substring(0, 50) || null;
|
|
if (userData.lastName !== undefined)
|
|
sanitized.lastName = userData.lastName?.trim().substring(0, 50) || null;
|
|
if (userData.company !== undefined)
|
|
sanitized.company = userData.company?.trim().substring(0, 100) || null;
|
|
if (userData.phone !== undefined)
|
|
sanitized.phone = userData.phone?.trim().substring(0, 20) || null;
|
|
|
|
// Handle authentication-related fields
|
|
if (userData.passwordHash !== undefined) sanitized.passwordHash = userData.passwordHash;
|
|
if (userData.failedLoginAttempts !== undefined)
|
|
sanitized.failedLoginAttempts = userData.failedLoginAttempts;
|
|
if (userData.lastLoginAt !== undefined) sanitized.lastLoginAt = userData.lastLoginAt;
|
|
if (userData.lockedUntil !== undefined) sanitized.lockedUntil = userData.lockedUntil;
|
|
|
|
return sanitized;
|
|
}
|
|
|
|
async getUserSummary(userId: string) {
|
|
try {
|
|
// Verify user exists
|
|
const user = await this.prisma.user.findUnique({ where: { id: userId } });
|
|
if (!user) {
|
|
throw new Error("User not found");
|
|
}
|
|
|
|
// Check if user has WHMCS mapping
|
|
const mapping = await this.mappingsService.findByUserId(userId);
|
|
if (!mapping?.whmcsClientId) {
|
|
this.logger.warn(`No WHMCS mapping found for user ${userId}`);
|
|
return {
|
|
stats: {
|
|
activeSubscriptions: 0,
|
|
unpaidInvoices: 0,
|
|
openCases: 0,
|
|
currency: "JPY",
|
|
},
|
|
nextInvoice: null,
|
|
recentActivity: [],
|
|
};
|
|
}
|
|
|
|
// Fetch live data from WHMCS in parallel
|
|
const [subscriptionsData, invoicesData] = await Promise.allSettled([
|
|
this.whmcsService.getSubscriptions(mapping.whmcsClientId, userId),
|
|
this.whmcsService.getInvoices(mapping.whmcsClientId, userId, {
|
|
limit: 50,
|
|
}),
|
|
]);
|
|
|
|
// Process subscriptions
|
|
let activeSubscriptions = 0;
|
|
let recentSubscriptions: Array<{
|
|
id: string;
|
|
status: string;
|
|
registrationDate: string;
|
|
productName: string;
|
|
}> = [];
|
|
if (subscriptionsData.status === "fulfilled") {
|
|
const subscriptions: Subscription[] = subscriptionsData.value.subscriptions;
|
|
activeSubscriptions = subscriptions.filter(
|
|
(sub: Subscription) => sub.status === "Active"
|
|
).length;
|
|
recentSubscriptions = subscriptions
|
|
.filter((sub: Subscription) => sub.status === "Active")
|
|
.sort((a: Subscription, b: Subscription) => {
|
|
const aTime = a.registrationDate
|
|
? new Date(a.registrationDate).getTime()
|
|
: Number.NEGATIVE_INFINITY;
|
|
const bTime = b.registrationDate
|
|
? new Date(b.registrationDate).getTime()
|
|
: Number.NEGATIVE_INFINITY;
|
|
return bTime - aTime;
|
|
})
|
|
.slice(0, 3)
|
|
.map((sub: Subscription) => ({
|
|
id: sub.id.toString(),
|
|
status: sub.status,
|
|
registrationDate: sub.registrationDate,
|
|
productName: sub.productName,
|
|
}));
|
|
} else {
|
|
this.logger.error(
|
|
`Failed to fetch subscriptions for user ${userId}:`,
|
|
subscriptionsData.reason
|
|
);
|
|
}
|
|
|
|
// Process invoices
|
|
let unpaidInvoices = 0;
|
|
let nextInvoice = null;
|
|
let recentInvoices: Array<{
|
|
id: string;
|
|
status: string;
|
|
dueDate?: string;
|
|
total: number;
|
|
number: string;
|
|
issuedAt?: string;
|
|
paidDate?: string;
|
|
}> = [];
|
|
if (invoicesData.status === "fulfilled") {
|
|
const invoices: Invoice[] = invoicesData.value.invoices;
|
|
|
|
// Count unpaid invoices
|
|
unpaidInvoices = invoices.filter(
|
|
(inv: Invoice) => inv.status === "Unpaid" || inv.status === "Overdue"
|
|
).length;
|
|
|
|
// Find next due invoice
|
|
const upcomingInvoices = invoices
|
|
.filter(
|
|
(inv: Invoice) => (inv.status === "Unpaid" || inv.status === "Overdue") && inv.dueDate
|
|
)
|
|
.sort((a: Invoice, b: Invoice) => {
|
|
const aTime = a.dueDate ? new Date(a.dueDate).getTime() : Number.POSITIVE_INFINITY;
|
|
const bTime = b.dueDate ? new Date(b.dueDate).getTime() : Number.POSITIVE_INFINITY;
|
|
return aTime - bTime;
|
|
});
|
|
|
|
if (upcomingInvoices.length > 0) {
|
|
const invoice = upcomingInvoices[0];
|
|
nextInvoice = {
|
|
id: invoice.id.toString(),
|
|
dueDate: invoice.dueDate,
|
|
amount: invoice.total,
|
|
currency: "JPY",
|
|
};
|
|
}
|
|
|
|
// Recent invoices for activity
|
|
recentInvoices = invoices
|
|
.sort((a: Invoice, b: Invoice) => {
|
|
const aTime = a.issuedAt ? new Date(a.issuedAt).getTime() : Number.NEGATIVE_INFINITY;
|
|
const bTime = b.issuedAt ? new Date(b.issuedAt).getTime() : Number.NEGATIVE_INFINITY;
|
|
return bTime - aTime;
|
|
})
|
|
.slice(0, 5)
|
|
.map((inv: Invoice) => ({
|
|
id: inv.id.toString(),
|
|
status: inv.status,
|
|
dueDate: inv.dueDate,
|
|
total: inv.total,
|
|
number: inv.number,
|
|
issuedAt: inv.issuedAt,
|
|
}));
|
|
} else {
|
|
this.logger.error(`Failed to fetch invoices for user ${userId}`, {
|
|
reason: getErrorMessage(invoicesData.reason),
|
|
});
|
|
}
|
|
|
|
// Build activity feed
|
|
const activities: Activity[] = [];
|
|
|
|
// Add invoice activities
|
|
recentInvoices.forEach(invoice => {
|
|
if (invoice.status === "Paid") {
|
|
activities.push({
|
|
id: `invoice-paid-${invoice.id}`,
|
|
type: "invoice_paid",
|
|
title: `Invoice #${invoice.number} paid`,
|
|
description: `Payment of ¥${invoice.total.toLocaleString()} processed`,
|
|
date: invoice.paidDate || invoice.issuedAt || new Date().toISOString(),
|
|
relatedId: Number(invoice.id),
|
|
});
|
|
} else if (invoice.status === "Unpaid" || invoice.status === "Overdue") {
|
|
activities.push({
|
|
id: `invoice-created-${invoice.id}`,
|
|
type: "invoice_created",
|
|
title: `Invoice #${invoice.number} created`,
|
|
description: `Amount: ¥${invoice.total.toLocaleString()}`,
|
|
date: invoice.issuedAt || new Date().toISOString(),
|
|
relatedId: Number(invoice.id),
|
|
});
|
|
}
|
|
});
|
|
|
|
// Add subscription activities
|
|
recentSubscriptions.forEach(subscription => {
|
|
activities.push({
|
|
id: `service-activated-${subscription.id}`,
|
|
type: "service_activated",
|
|
title: `${subscription.productName} activated`,
|
|
description: "Service successfully provisioned",
|
|
date: subscription.registrationDate,
|
|
relatedId: Number(subscription.id),
|
|
});
|
|
});
|
|
|
|
// Sort activities by date and take top 10
|
|
activities.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
|
|
const recentActivity = activities.slice(0, 10);
|
|
|
|
this.logger.log(`Generated dashboard summary for user ${userId}`, {
|
|
activeSubscriptions,
|
|
unpaidInvoices,
|
|
activitiesCount: recentActivity.length,
|
|
hasNextInvoice: !!nextInvoice,
|
|
});
|
|
|
|
return {
|
|
stats: {
|
|
activeSubscriptions,
|
|
unpaidInvoices,
|
|
openCases: 0, // TODO: Implement support cases when ready
|
|
currency: "JPY",
|
|
},
|
|
nextInvoice,
|
|
recentActivity,
|
|
};
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get user summary for ${userId}`, {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error(`Failed to retrieve dashboard data: ${getErrorMessage(error)}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get address information from WHMCS (authoritative source)
|
|
*/
|
|
async getAddress(userId: string): Promise<Address> {
|
|
try {
|
|
const mapping = await this.mappingsService.findByUserId(userId);
|
|
if (!mapping) {
|
|
throw new NotFoundException("User mapping not found");
|
|
}
|
|
|
|
// Delegate to vendor service
|
|
return await this.whmcsService.getClientAddress(mapping.whmcsClientId);
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get address for ${userId}`, {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw new Error(`Failed to retrieve address: ${getErrorMessage(error)}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update address in WHMCS (authoritative for client record address fields)
|
|
*/
|
|
async updateAddress(userId: string, address: UpdateAddressRequest): Promise<void> {
|
|
try {
|
|
const mapping = await this.mappingsService.findByUserId(userId);
|
|
if (!mapping) {
|
|
throw new NotFoundException("User mapping not found");
|
|
}
|
|
|
|
await this.whmcsService.updateClientAddress(mapping.whmcsClientId, address);
|
|
this.logger.log({ userId }, "Successfully updated address in WHMCS");
|
|
} catch (error) {
|
|
const msg = getErrorMessage(error);
|
|
this.logger.error({ userId, error: msg }, "Failed to update address in WHMCS");
|
|
if (msg.includes("WHMCS API Error")) {
|
|
throw new BadRequestException(msg.replace("WHMCS API Error: ", ""));
|
|
}
|
|
if (msg.includes("HTTP ")) {
|
|
throw new BadRequestException("Upstream WHMCS error. Please try again.");
|
|
}
|
|
if (msg.includes("Missing required WHMCS configuration")) {
|
|
throw new BadRequestException("Billing system not configured. Please contact support.");
|
|
}
|
|
throw new BadRequestException("Unable to update address.");
|
|
}
|
|
}
|
|
}
|