614 lines
25 KiB
TypeScript
614 lines
25 KiB
TypeScript
import { 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 { ReferenceType, ReferenceTypeDefinition, ReferenceTypeDefinitionPersist, ReferenceTypePersist, ReferenceTypeFieldPersist,ReferenceTypeField, AuthenticationConfiguration, AuthenticationConfigurationPersist, QueryConfigPersist, QueryConfig, ResultsConfigurationPersist, ResultFieldsMappingConfigurationPersist, ResultsConfiguration, ResultFieldsMappingConfiguration, ReferenceTypeSourceBaseConfigurationPersist, ReferenceTypeSourceBaseConfiguration, ReferenceTypeStaticOptionPersist, ReferenceTypeStaticOption } 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().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.`
|
|
})
|
|
});
|
|
}
|
|
|
|
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')] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
}
|
|
|
|
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().fromModel(x))); }
|
|
if (item.sources) { item.sources.map(x => this.sources.push(new ReferenceTypeSourceBaseConfigurationEditorModel().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: `fields[${index}].`
|
|
}), context.getValidation('fields')
|
|
)
|
|
),
|
|
sources: this.formBuilder.array(
|
|
(this.sources ?? []).map(
|
|
(item, index) => new ReferenceTypeSourceBaseConfigurationEditorModel(
|
|
this.validationErrorModel
|
|
).fromModel(item).buildForm({
|
|
rootPath: `sources[${index}].`
|
|
}), context.getValidation('sources')
|
|
)
|
|
)
|
|
});
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
}
|
|
|
|
export class ReferenceTypeSourceBaseConfigurationEditorModel implements ReferenceTypeSourceBaseConfigurationPersist {
|
|
type: ReferenceTypeSourceType;
|
|
key: string;
|
|
label: string;
|
|
ordinal: number;
|
|
|
|
url: string;
|
|
results: ResultsConfigurationEditorModel = new ResultsConfigurationEditorModel();
|
|
paginationPath: string;
|
|
contentType: string;
|
|
firstPage: string;
|
|
httpMethod: ReferenceTypeExternalApiHTTPMethodType;
|
|
requestBody?: string;
|
|
filterType?: string;
|
|
auth: AuthenticationConfigurationEditorModel = new AuthenticationConfigurationEditorModel();
|
|
queries?: QueryConfigEditorModel[] = [];
|
|
|
|
options : ReferenceTypeStaticOptionEditorModel[] = [];
|
|
|
|
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().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().fromModel(item.auth);
|
|
if(item.queries) { item.queries.map(x => this.queries.push(new QueryConfigEditorModel().fromModel(x))); }
|
|
|
|
if(item.options) { item.options.map(x => this.options.push(new ReferenceTypeStaticOptionEditorModel().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: `results.`,
|
|
//context: context.getValidation('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: `auth.`
|
|
}),
|
|
queries: this.formBuilder.array(
|
|
(this.queries ?? []).map(
|
|
(item, index) => new QueryConfigEditorModel(
|
|
this.validationErrorModel
|
|
).fromModel(item).buildForm({
|
|
rootPath: `queries[${index}].`
|
|
}), context.getValidation('queries')
|
|
)
|
|
),
|
|
|
|
options: this.formBuilder.array(
|
|
(this.options ?? []).map(
|
|
(item, index) => new ReferenceTypeStaticOptionEditorModel(
|
|
this.validationErrorModel
|
|
).fromModel(item).buildForm({
|
|
rootPath: `options[${index}].`
|
|
}), context.getValidation('options')
|
|
)
|
|
)
|
|
|
|
});
|
|
}
|
|
|
|
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: [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`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
}
|
|
|
|
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().fromModel(x))); }
|
|
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: `fieldsMapping[${index}].`
|
|
}), context.getValidation('fieldsMapping')
|
|
)
|
|
)
|
|
|
|
});
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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: "code", disabled: disabled }, 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;
|
|
}
|
|
}
|
|
|
|
export class AuthenticationConfigurationEditorModel implements AuthenticationConfigurationPersist {
|
|
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.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({
|
|
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: '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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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: disabled }, 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;
|
|
}
|
|
} |