2024-01-22 17:16:45 +01:00
|
|
|
import { FormArray, FormControl, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from "@angular/forms";
|
2023-11-24 17:42:23 +01:00
|
|
|
import { DescriptionTemplateFieldAutocompleteType } from "@app/core/common/enum/description-template-field-autocomplete-type";
|
2024-01-31 10:36:12 +01:00
|
|
|
import { DescriptionTemplateFieldDataExternalDatasetType } from "@app/core/common/enum/description-template-field-data-external-dataset-type";
|
2023-11-24 17:42:23 +01:00
|
|
|
import { DescriptionTemplateFieldType } from "@app/core/common/enum/description-template-field-type";
|
2023-10-31 10:19:52 +01:00
|
|
|
import { DescriptionTemplateFieldValidationType } from "@app/core/common/enum/description-template-field-validation-type";
|
2023-10-30 14:30:46 +01:00
|
|
|
import { DescriptionTemplateStatus } from "@app/core/common/enum/description-template-status";
|
2023-11-24 17:42:23 +01:00
|
|
|
import { UserDescriptionTemplateRole } from "@app/core/common/enum/user-description-template-role";
|
2023-10-31 10:19:52 +01:00
|
|
|
import { DescriptionTemplate, DescriptionTemplateDefinition, DescriptionTemplateField, DescriptionTemplateFieldSet, DescriptionTemplateMultiplicity, DescriptionTemplatePage, DescriptionTemplateRule, DescriptionTemplateSection } from "@app/core/model/description-template/description-template";
|
2024-01-31 10:36:12 +01:00
|
|
|
import { DescriptionTemplateAuthAutoCompleteDataPersist, DescriptionTemplateAutoCompleteDataPersist, DescriptionTemplateAutoCompleteSingleDataPersist, DescriptionTemplateBaseFieldDataPersist, DescriptionTemplateComboBoxOptionPersist, DescriptionTemplateDefinitionPersist, DescriptionTemplateFieldPersist, DescriptionTemplateFieldSetPersist, DescriptionTemplateMultiplicityPersist, DescriptionTemplatePagePersist, DescriptionTemplatePersist, DescriptionTemplatePlaceholderAndMultiplicityDataPersist, DescriptionTemplateRadioBoxDataPersist, DescriptionTemplateRadioBoxOptionPersist, DescriptionTemplateRulePersist, DescriptionTemplateSectionPersist, DescriptionTemplateUploadDataPersist, DescriptionTemplateUploadOptionPersist, DescriptionTemplateSelectDataPersist, UserDescriptionTemplatePersist, DescriptionTemplateExternalDatasetDataPersist } from "@app/core/model/description-template/description-template-persist";
|
2023-10-30 14:30:46 +01:00
|
|
|
import { BaseEditorModel } from "@common/base/base-form-editor-model";
|
|
|
|
import { BackendErrorValidator } from "@common/forms/validation/custom-validator";
|
|
|
|
import { ValidationErrorModel } from "@common/forms/validation/error-model/validation-error-model";
|
|
|
|
import { Validation, ValidationContext } from "@common/forms/validation/validation-context";
|
|
|
|
import { Guid } from "@common/types/guid";
|
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
export class DescriptionTemplateEditorModel extends BaseEditorModel implements DescriptionTemplatePersist {
|
2023-10-30 14:30:46 +01:00
|
|
|
label: string;
|
|
|
|
description: string;
|
2023-10-31 10:19:52 +01:00
|
|
|
language: string;
|
|
|
|
type: Guid;
|
2024-01-24 10:40:32 +01:00
|
|
|
status: DescriptionTemplateStatus = DescriptionTemplateStatus.Draft;
|
2023-11-24 17:42:23 +01:00
|
|
|
definition: DescriptionTemplateDefinitionEditorModel = new DescriptionTemplateDefinitionEditorModel();
|
|
|
|
users: UserDescriptionTemplateEditorModel[] = [];
|
2023-10-30 14:30:46 +01:00
|
|
|
permissions: string[];
|
|
|
|
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel();
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor() { super(); }
|
|
|
|
|
|
|
|
public fromModel(item: DescriptionTemplate): DescriptionTemplateEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.label = item.label;
|
|
|
|
this.description = item.description;
|
2024-01-19 13:28:31 +01:00
|
|
|
this.language = item.language;
|
|
|
|
this.type = item.type?.id;
|
|
|
|
this.status = item.status;
|
2024-01-22 17:16:45 +01:00
|
|
|
this.definition = new DescriptionTemplateDefinitionEditorModel(this.validationErrorModel).fromModel(item.definition);
|
2024-01-24 10:40:32 +01:00
|
|
|
if (item.users) { item.users.map(x => this.users.push(new UserDescriptionTemplateEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-30 14:30:46 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(context: ValidationContext = null, disabled: boolean = false): UntypedFormGroup {
|
|
|
|
if (context == null) { context = this.createValidationContext(); }
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
2023-10-31 10:19:52 +01:00
|
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
|
|
language: [{ value: this.language, disabled: disabled }, context.getValidation('language').validators],
|
|
|
|
type: [{ value: this.type, disabled: disabled }, context.getValidation('type').validators],
|
2023-10-30 14:30:46 +01:00
|
|
|
status: [{ value: this.status, disabled: disabled }, context.getValidation('status').validators],
|
2023-10-31 10:19:52 +01:00
|
|
|
definition: this.definition.buildForm({
|
|
|
|
rootPath: `definition.`
|
|
|
|
}),
|
2023-11-24 17:42:23 +01:00
|
|
|
users: this.formBuilder.array(
|
|
|
|
(this.users ?? []).map(
|
|
|
|
(item, index) => new UserDescriptionTemplateEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
|
|
|
rootPath: `users[${index}].`
|
|
|
|
}), context.getValidation('users')
|
|
|
|
)
|
|
|
|
),
|
2023-10-30 14:30:46 +01:00
|
|
|
hash: [{ value: this.hash, disabled: disabled }, context.getValidation('hash').validators]
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
createValidationContext(): ValidationContext {
|
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
|
|
|
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')] });
|
2023-10-31 10:19:52 +01:00
|
|
|
baseValidationArray.push({ key: 'description', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'description')] });
|
|
|
|
baseValidationArray.push({ key: 'language', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'language')] });
|
|
|
|
baseValidationArray.push({ key: 'type', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'type')] });
|
|
|
|
baseValidationArray.push({ key: 'type', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'type')] });
|
2023-10-30 14:30:46 +01:00
|
|
|
baseValidationArray.push({ key: 'status', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'status')] });
|
2023-11-24 17:42:23 +01:00
|
|
|
baseValidationArray.push({ key: 'users', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'users')] });
|
2023-10-30 14:30:46 +01:00
|
|
|
baseValidationArray.push({ key: 'hash', validators: [] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
2024-01-24 10:40:32 +01:00
|
|
|
createChildPage(index: number, id: string): UntypedFormGroup {
|
|
|
|
const page: DescriptionTemplatePageEditorModel = new DescriptionTemplatePageEditorModel(this.validationErrorModel);
|
|
|
|
page.id = id;
|
|
|
|
if (isNaN(index)) { page.ordinal = 0; } else { page.ordinal = index; }
|
|
|
|
return page.buildForm({ rootPath: 'definition.pages[' + index + '].' });
|
|
|
|
}
|
|
|
|
|
|
|
|
createChildSection(index: number): UntypedFormGroup {
|
|
|
|
const section: DescriptionTemplateSectionEditorModel = new DescriptionTemplateSectionEditorModel(this.validationErrorModel);
|
|
|
|
return section.buildForm({ rootPath: 'definition.sections[' + index + '].' });
|
|
|
|
}
|
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
static reApplyDefinitionValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, validationErrorModel } = params;
|
|
|
|
const control = formGroup?.get('definition');
|
|
|
|
DescriptionTemplateDefinitionEditorModel.reapplyPagesValidators({
|
|
|
|
formArray: control.get('pages') as UntypedFormArray,
|
|
|
|
rootPath: `definition.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
DescriptionTemplateDefinitionEditorModel.reapplySectionsValidators({
|
|
|
|
formArray: control.get('sections') as UntypedFormArray,
|
|
|
|
rootPath: `definition.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('users') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => UserDescriptionTemplateEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `users[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-10-30 14:30:46 +01:00
|
|
|
}
|
|
|
|
|
2023-11-24 17:42:23 +01:00
|
|
|
export class UserDescriptionTemplateEditorModel implements UserDescriptionTemplatePersist {
|
|
|
|
userId?: Guid;
|
|
|
|
role?: UserDescriptionTemplateRole;
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
public fromModel(item: UserDescriptionTemplatePersist): UserDescriptionTemplateEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.userId = item.userId;
|
|
|
|
this.role = item.role;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = UserDescriptionTemplateEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
userId: [{ value: this.userId, disabled: disabled }, context.getValidation('userId').validators],
|
|
|
|
role: [{ value: this.role, disabled: disabled }, context.getValidation('role').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'userId', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}userId`)] });
|
|
|
|
baseValidationArray.push({ key: 'role', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}role`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = UserDescriptionTemplateEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['userId', 'role'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
export class DescriptionTemplateDefinitionEditorModel implements DescriptionTemplateDefinitionPersist {
|
|
|
|
pages: DescriptionTemplatePageEditorModel[] = [];
|
|
|
|
sections: DescriptionTemplateSectionEditorModel[] = [];
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
public fromModel(item: DescriptionTemplateDefinition): DescriptionTemplateDefinitionEditorModel {
|
|
|
|
if (item) {
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.pages) { item.pages.map(x => this.pages.push(new DescriptionTemplatePageEditorModel(this.validationErrorModel).fromModel(x))); }
|
|
|
|
if (item.sections) { item.sections.map(x => this.sections.push(new DescriptionTemplateSectionEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateDefinitionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
return this.formBuilder.group({
|
|
|
|
pages: this.formBuilder.array(
|
|
|
|
(this.pages ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplatePageEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}pages[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('pages')
|
|
|
|
)
|
|
|
|
),
|
|
|
|
sections: this.formBuilder.array(
|
|
|
|
(this.sections ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateSectionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}sections[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('sections')
|
|
|
|
)
|
|
|
|
),
|
|
|
|
});
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'pages', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}pages`)] });
|
|
|
|
baseValidationArray.push({ key: 'sections', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}sections`)] });
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
static reapplyPagesValidators(params: {
|
|
|
|
formArray: UntypedFormArray,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
|
|
formArray?.controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplatePageEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}pages[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
static reapplySectionsValidators(params: {
|
|
|
|
formArray: UntypedFormArray,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
|
|
formArray?.controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateSectionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}sections[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
export class DescriptionTemplatePageEditorModel implements DescriptionTemplatePagePersist {
|
2023-12-20 08:20:38 +01:00
|
|
|
id: string;
|
2023-10-31 10:19:52 +01:00
|
|
|
ordinal: number;
|
|
|
|
title: string;
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
public fromModel(item: DescriptionTemplatePage): DescriptionTemplatePageEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.id = item.id;
|
|
|
|
this.ordinal = item.ordinal;
|
|
|
|
this.title = item.title;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplatePageEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
title: [{ value: this.title, disabled: disabled }, context.getValidation('title').validators]
|
|
|
|
});
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
|
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseValidationArray.push({ key: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
|
|
|
baseValidationArray.push({ key: 'title', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}title`)] });
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2023-10-30 14:30:46 +01:00
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplatePageEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'ordinal', 'title'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateSectionEditorModel implements DescriptionTemplateSectionPersist {
|
2023-12-20 08:20:38 +01:00
|
|
|
id: string;
|
2023-10-31 10:19:52 +01:00
|
|
|
ordinal: number;
|
2023-11-24 17:42:23 +01:00
|
|
|
defaultVisibility: boolean = false; // TODO: check if used and remove
|
|
|
|
multiplicity: boolean = false;
|
2023-10-31 10:19:52 +01:00
|
|
|
page: string;
|
|
|
|
title: string;
|
|
|
|
description: string;
|
|
|
|
sections?: DescriptionTemplateSectionEditorModel[] = [];
|
|
|
|
fieldSets: DescriptionTemplateFieldSetEditorModel[] = [];
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
public fromModel(item: DescriptionTemplateSection | DescriptionTemplateSectionEditorModel): DescriptionTemplateSectionEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.id = item.id;
|
|
|
|
this.ordinal = item.ordinal;
|
|
|
|
this.defaultVisibility = item.defaultVisibility;
|
|
|
|
this.multiplicity = item.multiplicity;
|
|
|
|
this.page = item.page;
|
|
|
|
this.title = item.title;
|
|
|
|
this.description = item.description;
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.sections) { item.sections.map(x => this.sections.push(new DescriptionTemplateSectionEditorModel(this.validationErrorModel).fromModel(x))); }
|
|
|
|
if (item.fieldSets) { item.fieldSets.map(x => this.fieldSets.push(new DescriptionTemplateFieldSetEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateSectionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
defaultVisibility: [{ value: this.defaultVisibility, disabled: disabled }, context.getValidation('defaultVisibility').validators],
|
|
|
|
multiplicity: [{ value: this.multiplicity, disabled: disabled }, context.getValidation('multiplicity').validators],
|
|
|
|
page: [{ value: this.page, disabled: disabled }, context.getValidation('page').validators],
|
|
|
|
title: [{ value: this.title, disabled: disabled }, context.getValidation('title').validators],
|
|
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
|
|
sections: this.formBuilder.array(
|
|
|
|
(this.sections ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateSectionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}sections[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('sections')
|
|
|
|
)
|
|
|
|
),
|
|
|
|
fieldSets: this.formBuilder.array(
|
|
|
|
(this.fieldSets ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateFieldSetEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}fieldSets[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('fieldSets')
|
|
|
|
)
|
|
|
|
)
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
2023-11-24 17:42:23 +01:00
|
|
|
baseValidationArray.push({ key: 'defaultVisibility', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}defaultVisibility`)] });
|
|
|
|
baseValidationArray.push({ key: 'multiplicity', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}multiplicity`)] });
|
2023-10-31 10:19:52 +01:00
|
|
|
baseValidationArray.push({ key: 'page', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}page`)] });
|
|
|
|
baseValidationArray.push({ key: 'title', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}title`)] });
|
|
|
|
baseValidationArray.push({ key: 'description', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}description`)] });
|
|
|
|
baseValidationArray.push({ key: 'sections', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}sections`)] });
|
|
|
|
baseValidationArray.push({ key: 'fieldSets', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fieldSets`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateSectionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'ordinal', 'defaultVisibility', 'multiplicity', 'page', 'title', 'description'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('sections') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateSectionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}sections[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
(formGroup.get('fieldSets') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateFieldSetEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}fieldSets[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateFieldSetEditorModel implements DescriptionTemplateFieldSetPersist {
|
2023-12-20 08:20:38 +01:00
|
|
|
id: string;
|
2023-10-31 10:19:52 +01:00
|
|
|
ordinal: number;
|
2023-11-24 17:42:23 +01:00
|
|
|
numbering: string = "0"; // Check if used and remove
|
2023-10-31 10:19:52 +01:00
|
|
|
title: string;
|
|
|
|
description: string;
|
|
|
|
extendedDescription: string;
|
|
|
|
additionalInformation: string;
|
2023-11-24 17:42:23 +01:00
|
|
|
multiplicity: DescriptionTemplateMultiplicityEditorModel = new DescriptionTemplateMultiplicityEditorModel();
|
|
|
|
hasCommentField: boolean = false;
|
2023-10-31 10:19:52 +01:00
|
|
|
fields: DescriptionTemplateFieldEditorModel[] = [];
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateFieldSet | DescriptionTemplateFieldSetEditorModel): DescriptionTemplateFieldSetEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.id = item.id;
|
|
|
|
this.ordinal = item.ordinal;
|
|
|
|
this.numbering = item.numbering;
|
|
|
|
this.title = item.title;
|
|
|
|
this.description = item.description;
|
|
|
|
this.extendedDescription = item.extendedDescription;
|
|
|
|
this.additionalInformation = item.additionalInformation;
|
|
|
|
this.hasCommentField = item.hasCommentField;
|
|
|
|
|
2024-01-22 17:16:45 +01:00
|
|
|
this.multiplicity = new DescriptionTemplateMultiplicityEditorModel(this.validationErrorModel).fromModel(item.multiplicity);
|
|
|
|
if (item.fields) { item.fields.map(x => this.fields.push(new DescriptionTemplateFieldEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateFieldSetEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
numbering: [{ value: this.numbering, disabled: disabled }, context.getValidation('numbering').validators],
|
|
|
|
title: [{ value: this.title, disabled: disabled }, context.getValidation('title').validators],
|
|
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
|
|
extendedDescription: [{ value: this.extendedDescription, disabled: disabled }, context.getValidation('extendedDescription').validators],
|
|
|
|
additionalInformation: [{ value: this.additionalInformation, disabled: disabled }, context.getValidation('additionalInformation').validators],
|
|
|
|
hasCommentField: [{ value: this.hasCommentField, disabled: disabled }, context.getValidation('hasCommentField').validators],
|
|
|
|
multiplicity: this.multiplicity.buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}multiplicity.`
|
2023-10-31 10:19:52 +01:00
|
|
|
}),
|
|
|
|
fields: this.formBuilder.array(
|
|
|
|
(this.fields ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateFieldEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}fields[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('fields')
|
|
|
|
)
|
|
|
|
)
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
|
|
|
baseValidationArray.push({ key: 'numbering', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}numbering`)] });
|
|
|
|
baseValidationArray.push({ key: 'title', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}title`)] });
|
|
|
|
baseValidationArray.push({ key: 'description', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}description`)] });
|
|
|
|
baseValidationArray.push({ key: 'extendedDescription', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}extendedDescription`)] });
|
|
|
|
baseValidationArray.push({ key: 'additionalInformation', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}additionalInformation`)] });
|
|
|
|
baseValidationArray.push({ key: 'hasCommentField', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}hasCommentField`)] });
|
|
|
|
baseValidationArray.push({ key: 'fields', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fields`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateFieldSetEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'ordinal', 'numbering', 'title', 'description', 'extendedDescription', 'additionalInformation', 'hasCommentField'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
DescriptionTemplateMultiplicityEditorModel.reapplyValidators({
|
|
|
|
formGroup: formGroup?.get('multiplicity') as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}multiplicity.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('fields') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateFieldEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}fields[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateMultiplicityEditorModel implements DescriptionTemplateMultiplicityPersist {
|
|
|
|
min: number;
|
|
|
|
max: number;
|
|
|
|
placeholder: string;
|
|
|
|
tableView: boolean;
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateMultiplicity): DescriptionTemplateMultiplicityEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.min = item.min;
|
|
|
|
this.max = item.max;
|
|
|
|
this.placeholder = item.placeholder;
|
|
|
|
this.tableView = item.tableView;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateMultiplicityEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
min: [{ value: this.min, disabled: disabled }, context.getValidation('min').validators],
|
|
|
|
max: [{ value: this.max, disabled: disabled }, context.getValidation('max').validators],
|
|
|
|
placeholder: [{ value: this.placeholder, disabled: disabled }, context.getValidation('placeholder').validators],
|
|
|
|
tableView: [{ value: this.tableView, disabled: disabled }, context.getValidation('tableView').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'min', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}min`)] });
|
2023-11-24 17:42:23 +01:00
|
|
|
baseValidationArray.push({ key: 'max', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}max`)] });
|
2023-10-31 10:19:52 +01:00
|
|
|
baseValidationArray.push({ key: 'placeholder', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}placeholder`)] });
|
|
|
|
baseValidationArray.push({ key: 'tableView', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}tableView`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateMultiplicityEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['min', 'max', 'placeholder', 'tableView'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
|
2023-11-24 17:42:23 +01:00
|
|
|
//
|
|
|
|
//
|
|
|
|
// Field Editor Model
|
|
|
|
//
|
|
|
|
//
|
2023-10-31 10:19:52 +01:00
|
|
|
export class DescriptionTemplateFieldEditorModel implements DescriptionTemplateFieldPersist {
|
2023-12-20 08:20:38 +01:00
|
|
|
id: string;
|
2023-10-31 10:19:52 +01:00
|
|
|
ordinal: number;
|
|
|
|
schematics: string[];
|
|
|
|
defaultValue: string;
|
|
|
|
visibilityRules: DescriptionTemplateRuleEditorModel[] = [];
|
2023-11-24 17:42:23 +01:00
|
|
|
validations: DescriptionTemplateFieldValidationType[] = [];
|
|
|
|
includeInExport: boolean = false;
|
|
|
|
data: DescriptionTemplateBaseFieldEditorModel = new DescriptionTemplateBaseFieldEditorModel();
|
2023-10-31 10:19:52 +01:00
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateField | DescriptionTemplateFieldEditorModel): DescriptionTemplateFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.id = item.id;
|
|
|
|
this.ordinal = item.ordinal;
|
|
|
|
this.schematics = item.schematics;
|
|
|
|
this.defaultValue = item.defaultValue;
|
|
|
|
this.validations = item.validations;
|
|
|
|
this.includeInExport = item.includeInExport;
|
|
|
|
|
2023-11-24 17:42:23 +01:00
|
|
|
this.data = this.getFieldEditorModel(item.data.fieldType).fromModel(item.data);
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.visibilityRules) { item.visibilityRules.map(x => this.visibilityRules.push(new DescriptionTemplateRuleEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
id: [{ value: this.id, disabled: disabled }, context.getValidation('id').validators],
|
|
|
|
ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],
|
|
|
|
schematics: [{ value: this.schematics, disabled: disabled }, context.getValidation('schematics').validators],
|
|
|
|
defaultValue: [{ value: this.defaultValue, disabled: disabled }, context.getValidation('defaultValue').validators],
|
|
|
|
validations: [{ value: this.validations, disabled: disabled }, context.getValidation('validations').validators],
|
|
|
|
includeInExport: [{ value: this.includeInExport, disabled: disabled }, context.getValidation('includeInExport').validators],
|
2023-11-24 17:42:23 +01:00
|
|
|
data: this.data.buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}data.`
|
2023-11-24 17:42:23 +01:00
|
|
|
}),
|
2023-10-31 10:19:52 +01:00
|
|
|
visibilityRules: this.formBuilder.array(
|
|
|
|
(this.visibilityRules ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateRuleEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}visibilityRules[${index}].`
|
2023-10-31 10:19:52 +01:00
|
|
|
}), context.getValidation('visibilityRules')
|
|
|
|
)
|
|
|
|
)
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'id', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}id`)] });
|
|
|
|
baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });
|
|
|
|
baseValidationArray.push({ key: 'schematics', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}schematics`)] });
|
|
|
|
baseValidationArray.push({ key: 'defaultValue', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}defaultValue`)] });
|
|
|
|
baseValidationArray.push({ key: 'validations', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}validations`)] });
|
|
|
|
baseValidationArray.push({ key: 'includeInExport', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}includeInExport`)] });
|
|
|
|
baseValidationArray.push({ key: 'visibilityRules', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}visibilityRules`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
|
|
|
|
private getFieldEditorModel(fieldType: DescriptionTemplateFieldType): DescriptionTemplateBaseFieldEditorModel {
|
|
|
|
switch (fieldType) {
|
|
|
|
case DescriptionTemplateFieldType.AUTO_COMPLETE:
|
2024-01-22 17:16:45 +01:00
|
|
|
return new DescriptionTemplateAutoCompleteFieldEditorModel(this.validationErrorModel);
|
2023-11-24 17:42:23 +01:00
|
|
|
case DescriptionTemplateFieldType.RADIO_BOX:
|
2024-01-22 17:16:45 +01:00
|
|
|
return new DescriptionTemplateRadioBoxFieldEditorModel(this.validationErrorModel);
|
2024-01-30 18:27:55 +01:00
|
|
|
case DescriptionTemplateFieldType.SELECT:
|
|
|
|
return new DescriptionTemplateSelectFieldEditorModel(this.validationErrorModel);
|
2023-11-24 17:42:23 +01:00
|
|
|
case DescriptionTemplateFieldType.BOOLEAN_DECISION:
|
|
|
|
case DescriptionTemplateFieldType.CHECK_BOX:
|
|
|
|
case DescriptionTemplateFieldType.FREE_TEXT:
|
|
|
|
case DescriptionTemplateFieldType.TEXT_AREA:
|
|
|
|
case DescriptionTemplateFieldType.RICH_TEXT_AREA:
|
|
|
|
case DescriptionTemplateFieldType.DATE_PICKER:
|
|
|
|
case DescriptionTemplateFieldType.TAGS:
|
|
|
|
case DescriptionTemplateFieldType.DATASET_IDENTIFIER:
|
|
|
|
case DescriptionTemplateFieldType.CURRENCY:
|
|
|
|
case DescriptionTemplateFieldType.VALIDATION:
|
2024-01-22 17:16:45 +01:00
|
|
|
return new DescriptionTemplateBaseFieldEditorModel(this.validationErrorModel);
|
2023-11-24 17:42:23 +01:00
|
|
|
case DescriptionTemplateFieldType.INTERNAL_DMP_ENTRIES_RESEARCHERS:
|
|
|
|
case DescriptionTemplateFieldType.INTERNAL_DMP_ENTRIES_DMPS:
|
|
|
|
case DescriptionTemplateFieldType.INTERNAL_DMP_ENTRIES_DATASETS:
|
|
|
|
case DescriptionTemplateFieldType.EXTERNAL_DATASETS:
|
|
|
|
case DescriptionTemplateFieldType.DATA_REPOSITORIES:
|
|
|
|
case DescriptionTemplateFieldType.JOURNAL_REPOSITORIES:
|
|
|
|
case DescriptionTemplateFieldType.PUB_REPOSITORIES:
|
|
|
|
case DescriptionTemplateFieldType.LICENSES:
|
|
|
|
case DescriptionTemplateFieldType.TAXONOMIES:
|
|
|
|
case DescriptionTemplateFieldType.PUBLICATIONS:
|
|
|
|
case DescriptionTemplateFieldType.REGISTRIES:
|
|
|
|
case DescriptionTemplateFieldType.SERVICES:
|
|
|
|
case DescriptionTemplateFieldType.RESEARCHERS:
|
|
|
|
case DescriptionTemplateFieldType.ORGANIZATIONS:
|
2024-01-22 17:16:45 +01:00
|
|
|
return new DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel(this.validationErrorModel);
|
2024-01-31 10:36:12 +01:00
|
|
|
case DescriptionTemplateFieldType.EXTERNAL_DATASETS:
|
|
|
|
return new DescriptionTemplateExternalDatasetFieldEditorModel(this.validationErrorModel);
|
2023-11-24 17:42:23 +01:00
|
|
|
case DescriptionTemplateFieldType.UPLOAD:
|
2024-01-22 17:16:45 +01:00
|
|
|
return new DescriptionTemplateUploadFieldEditorModel(this.validationErrorModel);
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateFieldEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['id', 'ordinal', 'schematics', 'defaultValue', 'validations', 'includeInExport'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
DescriptionTemplateBaseFieldEditorModel.reapplyBaseFieldValidators({
|
|
|
|
formGroup: formGroup?.get('data') as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}data.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('visibilityRules') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateRuleEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}visibilityRules[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplateBaseFieldDataPersist {
|
|
|
|
label: string;
|
|
|
|
fieldType: DescriptionTemplateFieldType;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateBaseFieldDataPersist): DescriptionTemplateBaseFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.label = item.label;
|
|
|
|
this.fieldType = item.fieldType;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateBaseFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
fieldType: [{ value: this.fieldType, disabled: disabled }, context.getValidation('fieldType').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'label', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'fieldType', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}fieldType`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyBaseFieldValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateBaseFieldEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['label', 'fieldType'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel extends DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplatePlaceholderAndMultiplicityDataPersist {
|
|
|
|
multiAutoComplete: boolean;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplatePlaceholderAndMultiplicityDataPersist): DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.multiAutoComplete = item.multiAutoComplete;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('multiAutoComplete', new FormControl({ value: this.multiAutoComplete, disabled: disabled }, context.getValidation('multiAutoComplete').validators));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'multiAutoComplete', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}multiAutoComplete`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['multiAutoComplete'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
2024-01-31 10:36:12 +01:00
|
|
|
//
|
|
|
|
//
|
|
|
|
// External Dataset Field
|
|
|
|
//
|
|
|
|
//
|
|
|
|
export class DescriptionTemplateExternalDatasetFieldEditorModel extends DescriptionTemplatePlaceholderAndMultiplicityFieldEditorModel implements DescriptionTemplateExternalDatasetDataPersist {
|
|
|
|
type: DescriptionTemplateFieldDataExternalDatasetType;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateExternalDatasetDataPersist): DescriptionTemplateExternalDatasetFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.type = item.type;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateExternalDatasetFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('type', new FormControl({ value: this.type, disabled: disabled }, context.getValidation('type').validators));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'type', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}type`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateExternalDatasetFieldEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['type'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-11-24 17:42:23 +01:00
|
|
|
//
|
|
|
|
//
|
|
|
|
// Autocomplete Field
|
|
|
|
//
|
|
|
|
//
|
|
|
|
export class DescriptionTemplateAutoCompleteFieldEditorModel extends DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplateAutoCompleteDataPersist {
|
|
|
|
multiAutoComplete: boolean;
|
|
|
|
autoCompleteSingleDataList: DescriptionTemplateAutoCompleteSingleDataEditorModel[] = [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateAutoCompleteDataPersist): DescriptionTemplateAutoCompleteFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.multiAutoComplete = item.multiAutoComplete;
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.autoCompleteSingleDataList) { item.autoCompleteSingleDataList.map(x => this.autoCompleteSingleDataList.push(new DescriptionTemplateAutoCompleteSingleDataEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateAutoCompleteFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('multiAutoComplete', new FormControl({ value: this.multiAutoComplete, disabled: disabled }, context.getValidation('multiAutoComplete').validators));
|
|
|
|
formGroup.setControl('autoCompleteSingleDataList', this.formBuilder.array(
|
|
|
|
(this.autoCompleteSingleDataList ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateAutoCompleteSingleDataEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}autoCompleteSingleDataList[${index}].`
|
2023-11-24 17:42:23 +01:00
|
|
|
}), context.getValidation('autoCompleteSingleDataList')
|
|
|
|
)));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'multiAutoComplete', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}multiAutoComplete`)] });
|
|
|
|
baseContext.validation.push({ key: 'autoCompleteSingleDataList', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}autoCompleteSingleDataList`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateAutoCompleteFieldEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['multiAutoComplete'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('options') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateAutoCompleteSingleDataEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}autoCompleteSingleDataList[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateAutoCompleteSingleDataEditorModel implements DescriptionTemplateAutoCompleteSingleDataPersist {
|
|
|
|
autocompleteType: DescriptionTemplateFieldAutocompleteType;
|
|
|
|
url: string;
|
|
|
|
autoCompleteOptions: DescriptionTemplateComboBoxOptionEditorModel = new DescriptionTemplateComboBoxOptionEditorModel();
|
|
|
|
optionsRoot: string;
|
|
|
|
hasAuth: boolean;
|
|
|
|
auth: DescriptionTemplateAuthAutoCompleteDataEditorModel = new DescriptionTemplateAuthAutoCompleteDataEditorModel();
|
|
|
|
method: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateAutoCompleteSingleDataPersist): DescriptionTemplateAutoCompleteSingleDataEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.autocompleteType = item.autocompleteType;
|
|
|
|
this.url = item.url;
|
2024-01-22 17:16:45 +01:00
|
|
|
this.autoCompleteOptions = new DescriptionTemplateComboBoxOptionEditorModel(this.validationErrorModel).fromModel(item.autoCompleteOptions);
|
2023-11-24 17:42:23 +01:00
|
|
|
this.optionsRoot = item.optionsRoot;
|
|
|
|
this.hasAuth = item.hasAuth;
|
2024-01-22 17:16:45 +01:00
|
|
|
this.auth = new DescriptionTemplateAuthAutoCompleteDataEditorModel(this.validationErrorModel).fromModel(item.auth);
|
2023-11-24 17:42:23 +01:00
|
|
|
this.method = item.method;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateAutoCompleteSingleDataEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
autocompleteType: [{ value: this.autocompleteType, disabled: disabled }, context.getValidation('autocompleteType').validators],
|
|
|
|
url: [{ value: this.url, disabled: disabled }, context.getValidation('url').validators],
|
|
|
|
optionsRoot: [{ value: this.optionsRoot, disabled: disabled }, context.getValidation('optionsRoot').validators],
|
|
|
|
hasAuth: [{ value: this.hasAuth, disabled: disabled }, context.getValidation('hasAuth').validators],
|
|
|
|
method: [{ value: this.method, disabled: disabled }, context.getValidation('method').validators],
|
|
|
|
autoCompleteOptions: this.autoCompleteOptions.buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}autoCompleteOptions.`
|
2023-11-24 17:42:23 +01:00
|
|
|
}),
|
|
|
|
auth: this.auth.buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}auth.`
|
2023-11-24 17:42:23 +01: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: 'autocompleteType', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}autocompleteType`)] });
|
|
|
|
baseValidationArray.push({ key: 'url', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}url`)] });
|
|
|
|
baseValidationArray.push({ key: 'optionsRoot', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}optionsRoot`)] });
|
|
|
|
baseValidationArray.push({ key: 'hasAuth', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}hasAuth`)] });
|
|
|
|
baseValidationArray.push({ key: 'method', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}method`)] });
|
|
|
|
baseValidationArray.push({ key: 'extendedDescription', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}extendedDescription`)] });
|
|
|
|
baseValidationArray.push({ key: 'additionalInformation', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}additionalInformation`)] });
|
|
|
|
baseValidationArray.push({ key: 'hasCommentField', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}hasCommentField`)] });
|
|
|
|
baseValidationArray.push({ key: 'fields', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fields`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateAutoCompleteSingleDataEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['autocompleteType', 'url', 'optionsRoot', 'hasAuth', 'method'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
DescriptionTemplateComboBoxOptionEditorModel.reapplyValidators({
|
|
|
|
formGroup: formGroup?.get('autoCompleteOptions') as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}autoCompleteOptions.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
DescriptionTemplateComboBoxOptionEditorModel.reapplyValidators({
|
|
|
|
formGroup: formGroup?.get('auth') as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}auth.`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateComboBoxOptionEditorModel implements DescriptionTemplateComboBoxOptionPersist {
|
|
|
|
label: string;
|
|
|
|
value: string;
|
|
|
|
source: string;
|
|
|
|
uri: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateComboBoxOptionPersist): DescriptionTemplateComboBoxOptionEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.label = item.label;
|
|
|
|
this.value = item.value;
|
|
|
|
this.source = item.source;
|
|
|
|
this.uri = item.uri;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateComboBoxOptionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
value: [{ value: this.value, disabled: disabled }, context.getValidation('value').validators],
|
|
|
|
source: [{ value: this.source, disabled: disabled }, context.getValidation('source').validators],
|
|
|
|
uri: [{ value: this.uri, disabled: disabled }, context.getValidation('uri').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'label', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'value', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });
|
|
|
|
baseValidationArray.push({ key: 'source', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}source`)] });
|
|
|
|
baseValidationArray.push({ key: 'uri', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}uri`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateComboBoxOptionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['label', 'value', 'source', 'uri'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateAuthAutoCompleteDataEditorModel implements DescriptionTemplateAuthAutoCompleteDataPersist {
|
|
|
|
url: string;
|
|
|
|
method: string;
|
|
|
|
body: string;
|
|
|
|
path: string;
|
|
|
|
type: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateAuthAutoCompleteDataPersist): DescriptionTemplateAuthAutoCompleteDataEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.url = item.url;
|
|
|
|
this.method = item.method;
|
|
|
|
this.body = item.body;
|
|
|
|
this.path = item.path;
|
|
|
|
this.type = item.type;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateAuthAutoCompleteDataEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
url: [{ value: this.url, disabled: disabled }, context.getValidation('url').validators],
|
|
|
|
method: [{ value: this.method, disabled: disabled }, context.getValidation('method').validators],
|
|
|
|
body: [{ value: this.body, disabled: disabled }, context.getValidation('body').validators],
|
|
|
|
path: [{ value: this.path, disabled: disabled }, context.getValidation('path').validators],
|
|
|
|
type: [{ value: this.type, disabled: disabled }, context.getValidation('type').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'url', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}url`)] });
|
|
|
|
baseValidationArray.push({ key: 'method', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}method`)] });
|
|
|
|
baseValidationArray.push({ key: 'body', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}body`)] });
|
|
|
|
baseValidationArray.push({ key: 'path', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}path`)] });
|
|
|
|
baseValidationArray.push({ key: 'type', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}type`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateAuthAutoCompleteDataEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['url', 'method', 'body', 'path', 'type'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// Radiobox Field
|
|
|
|
//
|
|
|
|
//
|
|
|
|
export class DescriptionTemplateRadioBoxFieldEditorModel extends DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplateRadioBoxDataPersist {
|
|
|
|
options: DescriptionTemplateRadioBoxDataEditorModel[] = [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateRadioBoxDataPersist): DescriptionTemplateRadioBoxFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.options) { item.options.map(x => this.options.push(new DescriptionTemplateRadioBoxDataEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateRadioBoxFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('options', this.formBuilder.array(
|
|
|
|
(this.options ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateRadioBoxDataEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}options[${index}].`
|
2023-11-24 17:42:23 +01:00
|
|
|
}), context.getValidation('options')
|
|
|
|
)));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'options', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}options`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyRadioBoxValidators(params: {
|
|
|
|
formArray: UntypedFormArray,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
|
|
formArray?.controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateRadioBoxDataEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}options[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateRadioBoxDataEditorModel implements DescriptionTemplateRadioBoxOptionPersist {
|
|
|
|
label: string;
|
|
|
|
value: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateRadioBoxOptionPersist): DescriptionTemplateRadioBoxDataEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.label = item.label;
|
|
|
|
this.value = item.value;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateRadioBoxDataEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
value: [{ value: this.value, disabled: disabled }, context.getValidation('value').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'label', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'value', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateRadioBoxDataEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['label', 'value'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
//
|
2024-01-30 18:27:55 +01:00
|
|
|
// Select Field
|
2023-11-24 17:42:23 +01:00
|
|
|
//
|
|
|
|
//
|
2024-01-30 18:27:55 +01:00
|
|
|
export class DescriptionTemplateSelectFieldEditorModel extends DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplateSelectDataPersist {
|
2023-11-24 17:42:23 +01:00
|
|
|
options: DescriptionTemplateComboBoxOptionEditorModel[] = [];
|
|
|
|
multiList: boolean;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
2024-01-30 18:27:55 +01:00
|
|
|
fromModel(item: DescriptionTemplateSelectDataPersist): DescriptionTemplateSelectFieldEditorModel {
|
2023-11-24 17:42:23 +01:00
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
|
|
|
this.multiList = item.multiList;
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.options) { item.options.map(x => this.options.push(new DescriptionTemplateComboBoxOptionEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
2024-01-30 18:27:55 +01:00
|
|
|
context = DescriptionTemplateSelectFieldEditorModel.createValidationContext({
|
2023-11-24 17:42:23 +01:00
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('multiList', new FormControl({ value: this.multiList, disabled: disabled }, context.getValidation('multiList').validators));
|
|
|
|
formGroup.setControl('options', this.formBuilder.array(
|
|
|
|
(this.options ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateComboBoxOptionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}options[${index}].`
|
2023-11-24 17:42:23 +01:00
|
|
|
}), context.getValidation('options')
|
|
|
|
)));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'options', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}options`)] });
|
|
|
|
baseContext.validation.push({ key: 'multiList', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}multiList`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyDepedencyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
2024-01-30 18:27:55 +01:00
|
|
|
const context = DescriptionTemplateSelectFieldEditorModel.createValidationContext({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['multiList'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
});
|
|
|
|
|
|
|
|
(formGroup.get('options') as FormArray).controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateComboBoxOptionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}options[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// Upload Field
|
|
|
|
//
|
|
|
|
//
|
|
|
|
export class DescriptionTemplateUploadFieldEditorModel extends DescriptionTemplateBaseFieldEditorModel implements DescriptionTemplateUploadDataPersist {
|
|
|
|
types: DescriptionTemplateUploadOptionEditorModel[] = [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { super(validationErrorModel); }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateUploadDataPersist): DescriptionTemplateUploadFieldEditorModel {
|
|
|
|
if (item) {
|
|
|
|
super.fromModel(item);
|
2024-01-22 17:16:45 +01:00
|
|
|
if (item.types) { item.types.map(x => this.types.push(new DescriptionTemplateUploadOptionEditorModel(this.validationErrorModel).fromModel(x))); }
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateUploadFieldEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const formGroup = super.buildForm({ context, disabled, rootPath });
|
|
|
|
formGroup.setControl('types', this.formBuilder.array(
|
|
|
|
(this.types ?? []).map(
|
|
|
|
(item, index) => new DescriptionTemplateUploadOptionEditorModel(
|
|
|
|
this.validationErrorModel
|
|
|
|
).fromModel(item).buildForm({
|
2024-01-22 17:16:45 +01:00
|
|
|
rootPath: `${rootPath}types[${index}].`
|
2023-11-24 17:42:23 +01:00
|
|
|
}), context.getValidation('types')
|
|
|
|
)));
|
|
|
|
return formGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static createValidationContext(params: {
|
|
|
|
rootPath?: string,
|
|
|
|
validationErrorModel: ValidationErrorModel
|
|
|
|
}): ValidationContext {
|
|
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = super.createValidationContext({ rootPath, validationErrorModel });
|
|
|
|
baseContext.validation.push({ key: 'types', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}types`)] });
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyUploadDataValidators(params: {
|
|
|
|
formArray: UntypedFormArray,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
|
|
formArray?.controls?.forEach(
|
|
|
|
(control, index) => DescriptionTemplateUploadOptionEditorModel.reapplyValidators({
|
|
|
|
formGroup: control as UntypedFormGroup,
|
|
|
|
rootPath: `${rootPath}types[${index}].`,
|
|
|
|
validationErrorModel: validationErrorModel
|
|
|
|
})
|
|
|
|
);
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateUploadOptionEditorModel implements DescriptionTemplateUploadOptionPersist {
|
|
|
|
label: string;
|
|
|
|
value: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateUploadOptionPersist): DescriptionTemplateUploadOptionEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.label = item.label;
|
|
|
|
this.value = item.value;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateUploadOptionEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
|
|
|
|
value: [{ value: this.value, disabled: disabled }, context.getValidation('value').validators],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'label', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
|
|
|
|
baseValidationArray.push({ key: 'value', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateUploadOptionEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['label', 'value'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-10-31 10:19:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export class DescriptionTemplateRuleEditorModel implements DescriptionTemplateRulePersist {
|
|
|
|
target: string;
|
|
|
|
value: string;
|
|
|
|
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
|
|
) { }
|
|
|
|
|
|
|
|
fromModel(item: DescriptionTemplateRule): DescriptionTemplateRuleEditorModel {
|
|
|
|
if (item) {
|
|
|
|
this.target = item.target;
|
|
|
|
this.value = item.value;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildForm(params?: {
|
|
|
|
context?: ValidationContext,
|
|
|
|
disabled?: boolean,
|
|
|
|
rootPath?: string
|
|
|
|
}): UntypedFormGroup {
|
|
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
|
|
if (context == null) {
|
|
|
|
context = DescriptionTemplateRuleEditorModel.createValidationContext({
|
|
|
|
validationErrorModel: this.validationErrorModel,
|
|
|
|
rootPath
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.formBuilder.group({
|
|
|
|
target: [{ value: this.target, disabled: disabled }, context.getValidation('target').validators],
|
|
|
|
value: [{ value: this.value, disabled: disabled }, context.getValidation('value').validators]
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
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: 'target', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}target`)] });
|
|
|
|
baseValidationArray.push({ key: 'value', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });
|
|
|
|
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
|
|
return baseContext;
|
|
|
|
}
|
2024-01-22 17:16:45 +01:00
|
|
|
|
|
|
|
static reapplyValidators(params: {
|
|
|
|
formGroup: UntypedFormGroup,
|
|
|
|
validationErrorModel: ValidationErrorModel,
|
|
|
|
rootPath: string
|
|
|
|
}): void {
|
|
|
|
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
|
|
const context = DescriptionTemplateRuleEditorModel.createValidationContext({
|
|
|
|
rootPath,
|
|
|
|
validationErrorModel
|
|
|
|
});
|
|
|
|
|
|
|
|
['target', 'value'].forEach(keyField => {
|
|
|
|
const control = formGroup?.get(keyField);
|
|
|
|
control?.clearValidators();
|
|
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
|
|
})
|
|
|
|
}
|
2023-11-24 17:42:23 +01:00
|
|
|
}
|