@hitsoft/e-donusum 1.0.5

package/src/lib/components/hit-xslt-rules/hit-xslt-rule.component.ts

@@ -0,0 +1,363 @@
+import { ABP, isNullOrEmpty, isNullOrUndefined, ListService, PagedResultDto, TrackByService } from '@abp/ng.core';
+import { Confirmation, ConfirmationService, ToasterService } from '@abp/ng.theme.shared';
+import { DateAdapter } from '@abp/ng.theme.shared/extensions';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, HostListener, OnInit, ViewChild } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';
+import { XsltFormatDto, XsltFormatService } from '../../proxy/xslt-formats';
+import { DxDataGridComponent, DxHtmlEditorComponent } from 'devextreme-angular';
+import { finalize, tap, filter, switchMap, ReplaySubject, Observable } from 'rxjs';
+import { HitXsltFormatService } from '../../hit-proxy/hit-xslt-formats/hit-xslt-format.service';
+import { ContentMasterInputDto } from '../../hit-proxy/hit-content-master/models';
+import { NoteRuleCreateDto } from '../../proxy/note-rules';
+import { XsltRuleWithNavigationPropertiesDto, XsltRuleService, XsltRuleCreateDto, XsltRuleDto } from '../../proxy/xslt-rules';
+import { HitScenarioTypesService } from '../../hit-proxy/hit-scenario-types/hit-scenario-type.service';
+import { HitDocumentTypesService } from '../../hit-proxy/hit-document-types/hit-document-type.service';
+import { HitNoteRulesService } from '../../hit-proxy/hit-note-rules/hit-note-rule.service';
+import { HitXsltRulesService } from '../../hit-proxy/hit-xslt-rules/hit-xslt-rule.service';
+import { PreviewRuleRequestDto, XsltRuleCreateOrUpdateDto } from '../../hit-proxy/hit-xslt-rules/models';
+import { HitXsltRuleDocTypesService } from '../../hit-proxy/hit-xslt-rule-doc-types/hit-xslt-rule-doc-type.service';
+import { HitXsltRuleScenariosService } from '../../hit-proxy/hit-xslt-rule-scenarios/hit-xslt-rule-scenario.service';
+import { PreviewQueryRequestDto } from '../../hit-proxy/hit-note-rules/models';
+
+@Component({
+    selector: 'lib-xslt-rule',
+    changeDetection: ChangeDetectionStrategy.Default,
+    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],
+    templateUrl: './hit-xslt-rule.component.html',
+    styles: [],
+})
+
+export class HitXsltRuleComponent implements OnInit {
+    @ViewChild('dxXsltRuleInstance', { static: false }) dxXsltRuleInstance: DxDataGridComponent
+    @ViewChild('dxScenarioInstance', { static: false }) dxScenarioInstance: DxDataGridComponent
+    @ViewChild('dxDocTypeInstance', { static: false }) dxDocTypeInstance: DxDataGridComponent
+    @ViewChild('dxParamInstance', { static: false }) dxParamInstance: DxDataGridComponent
+
+    xsltRuleDataSource: any
+    docTypeDataSource: any
+    scenarioDataSource: any
+
+    form: FormGroup;
+    enterPressed = false;
+
+    isModalBusy = false;
+    isModalOpen = false;
+
+    htmlMentionDataSource = [];
+    tablesDataSource = [];
+    xsltFormatTypesDataSource = [];
+
+    xsltFormatGridBoxValue: any;
+    isXsltFormatGridBoxOpened: boolean;
+    xsltFormats: any;
+
+    selected?: XsltRuleDto;
+    selectedDocTypes = []
+    selectedScenarios = []
+
+    previewDataSource: [] = [];
+    paramsDataSource = [];
+    isParameterless = false;
+    isModalBusyPreview = false;
+    isModalOpenPreview = false;
+
+    constructor(
+        public readonly list: ListService,
+        public readonly track: TrackByService,
+        public readonly service: HitXsltRulesService,
+        private confirmation: ConfirmationService,
+        private readonly toasterService: ToasterService,
+        private fb: FormBuilder,
+        private ref: ChangeDetectorRef,
+        private readonly scenarioTypesService: HitScenarioTypesService,
+        private readonly documentTypesService: HitDocumentTypesService,
+        private readonly noteRulesService: HitNoteRulesService,
+        private readonly xsltFormatsService: HitXsltFormatService,
+        private readonly xsltRuleDocTypesService: HitXsltRuleDocTypesService,
+        private readonly xsltRuleScenariosService: HitXsltRuleScenariosService
+    ) {
+        this.xsltFormatGridBox_displayExpr = this.xsltFormatGridBox_displayExpr.bind(this)
+    }
+
+    ngOnInit() {
+        debugger;
+        this.xsltRuleDataSource = this.service.LoadXsltRules;
+        this.scenarioDataSource = this.service.LoadScenarios;
+        this.docTypeDataSource = this.service.LoadDocTypes;
+        this.xsltFormats = this.xsltFormatsService.LoadXsltFormatsWithParam(0);
+        this.noteRulesService.getTableNames().subscribe(list => {
+            list.forEach(element => {
+                this.tablesDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/table-icon.png"
+                })
+                this.htmlMentionDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/table-icon.png"
+                })
+            });
+        })
+        this.service.getParamNames().subscribe(list => {
+            list.forEach(element => {
+                this.htmlMentionDataSource.push({
+                    text: element.displayName,
+                    id: element.id,
+                    icon: "/assets/images/key-icon.png"
+                })
+            })
+        })
+        this.xsltFormatsService.getTypes().subscribe(list => {
+            this.xsltFormatTypesDataSource = list;
+        })
+    }
+
+    buildForm() {
+        debugger;
+        const { ruleName, xsltType, document, orderNo, noteQuery, noteQueryHTML, isPassive, desc, xsltFormatId } =
+            this.selected || {};
+
+        this.form = this.fb.group({
+            ruleName: [ruleName ?? null, [Validators.required, Validators.maxLength(256)]],
+            xsltType: [xsltType ?? 0, []],
+            document: [document ?? null, []],
+            orderNo: [orderNo ?? 0, []],
+            noteQuery: [noteQuery ?? null, [Validators.maxLength(2048)]],
+            noteQueryHTML: [noteQueryHTML ?? null, [Validators.maxLength(2048)]],
+            isPassive: [isPassive ?? false, []],
+            desc: [desc ?? null, [Validators.maxLength(512)]],
+            xsltFormatId: [xsltFormatId ?? null, [Validators.required]],
+        });
+
+        if (!isNullOrUndefined(this.form.controls.xsltType.value))
+            this.xsltFormats = this.xsltFormatsService.LoadXsltFormatsWithParam(this.form.controls.xsltType.value)
+    }
+
+    hideForm() {
+        this.isModalOpen = false;
+        this.form.reset();
+    }
+
+    showForm() {
+        this.buildForm();
+        this.isModalOpen = true;
+    }
+
+    submitForm() {
+
+        if (this.enterPressed) {
+            this.enterPressed = false;
+            return;
+        }
+
+        if (this.form.invalid) return;
+
+        let xsltRuleReq = this.form.value as XsltRuleCreateOrUpdateDto
+        let xsltRuleScenariosReq = [];
+        let xsltRuleDocTypesReq = [];
+
+        this.dxScenarioInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {
+            xsltRuleScenariosReq.push({
+                xsltRuleId: this.selected?.id,
+                scenario: element.data.id
+            })
+        })
+
+        this.dxDocTypeInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {
+            xsltRuleDocTypesReq.push({
+                noteRuleId: this.selected?.id,
+                docType: element.data.id
+            })
+        })
+
+        xsltRuleReq.concurrencyStamp = this.selected?.concurrencyStamp;
+        xsltRuleReq.id = this.selected?.id
+
+        const request = this.selected
+            ? this.service.update(this.selected.id, {
+                xsltRule: xsltRuleReq,
+                xsltRuleScenarios: xsltRuleScenariosReq,
+                xsltRuleDocTypes: xsltRuleDocTypesReq
+            })
+            : this.service.create(
+                {
+                    xsltRule: xsltRuleReq,
+                    xsltRuleScenarios: xsltRuleScenariosReq,
+                    xsltRuleDocTypes: xsltRuleDocTypesReq
+                });
+
+        this.isModalBusy = true;
+
+        request
+            .pipe(
+                finalize(() => (this.isModalBusy = false)),
+                tap(() => this.hideForm())
+            )
+            .subscribe(() => this.dxXsltRuleInstance.instance.refresh());
+    }
+
+    create() {
+        this.selected = null;
+        this.xsltFormatGridBoxValue = null;
+        this.selectedDocTypes = []
+        this.selectedScenarios = []
+        this.showForm();
+    }
+
+    update(record: XsltRuleWithNavigationPropertiesDto) {
+        this.selected = record.xsltRule;
+
+        this.xsltRuleScenariosService.getSelectedScenarios(this.selected.id).subscribe(list => {
+            this.selectedScenarios = list.map(i => i.scenario);
+        })
+
+        this.xsltRuleDocTypesService.getSelectedDocTypes(this.selected.id).subscribe(list => {
+            this.selectedDocTypes = list.map(i => i.docType);
+        })
+
+        this.showForm();
+    }
+
+    delete(record: XsltRuleWithNavigationPropertiesDto) {
+        this.confirmation
+            .warn('eDonusum::DeleteConfirmationMessage', 'eDonusum::AreYouSure', {
+                messageLocalizationParams: [],
+            })
+            .pipe(
+                filter(status => status === Confirmation.Status.confirm),
+                switchMap(() => this.service.delete(record.xsltRule.id))
+            )
+            .subscribe(this.list.get);
+    }
+
+    xsltFormatGridBox_displayExpr(item) {
+        this.form.controls.xsltFormatId.setValue(item.id.toString())
+        return `${item.fileName}`;
+    }
+
+    onXsltFormatGridBoxOptionChanged(e) {
+
+        if (e.name === 'value') {
+            this.isXsltFormatGridBoxOpened = false;
+            this.ref.detectChanges();
+        }
+    }
+
+    xsltTypeChanged() {
+        this.xsltFormats = this.xsltFormatsService.LoadXsltFormatsWithParam(this.form.controls.xsltType.value)
+        this.xsltFormatGridBoxValue = null;
+        this.form.controls.xsltFormatId.setValue(null);
+    }
+
+    previewQuery() {
+
+        let xsltRuleReq = this.form.value as NoteRuleCreateDto
+        this.previewDataSource = [];
+        this.paramsDataSource = [];
+
+        if(isNullOrEmpty(xsltRuleReq.noteQueryHTML)){
+            this.toasterService.info('Sorgu bulunamadı.')
+            return;
+        }
+
+        let noteQuery = this.stripHTML(xsltRuleReq.noteQueryHTML);
+
+        if(isNullOrUndefined(this.form.controls.document.value)){
+            this.toasterService.warn('Tablo seçiniz.')
+            return;
+        }
+
+        const tableName = this.checkTableAfterFrom(noteQuery);
+
+        if (!tableName) {
+            this.toasterService.error("Seçili tablo ile sorguda başlanılan tablo aynı olmalı.");
+            return;
+        }
+
+        let params = noteQuery.match(/(BelgeKey|BelgeDetayKey|MuhatapKey|MuhatapGrupKey)/g);
+
+        if (!isNullOrUndefined(params)) {
+            this.paramsDataSource = [];
+            params.forEach(element => {
+                this.paramsDataSource.push({
+                    paramName: element.replace(":", ""),
+                    paramValue: ""
+                })
+            })
+        }
+
+        if (isNullOrEmpty(this.paramsDataSource) || this.paramsDataSource.length == 0) {
+            this.toasterService.info('eDonusum::QueryPreviewIsPreparing')
+            this.isParameterless = true;
+            this.runQuery();
+        }
+        else {
+            this.isParameterless = false;
+        }
+
+        this.isModalOpenPreview = true;
+    }
+
+    runQuery() {
+
+        let paramValues = [];
+
+        if (!this.isParameterless) {
+            this.toasterService.info('eDonusum::QueryPreviewIsPreparing')
+
+            this.dxParamInstance.instance.getVisibleRows().forEach(element => {
+                paramValues.push({
+                    paramName: element.data.paramName,
+                    paramValue: element.data.paramValue
+                });
+            })
+        }
+
+        let xsltRuleReq = this.form.value as XsltRuleCreateDto
+
+        let requestDto: PreviewRuleRequestDto = {
+            xsltRule: xsltRuleReq,
+            ruleParameters: paramValues
+        }
+
+        this.service.previewRuleResult(requestDto).subscribe(result => {
+            this.previewDataSource = result.value
+
+            if (this.previewDataSource.length > 0)
+                this.toasterService.success('eDonusum::QueryPreviewIsReady')
+            else
+                this.toasterService.warn('eDonusum::QueryPreviewNoResult')
+        })
+    }
+
+    @HostListener('document:keydown', ['$event'])
+    handleKeyDown(event: KeyboardEvent) {
+        if (event.key === 'Enter') {
+            this.enterPressed = true;
+        }
+    }
+
+    stripHTML(input: string): string {
+        const strippedHtml = input.replace("</p><p>", " ");
+        return strippedHtml.replace(/@/g, '').replace(/<.*?>/g, '');
+    }
+
+    checkTableAfterFrom(query: string): boolean {
+        const regex = /FROM\s+([@\w]+)/i;
+
+        const selectedTableName = this.tablesDataSource.filter(i => i.id == this.form.controls.document.value)[0].text
+        const match = query.match(regex);
+
+        if (match && match[1]) {
+            const tableName = match[1];
+            if (tableName === ("@" + selectedTableName) || tableName === selectedTableName) {
+                return true
+            }
+        }
+
+        return false;
+    }
+
+}

package/src/lib/components/hit-xslt-rules/hit-xslt-rule.module.ts

@@ -0,0 +1,40 @@
+import { CoreModule } from '@abp/ng.core';
+import { ThemeSharedModule } from '@abp/ng.theme.shared';
+import { NgModule } from '@angular/core';
+import {
+  NgbCollapseModule,
+  NgbDatepickerModule,
+  NgbDropdownModule,
+} from '@ng-bootstrap/ng-bootstrap';
+import { NgxValidateCoreModule } from '@ngx-validate/core';
+import { CommercialUiModule } from '@volo/abp.commercial.ng.ui';
+import { PageModule } from '@abp/ng.components/page';
+import { DxDataGridModule, DxDropDownBoxModule, DxHtmlEditorModule, DxLookupModule, DxSelectBoxModule, DxTabPanelModule, DxTextAreaModule, DxTextBoxModule } from 'devextreme-angular';
+import { HitXsltRuleComponent } from './hit-xslt-rule.component';
+
+@NgModule({
+  declarations: [HitXsltRuleComponent],
+  imports: [
+    CoreModule,
+    ThemeSharedModule,
+    CommercialUiModule,
+    NgxValidateCoreModule,
+    NgbCollapseModule,
+    NgbDatepickerModule,
+    NgbDropdownModule,
+    DxDataGridModule,
+    DxTextAreaModule,
+    DxTextBoxModule,
+    DxHtmlEditorModule,
+    DxSelectBoxModule,
+    DxLookupModule,
+    DxTabPanelModule,
+    PageModule,
+    DxDropDownBoxModule
+  ],
+})
+export class HitXsltRuleModule {}
+
+export function loadHitXsltRuleModuleAsChild() {
+  return Promise.resolve(HitXsltRuleModule);
+}