create user

src/configurable/configurable.controller.spec.ts

@@ -1,6 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ConfigurableController } from './configurable.controller';
-import { ConfigurableService } from './configurable.service';
+import { RoleService } from './roles.service';
 
 describe('ConfigurableController', () => {
   let controller: ConfigurableController;
@@ -8,7 +8,7 @@ describe('ConfigurableController', () => {
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [ConfigurableController],
-      providers: [ConfigurableService],
+      providers: [RoleService],
     }).compile();
 
     controller = module.get<ConfigurableController>(ConfigurableController);

src/configurable/configurable.controller.ts

@@ -9,14 +9,14 @@ import {
   ParseUUIDPipe,
   HttpStatus, Query,
 } from '@nestjs/common';
-import { ConfigurableService } from './configurable.service';
+import { RoleService } from './roles.service';
 
 @Controller({
   path: 'config',
   version: '1',
 })
 export class ConfigurableController {
-  constructor(private readonly usersService: ConfigurableService) {}
+  constructor(private readonly usersService: RoleService) {}
 
   @Get()
   async findAll(@Query('page') page: number) {

src/configurable/configurable.module.ts

@@ -2,11 +2,12 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Roles } from './entities/roles.entity';
 import { ConfigurableController } from './configurable.controller';
-import { ConfigurableService } from './configurable.service';
+import { RoleService } from './roles.service';
 
 @Module({
   imports: [TypeOrmModule.forFeature([Roles])],
   controllers: [ConfigurableController],
-  providers: [ConfigurableService],
+  providers: [RoleService],
+  exports: [RoleService]
 })
 export class ConfigurableModule {}

src/configurable/configurable.service.spec.ts

@@ -1,15 +1,15 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { ConfigurableService } from './configurable.service';
+import { RoleService } from './roles.service';
 
-describe('ConfigurableService', () => {
+describe('RoleService', () => {
-  let service: ConfigurableService;
+  let service: RoleService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [ConfigurableService],
+      providers: [RoleService],
     }).compile();
 
-    service = module.get<ConfigurableService>(ConfigurableService);
+    service = module.get<RoleService>(RoleService);
   });
 
   it('should be defined', () => {

src/configurable/roles.service.ts

@@ -4,7 +4,7 @@ import { Roles } from './entities/roles.entity';
 import { InjectRepository } from '@nestjs/typeorm';
 
 @Injectable()
-export class ConfigurableService {
+export class RoleService {
   constructor(
     @InjectRepository(Roles)
     private rolesRepository: Repository<Roles>,

src/users/users.controller.ts

@@ -23,6 +23,8 @@ export class UsersController {
 
   @Post()
   async create(@Body() createUserDto: CreateUserDto) {
+
+    
     return {
       data: await this.usersService.create(createUserDto),
       statusCode: HttpStatus.CREATED,

src/users/users.module.ts

@@ -4,9 +4,10 @@ import { UsersService } from './users.service';
 import { UsersController } from './users.controller';
 import { User } from './entities/user.entity';
 import { TransactionModule } from 'src/transaction/transaction.module';
+import { ConfigurableModule } from 'src/configurable/configurable.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([User]), TransactionModule],
+  imports: [TypeOrmModule.forFeature([User]), TransactionModule, ConfigurableModule],
   controllers: [UsersController],
   providers: [UsersService],
   exports: [UsersService],

src/users/users.service.ts

@@ -8,21 +8,28 @@ import { randomStringGenerator } from '@nestjs/common/utils/random-string-genera
 import { hashPassword } from '../helper/hash_password';
 import { CoaService } from 'src/transaction/coa.service';
 import { coaType } from 'src/helper/enum-list';
+import { RoleService } from 'src/configurable/roles.service';
 
 @Injectable()
 export class UsersService {
   constructor(
     @InjectRepository(User)
     private usersRepository: Repository<User>,
-    private coaService: CoaService
+    private coaService: CoaService,
+    private roleService: RoleService
   ) {}
 
   async create(createUserDto: CreateUserDto) {
+    const roles = await this.roleService.findOne(createUserDto.roleId);
+    const superior = await this.findExist(createUserDto.superior);
+    
     const salt = randomStringGenerator();
     const result = await this.usersRepository.insert({
       username: createUserDto.username,
       password: await hashPassword(createUserDto.password, salt),
       salt,
+      superior:superior,
+      roles:roles
     });
 
     return this.usersRepository.findOneOrFail(result.identifiers[0].id);
@@ -51,6 +58,24 @@ export class UsersService {
     });
   }
 
+  async findExist(id: string) {
+    try {
+     return await this.usersRepository.findOneOrFail(id);
+    } catch (e) {
+      if (e instanceof EntityNotFoundError) {
+        throw new HttpException(
+          {
+            statusCode: HttpStatus.NOT_FOUND,
+            error: 'Data not found',
+          },
+          HttpStatus.NOT_FOUND,
+        );
+      } else {
+        throw e;
+      }
+    }
+  }
+
   async findOne(id: string) {
     const coa = await this.coaService.findByUser(id,coaType.WALLET);
     try {