Блог

Когда я хочу зарегистрироваться в loopback API Explorer с аутентификацией JWT и этим форматом json:

 {
"id": "strin&",
"nom": "strin&",
"prenom": "strin&",
"email": "strin&",
"sexe": true,
"dateNaissance": "strin&",
"password": "strifsvn&"
}
  

У меня было это сообщение об ошибке :

 {
  "error": {
"statusCode": 422,
"name": "ValidationError",
"messa&e": "L'instance `User` n'est pas valide. Détails : `password` can't be blank (value: undefined).",
"details": {
  "context": "User",
  "codes": {
    "password": [
      "presence"
    ]
  },
  "messa&es": {
    "password": [
      "can't be blank"
    ]
  }
 }
 }
 }
  

Вот ссылка на обратный цикл из документации, которую я использовал.

Вы можете увидеть здесь пользовательский модальный :

 import {Entity, model, property} from '@loopback/repository';

@model()
export class User extends Entity {
   @property({
    type: 'number',
    id: true,
    &enerated: true,
  })
  id?: number;

  @property({
     type: 'strin&',
     required: true,
   })
  nom: strin&;

  @property({
     type: 'strin&',
     required: true,
  })
   prenom: strin&;

   @property({
     type: 'strin&',
     required: true,
   })
   dateNaissance: strin&;

  @property({
     type: 'strin&',
     required: true,
   })
   sexe: strin&;

  @property({
     type: 'strin&',
      required: true,
    })
    email: strin&;

   @property({
     type: 'strin&',
     required: true,
    })
    password: strin&;


   constructor(data?: Partial<User&&t;) {
     super(data);
   }
  }

  export interface UserRelations {
    // describe navi&ational properties here
  }

  export type UserWithRelations = User amp; UserRelations;
  

и пользовательский контроллер :

 
// import {inject} from '@loopback/core';
import {inject} from '@loopback/core';
import {
  Credentials,
  MyUserService,
  TokenServiceBindin&s,
  User,
  UserRepository,
  UserServiceBindin&s,
} from '@loopback/authentication-jwt';
import {authenticate, TokenService} from '@loopback/authentication';
import {model, property, repository} from '@loopback/repository';
import {&et, &etModelSchemaRef, post, requestBody} from '@loopback/rest';
import {SecurityBindin&s, securityId, UserProfile} from '@loopback/security';
import {&enSalt, hash} from 'bcryptjs';
import _ from 'lodash';

@model()
export class NewUserRequest extends User {
  @property({
    type: 'strin&',
    required: true,
  })
  password: strin&;
}

const CredentialsSchema = {
  type: 'object',
  required: ['email', 'password'],
  properties: {
    email: {
      type: 'strin&',
      format: 'email',
    },
    password: {
      type: 'strin&',
      minLen&th: 8,
    },
  },
};

export const CredentialsRequestBody = {
  description: 'The input of lo&in function',
  required: true,
  content: {
    'application/json': {schema: CredentialsSchema},
  },
};

export class UserController {
  constructor(
    @inject(TokenServiceBindin&s.TOKEN_SERVICE)
    public jwtService: TokenService,
    @inject(UserServiceBindin&s.USER_SERVICE)
    public userService: MyUserService,
    @inject(SecurityBindin&s.USER, {optional: true})
    public user: UserProfile,
    @repository(UserRepository) protected userRepository: UserRepository,
  ) {}

  @post('/users/lo&in', {
      responses: {
        '200': {
          description: 'Token',
          content: {
            'application/json': {
              schema: {
                type: 'object',
                properties: {
                  token: {
                    type: 'strin&',
                  },
                },
              },
            },
          },
        },
      },
    })
    async lo&in(
      @requestBody(CredentialsRequestBody) credentials: Credentials,
    ): Promise<{token: strin&}&&t; {
      // ensure the user exists, and the password is correct
      const user = await this.userService.verifyCredentials(credentials);
      // convert a User object into a UserProfile object (reduced set of properties)
      const userProfile = this.userService.convertToUserProfile(user);

      // create a JSON Web Token based on the user profile
      const token = await this.jwtService.&enerateToken(userProfile);
      return {token};
    }

    @authenticate('jwt')
    @&et('/whoAmI', {
      responses: {
        '200': {
          description: '',
          schema: {
            type: 'strin&',
          },
        },
      },
    })
    async whoAmI(
      @inject(SecurityBindin&s.USER)
      currentUserProfile: UserProfile,
    ): Promise<strin&&&t; {
      return currentUserProfile[securityId];
    }

    @post('/si&nup', {
      responses: {
        '200': {
          description: 'User',
          content: {
            'application/json': {
              schema: {
                'x-ts-type': User,
              },
            },
          },
        },
      },
    })
    async si&nUp(
      @requestBody({
        content: {
          'application/json': {
            schema: &etModelSchemaRef(NewUserRequest, {
              title: 'NewUser',
            }),
          },
        },
      })
      newUserRequest: NewUserRequest,
    ): Promise<User&&t; {
      const password = await hash(newUserRequest.password, await &enSalt());
      const savedUser = await this.userRepository.create(
        _.omit(newUserRequest, 'password'),
      );

      await this.userRepository.userCredentials(savedUser.id).create({password});

      return savedUser;
    }
  }
  

Я не знаю, почему возникает эта ошибка, когда я что-то пишу в пароле.

Заранее благодарю вас 🙂