### File

`src/factory/reactive-forms-factory.ts`

### Index

###### Methods
Public createFormArrayFromQuestions Public createFormGroupFromGroups Public createFormGroupFromQuestions Public createValidators

### Methods

Public createFormArrayFromQuestions
`createFormArrayFromQuestions(questions: [][])`
Defined in src/factory/reactive-forms-factory.ts:67
Parameters :
Name | Type | Optional | Description
questions | `[][]` |  |
Returns : `Promise<>`

Public createFormGroupFromGroups
`createFormGroupFromGroups(groups: Group[])`
Defined in src/factory/reactive-forms-factory.ts:14
Parameters :
Name | Type | Optional | Description
groups | `Group[]` |  |
Returns : `Promise<>`

Public createFormGroupFromQuestions
`createFormGroupFromQuestions(questions: Question[], checkDisabledQuestions: boolean)`
Defined in src/factory/reactive-forms-factory.ts:42
Parameters :
Name | Type | Optional | Description
questions | `Question[]` |  |
checkDisabledQuestions | `boolean` |  |
Returns : `Promise<>`

Public createValidators
`createValidators(validations: Validation[])`
Defined in src/factory/reactive-forms-factory.ts:89
Parameters :
Name | Type | Optional | Description
validations | `Validation[]` |  |
Returns : `Promise<[]>`

    import { FormGroup, FormArray, FormControl, ValidatorFn, Validators } from '@angular/forms';

    import { Group, GroupType, Fieldset, DataTable } from '../group';
    import { Choice, Question } from '../question';
    import { Validation, MinLength, MaxLength, Pattern, Required, Min, Max } from '../validation';
    import {
      ValidatorFactoryHandler, RequiredValidator, EmailValidator, MaxValidator, MinValidator,
      MaxLengthValidator, MinLengthValidator, PatternValidator
    } from '../chain-of-responsibility/validator-factory';
    import { ValidationTypeNotFoundError } from '../chain-of-responsibility/validator-factory/error';

    export class ReactiveFormsFactory {

      public static async createFormGroupFromGroups(groups: Group<any>[]): Promise<FormGroup> {
        return new Promise<FormGroup>(async (resolve: (formGroup: FormGroup) => void, reject: (error: string) => void) => {
          try {
            const formGroup: FormGroup = new FormGroup({});

            for await (const group of groups) {
              let control: FormGroup | FormArray;

              if (GroupType.FIELDSET === group.type) {
                control = await ReactiveFormsFactory.createFormGroupFromQuestions((<Fieldset>group).questions);
              } else {
                control = await ReactiveFormsFactory.createFormArrayFromQuestions((<DataTable>group).questions.slice(1));

                if ((<DataTable>group).validations && 0 < (<DataTable>group).validations.length) {
                  control.setValidators(await ReactiveFormsFactory.createValidators((<DataTable>group).validations));
                }
              }

              formGroup.addControl(group.code, control);
            }

            resolve(formGroup);
          } catch (error) {
            reject(error);
          }
        });
      }

      public static async createFormGroupFromQuestions(questions: Question<any>[], checkDisabledQuestions: boolean = true): Promise<FormGroup> {
        return new Promise<FormGroup>(async (resolve: (formGroup: FormGroup) => void, reject: (error: Error) => void) => {
          try {
            const formGroup: FormGroup = new FormGroup({});

            for await (const question of questions) {
              const validators: ValidatorFn[] = await ReactiveFormsFactory.createValidators(question.validations);
              const answer: any = ReactiveFormsFactory.getFormStateValue(question);
              const formState: any = { value: answer, disabled: checkDisabledQuestions && question.disabled };
              const control: FormControl = new FormControl(formState, validators);

              if (question.validations && 0 < question.validations.length) {
                control.setValidators(await ReactiveFormsFactory.createValidators(question.validations));
              }

              formGroup.addControl(question.name, control);
            }

            resolve(formGroup);
          } catch (error) {
            reject(error);
          }
        });
      }

      public static async createFormArrayFromQuestions(questions: Question<any>[][]): Promise<FormArray> {
        return new Promise<FormArray>(async (resolve: (formArray: FormArray) => void, reject: (error: Error) => void) => {
          try {
            const formArray: FormArray = new FormArray([]);

            for await (const question of questions) {
              const group: FormGroup = new FormGroup({});

              for (const column of question) {
                group.addControl(column.name, new FormControl(column.answer ? column.answer.value : null));
              }

              formArray.push(group);
            }

            resolve(formArray);
          } catch (error) {
            reject(error);
          }
        });
      }

      public static async createValidators(validations: Validation[]): Promise<ValidatorFn[]> {
        return new Promise<ValidatorFn[]>(async (resolve: (validators: ValidatorFn[]) => void, reject: (error: Error) => void) => {
          try {
            const validators: ValidatorFn[] = [];

            for await (const validation of validations) {
              const validatorFactoryHandler: ValidatorFactoryHandler = (new RequiredValidator())
                .append(new EmailValidator())
                .append(new MaxValidator())
                .append(new MinValidator())
                .append(new MaxLengthValidator())
                .append(new MinLengthValidator())
                .append(new PatternValidator());

              const validatorFn: ValidatorFn = validatorFactoryHandler.handle(validation);
              validators.push(validatorFn);
            }

            resolve(validators);
          } catch (error) {
            reject(error);
          }
        });
      }

      private static getFormStateValue(question: Question<any>): any {
        if ((<Choice>question).defaultOption && (!question.answer || !question.answer.value)) {
          return (<Choice>question).defaultOption;
        }

        if (question.answer && question.answer.value) {
          return question.answer.value;
        }

        return null;
      }
    }

# results matching ""

# No results matching ""