feat(backend): add management functionality

Author: NarwhalChen

backend/src/app.module.ts

@@ -20,6 +20,7 @@ import { MailModule } from './mail/mail.module';
 import { GitHubModule } from './github/github.module';
 import { AppConfigService } from './config/config.service';
 import { getDatabaseConfig } from './database.config';
+import { DashboardModule } from './dashboard/dashboard.module';
 
 @Module({
   imports: [
@@ -56,6 +57,7 @@ import { getDatabaseConfig } from './database.config';
     MailModule,
     TypeOrmModule.forFeature([User]),
     GitHubModule,
+    DashboardModule,
   ],
   providers: [
     AppResolver,

backend/src/dashboard/dashboard.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { DashboardResolver } from './dashboard.resolver';
+import { DashboardService } from './dashboard.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { User } from '../user/user.model';
+import { UserModule } from '../user/user.module';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([User]), UserModule],
+  providers: [DashboardResolver, DashboardService],
+  exports: [DashboardService],
+})
+export class DashboardModule {}

backend/src/dashboard/dashboard.resolver.ts

@@ -0,0 +1,54 @@
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { DashboardService } from './dashboard.service';
+import { User } from '../user/user.model';
+import {
+  CreateUserInput,
+  UpdateUserInput,
+  UserFilterInput,
+} from './dto/user-input';
+import { RequireRoles } from '../decorator/auth.decorator';
+import { UseGuards } from '@nestjs/common';
+import { GqlAuthGuard } from '../guard/gql-auth.guard';
+
+@Resolver(() => User)
+@UseGuards(GqlAuthGuard)
+export class DashboardResolver {
+  constructor(private readonly dashboardService: DashboardService) {}
+
+  @Query(() => [User])
+  @RequireRoles('Admin')
+  async dashboardUsers(
+    @Args('filter', { nullable: true }) filter?: UserFilterInput,
+  ): Promise<User[]> {
+    return this.dashboardService.findUsers(filter);
+  }
+
+  @Query(() => User)
+  @RequireRoles('Admin')
+  async dashboardUser(@Args('id') id: string): Promise<User> {
+    return this.dashboardService.findUserById(id);
+  }
+
+  @Mutation(() => User)
+  @RequireRoles('Admin')
+  async createDashboardUser(
+    @Args('input') input: CreateUserInput,
+  ): Promise<User> {
+    return this.dashboardService.createUser(input);
+  }
+
+  @Mutation(() => User)
+  @RequireRoles('Admin')
+  async updateDashboardUser(
+    @Args('id') id: string,
+    @Args('input') input: UpdateUserInput,
+  ): Promise<User> {
+    return this.dashboardService.updateUser(id, input);
+  }
+
+  @Mutation(() => Boolean)
+  @RequireRoles('Admin')
+  async deleteDashboardUser(@Args('id') id: string): Promise<boolean> {
+    return this.dashboardService.deleteUser(id);
+  }
+}

backend/src/dashboard/dashboard.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from '../user/user.model';
+import {
+  CreateUserInput,
+  UpdateUserInput,
+  UserFilterInput,
+} from './dto/user-input';
+import { hash } from 'bcrypt';
+
+@Injectable()
+export class DashboardService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+  ) {}
+
+  async findUsers(filter?: UserFilterInput): Promise<User[]> {
+    const query = this.userRepository.createQueryBuilder('user');
+
+    if (filter?.search) {
+      query.where('(user.username LIKE :search OR user.email LIKE :search)', {
+        search: `%${filter.search}%`,
+      });
+    }
+
+    if (filter?.isActive !== undefined) {
+      query.andWhere('user.isActive = :isActive', {
+        isActive: filter.isActive,
+      });
+    }
+
+    return query.getMany();
+  }
+
+  async findUserById(id: string): Promise<User> {
+    const user = await this.userRepository.findOne({ where: { id } });
+    if (!user) {
+      throw new NotFoundException(`User with ID ${id} not found`);
+    }
+    return user;
+  }
+
+  async createUser(input: CreateUserInput): Promise<User> {
+    const hashedPassword = await hash(input.password, 10);
+    const user = this.userRepository.create({
+      ...input,
+      password: hashedPassword,
+    });
+    return this.userRepository.save(user);
+  }
+
+  async updateUser(id: string, input: UpdateUserInput): Promise<User> {
+    const user = await this.findUserById(id);
+
+    if (input.password) {
+      input.password = await hash(input.password, 10);
+    }
+
+    Object.assign(user, input);
+    return this.userRepository.save(user);
+  }
+
+  async deleteUser(id: string): Promise<boolean> {
+    const result = await this.userRepository.delete(id);
+    return result.affected > 0;
+  }
+}

backend/src/dashboard/dto/user-input.ts

@@ -0,0 +1,51 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsEmail, IsOptional, IsString, MinLength } from 'class-validator';
+
+@InputType()
+export class CreateUserInput {
+  @Field()
+  @IsString()
+  @MinLength(2)
+  username: string;
+
+  @Field()
+  @IsEmail()
+  email: string;
+
+  @Field()
+  @IsString()
+  @MinLength(6)
+  password: string;
+}
+
+@InputType()
+export class UpdateUserInput {
+  @Field({ nullable: true })
+  @IsString()
+  @MinLength(2)
+  @IsOptional()
+  username?: string;
+
+  @Field({ nullable: true })
+  @IsEmail()
+  @IsOptional()
+  email?: string;
+
+  @Field({ nullable: true })
+  @IsString()
+  @MinLength(6)
+  @IsOptional()
+  password?: string;
+}
+
+@InputType()
+export class UserFilterInput {
+  @Field({ nullable: true })
+  @IsString()
+  @IsOptional()
+  search?: string;
+
+  @Field(() => Boolean, { nullable: true })
+  @IsOptional()
+  isActive?: boolean;
+}