Seatmap rendering and other updates

apps/edr-passenger-api/src/modules/auth/auth.service.ts

@@ -1,4 +1,4 @@
-import { Injectable, UnauthorizedException, ConflictException, BadRequestException } from '@nestjs/common';
+import { Injectable, UnauthorizedException, ConflictException, BadRequestException, NotFoundException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { PrismaService } from '../../common/prisma.service';
 import { RegisterDto, LoginDto, RequestOtpDto, VerifyOtpDto, RequestPasswordResetDto, ResetPasswordDto } from './auth.dto';
@@ -58,7 +58,7 @@ export class AuthService {
     
     await this.prisma.user.update({
       where: { id: user.id },
-      data: { failedLoginAttempts: 0, lockedUntil: null }
+      data: { failedLoginAttempts: 0, lockedUntil: null, lastLoginAt: new Date() }
     });
     
     await this.createAuditLog(user.id, 'USER_LOGIN', 'User', user.id, null, null);
@@ -131,6 +131,174 @@ export class AuthService {
     return { reset: true };
   }
 
+  async getUsers(filters: { search?: string; role?: string; status?: string; page?: number; pageSize?: number }) {
+    const { search, role, status, page = 1, pageSize = 10 } = filters;
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {
+      role: { not: 'PASSENGER' }, // Exclude passenger accounts
+    };
+
+    if (search) {
+      where.OR = [
+        { email: { contains: search, mode: 'insensitive' } },
+        { fullName: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    if (role) {
+      where.role = role;
+    }
+
+    // For status filtering, we check if user is active (no lock/block) or inactive
+    if (status === 'ACTIVE') {
+      where.AND = [
+        { blockedUntil: { lte: new Date() } },
+        { lockedUntil: { lte: new Date() } }
+      ];
+    } else if (status === 'INACTIVE') {
+      where.OR = [
+        { blockedUntil: { gt: new Date() } },
+        { lockedUntil: { gt: new Date() } }
+      ];
+    }
+
+    const [items, total] = await Promise.all([
+      this.prisma.user.findMany({
+        where,
+        select: {
+          id: true,
+          email: true,
+          fullName: true,
+          role: true,
+          lastLoginAt: true,
+          createdAt: true,
+          blockedUntil: true,
+          lockedUntil: true,
+        },
+        skip,
+        take: pageSize,
+        orderBy: { createdAt: 'desc' },
+      }),
+      this.prisma.user.count({ where }),
+    ]);
+
+    return {
+      items: items.map(user => ({
+        id: user.id,
+        email: user.email,
+        fullName: user.fullName,
+        role: user.role,
+        lastLogin: user.lastLoginAt,
+        status: (!user.blockedUntil || user.blockedUntil <= new Date()) &&
+                (!user.lockedUntil || user.lockedUntil <= new Date()) 
+          ? 'ACTIVE' 
+          : 'INACTIVE',
+      })),
+      total,
+      page,
+      pageSize,
+    };
+  }
+
+  async createUser(dto: { email: string; fullName: string; role: string; status?: string; password?: string }) {
+    const exists = await this.prisma.user.findFirst({
+      where: { OR: [{ email: dto.email }] },
+    });
+    if (exists) throw new ConflictException('Email already registered');
+
+    const passwordHash = await bcrypt.hash(dto.password || 'TempPassword123!', 10);
+    
+    const user = await this.prisma.user.create({
+      data: {
+        email: dto.email,
+        fullName: dto.fullName,
+        role: dto.role as any,
+        phone: dto.email, // Use email as phone temporarily for unique constraint
+        passwordHash,
+        blockedUntil: dto.status === 'INACTIVE' ? new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) : undefined,
+      },
+      select: {
+        id: true,
+        email: true,
+        fullName: true,
+        role: true,
+        lastLoginAt: true,
+        createdAt: true,
+      },
+    });
+
+    await this.createAuditLog(user.id, 'USER_CREATED', 'User', user.id, null, { email: user.email, role: dto.role });
+
+    return user;
+  }
+
+  async updateUser(id: string, dto: Partial<{ email: string; fullName: string; role: string; status: string }>) {
+    const user = await this.prisma.user.findUnique({ where: { id } });
+    if (!user) throw new NotFoundException('User not found');
+
+    const updateData: any = {};
+    if (dto.fullName) updateData.fullName = dto.fullName;
+    if (dto.role) updateData.role = dto.role;
+    if (dto.status === 'ACTIVE') {
+      updateData.blockedUntil = null;
+      updateData.lockedUntil = null;
+    } else if (dto.status === 'INACTIVE') {
+      updateData.blockedUntil = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000);
+    }
+
+    const updated = await this.prisma.user.update({
+      where: { id },
+      data: updateData,
+      select: {
+        id: true,
+        email: true,
+        fullName: true,
+        role: true,
+        lastLoginAt: true,
+        createdAt: true,
+      },
+    });
+
+    await this.createAuditLog(id, 'USER_UPDATED', 'User', id, { oldData: user }, { newData: updateData });
+
+    return updated;
+  }
+
+  async deleteUser(id: string) {
+    const user = await this.prisma.user.findUnique({ where: { id } });
+    if (!user) throw new NotFoundException('User not found');
+
+    // Don't actually delete, just deactivate
+    await this.prisma.user.update({
+      where: { id },
+      data: { blockedUntil: new Date(), lockedUntil: new Date() },
+    });
+
+    await this.createAuditLog(id, 'USER_DELETED', 'User', id, { email: user.email }, null);
+
+    return { deleted: true };
+  }
+
+  async resetUserPassword(id: string, tempPassword: string) {
+    const user = await this.prisma.user.findUnique({ where: { id } });
+    if (!user) throw new NotFoundException('User not found');
+
+    const passwordHash = await bcrypt.hash(tempPassword, 10);
+    await this.prisma.user.update({
+      where: { id },
+      data: {
+        passwordHash,
+        failedLoginAttempts: 0,
+        lockedUntil: null,
+      },
+    });
+
+    await this.createAuditLog(id, 'PASSWORD_RESET_ADMIN', 'User', id, null, { resetBy: 'admin' });
+
+    return { reset: true, tempPassword };
+  }
+
   private async signToken(userId: string, email: string, role: string, passengerId?: string, agentId?: string) {
     // Get the full user data to include fullName
     const user = await this.prisma.user.findUnique({