save

Author: alainabbas

Makefile

@@ -25,7 +25,7 @@ dev: ## Start development environment
 		-p $(APP_PORT):4000 \
 		-p 9229:9229 \
 		-v $(CURDIR):/data \
-		$(IMG_NAME) yarn start:debug
+		$(IMG_NAME) yarn start:debug 
 
 install: ## Install dependencies
 	@docker run -it --rm \

src/_common/abstracts/abstract-settings.service.ts

@@ -0,0 +1,45 @@
+import {AbstractServiceSchema} from "~/_common/abstracts/abstract.service.schema";
+import {InjectModel} from "@nestjs/mongoose";
+import {Model} from "mongoose";
+import {Settings, SettingsSchema} from "~/settings/_schemas/settings.schema";
+
+export class AbstractSettingsService extends AbstractServiceSchema {
+  protected settingsName: string
+
+  constructor(@InjectModel(Settings.name) protected _model: Model<Settings>) {
+    super();
+  }
+
+  protected async getParameter(settingName: string): Promise<object | null> {
+    try {
+      const enr=  await this.findOne({name: settingName})
+      return enr.parameters
+    } catch (e) {
+      return this.defaultValues()
+    }
+  }
+
+  protected async setParameter(settingName: string, parameters: object): Promise<any> {
+    const enr = new this._model({
+      name: settingName
+      , parameters: parameters
+    })
+    const ok= await this.upsert(
+      {name: settingName},
+      {
+        $setOnInsert: {
+          name: settingName
+        },
+        $set: {
+          "parameters": parameters
+        }
+      })
+    return ok
+  }
+
+  protected async defaultValues(): Promise<object> {
+
+    return {}
+  }
+
+}

src/management/passwd/passwd.controller.ts

@@ -8,7 +8,6 @@ import {VerifyTokenDto} from './_dto/verify-token.dto';
 import {ResetPasswordDto} from './_dto/reset-password.dto';
 import {omit} from "radash";
 import {PasswdadmService} from "~/settings/passwdadm/passwdadm.service";
-import {PasswordPolicies} from "~/settings/passwdadm/_schemas/PasswordPolicies";
 import {InitAccountDto} from "~/management/passwd/_dto/init-account.dto";
 import {InitResetDto} from "~/management/passwd/_dto/init-reset.dto";
 import crypto from "crypto";

src/management/passwd/passwd.service.ts

@@ -21,6 +21,7 @@ import {PasswdadmService} from "~/settings/passwdadm/passwdadm.service";
 import {IdentityState} from "~/management/identities/_enums/states.enum";
 import {InitResetDto} from "~/management/passwd/_dto/init-reset.dto";
 import {SmsService} from "~/management/passwd/sms-service";
+import {PasswordPoliciesDto} from "~/settings/passwdadm/dto/password-policy.dto";
 
 interface TokenData {
   k: string;
@@ -97,7 +98,7 @@ export class PasswdService extends AbstractService {
         }
       }else{
         //envoi par SMS si c est possible
-        const policies=await this.passwdadmService.getPolicies()
+        const policies=new PasswordPoliciesDto()
         if (policies.resetBySms === true){
           this.logger.log("Reset password asked by SMS for  : " + initDto.uid )
           const smsAttribute=this.config.get('frontPwd.identityMobileAttribute')

src/settings/_schemas/settings.schema.ts

@@ -0,0 +1,15 @@
+import { AbstractSchema } from '~/_common/abstracts/schemas/abstract.schema';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+export type SettingsDocument =  Document;
+
+@Schema({ versionKey: false })
+export class Settings extends AbstractSchema {
+  @Prop({ type: String, default: "" ,required: true, unique: true,})
+  name: string
+  @Prop({type: Object, default:{}})
+  parameters: object
+
+}
+
+export const SettingsSchema = SchemaFactory.createForClass(Settings);

src/settings/passwdadm/_schemas/PasswordPolicies.ts

@@ -4,39 +4,39 @@ import {IsNumber, IsBoolean, IsString} from 'class-validator';
 export class PasswordPoliciesDto {
   @IsNumber()
   @ApiProperty({ example: '8', description: 'Password minimal Length', type: Number })
-  public len: Number;
+  public len: number=10;
 
   @IsNumber()
   @ApiProperty({ example: '1', description: 'Minimal amount of letters in uppercase', type: Number })
-  public hasUpperCase: Number;
+  public hasUpperCase: number;
 
   @IsNumber()
   @ApiProperty({ example: '1', description: 'Minimal amount of letters in lowercase', type: Number })
-  public hasLowerCase: Number;
+  public hasLowerCase: number;
 
   @IsNumber()
   @ApiProperty({ example: '1', description: 'Minimal amount of numbers', type: Number })
-  public hasNumbers: Number;
+  public hasNumbers: number;
 
   @IsNumber()
   @ApiProperty({ example: '1', description: 'Minimal amount of special characters', type: Number })
-  public hasSpecialChars: Number;
+  public hasSpecialChars: number;
 
   @IsNumber()
   @ApiProperty({ example: '30', description: 'Minimal complexity (entropy), Below this number the password wont be accepted', type: Number })
-  public minComplexity: Number;
+  public minComplexity: number;
 
   @IsNumber()
   @ApiProperty({ example: '70', description: 'Good complexity (entropy), Upper this number the password is considered  good', type: Number })
-  public goodComplexity: Number;
+  public goodComplexity: number;
 
   @IsBoolean()
   @ApiProperty({ example: true, description: 'Teh password will be checked on Pwned', type: Boolean })
-  public checkPwned: Boolean;
+  public checkPwned: boolean;
 
   @IsBoolean()
   @ApiProperty({ example: true, description: 'Mote de passe peut etre reinitialisé par sms', type: Boolean })
-  public resetBySms: Boolean;
+  public resetBySms: boolean;
 
   @IsNumber()
   @ApiProperty({ example: '10', description: 'after X bad logins the user will be banned for  bannedTime', type: Number })

src/settings/passwdadm/dto/password-policy.dto.ts

@@ -3,6 +3,8 @@ import { PasswdadmService } from './passwdadm.service';
 import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
 import { Response } from 'express';
 import {omit} from "radash";
+import {InitAccountDto} from "~/management/passwd/_dto/init-account.dto";
+import {PasswordPoliciesDto} from "~/settings/passwdadm/dto/password-policy.dto";
 
 
 @Controller('passwd')
@@ -12,4 +14,12 @@ export class PasswdadmController {
 
   public constructor(private passwdadmService: PasswdadmService) { }
 
+  @Post('setpolicies')
+  @ApiOperation({summary: 'enregistre la police de mdp'})
+  @ApiResponse({status: HttpStatus.OK})
+  public async getPolicies(@Body() body: PasswordPoliciesDto,@Res() res: Response): Promise<Response> {
+    const data = await this.passwdadmService.setPolicies(body)
+    //const datax=omit(data.toObject,['_id'])
+    return res.status(HttpStatus.OK).json({data})
+  }
 }

src/settings/passwdadm/passwdadm.controller.ts

@@ -2,17 +2,14 @@ import { Module } from '@nestjs/common';
 import { PasswdadmService } from './passwdadm.service';
 import { PasswdadmController } from './passwdadm.controller';
 import { BackendsModule } from '~/core/backends/backends.module';
-import { IdentitiesModule } from '~/management/identities/identities.module';
 import {MongooseModule} from "@nestjs/mongoose";
-import {PasswordPolicies,PasswordPoliciesSchema} from "~/settings/passwdadm/_schemas/PasswordPolicies";
-
+import {Settings,SettingsSchema} from "~/settings/_schemas/settings.schema";
 @Module({
   imports: [BackendsModule,
-    IdentitiesModule,
     MongooseModule.forFeatureAsync([
       {
-        name: PasswordPolicies.name,
-        useFactory: () => PasswordPoliciesSchema,
+        name: Settings.name,
+        useFactory: () => SettingsSchema,
       },
     ]),
   ],

src/settings/passwdadm/passwdadm.module.ts

@@ -1,41 +1,27 @@
-import {BadRequestException, Injectable, InternalServerErrorException, NotFoundException} from '@nestjs/common';
-import Redis from 'ioredis';
-import {AbstractService} from '~/_common/abstracts/abstract.service';
-import {PasswordPolicies} from "~/settings/passwdadm/_schemas/PasswordPolicies";
-import {Model} from "mongoose";
+import {Document, Model} from "mongoose";
 import {InjectModel} from "@nestjs/mongoose";
-import {IdentitiesService} from "~/management/identities/identities.service";
 import stringEntropy from 'fast-password-entropy'
 import {pwnedPassword} from "hibp";
 import {PasswordPoliciesDto} from "~/settings/passwdadm/dto/password-policy.dto";
+import {AbstractSettingsService} from "~/_common/abstracts/abstract-settings.service";
+import {Injectable} from "@nestjs/common";
 
 @Injectable()
-export class PasswdadmService extends AbstractService {
-  public constructor(
-    protected readonly identities: IdentitiesService,
-    @InjectModel(PasswordPolicies.name) protected passwordPolicies: Model<PasswordPolicies>
-  ) {
-    super();
-  }
-
-  public async getPolicies(): Promise<PasswordPolicies> {
-    const passwordPolicies = await this.passwordPolicies.findOne()
-    if (passwordPolicies === null) {
-      return new this.passwordPolicies()
-    }
-    return passwordPolicies
-  }
+export class PasswdadmService extends AbstractSettingsService {
 
-  public async setPolicies(policies: PasswordPoliciesDto):Promise<boolean>{
-    //lecture de la police
-    let passwordPolicies = await this.passwordPolicies.findOne()
-    if (passwordPolicies === null) {
-      passwordPolicies= new this.passwordPolicies()
-    }
-    return true
 
+  public async getPolicies(): Promise<object> {
+    const parameters=this.getParameter('passwordpolicies')
+    return parameters
   }
 
+  public async  setPolicies(policies: PasswordPoliciesDto):Promise<any>{
+    return this.setParameter('passwordpolicies',policies)
+  }
+  public async checkPolicies(password: string): Promise<boolean> {
+     return true
+  }
+/*
   public async checkPolicies(password: string): Promise<boolean> {
     const policies = await this.getPolicies()
     if (password.length < policies.len) {
@@ -85,4 +71,13 @@ export class PasswdadmService extends AbstractService {
     }
     return true
   }
+
+ */
+  protected async defaultValues(): Promise<object> {
+    return new PasswordPoliciesDto()
+  }
+
+
+
+
 }