2024-01-18 10:59:42 +01:00
|
|
|
import { FormArray, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from "@angular/forms";
|
2023-10-24 09:40:26 +02:00
|
|
|
import { DmpBlueprintExtraFieldDataType } from "@app/core/common/enum/dmp-blueprint-field-type";
|
|
|
|
import { DmpBlueprintSectionFieldCategory } from "@app/core/common/enum/dmp-blueprint-section-field-category";
|
2023-10-20 17:01:09 +02:00
|
|
|
import { DmpBlueprintStatus } from "@app/core/common/enum/dmp-blueprint-status";
|
2023-10-24 09:40:26 +02:00
|
|
|
import { DmpBlueprintSystemFieldType } from "@app/core/common/enum/dmp-blueprint-system-field-type";
|
|
|
|
import { DescriptionTemplatesInSection, DescriptionTemplatesInSectionPersist, DmpBlueprint, DmpBlueprintDefinition, DmpBlueprintDefinitionPersist, DmpBlueprintDefinitionSection, DmpBlueprintDefinitionSectionPersist, DmpBlueprintPersist, FieldInSection, FieldInSectionPersist } from "@app/core/model/dmp-blueprint/dmp-blueprint";
|
|
|
|
import { BaseEditorModel } from "@common/base/base-form-editor-model";
|
2023-09-11 07:59:47 +02:00
|
|
|
import { BackendErrorValidator } from "@common/forms/validation/custom-validator";
|
|
|
|
import { ValidationErrorModel } from "@common/forms/validation/error-model/validation-error-model";
|
2023-10-24 09:40:26 +02:00
|
|
|
import { Validation, ValidationContext } from "@common/forms/validation/validation-context";
|
|
|
|
import { Guid } from "@common/types/guid";
|
|
|
|
|
|
|
|
export class DmpBlueprintEditorModel extends BaseEditorModel implements DmpBlueprintPersist {
|
|
|
|
label: string;
|
2024-01-24 16:50:34 +01:00
|
|
|
definition: DmpBlueprintDefinitionEditorModel = new DmpBlueprintDefinitionEditorModel();
|
2023-10-24 09:40:26 +02:00
|
|
|
status: DmpBlueprintStatus = DmpBlueprintStatus.Draft;
|
|
|
|
description: string;
|
|
|
|
permissions: string[];
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-09-11 07:59:47 +02:00
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel();
|
2023-10-24 09:40:26 +02:00
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
constructor() { super(); }
|
|
|
|
|
|
|
|
public fromModel(item: DmpBlueprint): DmpBlueprintEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.label = item.label;
|
|
|
|
this.status = item.status;
|
|
|
|
this.description = item.description;
|
2024-01-19 15:23:34 +01:00
|
|
|
this.definition = new DmpBlueprintDefinitionEditorModel(this.validationErrorModel).fromModel(item.definition);
|
2023-10-24 09:40:26 +02:00
|
|
|
}
|
2023-07-25 14:51:29 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-05 15:39:17 +02:00
|
|
|
buildForm(context: ValidationContext = null, disabled: boolean = false): UntypedFormGroup {
|
2023-09-11 07:59:47 +02:00
|
|
|
if (context == null) { context = this.createValidationContext(); }
|
2023-10-24 09:40:26 +02:00
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
status: [{ value: this.status, disabled: disabled }, context.getValidation('status').validators],
|
|
|
|
definition: this.definition.buildForm({
|
|
|
|
rootPath: `definition.`
|
|
|
|
}),
|
|
|
|
hash: [{ value: this.hash, disabled: disabled }, context.getValidation('hash').validators]
|
2023-07-25 14:51:29 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2023-09-11 07:59:47 +02:00
|
|
|
createValidationContext(): ValidationContext {
|
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
2023-10-24 09:40:26 +02:00
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'id', validators: [BackendErrorValidator(this.validationErrorModel, 'id')] });
|
|
|
|
baseValidationArray.push({ key: 'label', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'label')] });
|
|
|
|
baseValidationArray.push({ key: 'status', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'status')] });
|
|
|
|
baseValidationArray.push({ key: 'hash', validators: [] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
2023-09-11 07:59:47 +02:00
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-18 10:59:42 +01:00
|
|
|
|
|
|
|
createChildSection(index: number): UntypedFormGroup {
|
|
|
|
const section: DmpBlueprintDefinitionSectionEditorModel = new DmpBlueprintDefinitionSectionEditorModel(this.validationErrorModel);
|
|
|
|
section.id = Guid.create();
|
|
|
|
section.ordinal = index + 1;
|
|
|
|
section.hasTemplates = false;
|
|
|
|
return section.buildForm({ rootPath: 'definition.sections[' + index + '].' });
|
|
|
|
}
|
|
|
|
|
2024-01-25 14:49:34 +01:00
|
|
|
createChildSystemField(sectionIndex: number, index: number, systemFieldType: DmpBlueprintSystemFieldType): UntypedFormGroup{
|
|
|
|
const field: FieldInSectionEditorModel = new FieldInSectionEditorModel(this.validationErrorModel);
|
|
|
|
field.id = Guid.create();
|
|
|
|
field.ordinal = index + 1;
|
|
|
|
field.category = DmpBlueprintSectionFieldCategory.SYSTEM;
|
|
|
|
field.systemFieldType = systemFieldType;
|
|
|
|
field.required = (systemFieldType == DmpBlueprintSystemFieldType.TEXT || systemFieldType == DmpBlueprintSystemFieldType.HTML_TEXT) ? true : false;
|
|
|
|
return field.buildForm({ rootPath: 'definition.sections[' + sectionIndex + '].fields[' + index + '].'});
|
|
|
|
}
|
|
|
|
|
2024-01-18 10:59:42 +01:00
|
|
|
createChildExtraField(sectionIndex: number, index: number): UntypedFormGroup {
|
|
|
|
const field: FieldInSectionEditorModel = new FieldInSectionEditorModel(this.validationErrorModel);
|
|
|
|
field.id = Guid.create();
|
|
|
|
field.ordinal = index + 1;
|
|
|
|
field.category = DmpBlueprintSectionFieldCategory.EXTRA;
|
|
|
|
return field.buildForm({ rootPath: 'definition.sections[' + sectionIndex + '].fields[' + index + '].'});
|
|
|
|
}
|
|
|
|
|
|
|
|
createChildDescriptionTemplate(item: any, sectionIndex: number, index: number): UntypedFormGroup {
|
|
|
|
const descriptionTemplate: DescriptionTemplatesInSectionEditorModel = new DescriptionTemplatesInSectionEditorModel(this.validationErrorModel);
|
|
|
|
descriptionTemplate.id = Guid.create();
|
|
|
|
descriptionTemplate.descriptionTemplateId = item.id;
|
|
|
|
descriptionTemplate.label = item.label;
|
|
|
|
return descriptionTemplate.buildForm({ rootPath: 'definition.sections[' + sectionIndex + '].descriptionTemplates[' + index + '].'});
|
|
|
|
}
|
|
|
|
|
|
|
|
static reApplySectionValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, validationErrorModel } = params;
|
|
|
|
const control = formGroup?.get('definition');
|
|
|
|
DmpBlueprintDefinitionEditorModel.reapplySectionsValidators({
|
|
|
|
formArray: control.get('sections') as UntypedFormArray,
|
|
|
|
rootPath: `definition.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
}
|
2023-07-25 14:51:29 +02:00
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
export class DmpBlueprintDefinitionEditorModel implements DmpBlueprintDefinitionPersist {
|
|
|
|
sections: DmpBlueprintDefinitionSectionEditorModel[] = [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
public fromModel(item: DmpBlueprintDefinition): DmpBlueprintDefinitionEditorModel {
|
|
|
|
if (item) {
|
2024-01-19 15:23:34 +01:00
|
|
|
if (item.sections) { item.sections.map(x => this.sections.push(new DmpBlueprintDefinitionSectionEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-24 09:40:26 +02:00
|
|
|
}
|
2023-07-25 14:51:29 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DmpBlueprintDefinitionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
sections: this.formBuilder.array(
|
|
|
|
(this.sections ?? []).map(
|
|
|
|
(item, index) => new DmpBlueprintDefinitionSectionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2023-11-24 17:42:23 +01:00
|
|
|
rootPath: `${rootPath}sections[${index}].`
|
2023-10-24 09:40:26 +02:00
|
|
|
}), context.getValidation('sections')
|
|
|
|
)
|
|
|
|
),
|
2023-07-25 14:51:29 +02:00
|
|
|
});
|
|
|
|
}
|
2023-10-24 09:40:26 +02:00
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
|
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'sections', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}sections`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
|
|
|
|
2024-01-18 10:59:42 +01:00
|
|
|
static reapplySectionsValidators(params: {
|
|
|
|
formArray: UntypedFormArray,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
|
|
formArray?.controls?.forEach(
|
|
|
|
(control, index) => DmpBlueprintDefinitionSectionEditorModel.reapplySectionValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}sections[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-07-25 14:51:29 +02:00
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
export class DmpBlueprintDefinitionSectionEditorModel implements DmpBlueprintDefinitionSectionPersist {
|
|
|
|
id: Guid;
|
|
|
|
label: string;
|
|
|
|
description: string;
|
|
|
|
ordinal: number;
|
|
|
|
fields: FieldInSectionEditorModel[] = [];
|
|
|
|
hasTemplates: boolean;
|
|
|
|
descriptionTemplates?: DescriptionTemplatesInSectionEditorModel[] = [];
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
public fromModel(item: DmpBlueprintDefinitionSection): DmpBlueprintDefinitionSectionEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.id = item.id;
|
|
|
|
this.label = item.label;
|
|
|
|
this.description = item.description;
|
|
|
|
this.ordinal = item.ordinal;
|
|
|
|
this.hasTemplates = item.hasTemplates;
|
2024-01-19 15:23:34 +01:00
|
|
|
if (item.fields) { item.fields.map(x => this.fields.push(new FieldInSectionEditorModel(this.validationErrorModel).fromModel(x))); }
|
|
|
|
if (item.descriptionTemplates) { item.descriptionTemplates.map(x => this.descriptionTemplates.push(new DescriptionTemplatesInSectionEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-24 09:40:26 +02:00
|
|
|
}
|
2023-07-25 14:51:29 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DmpBlueprintDefinitionSectionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
|
|
hasTemplates: [{ value: this.hasTemplates, disabled: disabled }, context.getValidation('hasTemplates').validators],
|
|
|
|
fields: this.formBuilder.array(
|
|
|
|
(this.fields ?? []).map(
|
|
|
|
(item, index) => new FieldInSectionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-19 15:23:34 +01:00
|
|
|
rootPath: `${rootPath}fields[${index}].`
|
2023-10-24 09:40:26 +02:00
|
|
|
}), context.getValidation('fields')
|
|
|
|
)
|
|
|
|
),
|
|
|
|
descriptionTemplates: this.formBuilder.array(
|
|
|
|
(this.descriptionTemplates ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplatesInSectionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-19 15:23:34 +01:00
|
|
|
rootPath: `${rootPath}descriptionTemplates[${index}].`
|
2023-10-24 09:40:26 +02:00
|
|
|
}), context.getValidation('descriptionTemplates')
|
|
|
|
)
|
|
|
|
)
|
2023-07-25 14:51:29 +02:00
|
|
|
});
|
|
|
|
}
|
2023-09-11 07:59:47 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
|
2023-09-11 07:59:47 +02:00
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
2023-10-24 09:40:26 +02:00
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'label', validators: [Validators.required,BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
|
|
|
baseValidationArray.push({ key: 'description', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}description`)] });
|
|
|
|
baseValidationArray.push({ key: 'hasTemplates', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}hasTemplates`)] });
|
|
|
|
baseValidationArray.push({ key: 'fields', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fields`)] });
|
|
|
|
baseValidationArray.push({ key: 'descriptionTemplates', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}descriptionTemplates`)] });
|
|
|
|
baseValidationArray.push({ key: 'hash', validators: [] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
2023-09-11 07:59:47 +02:00
|
|
|
return baseContext;
|
|
|
|
}
|
2023-10-24 09:40:26 +02:00
|
|
|
|
2024-01-18 10:59:42 +01:00
|
|
|
static reapplySectionValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DmpBlueprintDefinitionSectionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id','label', 'ordinal', 'description', 'hasTemplates', 'hash'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('fields') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => FieldInSectionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}fields[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
2024-01-24 16:50:34 +01:00
|
|
|
(formGroup.get('descriptionTemplates') as FormArray).controls?.forEach(
|
2024-01-18 10:59:42 +01:00
|
|
|
(control, index) => DescriptionTemplatesInSectionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}descriptionTemplates[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2023-07-25 14:51:29 +02:00
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
export class FieldInSectionEditorModel implements FieldInSectionPersist {
|
|
|
|
public id: Guid;
|
|
|
|
public category: DmpBlueprintSectionFieldCategory;
|
|
|
|
public dataType: DmpBlueprintExtraFieldDataType;
|
|
|
|
public systemFieldType: DmpBlueprintSystemFieldType;
|
|
|
|
public label: string;
|
|
|
|
public placeholder: string;
|
|
|
|
public description: string;
|
2023-10-27 17:56:19 +02:00
|
|
|
public required: boolean = false;
|
2023-10-24 09:40:26 +02:00
|
|
|
public ordinal: number;
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: FieldInSection): FieldInSectionEditorModel {
|
2023-07-25 14:51:29 +02:00
|
|
|
this.id = item.id;
|
2023-08-03 12:10:36 +02:00
|
|
|
this.category = item.category;
|
2023-10-24 09:40:26 +02:00
|
|
|
this.dataType = item.dataType;
|
|
|
|
this.systemFieldType = item.systemFieldType;
|
2023-08-03 12:10:36 +02:00
|
|
|
this.label = item.label;
|
2023-10-24 09:40:26 +02:00
|
|
|
this.placeholder = item.placeholder;
|
|
|
|
this.description = item.description;
|
|
|
|
this.required = item.required;
|
|
|
|
this.ordinal = item.ordinal;
|
2023-07-25 14:51:29 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = FieldInSectionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
|
|
|
|
category: [{ value: this.category, disabled: disabled }, context.getValidation('category').validators],
|
|
|
|
dataType: [{ value: this.dataType, disabled: disabled }, context.getValidation('dataType').validators],
|
|
|
|
systemFieldType: [{ value: this.systemFieldType, disabled: disabled }, context.getValidation('systemFieldType').validators],
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
placeholder: [{ value: this.placeholder, disabled: disabled }, context.getValidation('placeholder').validators],
|
|
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
|
|
required: [{ value: this.required, disabled: disabled }, context.getValidation('required').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
|
2023-07-25 14:51:29 +02:00
|
|
|
});
|
|
|
|
}
|
2023-09-11 07:59:47 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
|
2023-09-11 07:59:47 +02:00
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
2023-10-24 09:40:26 +02:00
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
|
|
|
|
baseValidationArray.push({ key: 'category', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}category`)] });
|
|
|
|
baseValidationArray.push({ key: 'dataType', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}dataType`)] });
|
|
|
|
baseValidationArray.push({ key: 'systemFieldType', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}systemFieldType`)] });
|
|
|
|
baseValidationArray.push({ key: 'label', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'placeholder', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}placeholder`)] });
|
|
|
|
baseValidationArray.push({ key: 'description', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}description`)] });
|
|
|
|
baseValidationArray.push({ key: 'required', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}required`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
2023-09-11 07:59:47 +02:00
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-18 10:59:42 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = FieldInSectionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'category', 'dataType', 'systemFieldType', 'label', 'placeholder', 'description', 'required', 'ordinal'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-07-25 14:51:29 +02:00
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
export class DescriptionTemplatesInSectionEditorModel implements DescriptionTemplatesInSectionPersist {
|
|
|
|
id: Guid;
|
|
|
|
descriptionTemplateId: Guid;
|
|
|
|
label: string;
|
|
|
|
minMultiplicity: number;
|
|
|
|
maxMultiplicity: number;
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
2023-07-25 14:51:29 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
fromModel(item: DescriptionTemplatesInSection): DescriptionTemplatesInSectionEditorModel {
|
2023-07-25 14:51:29 +02:00
|
|
|
this.id = item.id;
|
|
|
|
this.descriptionTemplateId = item.descriptionTemplateId;
|
2023-10-24 09:40:26 +02:00
|
|
|
this.label = item.label;
|
|
|
|
this.minMultiplicity = item.minMultiplicity;
|
|
|
|
this.maxMultiplicity = item.maxMultiplicity;
|
2023-07-25 14:51:29 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplatesInSectionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
descriptionTemplateId: [{ value: this.descriptionTemplateId, disabled: disabled }, context.getValidation('descriptionTemplateId').validators],
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
minMultiplicity: [{ value: this.minMultiplicity, disabled: disabled }, context.getValidation('minMultiplicity').validators],
|
|
|
|
maxMultiplicity: [{ value: this.maxMultiplicity, disabled: disabled }, context.getValidation('maxMultiplicity').validators],
|
|
|
|
|
2023-07-25 14:51:29 +02:00
|
|
|
});
|
|
|
|
}
|
2023-09-11 07:59:47 +02:00
|
|
|
|
2023-10-24 09:40:26 +02:00
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
|
2023-09-11 07:59:47 +02:00
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
2023-10-24 09:40:26 +02:00
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'descriptionTemplateId', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}descriptionTemplateId`)] });
|
|
|
|
baseValidationArray.push({ key: 'label', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'minMultiplicity', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}minMultiplicity`)] });
|
|
|
|
baseValidationArray.push({ key: 'maxMultiplicity', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}maxMultiplicity`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
2023-09-11 07:59:47 +02:00
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-18 10:59:42 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplatesInSectionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'descriptionTemplateId', 'label', 'minMultiplicity', 'maxMultiplicity'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-10-24 09:40:26 +02:00
|
|
|
}
|