### File

`src/lib/reset-password/reset-password.form.ts`

### Index

###### Properties

- Public password
- Public passwordRepeat
- Public rxapFormGroup

###### Methods

- Public passwordEqual
- Public resetRepeat

### Methods

Public passwordEqual
`passwordEqual(control: RxapFormControl)`
Decorators : `@ControlValidator('passwordRepeat')`
Defined in src/lib/reset-password/reset-password.form.ts:106

Parameters :

Name | Type | Optional
control | `RxapFormControl` | No

Returns : `{ equal: string; }`

Public resetRepeat
`resetRepeat()`
Decorators : `@ControlSetValue('password')`
Defined in src/lib/reset-password/reset-password.form.ts:117
Returns : `void`

### Properties

Public password
Type : `RxapFormControl`
Decorators : `@UseFormControl({validators: undefined})`
Defined in src/lib/reset-password/reset-password.form.ts:98

Public passwordRepeat
Type : `RxapFormControl`
Decorators : `@UseFormControl({validators: undefined})`
Defined in src/lib/reset-password/reset-password.form.ts:103

Public rxapFormGroup
Type : `RxapFormGroup`
Defined in src/lib/reset-password/reset-password.form.ts:93

    import {
      Inject,
      Injectable,
      INJECTOR,
      Injector,
      Provider,
    } from '@angular/core';
    import { Validators } from '@angular/forms';
    import { MatSnackBar } from '@angular/material/snack-bar';
    import {
      ActivatedRoute,
      Router,
    } from '@angular/router';
    import {
      ControlSetValue,
      ControlValidator,
      FormSubmitMethod,
      FormType,
      RXAP_FORM_DEFINITION,
      RXAP_FORM_DEFINITION_BUILDER,
      RXAP_FORM_SUBMIT_METHOD,
      RxapForm,
      RxapFormBuilder,
      RxapFormControl,
      RxapFormGroup,
      UseFormControl,
    } from '@rxap/forms';
    import { firstValueFrom } from 'rxjs';
    import {
      map,
      switchMap,
      take,
      tap,
    } from 'rxjs/operators';
    import { SetNewPasswordWithResetTokenMethod } from './set-new-password-with-reset-token.method';

    export const RXAP_RESET_PASSWORD_FORM = 'rxap-reset-password';

    @Injectable()
    export class ResetPasswordFormSubmitMethod implements FormSubmitMethod<any> {
      constructor(
        @Inject(ActivatedRoute)
        private readonly route: ActivatedRoute,
        private readonly setNewPasswordWithResetTokenMethod: SetNewPasswordWithResetTokenMethod,
        @Inject(MatSnackBar)
        private readonly snackBar: MatSnackBar,
        @Inject(Router)
        private readonly router: Router,
      ) {
      }

      public call(value: { password: string }): boolean | Promise<boolean> {
        return firstValueFrom(this.route.params
          .pipe(
            take(1),
            map((params) => params['token']),
            switchMap((token) =>
              this.setNewPasswordWithResetTokenMethod.call({
                password: value.password,
                token,
              }),
            ),
            tap(
              {
                error: () => {
                  this.snackBar.open('Password reset failed.', undefined, {
                    duration: 3500,
                  });
                },
                next: () => {
                  this.snackBar.open('Password reset was successful.', undefined, {
                    duration: 3500,
                  });
                  return this.router.navigate([ '/' ]);
                },
              },
            ),
            map(() => true),
          ));
      }
    }

    export interface IResetPasswordForm {
      password: string;
      passwordRepeat: string;
    }

    @RxapForm({
      id: RXAP_RESET_PASSWORD_FORM,
    })
    @Injectable()
    export class ResetPasswordForm implements FormType<IResetPasswordForm> {
      public rxapFormGroup!: RxapFormGroup;

      @UseFormControl({
        validators: [ Validators.required ],
      })
      public password!: RxapFormControl;

      @UseFormControl({
        validators: [ Validators.required ],
      })
      public passwordRepeat!: RxapFormControl;

      @ControlValidator('passwordRepeat')
      public passwordEqual(control: RxapFormControl) {
        if (this.password.value === null || control.value === null) {
          return null;
        }
        if (this.password.value !== control.value) {
          return { equal: 'passwords are not equal' };
        }
        return null;
      }

      @ControlSetValue('password')
      public resetRepeat() {
        this.passwordRepeat.reset();
      }
    }

    export const ResetPasswordFormProviders: Provider[] = [
      ResetPasswordForm,
      {
        provide: RXAP_FORM_DEFINITION_BUILDER,
        useFactory: (injector: Injector) =>
          new RxapFormBuilder<IResetPasswordForm>(ResetPasswordForm, injector),
        deps: [ INJECTOR ],
      },
      {
        provide: RXAP_FORM_DEFINITION,
        useFactory: (builder: RxapFormBuilder<IResetPasswordForm>) =>
          builder.build(),
        deps: [ RXAP_FORM_DEFINITION_BUILDER ],
      },
      {
        provide: RXAP_FORM_SUBMIT_METHOD,
        useClass: ResetPasswordFormSubmitMethod,
      },
    ];

# results matching ""

# No results matching ""