argos/dmp-frontend/src/app/ui/admin/reference-type/editor/reference-type-editor.model.ts

import { FormArray, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from "@angular/forms";
import { ReferenceFieldDataType } from "@app/core/common/enum/reference-field-data-type";
import { ReferenceTypeExternalApiHTTPMethodType } from "@app/core/common/enum/reference-type-external-api-http-method-type";
import { ReferenceTypeSourceType } from "@app/core/common/enum/reference-type-source-type";
import { AuthenticationConfiguration, AuthenticationConfigurationPersist, DependencyProperty, DependencyPropertyPersist, QueryConfig, QueryConfigPersist, ReferenceType, ReferenceTypeDefinition, ReferenceTypeDefinitionPersist, ReferenceTypeField, ReferenceTypeFieldPersist, ReferenceTypePersist, ReferenceTypeSourceBaseConfiguration, ReferenceTypeSourceBaseConfigurationPersist, ReferenceTypeSourceBaseDependency, ReferenceTypeSourceBaseDependencyPersist, ReferenceTypeStaticOption, ReferenceTypeStaticOptionPersist, ResultFieldsMappingConfiguration, ResultFieldsMappingConfigurationPersist, ResultsConfiguration, ResultsConfigurationPersist } from "@app/core/model/reference-type/reference-type";
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 ReferenceTypeEditorModel extends BaseEditorModel implements ReferenceTypePersist {
	name: string;
	code: string;
	definition: ReferenceTypeDefinitionEditorModel = new ReferenceTypeDefinitionEditorModel();

	permissions: string[];

	public validationErrorModel: ValidationErrorModel = new ValidationErrorModel();
	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor() { super(); }

	public fromModel(item: ReferenceType): ReferenceTypeEditorModel {
		if (item) {
			this.id = item.id;
			this.name = item.name;
			this.code = item.code;
			this.definition = new ReferenceTypeDefinitionEditorModel(this.validationErrorModel).fromModel(item.definition);
			this.hash = item.hash;
			if (item.createdAt) { this.createdAt = item.createdAt; }
			if (item.updatedAt) { this.updatedAt = item.updatedAt; }
		}
		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],
			name: [{ value: this.name, disabled: disabled }, context.getValidation('name').validators],
			code: [{ value: this.code, disabled: disabled }, context.getValidation('code').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: 'name', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'name')] });
		baseValidationArray.push({ key: 'code', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'code')] });
		baseValidationArray.push({ key: 'hash', validators: [] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	createChildField(index: number): UntypedFormGroup {
		const field: ReferenceTypeFieldEditorModel = new ReferenceTypeFieldEditorModel(this.validationErrorModel);
		return field.buildForm({ rootPath: 'definition.fields[' + index + '].' });
	}

	createChildSource(index: number): UntypedFormGroup {
		const source: ReferenceTypeSourceBaseConfigurationEditorModel = new ReferenceTypeSourceBaseConfigurationEditorModel(this.validationErrorModel);
		return source.buildForm({ rootPath: 'definition.sources[' + index + '].' });
	}

	createFieldsMapping(sourceIndex: number, index: number): UntypedFormGroup {
		const fieldMapping: ResultFieldsMappingConfigurationEditorModel = new ResultFieldsMappingConfigurationEditorModel(this.validationErrorModel);
		return fieldMapping.buildForm({ rootPath: 'definition.sources[' + sourceIndex + '].results.fieldsMapping[' + index + '].'});
	}

	createOptions(sourceIndex: number, index: number): UntypedFormGroup {
		const fieldMapping: ReferenceTypeStaticOptionEditorModel = new ReferenceTypeStaticOptionEditorModel(this.validationErrorModel);
		return fieldMapping.buildForm({ rootPath: 'definition.sources[' + sourceIndex + '].options[' + index + '].'});
	}

	createQuery(sourceIndex: number, index: number): UntypedFormGroup {
		const query: QueryConfigEditorModel = new QueryConfigEditorModel(this.validationErrorModel);
		return query.buildForm({ rootPath: 'definition.sources[' + sourceIndex + '].queries[' + index + '].'});
	}

	createDepedency(sourceIndex: number, index: number): UntypedFormGroup {
		const dependency: ReferenceTypeSourceBaseDependencyEditorModel = new ReferenceTypeSourceBaseDependencyEditorModel(this.validationErrorModel);
		return dependency.buildForm({ rootPath: 'definition.sources[' + sourceIndex + '].dependencies[' + index + '].'});
	}

	createProperty(sourceIndex: number, dependencyIndex: number, index: number): UntypedFormGroup {
		const property: DependencyPropertyEditorModel = new DependencyPropertyEditorModel(this.validationErrorModel);
		return property.buildForm({ rootPath: 'definition.sources[' + sourceIndex + '].dependencies[' + dependencyIndex + '].properties[' + index + '].'});
	}

	static reApplyDefinitionFieldsValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
	}): void {

		const { formGroup, validationErrorModel } = params;
		const control = formGroup?.get('definition');
		ReferenceTypeDefinitionEditorModel.reapplyFieldsValidators({
			formArray: control.get('fields') as UntypedFormArray,
			rootPath: `definition.`,
			validationErrorModel: validationErrorModel
		});
	}

	static reApplyDefinitionSourcesValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
	}): void {

		const { formGroup, validationErrorModel } = params;
		const control = formGroup?.get('definition');
		ReferenceTypeDefinitionEditorModel.reapplySourcesValidators({
			formArray: control.get('sources') as UntypedFormArray,
			rootPath: `definition.`,
			validationErrorModel: validationErrorModel
		});
	}
}

export class ReferenceTypeDefinitionEditorModel implements ReferenceTypeDefinitionPersist {
	fields: ReferenceTypeFieldEditorModel[] = [];
	sources: ReferenceTypeSourceBaseConfigurationEditorModel[] = [];

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	public fromModel(item: ReferenceTypeDefinition): ReferenceTypeDefinitionEditorModel {
		if (item) {
			if (item.fields) { item.fields.map(x => this.fields.push(new ReferenceTypeFieldEditorModel(this.validationErrorModel).fromModel(x))); }
			if (item.sources) { item.sources.map(x => this.sources.push(new ReferenceTypeSourceBaseConfigurationEditorModel(this.validationErrorModel).fromModel(x))); }
		}
		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ReferenceTypeDefinitionEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			fields: this.formBuilder.array(
				(this.fields ?? []).map(
					(item, index) => new ReferenceTypeFieldEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}fields[${index}].`
					})
				), context.getValidation('fields').validators
			),
			sources: this.formBuilder.array(
				(this.sources ?? []).map(
					(item, index) => new ReferenceTypeSourceBaseConfigurationEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}sources[${index}].`
					})
				), context.getValidation('sources').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: 'fields', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fields`)] });
		baseValidationArray.push({ key: 'sources', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}sources`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyFieldsValidators(params: {
		formArray: UntypedFormArray,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {
		const { validationErrorModel, rootPath, formArray } = params;
		formArray?.controls?.forEach(
			(control, index) => ReferenceTypeFieldEditorModel.reapplyValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}fields[${index}].`,
				validationErrorModel: validationErrorModel
			})
		);
	}

	static reapplySourcesValidators(params: {
		formArray: UntypedFormArray,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {
		const { validationErrorModel, rootPath, formArray } = params;
		formArray?.controls?.forEach(
			(control, index) => ReferenceTypeSourceBaseConfigurationEditorModel.reapplyValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}sources[${index}].`,
				validationErrorModel: validationErrorModel
			})
		);
	}

}

export class ReferenceTypeFieldEditorModel implements ReferenceTypeFieldPersist {
	code: string;
	label: string;
	description: string;
	dataType: ReferenceFieldDataType;

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	public fromModel(item: ReferenceTypeField): ReferenceTypeFieldEditorModel {
		if (item) {
			this.code = item.code;
			this.label = item.label;
			this.description = item.description;
			this.dataType = item.dataType;
		}
		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ReferenceTypeFieldEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			code: [{ value: this.code, disabled: disabled }, context.getValidation('code').validators],
			label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
			description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
			dataType: [{ value: this.dataType, disabled: disabled }, context.getValidation('dataType').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: 'label', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
		baseValidationArray.push({ key: 'description', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}description`)] });
		baseValidationArray.push({ key: 'dataType', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}dataType`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ReferenceTypeFieldEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['code', 'label', 'description', 'dataType'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		})
	}
}

export class ReferenceTypeSourceBaseConfigurationEditorModel implements ReferenceTypeSourceBaseConfigurationPersist {
	type: ReferenceTypeSourceType;
	key: string;
	label: string;
	ordinal: number;

	url: string;
	results: ResultsConfigurationEditorModel = new ResultsConfigurationEditorModel(this.validationErrorModel);
	paginationPath: string;
	contentType: string;
	firstPage: string;
	httpMethod: ReferenceTypeExternalApiHTTPMethodType;
	requestBody?: string;
	filterType?: string;
	auth: AuthenticationConfigurationEditorModel = new AuthenticationConfigurationEditorModel(this.validationErrorModel);
	queries?: QueryConfigEditorModel[] = [];

	options: ReferenceTypeStaticOptionEditorModel[] = [];

	dependencies: ReferenceTypeSourceBaseDependencyEditorModel[] = [];

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	public fromModel(item: ReferenceTypeSourceBaseConfiguration): ReferenceTypeSourceBaseConfigurationEditorModel {
		if (item) {
			this.type = item.type;
			this.key = item.key;
			this.label = item.label;
			this.ordinal = item.ordinal;

			if (item.url) this.url = item.url;
			if (item.results) this.results = new ResultsConfigurationEditorModel(this.validationErrorModel).fromModel(item.results);
			if (item.paginationPath) this.paginationPath = item.paginationPath;
			if (item.contentType) this.contentType = item.contentType;
			if (item.firstPage) this.firstPage = item.firstPage;
			if (item.httpMethod) this.httpMethod = item.httpMethod;
			if (item.requestBody) this.requestBody = item.requestBody;
			if (item.filterType) this.filterType = item.filterType;
			if (item.auth) this.auth = new AuthenticationConfigurationEditorModel(this.validationErrorModel).fromModel(item.auth);
			if (item.queries) { item.queries.map(x => this.queries.push(new QueryConfigEditorModel(this.validationErrorModel).fromModel(x))); }

			if (item.options) {
				item.options.map(x => this.options.push(new ReferenceTypeStaticOptionEditorModel(this.validationErrorModel).fromModel(x)));
			} else {
				this.options.push(new ReferenceTypeStaticOptionEditorModel().fromModel({ code: 'reference_id', value: undefined }));
				this.options.push(new ReferenceTypeStaticOptionEditorModel().fromModel({ code: 'label', value: undefined }));
				this.options.push(new ReferenceTypeStaticOptionEditorModel().fromModel({ code: 'description', value: undefined }));
			}

			if (item.dependencies) { item.dependencies.map(x => this.dependencies.push(new ReferenceTypeSourceBaseDependencyEditorModel(this.validationErrorModel).fromModel(x))); }
		}
		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ReferenceTypeSourceBaseConfigurationEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			type: [{ value: this.type, disabled: disabled }, context.getValidation('type').validators],
			key: [{ value: this.key, disabled: disabled }, context.getValidation('key').validators],
			label: [{ value: this.label, disabled: disabled }, context.getValidation('label').validators],
			ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').validators],

			url: [{ value: this.url, disabled: disabled }, context.getValidation('url').validators],
			results: this.results.buildForm({
				rootPath: `${rootPath}results.`,
			}),
			paginationPath: [{ value: this.paginationPath, disabled: disabled }, context.getValidation('paginationPath').validators],
			contentType: [{ value: this.contentType, disabled: disabled }, context.getValidation('contentType').validators],
			firstPage: [{ value: this.firstPage, disabled: disabled }, context.getValidation('firstPage').validators],
			httpMethod: [{ value: this.httpMethod, disabled: disabled }, context.getValidation('httpMethod').validators],
			requestBody: [{ value: this.requestBody, disabled: disabled }, context.getValidation('requestBody').validators],
			filterType: [{ value: this.filterType, disabled: disabled }, context.getValidation('filterType').validators],
			auth: this.auth.buildForm({
				rootPath: `${rootPath}auth.`
			}),
			queries: this.formBuilder.array(
				(this.queries ?? []).map(
					(item, index) => new QueryConfigEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}queries[${index}].`
					})
				), context.getValidation('queries').validators
			),
			options: this.formBuilder.array(
				(this.options ?? []).map(
					(item, index) => new ReferenceTypeStaticOptionEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}options[${index}].`
					})
				), context.getValidation('options').validators
			),
			dependencies: this.formBuilder.array(
				(this.dependencies ?? []).map(
					(item, index) => new ReferenceTypeSourceBaseDependencyEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}dependencies[${index}].`
					})
				), context.getValidation('dependencies').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: 'type', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}type`)] });
		baseValidationArray.push({ key: 'key', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}key`)] });
		baseValidationArray.push({ key: 'label', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}label`)] });
		baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, Validators.pattern("^[0-9]*$"), BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });

		baseValidationArray.push({ key: 'url', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}url`)] });
		baseValidationArray.push({ key: 'paginationPath', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}paginationPath`)] });
		baseValidationArray.push({ key: 'contentType', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}contentType`)] });
		baseValidationArray.push({ key: 'firstPage', validators: [Validators.pattern("^[0-9]*$"), BackendErrorValidator(validationErrorModel, `${rootPath}firstPage`)] });
		baseValidationArray.push({ key: 'httpMethod', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}httpMethod`)] });
		baseValidationArray.push({ key: 'requestBody', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}requestBody`)] });
		baseValidationArray.push({ key: 'filterType', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}filterType`)] });
		baseValidationArray.push({ key: 'results', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}results`)] });
		baseValidationArray.push({ key: 'queries', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}queries`)] });

		baseValidationArray.push({ key: 'options', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}options`)] });

		baseValidationArray.push({ key: 'dependencies', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}dependencies`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ReferenceTypeSourceBaseConfigurationEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['type', 'key', 'label', 'ordinal', 'url', 'paginationPath', 'contentType', 'firstPage', 'httpMethod', 'requestBody','filterType'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		});

		AuthenticationConfigurationEditorModel.reapplyAuthValidators({
			formGroup: formGroup?.get('auth') as UntypedFormGroup,
			rootPath: `${rootPath}auth.`,
			validationErrorModel: validationErrorModel
		});

		ResultsConfigurationEditorModel.reapplyValidators({
			formGroup: formGroup?.get('results') as UntypedFormGroup,
			rootPath: `${rootPath}results.`,
			validationErrorModel: validationErrorModel
		});

		(formGroup.get('options') as FormArray).controls?.forEach(
			(control, index) => ReferenceTypeStaticOptionEditorModel.reapplyStaticOptionsValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}options[${index}].`,
				validationErrorModel: validationErrorModel
			}
			)
		);

		(formGroup.get('queries') as FormArray).controls?.forEach(
			(control, index) => QueryConfigEditorModel.reapplyValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}queries[${index}].`,
				validationErrorModel: validationErrorModel
			})
		);

		(formGroup.get('dependencies') as FormArray).controls?.forEach(
			(control, index) => ReferenceTypeSourceBaseDependencyEditorModel.reapplyDepedencyValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}dependencies[${index}].`,
				validationErrorModel: validationErrorModel
			})
		);
	}
}

export class ResultsConfigurationEditorModel implements ResultsConfigurationPersist {
	public resultsArrayPath: string;
	public fieldsMapping: ResultFieldsMappingConfigurationEditorModel[] = [];

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: ResultsConfiguration): ResultsConfigurationEditorModel {
		this.resultsArrayPath = item.resultsArrayPath;
		if (item.fieldsMapping) { item.fieldsMapping.map(x => this.fieldsMapping.push(new ResultFieldsMappingConfigurationEditorModel(this.validationErrorModel).fromModel(x))); }
		else {
			this.fieldsMapping.push(new ResultFieldsMappingConfigurationEditorModel().fromModel({ code: 'reference_id', responsePath: undefined }));
			this.fieldsMapping.push(new ResultFieldsMappingConfigurationEditorModel().fromModel({ code: 'label', responsePath: undefined }));
			this.fieldsMapping.push(new ResultFieldsMappingConfigurationEditorModel().fromModel({ code: 'description', responsePath: undefined }));
		}
		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ResultsConfigurationEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			resultsArrayPath: [{ value: this.resultsArrayPath, disabled: disabled }, context.getValidation('resultsArrayPath').validators],
			fieldsMapping: this.formBuilder.array(
				(this.fieldsMapping ?? []).map(
					(item, index) => new ResultFieldsMappingConfigurationEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}fieldsMapping[${index}].`
					})
				), context.getValidation('fieldsMapping').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: 'resultsArrayPath', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}resultsArrayPath`)] });
		baseValidationArray.push({ key: 'fieldsMapping', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}fieldsMapping`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ResultsConfigurationEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['resultsArrayPath'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		});

		(formGroup.get('fieldsMapping') as FormArray).controls?.forEach(
			(control, index) => ResultFieldsMappingConfigurationEditorModel.reapplyFieldsMappingValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}fieldsMapping[${index}].`,
				validationErrorModel: validationErrorModel
			}
			)
		);
	}
}

export class ResultFieldsMappingConfigurationEditorModel implements ResultFieldsMappingConfigurationPersist {
	public code: string;
	public responsePath: string;

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: ResultFieldsMappingConfiguration): ResultFieldsMappingConfigurationEditorModel {
		this.code = item.code;
		this.responsePath = item.responsePath;

		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ResultFieldsMappingConfigurationEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			code: [{ value: this.code, disabled: true }, context.getValidation('code').validators],
			responsePath: [{ value: this.responsePath, disabled: disabled }, context.getValidation('responsePath').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: [BackendErrorValidator(validationErrorModel, `${rootPath}code`)] });
		baseValidationArray.push({ key: 'responsePath', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}responsePath`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyFieldsMappingValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ResultFieldsMappingConfigurationEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['code', 'responsePath'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		});
	}
}

export class AuthenticationConfigurationEditorModel implements AuthenticationConfigurationPersist {
	public enabled: boolean = false;
	public authUrl: string;
	public authMethod: ReferenceTypeExternalApiHTTPMethodType;
	public authTokenPath: string;
	public authRequestBody: string;
	public type: string;

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: AuthenticationConfiguration): AuthenticationConfigurationEditorModel {
		this.enabled = item.enabled;
		this.authUrl = item.authUrl;
		this.authMethod = item.authMethod;
		this.authTokenPath = item.authTokenPath;
		this.authRequestBody = item.authRequestBody;
		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 = AuthenticationConfigurationEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			enabled: [{ value: this.enabled, disabled: disabled }, context.getValidation('enabled').validators],
			authUrl: [{ value: this.authUrl, disabled: disabled }, context.getValidation('authUrl').validators],
			authMethod: [{ value: this.authMethod, disabled: disabled }, context.getValidation('authMethod').validators],
			authTokenPath: [{ value: this.authTokenPath, disabled: disabled }, context.getValidation('authTokenPath').validators],
			authRequestBody: [{ value: this.authRequestBody, disabled: disabled }, context.getValidation('authRequestBody').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: 'enabled', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}enabled`)] });
		baseValidationArray.push({ key: 'authUrl', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}authUrl`)] });
		baseValidationArray.push({ key: 'authMethod', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}authMethod`)] });
		baseValidationArray.push({ key: 'authTokenPath', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}authTokenPath`)] });
		baseValidationArray.push({ key: 'authRequestBody', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}authRequestBody`)] });
		baseValidationArray.push({ key: 'type', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}type`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyAuthValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = AuthenticationConfigurationEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['enabled', 'authUrl', 'authMethod', 'authTokenPath', 'authRequestBody', 'type'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		})
	}
}

export class QueryConfigEditorModel implements QueryConfigPersist {
	public condition: string;
	public separator: string;
	public value: string;
	public ordinal: number;

	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: QueryConfig): QueryConfigEditorModel {
		this.condition = item.condition;
		this.separator = item.separator;
		this.value = item.value;
		this.ordinal = item.ordinal;

		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = QueryConfigEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			condition: [{ value: this.condition, disabled: disabled }, context.getValidation('condition').validators],
			separator: [{ value: this.separator, disabled: disabled }, context.getValidation('separator').validators],
			value: [{ value: this.value, disabled: disabled }, context.getValidation('value').validators],
			ordinal: [{ value: this.ordinal, disabled: disabled }, context.getValidation('ordinal').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: 'condition', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}condition`)] });
		baseValidationArray.push({ key: 'separator', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}separator`)] });
		baseValidationArray.push({ key: 'value', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });
		baseValidationArray.push({ key: 'ordinal', validators: [Validators.required, Validators.pattern("^[0-9]*$"), BackendErrorValidator(validationErrorModel, `${rootPath}ordinal`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = QueryConfigEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['condition', 'separator', 'value', 'ordinal'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		})
	}
}

export class ReferenceTypeStaticOptionEditorModel implements ReferenceTypeStaticOptionPersist {
	public code: string;
	public value: string;


	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: ReferenceTypeStaticOption): ReferenceTypeStaticOptionEditorModel {
		this.code = item.code;
		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 = ReferenceTypeStaticOptionEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			code: [{ value: this.code, disabled: true }, context.getValidation('code').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: 'code', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}code`)] });
		baseValidationArray.push({ key: 'value', validators: [BackendErrorValidator(validationErrorModel, `${rootPath}value`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyStaticOptionsValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ReferenceTypeStaticOptionEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['code', 'value'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		});

	}
}

export class ReferenceTypeSourceBaseDependencyEditorModel implements ReferenceTypeSourceBaseDependencyPersist {
	public referenceTypeCode: string;
	public key: string;
	public required = true;
	public properties: DependencyPropertyEditorModel[] = [];


	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: ReferenceTypeSourceBaseDependency): ReferenceTypeSourceBaseDependencyEditorModel {
		this.referenceTypeCode = item.referenceTypeCode;
		this.key = item.key;
		this.required = item.required;
		if (item.properties) { item.properties.map(x => this.properties.push(new DependencyPropertyEditorModel(this.validationErrorModel).fromModel(x))); }

		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = ReferenceTypeSourceBaseDependencyEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			referenceTypeCode: [{ value: this.referenceTypeCode, disabled: disabled }, context.getValidation('referenceTypeCode').validators],
			key: [{ value: this.key, disabled: disabled }, context.getValidation('key').validators],
			required: [{ value: this.required, disabled: true }, context.getValidation('required').validators],
			properties: this.formBuilder.array(
				(this.properties ?? []).map(
					(item, index) => new DependencyPropertyEditorModel(
						this.validationErrorModel
					).fromModel(item).buildForm({
						rootPath: `${rootPath}properties[${index}].`
					})
				), context.getValidation('properties').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: 'referenceTypeCode', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}referenceTypeCode`)] });
		baseValidationArray.push({ key: 'key', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}key`)] });
		baseValidationArray.push({ key: 'required', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}required`)] });
		baseValidationArray.push({ key: 'properties', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}properties`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyDepedencyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = ReferenceTypeSourceBaseDependencyEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['referenceTypeCode', 'key', 'required'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		});

		(formGroup.get('properties') as FormArray).controls?.forEach(
			(control, index) => DependencyPropertyEditorModel.reapplyPropertyValidators({
				formGroup: control as UntypedFormGroup,
				rootPath: `${rootPath}properties[${index}].`,
				validationErrorModel: validationErrorModel
			})
		);
	}
}

export class DependencyPropertyEditorModel implements DependencyPropertyPersist {
	public code: string;
	public target: string;
	public required = true;


	protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();

	constructor(
		public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
	) { }

	fromModel(item: DependencyProperty): DependencyPropertyEditorModel {
		this.code = item.code;
		this.target = item.target;
		this.required = item.required;

		return this;
	}

	buildForm(params?: {
		context?: ValidationContext,
		disabled?: boolean,
		rootPath?: string
	}): UntypedFormGroup {
		let { context = null, disabled = false, rootPath } = params ?? {}
		if (context == null) {
			context = DependencyPropertyEditorModel.createValidationContext({
				validationErrorModel: this.validationErrorModel,
				rootPath
			});
		}

		return this.formBuilder.group({
			code: [{ value: this.code, disabled: disabled }, context.getValidation('code').validators],
			target: [{ value: this.target, disabled: disabled }, context.getValidation('target').validators],
			required: [{ value: this.required, disabled: true }, context.getValidation('required').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: 'target', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}target`)] });
		baseValidationArray.push({ key: 'required', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}required`)] });

		baseContext.validation = baseValidationArray;
		return baseContext;
	}

	static reapplyPropertyValidators(params: {
		formGroup: UntypedFormGroup,
		validationErrorModel: ValidationErrorModel,
		rootPath: string
	}): void {

		const { formGroup, rootPath, validationErrorModel } = params;
		const context = DependencyPropertyEditorModel.createValidationContext({
			rootPath,
			validationErrorModel
		});

		['code', 'target', 'required'].forEach(keyField => {
			const control = formGroup?.get(keyField);
			control?.clearValidators();
			control?.addValidators(context.getValidation(keyField).validators);
		})
	}
}