249 lines
11 KiB
TypeScript
249 lines
11 KiB
TypeScript
import { UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from "@angular/forms";
|
|
import { PrefillingSource, PrefillingSourceDefinition, PrefillingSourceDefinitionField, PrefillingSourceDefinitionFieldPersist, PrefillingSourceDefinitionPersist, PrefillingSourcePersist } from "@app/core/model/prefilling-source/prefilling-source";
|
|
import { ExternalFetcherBaseSourceConfigurationEditorModel, QueryCaseConfigEditorModel, QueryConfigEditorModel } from "@app/ui/external-fetcher/external-fetcher-source-editor.model";
|
|
|
|
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";
|
|
|
|
export class PrefillingSourceEditorModel extends BaseEditorModel implements PrefillingSourcePersist {
|
|
label: string;
|
|
definition: PrefillingSourceDefinitionEditorModel = new PrefillingSourceDefinitionEditorModel();
|
|
permissions: string[];
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel();
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor() { super(); }
|
|
|
|
public fromModel(item: PrefillingSource): PrefillingSourceEditorModel {
|
|
if (item) {
|
|
super.fromModel(item);
|
|
this.label = item.label;
|
|
if (item.definition) this.definition = new PrefillingSourceDefinitionEditorModel(this.validationErrorModel).fromModel(item.definition);
|
|
}
|
|
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],
|
|
definition: this.definition.buildForm({
|
|
rootPath: `definition.`,
|
|
}),
|
|
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')] });
|
|
baseValidationArray.push({ key: 'definition', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'definition')] });
|
|
baseValidationArray.push({ key: 'hash', validators: [] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reApplyDefinitionValidators(params: {
|
|
formGroup: UntypedFormGroup,
|
|
validationErrorModel: ValidationErrorModel,
|
|
}): void {
|
|
|
|
const { formGroup, validationErrorModel } = params;
|
|
const control = formGroup?.get('definition');
|
|
PrefillingSourceDefinitionEditorModel.reapplyValidators({
|
|
formArray: control.get('fields') as UntypedFormArray,
|
|
rootPath: `definition.`,
|
|
validationErrorModel: validationErrorModel
|
|
});
|
|
}
|
|
|
|
createChildField(index: number): UntypedFormGroup {
|
|
const field: PrefillingSourceDefinitionFieldEditorModel = new PrefillingSourceDefinitionFieldEditorModel(this.validationErrorModel);
|
|
return field.buildForm({ rootPath: 'definition.fields[' + index + '].' });
|
|
}
|
|
}
|
|
|
|
export class PrefillingSourceDefinitionEditorModel implements PrefillingSourceDefinitionPersist {
|
|
fields: PrefillingSourceDefinitionFieldEditorModel[] = [];
|
|
searchConfiguration: ExternalFetcherBaseSourceConfigurationEditorModel = new ExternalFetcherBaseSourceConfigurationEditorModel();
|
|
getConfiguration: ExternalFetcherBaseSourceConfigurationEditorModel;
|
|
getEnabled = false;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: PrefillingSourceDefinition): PrefillingSourceDefinitionEditorModel {
|
|
if (item) {
|
|
if (item.fields) { item.fields.map(x => this.fields.push(new PrefillingSourceDefinitionFieldEditorModel(this.validationErrorModel).fromModel(x))); }
|
|
if (item.searchConfiguration) this.searchConfiguration = new ExternalFetcherBaseSourceConfigurationEditorModel(this.validationErrorModel).fromModel(item.searchConfiguration);
|
|
if (item.getConfiguration) {
|
|
this.getConfiguration = new ExternalFetcherBaseSourceConfigurationEditorModel(this.validationErrorModel).fromModel(item.getConfiguration);
|
|
this.getEnabled = true;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
buildForm(params?: {
|
|
context?: ValidationContext,
|
|
disabled?: boolean,
|
|
rootPath?: string
|
|
}): UntypedFormGroup {
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
if (context == null) {
|
|
context = PrefillingSourceDefinitionEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
const form: UntypedFormGroup = this.formBuilder.group({
|
|
fields: this.formBuilder.array(
|
|
(this.fields ?? []).map(
|
|
(item, index) => item.buildForm({
|
|
rootPath: `${rootPath}fields[${index}].`
|
|
}), context.getValidation('fields')
|
|
)
|
|
),
|
|
searchConfiguration: this.searchConfiguration.buildForm({
|
|
rootPath: `${rootPath}searchConfiguration.`
|
|
}),
|
|
getEnabled: [{ value: this.getEnabled, disabled: disabled }, context.getValidation('getEnabled').validators],
|
|
});
|
|
|
|
if (this.getConfiguration != null) {
|
|
form.addControl('getConfiguration', this.getConfiguration.buildForm({
|
|
rootPath: `${rootPath}getConfiguration.`
|
|
}));
|
|
}
|
|
return form;
|
|
}
|
|
|
|
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: 'fields', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}fields`)] });
|
|
baseValidationArray.push({ key: 'searchConfiguration', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}searchConfiguration`)] });
|
|
baseValidationArray.push({ key: 'getConfiguration', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}getConfiguration`)] });
|
|
baseValidationArray.push({ key: 'getEnabled', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}getConfiguration`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reapplyValidators(params: {
|
|
formArray: UntypedFormArray,
|
|
validationErrorModel: ValidationErrorModel,
|
|
rootPath: string
|
|
}): void {
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
formArray?.controls?.forEach(
|
|
(control, index) => PrefillingSourceDefinitionFieldEditorModel.reapplyValidators({
|
|
formGroup: control as UntypedFormGroup,
|
|
rootPath: `${rootPath}fields[${index}].`,
|
|
validationErrorModel: validationErrorModel
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
export class PrefillingSourceDefinitionFieldEditorModel implements PrefillingSourceDefinitionFieldPersist {
|
|
code: string;
|
|
systemFieldTarget: string;
|
|
semanticTarget: string;
|
|
trimRegex: string;
|
|
fixedValue: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: PrefillingSourceDefinitionField): PrefillingSourceDefinitionFieldEditorModel {
|
|
if (item) {
|
|
this.code = item.code;
|
|
this.systemFieldTarget = item.systemFieldTarget;
|
|
this.semanticTarget = item.semanticTarget;
|
|
this.trimRegex = item.trimRegex;
|
|
this.fixedValue = item.fixedValue;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
buildForm(params?: {
|
|
context?: ValidationContext,
|
|
disabled?: boolean,
|
|
rootPath?: string
|
|
}): UntypedFormGroup {
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
if (context == null) {
|
|
context = PrefillingSourceDefinitionFieldEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
return this.formBuilder.group({
|
|
code: [{ value: this.code, disabled: disabled }, context.getValidation('code').validators],
|
|
systemFieldTarget: [{ value: this.systemFieldTarget, disabled: disabled }, context.getValidation('systemFieldTarget').validators],
|
|
semanticTarget: [{ value: this.semanticTarget, disabled: disabled }, context.getValidation('semanticTarget').validators],
|
|
trimRegex: [{ value: this.trimRegex, disabled: disabled }, context.getValidation('trimRegex').validators],
|
|
fixedValue: [{ value: this.fixedValue, disabled: disabled }, context.getValidation('fixedValue').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: 'code', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}code`)] });
|
|
baseValidationArray.push({ key: 'systemFieldTarget', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}systemFieldTarget`)] });
|
|
baseValidationArray.push({ key: 'semanticTarget', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}semanticTarget`)] });
|
|
baseValidationArray.push({ key: 'trimRegex', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}trimRegex`)] });
|
|
baseValidationArray.push({ key: 'fixedValue', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}clientSecret`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reapplyValidators(params: {
|
|
formGroup: UntypedFormGroup,
|
|
validationErrorModel: ValidationErrorModel,
|
|
rootPath: string
|
|
}): void {
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
const context = PrefillingSourceDefinitionFieldEditorModel.createValidationContext({
|
|
rootPath,
|
|
validationErrorModel
|
|
});
|
|
|
|
['code', 'systemFieldTarget', 'semanticTarget', 'trimRegex', 'fixedValue'].forEach(keyField => {
|
|
const control = formGroup?.get(keyField);
|
|
control?.clearValidators();
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
})
|
|
}
|
|
}
|