File

src/controller/1.0.0/user.controller.ts

Prefix

1.0.0/users

Index

Methods

Methods

Async createAdminOrTrainer
createAdminOrTrainer(params: AddAdminOrTrainerDTO)
Decorators :
@Post('new-admin-or-trainer')
Parameters :
Name Type Optional
params AddAdminOrTrainerDTO No
Returns : {}
Async createNewUser
createNewUser(params: any)
Decorators :
@Post('new-user')
Parameters :
Name Type Optional
params any No
Returns : {}
Async deactivateAndActivateUsersById
deactivateAndActivateUsersById(userId)
Decorators :
@Post('activate-deactivate-users-by-ids/:userId')
@Roles(undefined)
Parameters :
Name Optional
userId No
Returns : {}
Async deactivateUser
deactivateUser(userId)
Decorators :
@UseGuards(undefined)
@Roles(undefined)
@Delete('delete-user-by-id/:userId')
Parameters :
Name Optional
userId No
Returns : {}
Async deleteUserByIDs
deleteUserByIDs(params: any)
Decorators :
@Post('delete-users-by-ids')
@Roles(undefined)
Parameters :
Name Type Optional
params any No
Returns : {}
Async editUser
editUser(params: any)
Decorators :
@Post('edit-user')
Parameters :
Name Type Optional
params any No
Returns : {}
Async editUserFromCMS
editUserFromCMS(params: EditUserDataFromCMSDTO)
Decorators :
@Post('edit-user-from-cms')
Parameters :
Name Type Optional
params EditUserDataFromCMSDTO No
Returns : Promise<any>
Async getAllAdmin
getAllAdmin()
Decorators :
@UseGuards(undefined, RolesGuard)
@Roles(undefined)
@Get('get-all-admin')
Returns : {}
Async getAllMainTrainer
getAllMainTrainer()
Decorators :
@UseGuards(undefined, RolesGuard)
@Roles(undefined)
@Get('get-all-maintainer')
Returns : {}
Async getAllPlayer
getAllPlayer()
Decorators :
@UseGuards(undefined, RolesGuard)
@Roles(undefined)
@Get('get-all-player')
Returns : {}
Async getAllUserWithoutAdmin
getAllUserWithoutAdmin()
Decorators :
@UseGuards(undefined, RolesGuard)
@Roles(undefined)
@Get('get-all-without-admin')
Returns : {}
Async getNewUserCode
getNewUserCode()
Decorators :
@Get('new-code')
Returns : {}
Async getOneById
getOneById(userId)
Decorators :
@UseGuards(undefined)
@Get('user-by-id')
Parameters :
Name Optional
userId No
Returns : {}
Async getUserByCourse
getUserByCourse(courseId)
Decorators :
@Get('users-by-course/:courseId')
Parameters :
Name Optional
courseId No
Returns : Promise<UserCourseResponseDTO>
Async getUserByCourseEcxam
getUserByCourseEcxam(courseId)
Decorators :
@Get('users-by-course-exam/:courseId')
Parameters :
Name Optional
courseId No
Returns : Promise<UserCourseResponseDTO>
Async getUserCourses
getUserCourses(userId)
Decorators :
@Get('user-course/:userId')
Parameters :
Name Optional
userId No
Returns : Promise<any>
Async login
login(req: Request, params: LoginDTO)
Decorators :
@UseGuards(undefined)
@Post('login')
@HttpCode(200)
Parameters :
Name Type Optional
req Request No
params LoginDTO No
Async loginWithQR
loginWithQR(params: QrLoginDTO)
Decorators :
@Post('login-with-qr')
Parameters :
Name Type Optional
params QrLoginDTO No
Returns : Promise<QrCodeLoginResponseDTO>
Async modifyAdminAndTrainer
modifyAdminAndTrainer(params: ModifyAdminDTO)
Decorators :
@UseGuards(undefined)
@Post('modify-admin-and-trainer')
Parameters :
Name Type Optional
params ModifyAdminDTO No
Async modifyUser
modifyUser(params: ModifyUserDTO)
Decorators :
@UseGuards(undefined)
@Post('modify-user')
Parameters :
Name Type Optional
params ModifyUserDTO No
Async registrationFromCMSbyTM
registrationFromCMSbyTM(params: RegistrationFromCMSDTO)
Decorators :
@UseGuards(undefined, RolesGuard)
@Roles(undefined)
@Post('registration-from-cms')
Parameters :
Name Type Optional
params RegistrationFromCMSDTO No
import {
  Controller,
  Get,
  UseGuards,
  Post,
  Body,
  Request,
  HttpCode,
  Param,
  Delete,
  Query,
} from "@nestjs/common";
import { AuthGuard } from "@nestjs/passport";
import { JwtService } from "@nestjs/jwt";
import { LoginDTO } from "../../dto/1.0.0/user/login.dto";
import { UserService100 } from "../../service/1.0.0/user.service";
import { User } from "../../entity/user.entity";
import { ModifyUserDTO } from "../../dto/1.0.0/user/modifyuser.dto";
import { RegistrationResponseDTO } from "../../dto/1.0.0/user/registration.response.dto";
import { LoginResponseDTO } from "../../dto/1.0.0/user/login.response.dto";
import { RolesGuard } from "src/module/auth/guard/roles.guard";
import { ROLES } from "src/constant/roles.contant";
import { RegistrationFromCMSDTO } from "src/dto/1.0.0/user/registration-from-cms.dto";
import { Roles } from "src/module/auth/decorator/roles.decorator";
import { QrCodeLoginResponseDTO } from "src/dto/1.0.0/user/qr-code-login-response.dto";
import { QrLoginDTO } from "src/dto/1.0.0/user/qr-login.dto";
import { UserCourseResponseDTO } from "src/dto/1.0.0/user/user-course-response.dto";
import { ModifyAdminDTO } from "src/dto/1.0.0/user/modify-admin.dto";
import { AddAdminOrTrainerDTO } from "src/dto/1.0.0/user/add-admin-or-trainer.dto";
import { EditUserDataFromCMSDTO } from "src/dto/1.0.0/user/edit-user-data-from-cms.dto";

@Controller("1.0.0/users")
export class UserController100 {
  constructor(
    private readonly userService: UserService100,
    private readonly jwtService: JwtService
  ) {}

  @UseGuards(AuthGuard("local"))
  @Post("login")
  @HttpCode(200)
  async login(
    @Request() req: Request,
    @Body() params: LoginDTO
  ): Promise<LoginResponseDTO> {
    const user = (req as any).user as User;

    return {
      user,
      accessToken: this.jwtService.sign({
        sub: user.id,
      }),
    };
  }

  @UseGuards(AuthGuard("jwt"))
  @Roles([ROLES.admin, ROLES.maintainer])
  @Delete("delete-user-by-id/:userId")
  async deactivateUser(@Param("userId") userId) {
    return await this.userService.deactiavateUser(userId);
  }

  // @Post("forgot-password")
  // async forgotPassword(@Body() params: ForgotPasswordDTO) {
  //   return await this.userService.forgotPassword(params.email);
  // }
  @UseGuards(AuthGuard("jwt"), RolesGuard)
  @Roles([ROLES.admin, ROLES.maintainer])
  @Get("get-all-without-admin")
  async getAllUserWithoutAdmin() {
    return await this.userService.getAllFilteredUserWithoutAdmin();
  }
  @UseGuards(AuthGuard("jwt"), RolesGuard)
  @Roles([ROLES.admin, ROLES.maintainer])
  @Get("get-all-player")
  async getAllPlayer() {
    return await this.userService.getAllPlayer();
  }
  @UseGuards(AuthGuard("jwt"), RolesGuard)
  @Roles([ROLES.admin, ROLES.maintainer])
  @Get("get-all-maintainer")
  async getAllMainTrainer() {
    return await this.userService.getAllMaintainer();
  }

  @UseGuards(AuthGuard("jwt"), RolesGuard)
  @Roles([ROLES.admin, ROLES.maintainer])
  @Get("get-all-admin")
  async getAllAdmin() {
    return await this.userService.getAllAdmin();
  }

  @UseGuards(AuthGuard("jwt"), RolesGuard)
  @Roles([ROLES.admin, ROLES.maintainer])
  @Post("registration-from-cms")
  async registrationFromCMSbyTM(
    @Body() params: RegistrationFromCMSDTO
  ): Promise<RegistrationResponseDTO> {
    const user: User = await this.userService.createNewUserFromCMSbyAdmin(
      params
    );
    return {
      user,
    };
  }

  @Post("delete-users-by-ids")
  @Roles([ROLES.admin])
  async deleteUserByIDs(@Body() params: any) {
    return await this.userService.deleteUsersByIds(params);
  }

  @Post("activate-deactivate-users-by-ids/:userId")
  @Roles([ROLES.admin])
  async deactivateAndActivateUsersById(@Param("userId") userId) {
    return await this.userService.deactivateAndActivateUsersById(userId);
  }

  @UseGuards(AuthGuard("jwt"))
  @Get("user-by-id")
  async getOneById(@Query("userId") userId) {
    return await this.userService.getOneUser(userId);
  }

  @UseGuards(AuthGuard("jwt"))
  @Post("modify-admin-and-trainer")
  async modifyAdminAndTrainer(
    @Body() params: ModifyAdminDTO
  ): Promise<RegistrationResponseDTO> {
    const user: User = await this.userService.modifyAdminAndTrainer(params);

    return {
      user,
    };
  }
  @UseGuards(AuthGuard("jwt"))
  @Post("modify-user")
  async modifyUser(
    @Body() params: ModifyUserDTO
  ): Promise<RegistrationResponseDTO> {
    const user: User = await this.userService.modifyUser(params);

    return {
      user,
    };
  }

  @Post("login-with-qr")
  async loginWithQR(
    @Body() params: QrLoginDTO
  ): Promise<QrCodeLoginResponseDTO> {
    return await this.userService.loginWithQrCode(params);
  }
  @Post("edit-user-from-cms")
  async editUserFromCMS(@Body() params: EditUserDataFromCMSDTO): Promise<any> {
    return await this.userService.editUserFromProfile(params);
  }
  //@UseGuards(AuthGuard("jwt"))
  @Get("users-by-course/:courseId")
  async getUserByCourse(
    @Param("courseId") courseId
  ): Promise<UserCourseResponseDTO> {
    return await this.userService.getUserByCourse(courseId);
  }
  @Get("users-by-course-exam/:courseId")
  async getUserByCourseEcxam(
    @Param("courseId") courseId
  ): Promise<UserCourseResponseDTO> {
    return await this.userService.getUserByCourseExam(courseId);
  }
  @Get("new-code")
  async getNewUserCode() {
    return await this.userService.generateID();
  }
  @Post("new-user")
  async createNewUser(@Body() params: any) {
    const obj = await this.userService.createNewUser(params);
    return obj;
  }
  @Post("edit-user")
  async editUser(@Body() params: any) {
    const obj = await this.userService.editUser(params);
    return obj;
  }
  @Post("new-admin-or-trainer")
  async createAdminOrTrainer(@Body() params: AddAdminOrTrainerDTO) {
    const obj = await this.userService.createAdminOrTrainer(params);
    return obj;
  }
  @Get("user-course/:userId")
  async getUserCourses(@Param("userId") userId): Promise<any> {
    return await this.userService.getUserCourses(userId);
  }
}


result-matching ""

    No results matching ""