661 lines
25 KiB
TypeScript
661 lines
25 KiB
TypeScript
|
|
import { AfterViewInit, Component, ViewChild } from '@angular/core';
|
|
import { FormArray, FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';
|
|
import { ActivatedRoute, Params, Router } from '@angular/router';
|
|
import { DmpProfileFieldDataType } from '@app/core/common/enum/dmp-profile-field-type';
|
|
import { DmpProfileStatus } from '@app/core/common/enum/dmp-profile-status';
|
|
import { DmpProfileType } from '@app/core/common/enum/dmp-profile-type';
|
|
import { DmpProfile } from '@app/core/model/dmp-profile/dmp-profile';
|
|
import { DmpProfileService } from '@app/core/services/dmp/dmp-profile.service';
|
|
import { SnackBarNotificationLevel, UiNotificationService } from '@app/core/services/notification/ui-notification-service';
|
|
import { EnumUtils } from '@app/core/services/utilities/enum-utils.service';
|
|
import { DmpProfileEditorModel, DmpProfileFieldEditorModel } from '@app/ui/admin/dmp-profile/editor/dmp-profile-editor.model';
|
|
import { DmpProfileExternalAutoCompleteFieldDataEditorModel } from '@app/ui/admin/dmp-profile/editor/external-autocomplete/dmp-profile-external-autocomplete-field-editor.model';
|
|
import { BreadcrumbItem } from '@app/ui/misc/breadcrumb/definition/breadcrumb-item';
|
|
import { BaseComponent } from '@common/base/base.component';
|
|
import { FormService } from '@common/forms/form-service';
|
|
import { ValidationErrorModel } from '@common/forms/validation/error-model/validation-error-model';
|
|
import { TranslateService } from '@ngx-translate/core';
|
|
import { environment } from 'environments/environment';
|
|
import * as FileSaver from 'file-saver';
|
|
import { Observable, of as observableOf } from 'rxjs';
|
|
import { map, takeUntil } from 'rxjs/operators';
|
|
import { ConfigurationService } from '@app/core/services/configuration/configuration.service';
|
|
import { HttpClient } from '@angular/common/http';
|
|
import { MatomoService } from '@app/core/services/matomo/matomo-service';
|
|
import { MatDialog } from '@angular/material/dialog';
|
|
import { ConfirmationDialogComponent } from '@common/modules/confirmation-dialog/confirmation-dialog.component';
|
|
import { MultipleAutoCompleteConfiguration } from '@app/library/auto-complete/multiple/multiple-auto-complete-configuration';
|
|
import { DatasetProfileModel } from '@app/core/model/dataset/dataset-profile';
|
|
import { DataTableRequest } from '@app/core/model/data-table/data-table-request';
|
|
import { DatasetProfileCriteria } from '@app/core/query/dataset-profile/dataset-profile-criteria';
|
|
import { DmpService } from '@app/core/services/dmp/dmp.service';
|
|
import { AvailableProfilesComponent } from '@app/ui/dmp/editor/available-profiles/available-profiles.component';
|
|
import { DatasetPreviewDialogComponent } from '@app/ui/dmp/dataset-preview/dataset-preview-dialog.component';
|
|
import { CdkDragDrop, CdkDropList, CdkDrag, moveItemInArray } from '@angular/cdk/drag-drop';
|
|
import { DmpBlueprint, DmpBlueprintDefinition, ExtraFieldType, FieldCategory, SystemFieldType } from '@app/core/model/dmp/dmp-blueprint/dmp-blueprint';
|
|
import { DescriptionTemplatesInSectionEditor, DmpBlueprintEditor, FieldInSectionEditor, SectionDmpBlueprintEditor } from './dmp-blueprint-editor.model';
|
|
import { Guid } from '@common/types/guid';
|
|
import { isNullOrUndefined } from '@app/utilities/enhancers/utils';
|
|
import { DmpBlueprintListing } from '@app/core/model/dmp/dmp-blueprint/dmp-blueprint-listing';
|
|
import { FormValidationErrorsDialogComponent } from '@common/forms/form-validation-errors-dialog/form-validation-errors-dialog.component';
|
|
|
|
|
|
@Component({
|
|
selector: 'app-dmp-profile-editor-component',
|
|
templateUrl: 'dmp-profile-editor.component.html',
|
|
styleUrls: ['./dmp-profile-editor.component.scss']
|
|
})
|
|
export class DmpProfileEditorComponent extends BaseComponent implements AfterViewInit {
|
|
|
|
isNew = true;
|
|
isClone = false;
|
|
viewOnly = false;
|
|
dmpProfileModel: DmpProfileEditorModel;
|
|
dmpBlueprintModel: DmpBlueprintEditor;
|
|
formGroup: FormGroup = null;
|
|
host: string;
|
|
dmpProfileId: string;
|
|
breadCrumbs: Observable<BreadcrumbItem[]>;
|
|
|
|
dmpBlueprintsFormGroup: FormGroup = null;
|
|
|
|
profilesAutoCompleteConfiguration: MultipleAutoCompleteConfiguration;
|
|
|
|
fieldList = [
|
|
{label: 'Title', type: SystemFieldType.TEXT},
|
|
{label: 'Description', type: SystemFieldType.HTML_TEXT},
|
|
{label: 'Researchers', type: SystemFieldType.RESEARCHERS},
|
|
{label: 'Organizations', type: SystemFieldType.ORGANIZATIONS},
|
|
{label: 'Language', type: SystemFieldType.LANGUAGE},
|
|
{label: 'Contact', type: SystemFieldType.CONTACT},
|
|
{label: 'Funder', type: SystemFieldType.FUNDER},
|
|
{label: 'Grant', type: SystemFieldType.GRANT},
|
|
{label: 'Project', type: SystemFieldType.PROJECT},
|
|
{label: 'License', type: SystemFieldType.LICENSE},
|
|
{label: 'Access Rights', type: SystemFieldType.ACCESS_RIGHTS}
|
|
];
|
|
systemFieldListPerSection: Array<Array<any>> = new Array();
|
|
descriptionTemplatesPerSection: Array<Array<DatasetProfileModel>> = new Array<Array<DatasetProfileModel>>();
|
|
|
|
constructor(
|
|
private dmpProfileService: DmpProfileService,
|
|
private _service: DmpService,
|
|
private route: ActivatedRoute,
|
|
private router: Router,
|
|
private language: TranslateService,
|
|
private enumUtils: EnumUtils,
|
|
private uiNotificationService: UiNotificationService,
|
|
private formService: FormService,
|
|
private fb: FormBuilder,
|
|
private configurationService: ConfigurationService,
|
|
private httpClient: HttpClient,
|
|
private matomoService: MatomoService,
|
|
private dialog: MatDialog
|
|
) {
|
|
super();
|
|
this.host = configurationService.server;
|
|
}
|
|
|
|
ngAfterViewInit() {
|
|
this.matomoService.trackPageView('Admin: DMP Profile Edit');
|
|
|
|
this.profilesAutoCompleteConfiguration = {
|
|
filterFn: this.filterProfiles.bind(this),
|
|
initialItems: (excludedItems: any[]) => this.filterProfiles('').pipe(map(result => result.filter(resultItem => (excludedItems || []).map(x => x.id).indexOf(resultItem.id) === -1))),
|
|
displayFn: (item) => item['label'],
|
|
titleFn: (item) => item['label'],
|
|
subtitleFn: (item) => item['description'],
|
|
popupItemActionIcon: 'visibility'
|
|
};
|
|
|
|
this.route.params
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe((params: Params) => {
|
|
this.dmpProfileId = params['id'];
|
|
const cloneId = params['cloneid'];
|
|
|
|
if (this.dmpProfileId != null) {
|
|
this.isNew = false;
|
|
this.dmpProfileService.getSingleBlueprint(this.dmpProfileId).pipe(map(data => data as DmpBlueprint))
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe(data => {
|
|
this.dmpBlueprintModel = new DmpBlueprintEditor().fromModel(data);
|
|
this.formGroup = this.dmpBlueprintModel.buildForm();
|
|
this.buildSystemFields();
|
|
this.fillDescriptionTemplatesInMultAutocomplete();
|
|
if (this.dmpBlueprintModel.status == DmpProfileStatus.Finalized) {
|
|
this.formGroup.disable();
|
|
this.viewOnly = true
|
|
}
|
|
this.breadCrumbs = observableOf([{
|
|
parentComponentName: 'DmpProfileListingComponent',
|
|
label: this.language.instant('NAV-BAR.TEMPLATE'),
|
|
url: '/dmp-profiles/' + this.dmpProfileId
|
|
}]);
|
|
});
|
|
} else if (cloneId != null) {
|
|
this.isClone = true;
|
|
this.dmpProfileService.clone(cloneId).pipe(map(data => data as DmpBlueprint), takeUntil(this._destroyed))
|
|
.subscribe(
|
|
data => {
|
|
this.dmpBlueprintModel = new DmpBlueprintEditor().fromModel(data);
|
|
this.dmpBlueprintModel.id = null;
|
|
this.dmpBlueprintModel.created = null;
|
|
this.dmpBlueprintModel.status = DmpProfileStatus.Draft;
|
|
this.formGroup = this.dmpBlueprintModel.buildForm();
|
|
this.buildSystemFields();
|
|
this.fillDescriptionTemplatesInMultAutocomplete();
|
|
},
|
|
error => this.onCallbackError(error)
|
|
);
|
|
} else {
|
|
this.dmpProfileModel = new DmpProfileEditorModel();
|
|
this.dmpBlueprintModel = new DmpBlueprintEditor();
|
|
setTimeout(() => {
|
|
// this.formGroup = this.dmpProfileModel.buildForm();
|
|
// this.addField();
|
|
this.dmpBlueprintModel.status = DmpProfileStatus.Draft;
|
|
this.formGroup = this.dmpBlueprintModel.buildForm();
|
|
});
|
|
this.breadCrumbs = observableOf([{
|
|
parentComponentName: 'DmpProfileListingComponent',
|
|
label: this.language.instant('NAV-BAR.TEMPLATE'),
|
|
url: '/dmp-profiles/' + this.dmpProfileId
|
|
}]);
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
buildSystemFields(){
|
|
const sections = this.sectionsArray().controls.length;
|
|
for(let i = 0; i < sections; i++){
|
|
let systemFieldsInSection = new Array();
|
|
this.fieldsArray(i).controls.forEach((field) => {
|
|
if((field.get('category').value == FieldCategory.SYSTEM || field.get('category').value == 'SYSTEM')){
|
|
systemFieldsInSection.push(this.fieldList.find(f => f.type == field.get('type').value).type);
|
|
}
|
|
})
|
|
this.systemFieldListPerSection.push(systemFieldsInSection);
|
|
}
|
|
}
|
|
|
|
fillDescriptionTemplatesInMultAutocomplete(){
|
|
const sections = this.sectionsArray().controls.length;
|
|
for(let i = 0; i < sections; i++){
|
|
let descriptionTemplatesInSection = new Array<DatasetProfileModel>();
|
|
this.descriptionTemplatesArray(i).controls.forEach((template) => {
|
|
descriptionTemplatesInSection.push({id: template.value.descriptionTemplateId, label: template.value.label, description: ""});
|
|
})
|
|
this.descriptionTemplatesPerSection.push(descriptionTemplatesInSection);
|
|
}
|
|
}
|
|
|
|
checkForProfiles(event, sectionIndex: number) {
|
|
if (event.checked === false) {
|
|
this.descriptionTemplatesPerSection[sectionIndex] = new Array<DatasetProfileModel>();
|
|
this.descriptionTemplatesArray(sectionIndex).clear();
|
|
}
|
|
}
|
|
|
|
filterProfiles(value: string): Observable<DatasetProfileModel[]> {
|
|
const request = new DataTableRequest<DatasetProfileCriteria>(null, null, { fields: ['+label'] });
|
|
const criteria = new DatasetProfileCriteria();
|
|
criteria.like = value;
|
|
request.criteria = criteria;
|
|
return this._service.searchDMPProfiles(request);
|
|
}
|
|
|
|
sectionsArray(): FormArray {
|
|
//return this.dmpBlueprintsFormGroup.get('sections') as FormArray;
|
|
return this.formGroup.get('definition').get('sections') as FormArray;
|
|
}
|
|
|
|
addSection(): void {
|
|
const section: SectionDmpBlueprintEditor = new SectionDmpBlueprintEditor();
|
|
section.id = Guid.create().toString();
|
|
section.ordinal = this.sectionsArray().length + 1;
|
|
section.hasTemplates = false;
|
|
this.sectionsArray().push(section.buildForm());
|
|
this.systemFieldListPerSection.push(new Array());
|
|
this.descriptionTemplatesPerSection.push(new Array());
|
|
}
|
|
|
|
removeSection(sectionIndex: number): void {
|
|
this.systemFieldListPerSection.splice(sectionIndex, 1);
|
|
this.descriptionTemplatesPerSection.splice(sectionIndex, 1);
|
|
this.sectionsArray().removeAt(sectionIndex);
|
|
this.sectionsArray().controls.forEach((section, index) => {
|
|
section.get('ordinal').setValue(index + 1);
|
|
});
|
|
}
|
|
|
|
fieldsArray(sectionIndex: number): FormArray {
|
|
return this.sectionsArray().at(sectionIndex).get('fields') as FormArray;
|
|
}
|
|
|
|
addField(sectionIndex: number, fieldCategory: FieldCategory, fieldType?: number): void {
|
|
const field: FieldInSectionEditor = new FieldInSectionEditor();
|
|
field.id = Guid.create().toString();
|
|
field.ordinal = this.fieldsArray(sectionIndex).length + 1;
|
|
field.category = fieldCategory;
|
|
if(!isNullOrUndefined(fieldType)){
|
|
field.type = fieldType
|
|
}
|
|
field.required = (!isNullOrUndefined(fieldType) && (fieldType == 0 || fieldType == 1)) ? true : false;
|
|
this.fieldsArray(sectionIndex).push(field.buildForm());
|
|
}
|
|
|
|
removeField(sectionIndex: number, fieldIndex: number): void {
|
|
this.fieldsArray(sectionIndex).removeAt(fieldIndex);
|
|
}
|
|
|
|
systemFieldsArray(sectionIndex: number): FormArray {
|
|
return this.sectionsArray().at(sectionIndex).get('systemFields') as FormArray;
|
|
}
|
|
|
|
initSystemField(systemField?: SystemFieldType): FormGroup {
|
|
return this.fb.group({
|
|
id: this.fb.control(Guid.create().toString()),
|
|
type: this.fb.control(systemField),
|
|
label: this.fb.control(''),
|
|
placeholder: this.fb.control(''),
|
|
description: this.fb.control(''),
|
|
required: this.fb.control(true),
|
|
ordinal: this.fb.control('')
|
|
});
|
|
}
|
|
|
|
addSystemField(sectionIndex: number, systemField?: SystemFieldType): void {
|
|
this.addField(sectionIndex, FieldCategory.SYSTEM, systemField);
|
|
}
|
|
|
|
transfromEnumToString(type: SystemFieldType): string{
|
|
return this.fieldList.find(f => f.type == type).label;
|
|
}
|
|
|
|
selectedFieldType(type: SystemFieldType, sectionIndex: number): void {
|
|
if (this.systemFieldDisabled(type, sectionIndex)) return;
|
|
let index = this.systemFieldListPerSection[sectionIndex].indexOf(type);
|
|
if (index == -1) {
|
|
this.systemFieldListPerSection[sectionIndex].push(type);
|
|
this.addSystemField(sectionIndex, type);
|
|
}
|
|
else {
|
|
this.systemFieldListPerSection[sectionIndex].splice(index, 1);
|
|
this.removeSystemField(sectionIndex, type);
|
|
}
|
|
}
|
|
|
|
systemFieldDisabled(systemField: SystemFieldType, sectionIndex: number) {
|
|
let i = 0;
|
|
for (let s in this.sectionsArray().controls) {
|
|
if (i != sectionIndex) {
|
|
for (let f of this.fieldsArray(i).controls) {
|
|
if ((f.get('category').value == FieldCategory.SYSTEM || f.get('category').value == 'SYSTEM') && f.get('type').value == systemField) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
removeSystemFieldWithIndex(sectionIndex: number, fieldIndex: number): void {
|
|
let type: SystemFieldType = this.fieldsArray(sectionIndex).at(fieldIndex).get('type').value;
|
|
let index = this.systemFieldListPerSection[sectionIndex].indexOf(type);
|
|
this.systemFieldListPerSection[sectionIndex] = this.systemFieldListPerSection[sectionIndex].filter(types => types != type);
|
|
this.fieldsArray(sectionIndex).removeAt(fieldIndex);
|
|
}
|
|
|
|
removeSystemField(sectionIndex: number, systemField: SystemFieldType): void {
|
|
let i = 0;
|
|
for(let f of this.fieldsArray(sectionIndex).controls){
|
|
if((f.get('category').value == FieldCategory.SYSTEM || f.get('category').value == 'SYSTEM') && f.get('type').value == systemField){
|
|
this.fieldsArray(sectionIndex).removeAt(i);
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
descriptionTemplatesArray(sectionIndex: number): FormArray {
|
|
return this.sectionsArray().at(sectionIndex).get('descriptionTemplates') as FormArray;
|
|
}
|
|
|
|
addDescriptionTemplate(descriptionTemplate, sectionIndex: number): void {
|
|
this.descriptionTemplatesArray(sectionIndex).push(this.fb.group({
|
|
label: this.fb.control(descriptionTemplate.value)
|
|
}));
|
|
}
|
|
|
|
removeDescriptionTemplate(sectionIndex: number, templateIndex: number): void {
|
|
this.descriptionTemplatesArray(sectionIndex).removeAt(templateIndex);
|
|
}
|
|
|
|
extraFieldsArray(sectionIndex: number): FormArray {
|
|
return this.sectionsArray().at(sectionIndex).get('extraFields') as FormArray;
|
|
}
|
|
|
|
addExtraField(sectionIndex: number): void {
|
|
this.addField(sectionIndex, FieldCategory.EXTRA);
|
|
}
|
|
|
|
removeExtraField(sectionIndex: number, fieldIndex: number): void {
|
|
this.fieldsArray(sectionIndex).removeAt(fieldIndex);
|
|
}
|
|
|
|
getExtraFieldTypes(): Number[] {
|
|
let keys: string[] = Object.keys(ExtraFieldType);
|
|
keys = keys.slice(0, keys.length / 2);
|
|
const values: Number[] = keys.map(Number);
|
|
return values;
|
|
}
|
|
|
|
getExtraFieldTypeValue(extraFieldType: ExtraFieldType): string {
|
|
switch (extraFieldType) {
|
|
case ExtraFieldType.TEXT: return 'Text';
|
|
case ExtraFieldType.RICH_TEXT: return 'Rich Text';
|
|
case ExtraFieldType.DATE: return 'Date';
|
|
case ExtraFieldType.NUMBER: return 'Number';
|
|
}
|
|
}
|
|
|
|
drop(event: CdkDragDrop<string[]>, sectionIndex: number) {
|
|
moveItemInArray(this.fieldsArray(sectionIndex).controls, event.previousIndex, event.currentIndex);
|
|
moveItemInArray(this.fieldsArray(sectionIndex).value, event.previousIndex, event.currentIndex);
|
|
}
|
|
|
|
dropSections(event: CdkDragDrop<string[]>) {
|
|
moveItemInArray(this.sectionsArray().controls, event.previousIndex, event.currentIndex);
|
|
moveItemInArray(this.sectionsArray().value, event.previousIndex, event.currentIndex);
|
|
this.sectionsArray().controls.forEach((section, index) => {
|
|
section.get('ordinal').setValue(index + 1);
|
|
});
|
|
moveItemInArray(this.systemFieldListPerSection, event.previousIndex, event.currentIndex);
|
|
moveItemInArray(this.descriptionTemplatesPerSection, event.previousIndex, event.currentIndex);
|
|
}
|
|
|
|
moveItemInFormArray(formArray: FormArray, fromIndex: number, toIndex: number): void {
|
|
const dir = toIndex > fromIndex ? 1 : -1;
|
|
|
|
const item = formArray.at(fromIndex);
|
|
for (let i = fromIndex; i * dir < toIndex * dir; i = i + dir) {
|
|
const current = formArray.at(i + dir);
|
|
formArray.setControl(i, current);
|
|
}
|
|
formArray.setControl(toIndex, item);
|
|
}
|
|
|
|
// clearForm(): void{
|
|
// this.dmpBlueprintsFormGroup.reset();
|
|
// }
|
|
|
|
onRemoveTemplate(event, sectionIndex: number) {
|
|
const profiles = this.descriptionTemplatesArray(sectionIndex).controls;
|
|
const foundIndex = profiles.findIndex(profile => profile.get('descriptionTemplateId').value === event.id);
|
|
foundIndex !== -1 && this.descriptionTemplatesArray(sectionIndex).removeAt(foundIndex);
|
|
}
|
|
|
|
onPreviewTemplate(event, sectionIndex: number) {
|
|
const dialogRef = this.dialog.open(DatasetPreviewDialogComponent, {
|
|
width: '590px',
|
|
minHeight: '200px',
|
|
restoreFocus: false,
|
|
data: {
|
|
template: event
|
|
},
|
|
panelClass: 'custom-modalbox'
|
|
});
|
|
dialogRef.afterClosed().pipe(takeUntil(this._destroyed)).subscribe(result => {
|
|
if (result) {
|
|
const profile: DescriptionTemplatesInSectionEditor = new DescriptionTemplatesInSectionEditor();
|
|
profile.id = Guid.create().toString();
|
|
profile.descriptionTemplateId = event.id;
|
|
profile.label = event.label;
|
|
this.descriptionTemplatesArray(sectionIndex).push(profile.buildForm());
|
|
|
|
const items = this.descriptionTemplatesPerSection[sectionIndex];
|
|
items.push({id: event.id, label: event.label, description: ""});
|
|
this.descriptionTemplatesPerSection[sectionIndex] = [...items];
|
|
}
|
|
});
|
|
}
|
|
|
|
onOptionSelected(item, sectionIndex){
|
|
const profile: DescriptionTemplatesInSectionEditor = new DescriptionTemplatesInSectionEditor();
|
|
profile.id = Guid.create().toString();
|
|
profile.descriptionTemplateId = item.id;
|
|
profile.label = item.label;
|
|
this.descriptionTemplatesArray(sectionIndex).push(profile.buildForm());
|
|
}
|
|
|
|
checkValidity() {
|
|
this.formService.touchAllFormFields(this.formGroup);
|
|
if (!this.isFormValid()) { return false; }
|
|
let errorMessages = [];
|
|
if(!this.hasTitle()) {
|
|
errorMessages.push("Title should be set.");
|
|
}
|
|
if(!this.hasDescription()) {
|
|
errorMessages.push("Description should be set.");
|
|
}
|
|
if(!this.hasDescriptionTemplates()) {
|
|
errorMessages.push("At least one section should have description templates.");
|
|
}
|
|
if(errorMessages.length > 0) {
|
|
this.showValidationErrorsDialog(undefined, errorMessages);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
formSubmit(): void {
|
|
if (this.checkValidity())
|
|
this.onSubmit();
|
|
}
|
|
|
|
public isFormValid() {
|
|
return this.formGroup.valid;
|
|
}
|
|
|
|
hasTitle(): boolean {
|
|
const dmpBlueprint: DmpBlueprint = this.formGroup.value;
|
|
return dmpBlueprint.definition.sections.some(section => section.fields.some(field => (field.category === FieldCategory.SYSTEM || field.category as unknown === 'SYSTEM') && field.type === SystemFieldType.TEXT));
|
|
}
|
|
|
|
hasDescription(): boolean {
|
|
const dmpBlueprint: DmpBlueprint = this.formGroup.value;
|
|
return dmpBlueprint.definition.sections.some(section => section.fields.some(field => (field.category === FieldCategory.SYSTEM || field.category as unknown === 'SYSTEM') && field.type === SystemFieldType.HTML_TEXT));
|
|
}
|
|
|
|
hasDescriptionTemplates(): boolean {
|
|
const dmpBlueprint: DmpBlueprint = this.formGroup.value;
|
|
return dmpBlueprint.definition.sections.some(section => section.hasTemplates == true);
|
|
}
|
|
|
|
private showValidationErrorsDialog(projectOnly?: boolean, errmess?: string[]) {
|
|
|
|
const dialogRef = this.dialog.open(FormValidationErrorsDialogComponent, {
|
|
disableClose: true,
|
|
autoFocus: false,
|
|
restoreFocus: false,
|
|
data: {
|
|
errorMessages:errmess,
|
|
projectOnly: projectOnly
|
|
},
|
|
});
|
|
|
|
}
|
|
|
|
onSubmit(): void {
|
|
this.dmpProfileService.createBlueprint(this.formGroup.value)
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe(
|
|
complete => this.onCallbackSuccess(),
|
|
error => this.onCallbackError(error)
|
|
);
|
|
}
|
|
|
|
onCallbackSuccess(): void {
|
|
this.uiNotificationService.snackBarNotification(this.isNew ? this.language.instant('GENERAL.SNACK-BAR.SUCCESSFUL-CREATION') : this.language.instant('GENERAL.SNACK-BAR.SUCCESSFUL-UPDATE'), SnackBarNotificationLevel.Success);
|
|
this.router.navigate(['/dmp-profiles']);
|
|
}
|
|
|
|
onCallbackError(errorResponse: any) {
|
|
this.setErrorModel(errorResponse.error);
|
|
this.formService.validateAllFormFields(this.formGroup);
|
|
}
|
|
|
|
public setErrorModel(validationErrorModel: ValidationErrorModel) {
|
|
Object.keys(validationErrorModel).forEach(item => {
|
|
(<any>this.dmpProfileModel.validationErrorModel)[item] = (<any>validationErrorModel)[item];
|
|
});
|
|
}
|
|
|
|
public cancel(): void {
|
|
this.router.navigate(['/dmp-profiles']);
|
|
}
|
|
|
|
// addField() {
|
|
// (<FormArray>this.formGroup.get('definition').get('fields')).push(new DmpProfileFieldEditorModel().buildForm());
|
|
// }
|
|
|
|
// removeField(index: number) {
|
|
// (<FormArray>this.formGroup.get('definition').get('fields')).controls.splice(index, 1);
|
|
// }
|
|
|
|
getDMPProfileFieldDataTypeValues(): Number[] {
|
|
let keys: string[] = Object.keys(DmpProfileFieldDataType);
|
|
keys = keys.slice(0, keys.length / 2);
|
|
const values: Number[] = keys.map(Number);
|
|
return values;
|
|
}
|
|
|
|
getDMPProfileFieldDataTypeWithLanguage(fieldType: DmpProfileFieldDataType): string {
|
|
let result = '';
|
|
this.language.get(this.enumUtils.toDmpProfileFieldDataTypeString(fieldType))
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe((value: string) => {
|
|
result = value;
|
|
});
|
|
return result;
|
|
}
|
|
|
|
getDMPProfileFieldTypeValues(): Number[] {
|
|
let keys: string[] = Object.keys(DmpProfileType);
|
|
keys = keys.slice(0, keys.length / 2);
|
|
const values: Number[] = keys.map(Number);
|
|
return values;
|
|
}
|
|
|
|
getDMPProfileFieldTypeWithLanguage(profileType: DmpProfileType): string {
|
|
let result = '';
|
|
this.language.get(this.enumUtils.toDmpProfileTypeString(profileType))
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe((value: string) => {
|
|
result = value;
|
|
});
|
|
return result;
|
|
}
|
|
|
|
delete() {
|
|
this.dialog.open(ConfirmationDialogComponent,{data:{
|
|
isDeleteConfirmation: true,
|
|
confirmButton: this.language.instant('DMP-PROFILE-EDITOR.CONFIRM-DELETE-DIALOG.CONFIRM-BUTTON'),
|
|
cancelButton: this.language.instant("DMP-PROFILE-EDITOR.CONFIRM-DELETE-DIALOG.CANCEL-BUTTON"),
|
|
message: this.language.instant("DMP-PROFILE-EDITOR.CONFIRM-DELETE-DIALOG.MESSAGE")
|
|
}})
|
|
.afterClosed()
|
|
.subscribe(
|
|
confirmed =>{
|
|
if(confirmed){
|
|
if(this.formGroup.get('status').value == DmpProfileStatus.Draft) {
|
|
this.formGroup.get('status').setValue(DmpProfileStatus.Deleted);
|
|
this.dmpProfileService.createBlueprint(this.formGroup.value)
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe(
|
|
complete => this.onCallbackSuccess(),
|
|
error => this.onCallbackError(error)
|
|
);
|
|
}
|
|
else {
|
|
this.dmpProfileService.delete(this.dmpProfileId)
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe(
|
|
complete => this.onCallbackSuccess(),
|
|
error => {
|
|
if (error.error.statusCode == 674) {
|
|
this.uiNotificationService.snackBarNotification(this.language.instant('GENERAL.SNACK-BAR.UNSUCCESSFUL-DMP-BLUEPRINT-DELETE'), SnackBarNotificationLevel.Error);
|
|
} else {
|
|
this.uiNotificationService.snackBarNotification(this.language.instant(error.message), SnackBarNotificationLevel.Error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}
|
|
)
|
|
|
|
}
|
|
|
|
finalize() {
|
|
if (this.checkValidity()) {
|
|
this.formGroup.get('status').setValue(DmpProfileStatus.Finalized);
|
|
this.onSubmit();
|
|
}
|
|
}
|
|
|
|
downloadXML(): void {
|
|
this.dmpProfileService.downloadXML(this.dmpProfileId)
|
|
.pipe(takeUntil(this._destroyed))
|
|
.subscribe(response => {
|
|
const blob = new Blob([response.body], { type: 'application/xml' });
|
|
const filename = this.getFilenameFromContentDispositionHeader(response.headers.get('Content-Disposition'));
|
|
|
|
FileSaver.saveAs(blob, filename);
|
|
});
|
|
}
|
|
|
|
|
|
getFilenameFromContentDispositionHeader(header: string): string {
|
|
const regex: RegExp = new RegExp(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/g);
|
|
|
|
const matches = header.match(regex);
|
|
let filename: string;
|
|
for (let i = 0; i < matches.length; i++) {
|
|
const match = matches[i];
|
|
if (match.includes('filename="')) {
|
|
filename = match.substring(10, match.length - 1);
|
|
break;
|
|
} else if (match.includes('filename=')) {
|
|
filename = match.substring(9);
|
|
break;
|
|
}
|
|
}
|
|
return filename;
|
|
}
|
|
|
|
isExternalAutocomplete(formGroup: FormGroup) {
|
|
if (formGroup.get('dataType').value == DmpProfileFieldDataType.ExternalAutocomplete) {
|
|
this.addControl(formGroup);
|
|
return true;
|
|
} else {
|
|
this.removeControl(formGroup);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
addControl(formGroup: FormGroup) {
|
|
if (formGroup.get('dataType').value == 3)
|
|
formGroup.addControl('externalAutocomplete', new DmpProfileExternalAutoCompleteFieldDataEditorModel().buildForm());
|
|
}
|
|
|
|
removeControl(formGroup: FormGroup) {
|
|
if (formGroup.get('dataType').value != 3)
|
|
formGroup.removeControl('externalAutocomplete');
|
|
}
|
|
}
|