356 lines
13 KiB
TypeScript
356 lines
13 KiB
TypeScript
import { UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from "@angular/forms";
|
|
import { Tenant, TenantConfig, TenantConfigPersist, TenantDepositConfig, TenantDepositConfigPersist, TenantFileTransformersConfig, TenantFileTransformersConfigPersist, TenantPersist, TenantSource, TenantSourcePersist } from "@app/core/model/tenant/tenant";
|
|
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 TenantEditorModel extends BaseEditorModel implements TenantPersist {
|
|
name: string;
|
|
code: string;
|
|
description: string;
|
|
config: TenantConfigEditorModel = new TenantConfigEditorModel();
|
|
permissions: string[];
|
|
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel();
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor() { super(); }
|
|
|
|
public fromModel(item: Tenant): TenantEditorModel {
|
|
if (item) {
|
|
super.fromModel(item);
|
|
this.name = item.name;
|
|
this.code = item.code;
|
|
this.description = item.description;
|
|
if (item.config) this.config = new TenantConfigEditorModel(this.validationErrorModel).fromModel(item.config);
|
|
}
|
|
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],
|
|
description: [{ value: this.description, disabled: disabled }, context.getValidation('description').validators],
|
|
config: this.config.buildForm({
|
|
rootPath: `config.`,
|
|
}),
|
|
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: 'description', validators: [Validators.required, BackendErrorValidator(this.validationErrorModel, 'description')] });
|
|
baseValidationArray.push({ key: 'hash', validators: [] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reApplyDepositSourcesValidators(params: {
|
|
formGroup: UntypedFormGroup,
|
|
validationErrorModel: ValidationErrorModel,
|
|
}): void {
|
|
|
|
const { formGroup, validationErrorModel } = params;
|
|
const control = formGroup?.get('config').get('deposit');
|
|
TenantDepositConfigEditorModel.reapplySourcesFieldsValidators({
|
|
formArray: control.get('sources') as UntypedFormArray,
|
|
rootPath: `config.deposit.`,
|
|
validationErrorModel: validationErrorModel
|
|
});
|
|
}
|
|
|
|
static reApplyFileTransformerSourcesValidators(params: {
|
|
formGroup: UntypedFormGroup,
|
|
validationErrorModel: ValidationErrorModel,
|
|
}): void {
|
|
|
|
const { formGroup, validationErrorModel } = params;
|
|
const control = formGroup?.get('config').get('fileTransformers');
|
|
TenantDepositConfigEditorModel.reapplySourcesFieldsValidators({
|
|
formArray: control.get('sources') as UntypedFormArray,
|
|
rootPath: `config.fileTransformers.`,
|
|
validationErrorModel: validationErrorModel
|
|
});
|
|
}
|
|
}
|
|
|
|
export class TenantConfigEditorModel implements TenantConfigPersist {
|
|
deposit: TenantDepositConfigEditorModel = new TenantDepositConfigEditorModel();
|
|
fileTransformers: TenantFileTransformersConfigEditorModel = new TenantFileTransformersConfigEditorModel();
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: TenantConfig): TenantConfigEditorModel {
|
|
if (item) {
|
|
if (item.deposit) this.deposit = new TenantDepositConfigEditorModel(this.validationErrorModel).fromModel(item.deposit);
|
|
if (item.fileTransformers) this.fileTransformers = new TenantFileTransformersConfigEditorModel(this.validationErrorModel).fromModel(item.fileTransformers);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
buildForm(params?: {
|
|
context?: ValidationContext,
|
|
disabled?: boolean,
|
|
rootPath?: string
|
|
}): UntypedFormGroup {
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
if (context == null) {
|
|
context = TenantConfigEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
return this.formBuilder.group({
|
|
deposit: this.deposit.buildForm({
|
|
rootPath: `${rootPath}deposit.`
|
|
}),
|
|
fileTransformers: this.fileTransformers.buildForm({
|
|
rootPath: `${rootPath}fileTransformers.`
|
|
}),
|
|
});
|
|
}
|
|
|
|
static createValidationContext(params: {
|
|
rootPath?: string,
|
|
validationErrorModel: ValidationErrorModel
|
|
}): ValidationContext {
|
|
const { rootPath = '', validationErrorModel } = params;
|
|
|
|
const baseContext: ValidationContext = new ValidationContext();
|
|
const baseValidationArray: Validation[] = new Array<Validation>();
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
}
|
|
|
|
export class TenantDepositConfigEditorModel implements TenantDepositConfigPersist {
|
|
sources: TenantSourceEditorModel[]= [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: TenantDepositConfig): TenantDepositConfigEditorModel {
|
|
if (item) {
|
|
if (item.sources) { item.sources.map(x => this.sources.push(new TenantSourceEditorModel(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 = TenantDepositConfigEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
return this.formBuilder.group({
|
|
sources: this.formBuilder.array(
|
|
(this.sources ?? []).map(
|
|
(item, index) => item.buildForm({
|
|
rootPath: `${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: 'sources', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}sources`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reapplySourcesFieldsValidators(params: {
|
|
formArray: UntypedFormArray,
|
|
validationErrorModel: ValidationErrorModel,
|
|
rootPath: string
|
|
}): void {
|
|
const { validationErrorModel, rootPath, formArray } = params;
|
|
formArray?.controls?.forEach(
|
|
(control, index) => TenantSourceEditorModel.reapplyValidators({
|
|
formGroup: control as UntypedFormGroup,
|
|
rootPath: `${rootPath}sources[${index}].`,
|
|
validationErrorModel: validationErrorModel
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
export class TenantFileTransformersConfigEditorModel implements TenantFileTransformersConfigPersist {
|
|
sources: TenantSourceEditorModel[]= [];
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: TenantFileTransformersConfig): TenantFileTransformersConfigEditorModel {
|
|
if (item) {
|
|
if (item.sources) { item.sources.map(x => this.sources.push(new TenantSourceEditorModel(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 = TenantFileTransformersConfigEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
return this.formBuilder.group({
|
|
sources: this.formBuilder.array(
|
|
(this.sources ?? []).map(
|
|
(item, index) => item.buildForm({
|
|
rootPath: `${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: 'sources', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}sources`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
}
|
|
|
|
export class TenantSourceEditorModel implements TenantSourcePersist {
|
|
url: string;
|
|
codes: string[]= [];
|
|
issuerUrl: string;
|
|
clientId: string;
|
|
clientSecret: string;
|
|
scope: string;
|
|
|
|
protected formBuilder: UntypedFormBuilder = new UntypedFormBuilder();
|
|
|
|
constructor(
|
|
public validationErrorModel: ValidationErrorModel = new ValidationErrorModel()
|
|
) { }
|
|
|
|
public fromModel(item: TenantSource): TenantSourceEditorModel {
|
|
if (item) {
|
|
this.url = item.url;
|
|
//if (item.codes) { item.codes.map(x => this.codes.push(new SourceCodeEditorModel().fromModel(x))); }
|
|
this.codes = item.codes;
|
|
this.issuerUrl = item.issuerUrl;
|
|
this.clientId = item.clientId;
|
|
this.clientSecret = item.clientSecret;
|
|
this.scope = item.scope;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
buildForm(params?: {
|
|
context?: ValidationContext,
|
|
disabled?: boolean,
|
|
rootPath?: string
|
|
}): UntypedFormGroup {
|
|
let { context = null, disabled = false, rootPath } = params ?? {}
|
|
if (context == null) {
|
|
context = TenantSourceEditorModel.createValidationContext({
|
|
validationErrorModel: this.validationErrorModel,
|
|
rootPath
|
|
});
|
|
}
|
|
|
|
return this.formBuilder.group({
|
|
url: [{ value: this.url, disabled: disabled }, context.getValidation('url').validators],
|
|
issuerUrl: [{ value: this.issuerUrl, disabled: disabled }, context.getValidation('issuerUrl').validators],
|
|
clientId: [{ value: this.clientId, disabled: disabled }, context.getValidation('clientId').validators],
|
|
clientSecret: [{ value: this.clientSecret, disabled: disabled }, context.getValidation('clientSecret').validators],
|
|
scope: [{ value: this.scope, disabled: disabled }, context.getValidation('scope').validators],
|
|
codes: [{ value: this.codes, disabled: disabled }, context.getValidation('codes').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: 'codes', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}codes`)] });
|
|
baseValidationArray.push({ key: 'issuerUrl', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}issuerUrl`)] });
|
|
baseValidationArray.push({ key: 'clientId', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}clientId`)] });
|
|
baseValidationArray.push({ key: 'clientSecret', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}clientSecret`)] });
|
|
baseValidationArray.push({ key: 'scope', validators: [Validators.required, BackendErrorValidator(validationErrorModel, `${rootPath}scope`)] });
|
|
|
|
baseContext.validation = baseValidationArray;
|
|
return baseContext;
|
|
}
|
|
|
|
static reapplyValidators(params: {
|
|
formGroup: UntypedFormGroup,
|
|
validationErrorModel: ValidationErrorModel,
|
|
rootPath: string
|
|
}): void {
|
|
|
|
const { formGroup, rootPath, validationErrorModel } = params;
|
|
const context = TenantSourceEditorModel.createValidationContext({
|
|
rootPath,
|
|
validationErrorModel
|
|
});
|
|
|
|
['url', 'codes', 'issuerUrl', 'clientId', 'clientSecret', 'scope'].forEach(keyField => {
|
|
const control = formGroup?.get(keyField);
|
|
control?.clearValidators();
|
|
control?.addValidators(context.getValidation(keyField).validators);
|
|
})
|
|
}
|
|
}
|