PING et backendconfig

Author: alainabbas

docs/DAEMON.md

@@ -1 +1,2 @@
 # Communication avec sesame-daemon
+Voir doc sesame-daemon

src/app.module.ts

@@ -5,6 +5,7 @@ import { PasswdModule } from './passwd/passwd.module';
 import { BullModule } from '@nestjs/bullmq';
 import { AuthModule } from './auth/auth.module';
 import {ConfigModule, ConfigService} from '@nestjs/config';
+import { BackendsModule } from './backends/backends.module';
 
 import config from './config'
 
@@ -14,6 +15,7 @@ import config from './config'
       load: [config]
     }),
     PasswdModule,
-    AuthModule]
+    AuthModule,
+    BackendsModule]
 })
 export class AppModule {}

src/backends/backends.controller.spec.ts

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

src/backends/backends.controller.ts

@@ -0,0 +1,36 @@
+import {Body, Controller, Logger, Post,Get, Res, UseGuards} from '@nestjs/common';
+import {BackendsService} from './backends.service';
+import {ChangePasswordDto} from "../passwd/dto/change-password.dto";
+import {Queue, QueueEvents} from "bullmq";
+import {ApiBearerAuth, ApiOperation, ApiResponse, ApiTags} from "@nestjs/swagger";
+import {AuthGuard} from "@nestjs/passport";
+import {Response} from "express";
+import {PasswdService} from "../passwd/passwd.service";
+
+@Controller('backends')
+@ApiTags('backends')
+export class BackendsController {
+    private readonly logger = new Logger(BackendsController.name);
+
+    constructor(private backendsService: BackendsService) {
+    }
+
+    @Get('list')
+    @ApiOperation({summary: 'List backends from daemon'})
+    @ApiResponse({status: 200, description: 'List ok '})
+    @ApiBearerAuth()
+    @UseGuards(AuthGuard("api-key"))
+    async list(@Res() res: Response): Promise<Response> {
+        const backend = await this.backendsService.list()
+        return res.status(200).json(backend);
+    }
+    @Get('alive')
+    @ApiOperation({summary: 'test backends '})
+    @ApiResponse({status: 200, description: 'command executed '})
+    @ApiBearerAuth()
+    @UseGuards(AuthGuard("api-key"))
+    async alive(@Res() res: Response): Promise<Response> {
+        const backend = await this.backendsService.alive()
+        return res.status(200).json(backend);
+    }
+}

src/backends/backends.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { BackendsService } from './backends.service';
+import { BackendsController } from './backends.controller';
+import {ConfigModule} from "@nestjs/config";
+
+@Module({
+  imports:[ConfigModule],
+  controllers: [BackendsController],
+  providers: [BackendsService],
+})
+export class BackendsModule {}

src/backends/backends.service.spec.ts

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

src/backends/backends.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+import Redis from "ioredis";
+import crypto from "crypto";
+import {ConfigService} from "@nestjs/config";
+import {Queue, QueueEvents} from "bullmq";
+
+@Injectable()
+export class BackendsService {
+
+    constructor(private readonly configService:ConfigService) {}
+    async list() {
+        const redisConfig={host:this.configService.get('redis.host'),port:this.configService.get('redis.port')}
+        const queue=new Queue(this.configService.get('nameQueue'),{connection:redisConfig})
+        const queueEvents = new QueueEvents(this.configService.get('nameQueue'),{connection: redisConfig})
+        const job=await queue.add('LISTBACKEND',"x")
+        queueEvents.on('failed',(errors)=>{
+            console.log(errors)
+        })
+        return await job.waitUntilFinished(queueEvents,30000)
+    }
+    async alive() {
+        const redisConfig={host:this.configService.get('redis.host'),port:this.configService.get('redis.port')}
+        const queue=new Queue(this.configService.get('nameQueue'),{connection:redisConfig})
+        const queueEvents = new QueueEvents(this.configService.get('nameQueue'),{connection: redisConfig})
+        const job=await queue.add('PING',"x")
+        queueEvents.on('failed',(errors)=>{
+            console.log(errors)
+        })
+        return await job.waitUntilFinished(queueEvents,30000)
+    }
+
+
+
+
+}

src/passwd/passwd.controller.ts

@@ -23,7 +23,7 @@ export class PasswdController {
 
     @Post('change')
     @ApiOperation({summary: 'change password'})
-    @ApiResponse({status: 201, description: 'Password has been successfully changed.'})
+    @ApiResponse({status: 200, description: 'Password has been successfully changed.'})
     @ApiResponse({status: 403, description: 'Old password wrong'})
     @ApiResponse({status: 500, description: 'Backend error'})
     @ApiBearerAuth()
@@ -35,27 +35,27 @@ export class PasswdController {
         data.data.uid = cpwd.uid
         this.logger.log('call passwd change for : ' + cpwd.uid)
         if (data.data.status === 0) {
-            return res.status(201).json(data);
+            return res.status(200).json(data);
         } else {
             if (data.data.status === 1) {
                 return res.status(403).json(data);
             }
-            this.logger.log('ERROR : ' + data)
-            return res.status(201).json(data);
+            return res.status(200).json(data);
         }
     }
 
     @Post('gettoken')
     @ApiOperation({summary: 'ask token for reseting password'})
-    @ApiResponse({status: 201, description: 'Token', content: {}})
+    @ApiResponse({status: 200, description: 'Token', content: {}})
     @ApiResponse({status: 500, description: 'Backend error'})
     @ApiBearerAuth()
     @UseGuards(AuthGuard("api-key"))
     async gettoken(@Body() asktoken: AskTokenDto, @Res() res: Response): Promise<Response> {
+        this.logger.log('GetToken for : ' + asktoken.uid)
         const data = await this.passwdService.askToken(asktoken)
         const ret = {token: data}
         console.log(ret)
-        return res.status(201).json(ret);
+        return res.status(200).json(ret);
     }
     @Post('verifytoken')
     @ApiOperation({summary: 'ask token for reseting password'})
@@ -64,29 +64,32 @@ export class PasswdController {
     @ApiBearerAuth()
     @UseGuards(AuthGuard("api-key"))
     async verifyToken(@Body() token:VerifyTokenDto ,@Res() res: Response): Promise<Response> {
+        this.logger.log('Verify token : ' + token.token)
     const ok=await this.passwdService.verifyToken(token.token)
+        console.log('reponse : ' + ok)
         if (ok === true){
-            return res.status(201).json(token)
+            console.log('reponse : 200')
+            return res.status(200).json({'status':0})
         }else{
-            return res.status(500).json(token)
+            return res.status(200).json({'status':1})
         }
 
     }
     @Post('reset')
     @ApiOperation({summary: 'reset password'})
-    @ApiResponse({status: 201, description: 'Reset OK'})
+    @ApiResponse({status: 200, description: 'Reset OK'})
     @ApiResponse({status: 500, description: 'Reset KO'})
     @ApiBearerAuth()
     @UseGuards(AuthGuard("api-key"))
     async reset(@Body() data:ResetPasswordDto,@Res()res:Response):Promise<Response>{
-        const tokenData=await this.passwdService.decryptToken(data.token)
-        if (Object.keys(tokenData).length === 0){
-            return res.status(500).json({'status':1,'error':'invalid token'})
-        }else{
-
-            return res.status(200).json({'status':0,'error':''})
-
+        //this.logger.log('password reset : ' + data)
+        const resetData=await this.passwdService.reset(data)
+        //this.logger.log(resetData)
+        if (resetData.status === 0){
+            return res.status(200).json(resetData)
 
+        }else{
+            return res.status(200).json({'status':1,'error':'invalid token'})
         }
 
     }

src/passwd/passwd.service.ts

@@ -37,10 +37,13 @@ export class PasswdService {
   }
   async verifyToken(token){
       const data=await this.decryptToken(token)
-      console.log('r :  '+JSON.stringify(data))
+      console.log('r (verifyToken service) :  ')
+      console.log(data)
+      console.log('longueur' + Object.keys(data).length)
       if (Object.keys(data).length === 0){
           return false
       }else{
+          console.log('return true')
           return true
       }
 
@@ -61,21 +64,26 @@ export class PasswdService {
           decipher.setAuthTag(Buffer.from(cypherData.tag, 'base64'));
           let plaintext = decipher.update(token, 'base64', 'ascii');
           console.log('texte : ' + plaintext)
+          //delete key
+          //redis.del([token])
           return JSON.parse(plaintext)
       }else{
           return {}
       }
   }
   async reset(data:ResetPasswordDto){
       const tokenData=await this.decryptToken(data.token)
+      console.log(tokenData)
       if (Object.keys(tokenData).length === 0){
-          return false
+          return {'status':1,'error':'invalid token'}
       }
       const redisConfig={host:this.configService.get('redis.host'),port:this.configService.get('redis.port')}
       const queue=new Queue(this.configService.get('nameQueue'),{connection:redisConfig})
       const queueEvents = new QueueEvents(this.configService.get('nameQueue'),{connection: redisConfig})
-      const job=await queue.add('RESETPWD',tokenData)
+      const backendData={'uid':tokenData.uid,'newPassword':data.newPassword}
+      const job=await queue.add('RESETPWD',backendData)
       queueEvents.on('failed',(errors)=>{
+          console.log('Erreur queue')
           console.log(errors)
       })
       return await job.waitUntilFinished(queueEvents,30000)

src/swagger.ts

@@ -1,10 +1,10 @@
 import {DocumentBuilder, SwaggerModule} from "@nestjs/swagger";
 export default function swagger(app){
     const config = new DocumentBuilder()
-        .setTitle('Password manager')
-        .setDescription('Change reset password')
-        .setVersion('1.0')
-        .addTag('passwd')
+        .setTitle('Sesame Orchestrator API')
+        .setDescription('Sesame')
+        .setVersion('0.1')
+        .addTag('sesame-orchestrator')
         .addBearerAuth({type: 'http',scheme : 'bearer'})
         .build();
     const document = SwaggerModule.createDocument(app, config);