164 implement user management

prisma/schema.prisma

@@ -60,6 +60,7 @@ model AccountUser {
   userId    String
   roleId    String
   accountId String
+  isActive Boolean @default(true)
 
   deletedAt DateTime?
   createdAt DateTime  @default(now())

prisma/seed.ts

@@ -18,6 +18,11 @@ async function seedBatchOne() {
         type: RoleType.MENTOR,
         isDefault: true,
       },
+      {
+        name: 'Admin',
+        type: RoleType.ADMIN,
+        isDefault: true,
+      },
     ],
     skipDuplicates: true, // Prevent duplicate seeding
   });

src/app.module.ts

@@ -8,6 +8,8 @@ import { MentorModule } from './modules/mentor/mentor.module';
 import { ChatModule } from './modules/chat/chat.module';
 import { RabbitmqModule } from './common/rabbitmq/rabbitmq.module';
 import { MessageModule } from './modules/message/message.module';
+import { AdminProfileModule } from './modules/admin/adminProfile/admin-profile.module';
+import { RoleModule } from './modules/admin/role/role.module';
 
 @Module({
   imports: [
@@ -25,6 +27,8 @@ import { MessageModule } from './modules/message/message.module';
     ChatModule,
     RabbitmqModule,
     MessageModule,
+    AdminProfileModule,
+    RoleModule,
   ],
   providers: [PrismaService],
   controllers: [],

src/modules/admin/adminProfile/admin-profile.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AdminProfileController } from './admin-profile.controller';
+import { AdminProfileService } from './admin-profile.service';
+
+describe('AdminProfileController', () => {
+  let controller: AdminProfileController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AdminProfileController],
+      providers: [AdminProfileService],
+    }).compile();
+
+    controller = module.get<AdminProfileController>(AdminProfileController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/modules/admin/adminProfile/admin-profile.controller.ts

@@ -0,0 +1,49 @@
+import { Controller, Get, Body, Patch, Param, UseGuards } from '@nestjs/common';
+import { AuthGuard } from 'src/modules/auth/guard/auth/auth.guard';
+import { AdminProfileService } from './admin-profile.service';
+import { UpdateAdminProfileDto } from './dto/update-admin-profile.dto';
+import { RoleGuard } from 'src/modules/auth/guard/role/role.guard';
+import { Roles } from '../../auth/auth.decorator';
+
+@Controller('admin/profile')
+@UseGuards(AuthGuard)
+export class AdminProfileController {
+  constructor(private readonly adminProfileService: AdminProfileService) {}
+
+  @Get(':accountId/:userId/')
+  @UseGuards(RoleGuard)
+  @Roles('OWNER', 'ADMIN')
+  findOne(
+    @Param('userId') userId: string,
+    @Param('accountId') accountId: string,
+  ) {
+    return this.adminProfileService.findOne(userId, accountId);
+  }
+
+  @Patch(':id')
+  @UseGuards(RoleGuard)
+  @Roles('OWNER', 'ADMIN')
+  update(
+    @Param('id') id: string,
+    @Body() updateAdminProfileDto: UpdateAdminProfileDto,
+  ) {
+    return this.adminProfileService.update(id, updateAdminProfileDto);
+  }
+
+  @Get(':accountId')
+  @UseGuards(RoleGuard)
+  @Roles('OWNER')
+  findAll(@Param('accountId') accountId) {
+    return this.adminProfileService.findAll(accountId);
+  }
+
+  @Patch(':userId/activate/:accountId')
+  @UseGuards(RoleGuard)
+  @Roles('OWNER')
+  activate(
+    @Param('accountId') accountId: string,
+    @Param('userId') userId: string,
+  ) {
+    return this.adminProfileService.toggleActiveStatus(accountId, userId);
+  }
+}

src/modules/admin/adminProfile/admin-profile.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { AdminProfileService } from './admin-profile.service';
+import { AdminProfileController } from './admin-profile.controller';
+import { PrismaService } from '../../prisma/prisma.service';
+import { JwtService } from '@nestjs/jwt';
+
+@Module({
+  controllers: [AdminProfileController],
+  providers: [AdminProfileService, PrismaService, JwtService],
+})
+export class AdminProfileModule {}

src/modules/admin/adminProfile/admin-profile.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AdminProfileService } from './admin-profile.service';
+
+describe('AdminProfileService', () => {
+  let service: AdminProfileService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AdminProfileService],
+    }).compile();
+
+    service = module.get<AdminProfileService>(AdminProfileService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/modules/admin/adminProfile/admin-profile.service.ts

@@ -0,0 +1,167 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from 'src/modules/prisma/prisma.service';
+import { AdminDto } from './dto/admin.dto';
+import { UpdateAdminProfileDto } from './dto/update-admin-profile.dto';
+
+@Injectable()
+export class AdminProfileService {
+  constructor(private prisma: PrismaService) {}
+
+  async findOne(userId: string, accountId: string): Promise<AdminDto> {
+    const admin = await this.prisma.user.findFirst({
+      where: {
+        id: userId,
+        deletedAt: null,
+      },
+      include: {
+        AccountUser: {
+          where: {
+            accountId: accountId,
+          },
+        },
+      },
+    });
+
+    if (!admin) {
+      throw new NotFoundException('Admin not found');
+    }
+
+    const accountUser = admin.AccountUser.find(
+      (au) => au.accountId === accountId,
+    );
+
+    return new AdminDto({
+      id: admin.id,
+      name: admin.name,
+      email: admin.email,
+      isActive: accountUser?.isActive,
+    });
+  }
+
+  async update(
+    id: string,
+    updateAdminProfileDto: UpdateAdminProfileDto,
+  ): Promise<AdminDto> {
+    console.log('Updating admin with ID:', id);
+
+    const existingAdmin = await this.prisma.user.findFirst({
+      where: {
+        id: id,
+        deletedAt: null,
+      },
+    });
+
+    if (!existingAdmin) {
+      throw new NotFoundException('Admin not found');
+    }
+
+    const updatedAdmin = await this.prisma.user.update({
+      where: { id: id },
+      data: {
+        ...updateAdminProfileDto,
+      },
+    });
+
+    console.log('Updated admin:', updatedAdmin);
+
+    return new AdminDto({ ...updatedAdmin });
+  }
+
+  async findAll(accountId: string): Promise<AdminDto[]> {
+    const admins = await this.prisma.user.findMany({
+      where: {
+        deletedAt: null,
+        OR: [
+          {
+            AccountUser: {
+              some: {
+                accountId: accountId,
+                Role: {
+                  name: 'Admin',
+                },
+              },
+            },
+          },
+          {
+            AccountUser: {
+              some: {
+                accountId: accountId,
+                Role: {
+                  name: 'Owner',
+                },
+              },
+            },
+          },
+        ],
+      },
+      include: {
+        AccountUser: {
+          include: {
+            Role: true,
+          },
+        },
+      },
+    });
+
+    console.log('Filtered Admin Data:', JSON.stringify(admins, null, 2));
+
+    return admins.map((admin) => {
+      const accountUser = admin.AccountUser.find(
+        (au) => au.accountId === accountId,
+      );
+
+      return new AdminDto({
+        id: admin.id,
+        name: admin.name,
+        email: admin.email,
+        isActive: accountUser?.isActive,
+      });
+    });
+  }
+
+  async toggleActiveStatus(
+    accountId: string,
+    userId: string,
+  ): Promise<AdminDto> {
+    const accountUser = await this.prisma.accountUser.findFirst({
+      where: {
+        accountId: accountId,
+        userId: userId,
+      },
+    });
+
+    const updatedAccountUser = await this.prisma.accountUser.update({
+      where: {
+        id: accountUser.id,
+      },
+      data: {
+        isActive: !accountUser.isActive,
+      },
+    });
+
+    const updatedUser = await this.prisma.user.findFirst({
+      where: {
+        id: userId,
+        deletedAt: null,
+      },
+      include: {
+        AccountUser: {
+          where: {
+            accountId: accountId,
+          },
+        },
+      },
+    });
+
+    if (!updatedUser) {
+      throw new NotFoundException('User not found');
+    }
+
+    return new AdminDto({
+      id: updatedUser.id,
+      name: updatedUser.name,
+      email: updatedUser.email,
+      isActive: updatedAccountUser.isActive,
+    });
+  }
+}

src/modules/admin/adminProfile/dto/admin.dto.ts

@@ -0,0 +1,34 @@
+// src/posts/dto/post.dto.ts
+
+import { Expose } from 'class-transformer';
+
+export class AdminDto {
+  @Expose()
+  id: string;
+
+  @Expose()
+  name: string;
+
+  @Expose()
+  email: string;
+
+  @Expose()
+  isActive: boolean;
+
+  @Expose()
+  AccountUser: any;
+
+  @Expose()
+  roleName: string; // Add the roleName field
+
+  constructor(partial: Partial<AdminDto>) {
+    // console.log('partial', partial);
+    Object.assign(this, {
+      id: partial.id,
+      name: partial.name,
+      email: partial.email,
+      isActive: partial.isActive,
+      AccountUser: partial.AccountUser,
+    });
+  }
+}

src/modules/admin/adminProfile/dto/update-admin-profile.dto.ts

@@ -0,0 +1,15 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdateAdminProfileDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  password?: string;
+}

src/modules/admin/adminProfile/entities/admin-profile.entity.ts

@@ -0,0 +1 @@
+export class AdminProfile {}

src/modules/admin/channel/channel.controller.ts

@@ -16,10 +16,11 @@ import { UpdateChannelDto } from './dto/update-channel.dto';
 import { GetChannelDto } from './dto/get-channel.dto';
 import { Roles } from 'src/modules/auth/auth.decorator';
 import { AuthGuard } from 'src/modules/auth/guard/auth/auth.guard';
+import { RoleGuard } from 'src/modules/auth/guard/role/role.guard';
 
 @Controller('admin/channel')
-@UseGuards(AuthGuard)
-@Roles('OWNER')
+@UseGuards(AuthGuard, RoleGuard)
+@Roles('OWNER', 'ADMIN')
 export class ChannelController {
   constructor(private readonly channelService: ChannelService) {}
 

src/modules/admin/mentor/mentor.controller.ts

@@ -13,13 +13,14 @@ import {
 import { MentorService } from './mentor.service';
 import { Roles } from 'src/modules/auth/auth.decorator';
 import { AuthGuard } from 'src/modules/auth/guard/auth/auth.guard';
+import { RoleGuard } from 'src/modules/auth/guard/role/role.guard';
 import { GetMentorDto } from './dto/get-mentor.dto';
 import { CreateMentorDto } from './dto/create-mentor.dto';
 import { UpdateMentorDto } from './dto/update-mentor.dto';
 
 @Controller('admin/mentor')
-@UseGuards(AuthGuard)
-@Roles('OWNER')
+@UseGuards(AuthGuard, RoleGuard)
+@Roles('OWNER', 'ADMIN')
 export class MentorController {
   constructor(private readonly mentorService: MentorService) {}
 

src/modules/admin/role/dto/create-role.dto.ts

@@ -0,0 +1 @@
+export class CreateRoleDto {}

src/modules/admin/role/dto/update-role.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateRoleDto } from './create-role.dto';
+
+export class UpdateRoleDto extends PartialType(CreateRoleDto) {}