@hitsoft/e-donusum 1.0.75 → 1.0.77

package/esm2020/lib/components/hit-despatches/hit-despatch.component.mjs

@@ -169,11 +169,11 @@ export class HitDespatchComponent {
         debugger;
         this.service.getDespatchXML(record.id, record.resourceDocType).subscribe(irsaliye => {
             const source = `data:${irsaliye.mimeType};base64,${irsaliye.content}`;
-            this.hitSharedService.previewFile(irsaliye.content);
-            /*const link = document.createElement('a');
+            //this.hitSharedService.previewFile(irsaliye.content);
+            const link = document.createElement('a');
             link.href = source;
             link.download = `${irsaliye.filename}`;
-            link.click();*/
+            link.click();
         });
     }
     getDocObjectName(data) {
@@ -197,10 +197,10 @@ export class HitDespatchComponent {
     getDespatchView(record) {
         this.service.getDespatchView(record.uuId).subscribe(item => {
             const source = `data:${item.mimeType};base64,${item.content}`;
-            const newTab = window.open();
-            newTab.document.title = record.id;
-            newTab.document.body.innerHTML = `<iframe src="${source}" width="100%" height="100%" style="border:none;"></iframe>`;
-            //this.hitSharedService.previewFile(item.content);
+            //  const newTab = window.open();
+            // newTab.document.title = record.id
+            // newTab.document.body.innerHTML = `<iframe src="${source}" width="100%" height="100%" style="border:none;"></iframe>`;
+            this.hitSharedService.previewFile(item.content);
             /*const link = document.createElement('a');
             link.href = source;
             link.download = `${item.filename}`;
@@ -298,4 +298,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                 type: ViewChild,
                 args: ['dxDespatchSerialInstance', { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit-despatch.component.js","sourceRoot":"","sources":["../../../../../../projects/e-donusum/src/lib/components/hit-despatches/hit-despatch.component.ts","../../../../../../projects/e-donusum/src/lib/components/hit-despatches/hit-despatch.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ABP, isNullOrEmpty, isNullOrUndefined, ListService, PagedResultDto } from '@abp/ng.core';\r\nimport { DateAdapter } from '@abp/ng.theme.shared/extensions';\r\nimport { ChangeDetectionStrategy, Component, HostListener, OnInit, Pipe, PipeTransform, ViewChild } from '@angular/core';\r\nimport { NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';\r\nimport { DxDataGridComponent } from 'devextreme-angular';\r\nimport { HitDespatchService } from '../../hit-proxy/hit-despatches/hit-despatch.service';\r\nimport { HitFileDocumentTypeService } from '../../hit-proxy/hit-file-document-type/hit-file-document-type.service';\r\nimport { Confirmation, ConfirmationService, ToasterService } from '@abp/ng.theme.shared';\r\nimport { HitGibPartnerPkService } from '../../hit-proxy/hit-gib-partner-pks/hit-gib-partner-pk.service';\r\nimport { HitDocumentSerialService } from '../../hit-proxy/hit-document-serials/hit-document-serial.service';\r\nimport { HitSharedService } from '../../hit-proxy/shared/hit-shared.service';\r\n@Component({\r\n    selector: 'lib-despatch',\r\n    changeDetection: ChangeDetectionStrategy.Default,\r\n    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],\r\n    templateUrl: './hit-despatch.component.html',\r\n    styles: [],\r\n})\r\nexport class HitDespatchComponent implements OnInit {\r\n    @ViewChild('dxDespatchInstance', { static: false }) dxDespatchInstance: DxDataGridComponent\r\n    @ViewChild('dxDespatchFileInstance', { static: false }) dxDespatchFileInstance: DxDataGridComponent\r\n    @ViewChild('dxDespatchSerialInstance', { static: false }) dxDespatchSerialInstance: DxDataGridComponent\r\n\r\n    despatchesDataSource: any\r\n    despatchStatusLookup: any\r\n    despatchReceiverResponseLookup: any\r\n    despatchObjectsEnumLookup: any\r\n    despatchReceiverPKDataSource: any\r\n    despatchSerialDataSource: any\r\n\r\n    despatchFileNameLookup: any\r\n    despatchFilesDataSource: any\r\n\r\n    isFileModalOpen = false;\r\n    isFileModalBusy = false;\r\n\r\n    isPKModalOpen = false;\r\n    isPKModalBusy = false;\r\n    pkModalSelectedDespatchId: any;\r\n    pkModalSelectedDespatchResourceDocEntry: any;\r\n\r\n    isSerialModalOpen = false;\r\n    isSerialModalBusy = false;\r\n    serialModalSelectedDespatchId: any;\r\n    serialModalSelectedDespatchResourceDocEntry: any;\r\n\r\n    constructor(\r\n        public readonly list: ListService,\r\n        public readonly service: HitDespatchService,\r\n        private readonly fileDocumentTypeService: HitFileDocumentTypeService,\r\n        private readonly gibPartnerPkService: HitGibPartnerPkService,\r\n        private readonly hitDocumentSerialService: HitDocumentSerialService,\r\n        private readonly confirmation: ConfirmationService,\r\n        private readonly toasterService: ToasterService,\r\n        private readonly hitSharedService: HitSharedService\r\n    ) { }\r\n    ngOnInit(): void {\r\n        this.despatchesDataSource = this.service.LoadDespatches;\r\n        this.service.getStatuses().subscribe(list => {\r\n            this.despatchStatusLookup = list;\r\n        });\r\n        this.service.getReceiverResponses().subscribe(list => {\r\n            this.despatchReceiverResponseLookup = list;\r\n        })\r\n        this.service.getSapObjects().subscribe(list => {\r\n            this.despatchObjectsEnumLookup = list;\r\n        })\r\n        this.fileDocumentTypeService.getFileDocumentTypes().subscribe(list => {\r\n            debugger;\r\n            this.despatchFileNameLookup = list;\r\n        })\r\n    }\r\n\r\n    sendDespatchSingle(record) {\r\n        let ids: string[] = [record.id];\r\n\r\n        if (isNullOrEmpty(record.selectedDespatchSerial)) {\r\n            this.confirmation\r\n                .info('Belge seri seçimi yapılmadığı için entegratörde bulunan varsayılan seriyle gönderilecektir. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.service.sendDespatchById(ids).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else {\r\n            this.service.sendDespatchById(ids).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n        }\r\n\r\n    }\r\n\r\n    sendDespatchMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\r\n\r\n        this.dxDespatchInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedDespatchSerial\r\n            })\r\n        })\r\n\r\n        if (ids.filter(p => isNullOrEmpty(p.selectedSerial)).length > 0) {\r\n            this.confirmation\r\n                .info('Seri seçimi yapılmayan belgeler için entegratörde bulunan varsayılan seriyle gönderim yapılacaktır. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.service.sendDespatchById(ids.map(p => p.id)).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else {\r\n            this.service.sendDespatchById(ids.map(p => p.id)).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n        }\r\n\r\n\r\n        /*\r\n        debugger;\r\n\r\n        this.dxInvoiceInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedInvoiceSerial\r\n            })\r\n        })\r\n\r\n        if(ids.filter(p => isNullOrEmpty(p.selectedSerial)).length > 0){\r\n             this.confirmation\r\n                .info('Seri seçimi yapılmayan belgeler için entegratörde bulunan varsayılan seriyle gönderim yapılacaktır. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.invoiceService.sendInvoiceById(ids.map(p => p.id)).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else{\r\n            this.invoiceService.sendInvoiceById(ids.map(p => p.id)).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n        }\r\n        */\r\n    }\r\n    setDespatchCancelWithOpen(record) {\r\n\r\n        this.service.setDespatchCancelById(record.id, 1).subscribe(() => {\r\n            this.dxDespatchInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    setDespatchCancelWithRevise(record) {\r\n\r\n        this.service.setDespatchCancelById(record.id, 6).subscribe(() => {\r\n            this.dxDespatchInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    listDespatchReceiverPK(record) {\r\n        debugger;\r\n        this.gibPartnerPkService.GetCustomerActivePKS(record.deliveryCustomerPartyVknTckn, 2).subscribe(pks => {\r\n            this.despatchReceiverPKDataSource = pks.map(item => ({ Adres: item }));;\r\n            this.pkModalSelectedDespatchId = record.id;\r\n            this.pkModalSelectedDespatchResourceDocEntry = record.resourceDocEntry;\r\n        })\r\n        this.isPKModalOpen = true;\r\n    }\r\n\r\n    listActiveSeries(record) {\r\n        debugger;\r\n        this.hitDocumentSerialService.ListActiveSeriesForDocument(1).subscribe(serials => {\r\n            this.despatchSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.serialModalSelectedDespatchId = record.id;\r\n            this.serialModalSelectedDespatchResourceDocEntry = record.resourceDocEntry;\r\n        })\r\n        this.isSerialModalOpen = true;\r\n    }\r\n\r\n    selectPKAddress(record) {\r\n        console.log(record.Adres, this.pkModalSelectedDespatchId, this.pkModalSelectedDespatchResourceDocEntry)\r\n        this.service.updateDespatchReceiver(this.pkModalSelectedDespatchId, record.Adres).subscribe(() => {\r\n            this.isPKModalOpen = false;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    selectDespatchSerial(record) {\r\n        this.service.updateDespatchSerial(this.serialModalSelectedDespatchId, record.Seri).subscribe(() => {\r\n            this.isSerialModalOpen = false;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    getDespatchPreview(record) {\r\n        debugger;\r\n        this.service.getDespatchPreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:text/html;base64,${fatura.previewHTML}`;\r\n            //this.hitSharedService.previewFile(btoa(unescape(encodeURIComponent(fatura.previewHTML))));\r\n\r\n            const newTab = window.open();\r\n            newTab.document.title = record.id\r\n            newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        });\r\n    }\r\n    getDespatchXML(record) {\r\n        debugger;\r\n        this.service.getDespatchXML(record.id, record.resourceDocType).subscribe(irsaliye => {\r\n            const source = `data:${irsaliye.mimeType};base64,${irsaliye.content}`;\r\n            this.hitSharedService.previewFile(irsaliye.content);\r\n\r\n\r\n            /*const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${irsaliye.filename}`;\r\n            link.click();*/\r\n        });\r\n    }\r\n\r\n    getDocObjectName(data) {\r\n        return ((data.isDraft ? \"Taslak \" : \"\") + this.despatchObjectsEnumLookup.find((x) => x.id == (data.isDraft ? data.resourceSubDocType : data.resourceDocType)).displayName);\r\n    }\r\n\r\n    getIconClass(responseId) {\r\n        if (responseId == 0) {\r\n            return \"fas fa-clock\";\r\n        }\r\n        else if (responseId == 1) {\r\n            return \"fas fa-check-circle\";\r\n        }\r\n        else if (responseId == 2) {\r\n            return \"fas fa-times-circle\";\r\n        }\r\n        else if (responseId == 3) {\r\n            return \"fas fa-minus-circle\"\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    getDespatchView(record) {\r\n        this.service.getDespatchView(record.uuId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\r\n\r\n             const newTab = window.open();\r\n            newTab.document.title = record.id\r\n            newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        \r\n            //this.hitSharedService.previewFile(item.content);\r\n\r\n            /*const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${item.filename}`;\r\n            link.click();*/\r\n        });\r\n    }\r\n\r\n    getDespatchResponses() {\r\n        this.service.getDespatchResponses(new Date().toISOString(), new Date().toISOString()).subscribe(() => {\r\n            debugger;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    getReceiverResponseName(responseId) {\r\n        const response = this.despatchReceiverResponseLookup.find((x) => x.id === responseId);\r\n        if (response) {\r\n            return response.displayName;\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    showAllFiles(record) {\r\n        debugger;\r\n        this.despatchFilesDataSource = this.service.LoadDespatchFiles(record.uuId)\r\n        this.isFileModalOpen = true;\r\n    }\r\n\r\n    DownloadFile(record) {\r\n        this.service.downloadFileById(record.contentMasterId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\r\n            const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${item.filename}`;\r\n            link.click();\r\n        });\r\n    }\r\n\r\n    downloadPDFMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\r\n\r\n        this.dxDespatchInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedDespatchSerial\r\n            })\r\n        })\r\n\r\n        this.service.getDespatchPdfsMultiple(ids.map(p => p.id)).subscribe(data => {\r\n            debugger;\r\n            const byteCharacters = atob(data);\r\n            const byteNumbers = new Array(byteCharacters.length);\r\n\r\n            for (let i = 0; i < byteCharacters.length; i++) {\r\n                byteNumbers[i] = byteCharacters.charCodeAt(i);\r\n            }\r\n\r\n            const byteArray = new Uint8Array(byteNumbers);\r\n            const blob = new Blob([byteArray], { type: 'application/zip' });\r\n\r\n            // İndirme\r\n            const url = window.URL.createObjectURL(blob);\r\n            const a = document.createElement('a');\r\n            a.href = url;\r\n            a.download = 'Irsaliyeler-' + this.getZipDate() + '.zip';\r\n            a.click();\r\n\r\n            window.URL.revokeObjectURL(url);\r\n        });\r\n        debugger;\r\n\r\n    }\r\n\r\n    getZipDate() {\r\n        const date = new Date();\r\n\r\n        // Gün, Ay, Yıl, Saat, Dakika, Saniye formatında manuel düzenleme\r\n        const day = String(date.getDate()).padStart(2, '0');\r\n        const month = String(date.getMonth() + 1).padStart(2, '0');\r\n        const year = date.getFullYear();\r\n        const hours = String(date.getHours()).padStart(2, '0');\r\n        const minutes = String(date.getMinutes()).padStart(2, '0');\r\n        const seconds = String(date.getSeconds()).padStart(2, '0');\r\n\r\n        return `${year}.${month}.${day}-${hours}.${minutes}.${seconds}`;\r\n    }\r\n\r\n    getReceiptAdvicePreview(record) {\r\n        debugger;\r\n        this.service.getReceiptAdvicePreview(record.id,).subscribe(despatch => {\r\n            const source = `data:text/html;base64,${despatch.previewHTML}`;\r\n            //this.hitSharedService.previewFile(despatch.previewHTML);\r\n\r\n            const newTab = window.open();\r\n            newTab.document.title = record.id\r\n            newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        });\r\n    }\r\n}","<abp-page [title]=\"'eDonusum::Despatches' | abpLocalization\">\r\n  <abp-page-toolbar-container class=\"col\">\r\n    <div class=\"text-lg-end pt-2\">\r\n      <!-- <button\r\n            class=\"btn btn-primary btn-sm mx-2\"\r\n            type=\"button\"\r\n            [disabled]=\"isExportToExcelBusy\"\r\n            (click)=\"exportToExcel()\"\r\n          >\r\n            {{ 'eDonusum::ExportToExcel' | abpLocalization }}\r\n          </button>\r\n     -->\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"downloadPDFMultiple()\">\r\n        <i class=\"fa fa-download me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::DownloadPDFMultiple' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendDespatchMultiple()\">\r\n        <i class=\"fa fa-envelope me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::AddToQueue' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"getDespatchResponses()\">\r\n        <i class=\"fa fa-question me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::CheckResponses' | abpLocalization }}\r\n      </button>\r\n      <!-- <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendInvoiceToEntegrator()\">\r\n        <i class=\"fa fa-envelope me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::SendToEntegratorManual' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-warning\" type=\"button\"\r\n        (click)=\"getInvoicesFromConnector()\">\r\n        <i class=\"fa fa-plus me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::GetFromConnectorManual' | abpLocalization }}\r\n      </button> -->\r\n\r\n    </div>\r\n  </abp-page-toolbar-container>\r\n  <p>Gönderimi tamamlanan ve gönderilmesi beklenen irsaliyeleri listeleyen ekran</p>\r\n\r\n  <div class=\"card\">\r\n    <div class=\"card-body\">\r\n      <dx-data-grid #dxDespatchInstance [dataSource]=\"despatchesDataSource\" [showRowLines]=\"true\" [showBorders]=\"true\"\r\n        [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\" [allowColumnResizing]=\"true\"\r\n        columnResizingMode=\"widget\" [allowColumnReordering]=\"true\" [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"true\"\r\n        [rowAlternationEnabled]=\"true\" style=\"height: 75vh;\">\r\n        <dxo-pager [visible]=\"true\" [showInfo]=\"true\" [allowedPageSizes]=\"[50,100,200]\" [showNavigationButtons]=\"true\"\r\n          [showPageSizeSelector]=\"true\">\r\n        </dxo-pager>\r\n        <dxo-paging [pageSize]=\"50\"></dxo-paging>\r\n        <dxo-selection mode=\"multiple\" selectAllMode=\"page\" showCheckBoxesMode=\"always\">\r\n        </dxo-selection>\r\n        <dxo-column-chooser [allowSearch]=\"true\" [enabled]=\"true\" mode=\"select\"></dxo-column-chooser>\r\n        <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n        <dxo-group-panel [visible]=\"true\" [allowColumnDragging]=\"true\"></dxo-group-panel>\r\n        <dxo-grouping #expand [autoExpandAll]=\"false\" [allowCollapsing]=\"true\"\r\n          [contextMenuEnabled]=\"true\"></dxo-grouping>\r\n        <dxo-header-filter [allowSearch]=\"true\" [visible]=\"true\"></dxo-header-filter>\r\n        <dxo-filter-row [visible]=\"true\"></dxo-filter-row>\r\n        <dxo-export [enabled]=\"true\" [allowExportSelectedData]=\"false\"></dxo-export>\r\n        <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n        <dxo-filter-builder [allowHierarchicalFields]=\"true\"></dxo-filter-builder>\r\n        <dxo-filter-panel [visible]=\"true\"></dxo-filter-panel>\r\n        <dxo-sorting mode=\"single\"></dxo-sorting>\r\n        <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n        <dxi-column [fixed]=\"true\" dataField=\"id\" width=\"120\" [allowGrouping]=\"false\" [allowFiltering]=\"false\"\r\n          [allowHeaderFiltering]=\"false\" [allowHiding]=\"false\" [allowReordering]=\"false\"\r\n          cellTemplate=\"operationTemplate\" caption=\"{{ 'AbpUi::Actions' | abpLocalization }}\">\r\n          <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n            <div ngbDropdown container=\"body\" class=\"d-inline-block\">\r\n              <button class=\"btn btn-primary btn-sm dropdown-toggle\" data-toggle=\"dropdown\" aria-haspopup=\"true\"\r\n                ngbDropdownToggle [disabled]=\"disabledIdColumn\">\r\n                <i class=\"fa fa-cog mr-1\" aria-hidden=\"true\"></i>\r\n                {{ 'AbpUi::Actions' | abpLocalization }}\r\n              </button>\r\n              <div ngbDropdownMenu>\r\n                <!-- <button ngbDropdownItem (click)=\"update(row.data)\">\r\n                    <i class=\"fa fa-edit\" aria-hidden=\"true\"></i> {{ 'AbpUi::Edit' | abpLocalization }}\r\n                  </button>\r\n                  <button ngbDropdownItem (click)=\"delete(row.data)\">\r\n                    <i class=\"fa fa-trash\" aria-hidden=\"true\"></i> {{ 'AbpUi::Delete' | abpLocalization }}\r\n                  </button> -->\r\n                <button ngbDropdownItem (click)=\"sendDespatchSingle(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-envelope\" aria-hidden=\"true\"></i> {{ 'eDonusum::AddToQueue' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"setDespatchCancelWithOpen(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i> {{ 'eDonusum::SetCancelWithOpen' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"setDespatchCancelWithRevise(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i> {{ 'eDonusum::SetCancelWithRevise' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"listDespatchReceiverPK(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-pencil\" aria-hidden=\"true\"></i> {{ 'eDonusum::SelectReceiverPK' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"listActiveSeries(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-tasks\" aria-hidden=\"true\"></i> {{ 'eDonusum::SelectSerialForDocument' |\r\n                  abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchView(row.data)\"\r\n                  *ngIf=\"row.data.status == 300 || row.data.status == 340 || row.data.status == 380 || row.data.status == 700\">\r\n                  <i class=\"fa fa-eye\" aria-hidden=\"true\"></i> {{ 'eDonusum::GetPDFView' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchPreview(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::Preview' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchXML(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::PreviewXML' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"showAllFiles(row.data)\"\r\n                  *ngIf=\"row.data.status == 300 || row.data.status == 340 || row.data.status == 380 || row.data.status == 700\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::ShowAllFiles' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getReceiptAdvicePreview(row.data)\" *ngIf=\"row.data.status == 700\">\r\n                  <i class=\"fa fa-envelope\" aria-hidden=\"true\"></i> {{ 'eDonusum::ShowResponse' | abpLocalization }}\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"issueDate\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::IssueDate'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"resourceDocEntry\"\r\n          caption=\"{{'eDonusum::ResourceDocEntry'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"resourceDocNum\"\r\n          caption=\"{{'eDonusum::ResourceDocNum'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"despatchId\" caption=\"{{'eDonusum::DespatchId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column cellTemplate=\"docTypeTemplate\" dataField=\"resourceDocType\"\r\n          caption=\"{{'eDonusum::ResourceDocType'|abpLocalization}}\">\r\n        </dxi-column>\r\n        <div *dxTemplate=\"let data of 'docTypeTemplate'\">\r\n          {{getDocObjectName(data.data)}}\r\n        </div>\r\n        <dxi-column dataField=\"deliveryCustomerPartyName\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyName'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"deliveryCustomerPartyVknTckn\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyVknTckn'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"status\" caption=\"{{'eDonusum::Status'|abpLocalization}}\">\r\n          <dxo-lookup [dataSource]=\"despatchStatusLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"profileId\" caption=\"{{'eDonusum::DespatchProfileId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"despatchAdviceTypeCode\"\r\n          caption=\"{{'eDonusum::DespatchAdviceTypeCode'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"receiverResponse\" caption=\"{{'eDonusum::ReceiverResponse'|abpLocalization}}\"\r\n          cellTemplate=\"iconTemplate\">\r\n          <dxo-lookup [dataSource]=\"despatchReceiverResponseLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <div *dxTemplate=\"let data of 'iconTemplate'\">\r\n          <i [ngClass]=\"getIconClass(data.data.receiverResponse)\"\r\n            [ngStyle]=\"{'color':data.data.receiverResponse == '1' ? 'green' : data.data.receiverResponse == '2' ? 'red' : data.data.receiverResponse == '3' ? 'orange' : 'gray'}\"></i>\r\n          {{getReceiverResponseName(data.data.receiverResponse)}}\r\n\r\n        </div>\r\n\r\n        <dxi-column dataField=\"receiverResponseDesc\"\r\n          caption=\"{{'eDonusum::ReceiverResponseDesc'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"documentCurrencyCode\" caption=\"{{'eDonusum::DocCurrency'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedReceiverPK\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::SelectedReceiverPK'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedDespatchSerial\"\r\n          caption=\"{{'eDonusum::SelectedDespatchSerial'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"uuId\" caption=\"{{'eDonusum::UuId'|abpLocalization}}\"></dxi-column>\r\n      </dx-data-grid>\r\n    </div>\r\n  </div>\r\n</abp-page>\r\n\r\n<abp-modal [busy]=\"isFileModalBusy\" [(visible)]=\"isFileModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{ 'eDonusum::DespatchFiles' | abpLocalization }}\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxDespatchFileInstance [dataSource]=\"despatchFilesDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [fixed]=\"true\" dataField=\"id\" width=\"120\" [allowGrouping]=\"false\" [allowFiltering]=\"false\"\r\n                  [allowHeaderFiltering]=\"false\" [allowHiding]=\"false\" [allowReordering]=\"false\"\r\n                  cellTemplate=\"operationTemplate\" caption=\"{{ 'AbpUi::Actions' | abpLocalization }}\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <div ngbDropdown container=\"body\" class=\"d-inline-block\">\r\n                      <button class=\"btn btn-primary btn-sm dropdown-toggle\" data-toggle=\"dropdown\" aria-haspopup=\"true\"\r\n                        ngbDropdownToggle [disabled]=\"disabledIdColumn\">\r\n                        <i class=\"fa fa-cog mr-1\" aria-hidden=\"true\"></i>\r\n                        {{ 'AbpUi::Actions' | abpLocalization }}\r\n                      </button>\r\n                      <div ngbDropdownMenu>\r\n                        <button ngbDropdownItem (click)=\"DownloadFile(row.data)\">\r\n                          <i class=\"fa fa-download\" aria-hidden=\"true\"></i> {{ 'eDonusum::Download' | abpLocalization\r\n                          }}\r\n                        </button>\r\n                      </div>\r\n                    </div>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column [allowEditing]=\"false\" dataField=\"extraItem\" caption=\"{{'eDonusum::Name'|abpLocalization}}\">\r\n                  <dxo-lookup [dataSource]=\"despatchFileNameLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n                  </dxo-lookup>\r\n                </dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>\r\n\r\n<abp-modal [busy]=\"isSerialModalBusy\" [(visible)]=\"isSerialModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      Belge Seri Seçimi\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxDespatchSerialInstance [dataSource]=\"despatchSerialDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [width]=\"80\" cellTemplate=\"operationTemplate\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <button class=\"btn btn-primary btn-sm\" (click)=\"selectDespatchSerial(row.data)\">\r\n                      <i class=\"fa fa-check\" aria-hidden=\"true\"></i> Seç\r\n                    </button>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column dataField=\"Seri\" caption=\"Seri\"></dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>\r\n\r\n<abp-modal [busy]=\"isPKModalBusy\" [(visible)]=\"isPKModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{pkModalSelectedDespatchResourceDocEntry}} {{ 'eDonusum::ReceiverPKS' | abpLocalization }}\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxReceiverPKSInstance [dataSource]=\"despatchReceiverPKDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [width]=\"80\" cellTemplate=\"operationTemplate\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <button class=\"btn btn-primary btn-sm\" (click)=\"selectPKAddress(row.data)\">\r\n                      <i class=\"fa fa-check\" aria-hidden=\"true\"></i> Seç\r\n                    </button>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column dataField=\"Adres\" caption=\"Adres\"></dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit-despatch.component.js","sourceRoot":"","sources":["../../../../../../projects/e-donusum/src/lib/components/hit-despatches/hit-despatch.component.ts","../../../../../../projects/e-donusum/src/lib/components/hit-despatches/hit-despatch.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAO,aAAa,EAAqB,WAAW,EAAkB,MAAM,cAAc,CAAC;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAA6C,SAAS,EAAE,MAAM,eAAe,CAAC;AACzH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;;;;;;;;;;;;;;;AAe5D,MAAM,OAAO,oBAAoB;IA4B7B,YACoB,IAAiB,EACjB,OAA2B,EAC1B,uBAAmD,EACnD,mBAA2C,EAC3C,wBAAkD,EAClD,YAAiC,EACjC,cAA8B,EAC9B,gBAAkC;QAPnC,SAAI,GAAJ,IAAI,CAAa;QACjB,YAAO,GAAP,OAAO,CAAoB;QAC1B,4BAAuB,GAAvB,uBAAuB,CAA4B;QACnD,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,iBAAY,GAAZ,YAAY,CAAqB;QACjC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,qBAAgB,GAAhB,gBAAgB,CAAkB;QArBvD,oBAAe,GAAG,KAAK,CAAC;QACxB,oBAAe,GAAG,KAAK,CAAC;QAExB,kBAAa,GAAG,KAAK,CAAC;QACtB,kBAAa,GAAG,KAAK,CAAC;QAItB,sBAAiB,GAAG,KAAK,CAAC;QAC1B,sBAAiB,GAAG,KAAK,CAAC;IAatB,CAAC;IACL,QAAQ;QACJ,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC;QACxD,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACxC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACrC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACjD,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC;QAC/C,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAC1C,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;QAC1C,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,uBAAuB,CAAC,oBAAoB,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACjE,QAAQ,CAAC;YACT,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACvC,CAAC,CAAC,CAAA;IACN,CAAC;IAED,kBAAkB,CAAC,MAAM;QACrB,IAAI,GAAG,GAAa,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,aAAa,CAAC,MAAM,CAAC,sBAAsB,CAAC,EAAE;YAC9C,IAAI,CAAC,YAAY;iBACZ,IAAI,CAAC,0HAA0H,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC;iBACtK,SAAS,CAAC,CAAC,MAA2B,EAAE,EAAE;gBACvC,IAAI,MAAM,IAAI,SAAS;oBACnB,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;;oBAC9F,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YAC5E,CAAC,CAAC,CAAC;SACV;aACI;YACD,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;SAClG;IAEL,CAAC;IAED,oBAAoB;QAChB,IAAI,GAAG,GAAkD,EAAE,CAAC;QAE5D,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAClG,GAAG,CAAC,IAAI,CAAC;gBACL,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnB,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB;aACtD,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;QAEF,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7D,IAAI,CAAC,YAAY;iBACZ,IAAI,CAAC,kIAAkI,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC;iBAC9K,SAAS,CAAC,CAAC,MAA2B,EAAE,EAAE;gBACvC,IAAI,MAAM,IAAI,SAAS;oBACnB,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;;oBAC7G,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YAC5E,CAAC,CAAC,CAAC;SACV;aACI;YACD,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;SACjH;QAGD;;;;;;;;;;;;;;;;;;;;;;UAsBE;IACN,CAAC;IACD,yBAAyB,CAAC,MAAM;QAE5B,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC5D,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;YAC1C,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,yDAAyD,CAAC,CAAC;QAC3F,CAAC,CAAC,CAAC;IACP,CAAC;IAED,2BAA2B,CAAC,MAAM;QAE9B,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC5D,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;YAC1C,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,yDAAyD,CAAC,CAAC;QAC3F,CAAC,CAAC,CAAC;IACP,CAAC;IAED,sBAAsB,CAAC,MAAM;QACzB,QAAQ,CAAC;QACT,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,MAAM,CAAC,4BAA4B,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAClG,IAAI,CAAC,4BAA4B,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAAA,CAAC;YACxE,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,uCAAuC,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAC3E,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,gBAAgB,CAAC,MAAM;QACnB,QAAQ,CAAC;QACT,IAAI,CAAC,wBAAwB,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;YAC7E,IAAI,CAAC,wBAAwB,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAAA,CAAC;YACvE,IAAI,CAAC,6BAA6B,GAAG,MAAM,CAAC,EAAE,CAAC;YAC/C,IAAI,CAAC,2CAA2C,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAC/E,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAClC,CAAC;IAED,eAAe,CAAC,MAAM;QAClB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,yBAAyB,EAAE,IAAI,CAAC,uCAAuC,CAAC,CAAA;QACvG,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,IAAI,CAAC,yBAAyB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC7F,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC3B,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;QAC9C,CAAC,CAAC,CAAA;IACN,CAAC;IAED,oBAAoB,CAAC,MAAM;QACvB,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC9F,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;YAC/B,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;QAC9C,CAAC,CAAC,CAAA;IACN,CAAC;IAED,kBAAkB,CAAC,MAAM;QACrB,QAAQ,CAAC;QACT,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAClF,MAAM,MAAM,GAAG,yBAAyB,MAAM,CAAC,WAAW,EAAE,CAAC;YAC7D,4FAA4F;YAE5F,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;YAC7B,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAG,MAAM,CAAC,EAAE,CAAA;YACjC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,GAAG,gBAAgB,MAAM,6DAA6D,CAAC;QACzH,CAAC,CAAC,CAAC;IACP,CAAC;IACD,cAAc,CAAC,MAAM;QACjB,QAAQ,CAAC;QACT,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YAChF,MAAM,MAAM,GAAG,QAAQ,QAAQ,CAAC,QAAQ,WAAW,QAAQ,CAAC,OAAO,EAAE,CAAC;YACtE,sDAAsD;YAGtD,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACzC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACvC,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,IAAI;QACjB,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IAC/K,CAAC;IAED,YAAY,CAAC,UAAU;QACnB,IAAI,UAAU,IAAI,CAAC,EAAE;YACjB,OAAO,cAAc,CAAC;SACzB;aACI,IAAI,UAAU,IAAI,CAAC,EAAE;YACtB,OAAO,qBAAqB,CAAC;SAChC;aACI,IAAI,UAAU,IAAI,CAAC,EAAE;YACtB,OAAO,qBAAqB,CAAC;SAChC;aACI,IAAI,UAAU,IAAI,CAAC,EAAE;YACtB,OAAO,qBAAqB,CAAA;SAC/B;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAED,eAAe,CAAC,MAAM;QAClB,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACvD,MAAM,MAAM,GAAG,QAAQ,IAAI,CAAC,QAAQ,WAAW,IAAI,CAAC,OAAO,EAAE,CAAC;YAE9D,iCAAiC;YACjC,oCAAoC;YACpC,wHAAwH;YAExH,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAEhD;;;2BAGe;QACnB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,oBAAoB;QAChB,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACjG,QAAQ,CAAC;YACT,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;QAC9C,CAAC,CAAC,CAAA;IACN,CAAC;IAED,uBAAuB,CAAC,UAAU;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;QACtF,IAAI,QAAQ,EAAE;YACV,OAAO,QAAQ,CAAC,WAAW,CAAC;SAC/B;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAED,YAAY,CAAC,MAAM;QACf,QAAQ,CAAC;QACT,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAC1E,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,YAAY,CAAC,MAAM;QACf,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACnE,MAAM,MAAM,GAAG,QAAQ,IAAI,CAAC,QAAQ,WAAW,IAAI,CAAC,OAAO,EAAE,CAAC;YAC9D,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACzC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,mBAAmB;QACf,IAAI,GAAG,GAAkD,EAAE,CAAC;QAE5D,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAClG,GAAG,CAAC,IAAI,CAAC;gBACL,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnB,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB;aACtD,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YACtE,QAAQ,CAAC;YACT,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAErD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC5C,WAAW,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;aACjD;YAED,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC;YAC9C,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC;YAEhE,UAAU;YACV,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAC7C,MAAM,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACtC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC;YACb,CAAC,CAAC,QAAQ,GAAG,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,GAAG,MAAM,CAAC;YACzD,CAAC,CAAC,KAAK,EAAE,CAAC;YAEV,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,QAAQ,CAAC;IAEb,CAAC;IAED,UAAU;QACN,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAExB,iEAAiE;QACjE,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACvD,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC3D,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAE3D,OAAO,GAAG,IAAI,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,IAAI,OAAO,EAAE,CAAC;IACpE,CAAC;IAED,uBAAuB,CAAC,MAAM;QAC1B,QAAQ,CAAC;QACT,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,CAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YAClE,MAAM,MAAM,GAAG,yBAAyB,QAAQ,CAAC,WAAW,EAAE,CAAC;YAC/D,0DAA0D;YAE1D,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;YAC7B,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAG,MAAM,CAAC,EAAE,CAAA;YACjC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,GAAG,gBAAgB,MAAM,6DAA6D,CAAC;QACzH,CAAC,CAAC,CAAC;IACP,CAAC;;iHApUQ,oBAAoB;qGAApB,oBAAoB,uCAJlB,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC,8XCdhF,ozlBA2TY;2FDzSC,oBAAoB;kBAPhC,SAAS;+BACI,cAAc,mBACP,uBAAuB,CAAC,OAAO,aACrC,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;sVAKxB,kBAAkB;sBAArE,SAAS;uBAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;gBACM,sBAAsB;sBAA7E,SAAS;uBAAC,wBAAwB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;gBACI,wBAAwB;sBAAjF,SAAS;uBAAC,0BAA0B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE","sourcesContent":["import { ABP, isNullOrEmpty, isNullOrUndefined, ListService, PagedResultDto } from '@abp/ng.core';\r\nimport { DateAdapter } from '@abp/ng.theme.shared/extensions';\r\nimport { ChangeDetectionStrategy, Component, HostListener, OnInit, Pipe, PipeTransform, ViewChild } from '@angular/core';\r\nimport { NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';\r\nimport { DxDataGridComponent } from 'devextreme-angular';\r\nimport { HitDespatchService } from '../../hit-proxy/hit-despatches/hit-despatch.service';\r\nimport { HitFileDocumentTypeService } from '../../hit-proxy/hit-file-document-type/hit-file-document-type.service';\r\nimport { Confirmation, ConfirmationService, ToasterService } from '@abp/ng.theme.shared';\r\nimport { HitGibPartnerPkService } from '../../hit-proxy/hit-gib-partner-pks/hit-gib-partner-pk.service';\r\nimport { HitDocumentSerialService } from '../../hit-proxy/hit-document-serials/hit-document-serial.service';\r\nimport { HitSharedService } from '../../hit-proxy/shared/hit-shared.service';\r\n@Component({\r\n    selector: 'lib-despatch',\r\n    changeDetection: ChangeDetectionStrategy.Default,\r\n    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],\r\n    templateUrl: './hit-despatch.component.html',\r\n    styles: [],\r\n})\r\nexport class HitDespatchComponent implements OnInit {\r\n    @ViewChild('dxDespatchInstance', { static: false }) dxDespatchInstance: DxDataGridComponent\r\n    @ViewChild('dxDespatchFileInstance', { static: false }) dxDespatchFileInstance: DxDataGridComponent\r\n    @ViewChild('dxDespatchSerialInstance', { static: false }) dxDespatchSerialInstance: DxDataGridComponent\r\n\r\n    despatchesDataSource: any\r\n    despatchStatusLookup: any\r\n    despatchReceiverResponseLookup: any\r\n    despatchObjectsEnumLookup: any\r\n    despatchReceiverPKDataSource: any\r\n    despatchSerialDataSource: any\r\n\r\n    despatchFileNameLookup: any\r\n    despatchFilesDataSource: any\r\n\r\n    isFileModalOpen = false;\r\n    isFileModalBusy = false;\r\n\r\n    isPKModalOpen = false;\r\n    isPKModalBusy = false;\r\n    pkModalSelectedDespatchId: any;\r\n    pkModalSelectedDespatchResourceDocEntry: any;\r\n\r\n    isSerialModalOpen = false;\r\n    isSerialModalBusy = false;\r\n    serialModalSelectedDespatchId: any;\r\n    serialModalSelectedDespatchResourceDocEntry: any;\r\n\r\n    constructor(\r\n        public readonly list: ListService,\r\n        public readonly service: HitDespatchService,\r\n        private readonly fileDocumentTypeService: HitFileDocumentTypeService,\r\n        private readonly gibPartnerPkService: HitGibPartnerPkService,\r\n        private readonly hitDocumentSerialService: HitDocumentSerialService,\r\n        private readonly confirmation: ConfirmationService,\r\n        private readonly toasterService: ToasterService,\r\n        private readonly hitSharedService: HitSharedService\r\n    ) { }\r\n    ngOnInit(): void {\r\n        this.despatchesDataSource = this.service.LoadDespatches;\r\n        this.service.getStatuses().subscribe(list => {\r\n            this.despatchStatusLookup = list;\r\n        });\r\n        this.service.getReceiverResponses().subscribe(list => {\r\n            this.despatchReceiverResponseLookup = list;\r\n        })\r\n        this.service.getSapObjects().subscribe(list => {\r\n            this.despatchObjectsEnumLookup = list;\r\n        })\r\n        this.fileDocumentTypeService.getFileDocumentTypes().subscribe(list => {\r\n            debugger;\r\n            this.despatchFileNameLookup = list;\r\n        })\r\n    }\r\n\r\n    sendDespatchSingle(record) {\r\n        let ids: string[] = [record.id];\r\n\r\n        if (isNullOrEmpty(record.selectedDespatchSerial)) {\r\n            this.confirmation\r\n                .info('Belge seri seçimi yapılmadığı için entegratörde bulunan varsayılan seriyle gönderilecektir. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.service.sendDespatchById(ids).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else {\r\n            this.service.sendDespatchById(ids).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n        }\r\n\r\n    }\r\n\r\n    sendDespatchMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\r\n\r\n        this.dxDespatchInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedDespatchSerial\r\n            })\r\n        })\r\n\r\n        if (ids.filter(p => isNullOrEmpty(p.selectedSerial)).length > 0) {\r\n            this.confirmation\r\n                .info('Seri seçimi yapılmayan belgeler için entegratörde bulunan varsayılan seriyle gönderim yapılacaktır. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.service.sendDespatchById(ids.map(p => p.id)).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else {\r\n            this.service.sendDespatchById(ids.map(p => p.id)).subscribe(() => this.dxDespatchInstance.instance.refresh());\r\n        }\r\n\r\n\r\n        /*\r\n        debugger;\r\n\r\n        this.dxInvoiceInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedInvoiceSerial\r\n            })\r\n        })\r\n\r\n        if(ids.filter(p => isNullOrEmpty(p.selectedSerial)).length > 0){\r\n             this.confirmation\r\n                .info('Seri seçimi yapılmayan belgeler için entegratörde bulunan varsayılan seriyle gönderim yapılacaktır. Devam etmek istiyor musunuz?', { key: '::Bilgi', defaultValue: '' })\r\n                .subscribe((status: Confirmation.Status) => {\r\n                    if (status == \"confirm\")\r\n                        this.invoiceService.sendInvoiceById(ids.map(p => p.id)).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n                    else this.toasterService.info(\"Herhangi bir işlem gerçekleştirilmedi.\");\r\n                });\r\n        }\r\n        else{\r\n            this.invoiceService.sendInvoiceById(ids.map(p => p.id)).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n        }\r\n        */\r\n    }\r\n    setDespatchCancelWithOpen(record) {\r\n\r\n        this.service.setDespatchCancelById(record.id, 1).subscribe(() => {\r\n            this.dxDespatchInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    setDespatchCancelWithRevise(record) {\r\n\r\n        this.service.setDespatchCancelById(record.id, 6).subscribe(() => {\r\n            this.dxDespatchInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    listDespatchReceiverPK(record) {\r\n        debugger;\r\n        this.gibPartnerPkService.GetCustomerActivePKS(record.deliveryCustomerPartyVknTckn, 2).subscribe(pks => {\r\n            this.despatchReceiverPKDataSource = pks.map(item => ({ Adres: item }));;\r\n            this.pkModalSelectedDespatchId = record.id;\r\n            this.pkModalSelectedDespatchResourceDocEntry = record.resourceDocEntry;\r\n        })\r\n        this.isPKModalOpen = true;\r\n    }\r\n\r\n    listActiveSeries(record) {\r\n        debugger;\r\n        this.hitDocumentSerialService.ListActiveSeriesForDocument(1).subscribe(serials => {\r\n            this.despatchSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.serialModalSelectedDespatchId = record.id;\r\n            this.serialModalSelectedDespatchResourceDocEntry = record.resourceDocEntry;\r\n        })\r\n        this.isSerialModalOpen = true;\r\n    }\r\n\r\n    selectPKAddress(record) {\r\n        console.log(record.Adres, this.pkModalSelectedDespatchId, this.pkModalSelectedDespatchResourceDocEntry)\r\n        this.service.updateDespatchReceiver(this.pkModalSelectedDespatchId, record.Adres).subscribe(() => {\r\n            this.isPKModalOpen = false;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    selectDespatchSerial(record) {\r\n        this.service.updateDespatchSerial(this.serialModalSelectedDespatchId, record.Seri).subscribe(() => {\r\n            this.isSerialModalOpen = false;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    getDespatchPreview(record) {\r\n        debugger;\r\n        this.service.getDespatchPreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:text/html;base64,${fatura.previewHTML}`;\r\n            //this.hitSharedService.previewFile(btoa(unescape(encodeURIComponent(fatura.previewHTML))));\r\n\r\n            const newTab = window.open();\r\n            newTab.document.title = record.id\r\n            newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        });\r\n    }\r\n    getDespatchXML(record) {\r\n        debugger;\r\n        this.service.getDespatchXML(record.id, record.resourceDocType).subscribe(irsaliye => {\r\n            const source = `data:${irsaliye.mimeType};base64,${irsaliye.content}`;\r\n            //this.hitSharedService.previewFile(irsaliye.content);\r\n\r\n\r\n            const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${irsaliye.filename}`;\r\n            link.click();\r\n        });\r\n    }\r\n\r\n    getDocObjectName(data) {\r\n        return ((data.isDraft ? \"Taslak \" : \"\") + this.despatchObjectsEnumLookup.find((x) => x.id == (data.isDraft ? data.resourceSubDocType : data.resourceDocType)).displayName);\r\n    }\r\n\r\n    getIconClass(responseId) {\r\n        if (responseId == 0) {\r\n            return \"fas fa-clock\";\r\n        }\r\n        else if (responseId == 1) {\r\n            return \"fas fa-check-circle\";\r\n        }\r\n        else if (responseId == 2) {\r\n            return \"fas fa-times-circle\";\r\n        }\r\n        else if (responseId == 3) {\r\n            return \"fas fa-minus-circle\"\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    getDespatchView(record) {\r\n        this.service.getDespatchView(record.uuId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\r\n\r\n            //  const newTab = window.open();\r\n            // newTab.document.title = record.id\r\n            // newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        \r\n            this.hitSharedService.previewFile(item.content);\r\n\r\n            /*const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${item.filename}`;\r\n            link.click();*/\r\n        });\r\n    }\r\n\r\n    getDespatchResponses() {\r\n        this.service.getDespatchResponses(new Date().toISOString(), new Date().toISOString()).subscribe(() => {\r\n            debugger;\r\n            this.dxDespatchInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    getReceiverResponseName(responseId) {\r\n        const response = this.despatchReceiverResponseLookup.find((x) => x.id === responseId);\r\n        if (response) {\r\n            return response.displayName;\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    showAllFiles(record) {\r\n        debugger;\r\n        this.despatchFilesDataSource = this.service.LoadDespatchFiles(record.uuId)\r\n        this.isFileModalOpen = true;\r\n    }\r\n\r\n    DownloadFile(record) {\r\n        this.service.downloadFileById(record.contentMasterId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\r\n            const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${item.filename}`;\r\n            link.click();\r\n        });\r\n    }\r\n\r\n    downloadPDFMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\r\n\r\n        this.dxDespatchInstance.instance.getVisibleRows().filter(i => i.isSelected == true).forEach(element => {\r\n            ids.push({\r\n                id: element.data.id,\r\n                selectedSerial: element.data.selectedDespatchSerial\r\n            })\r\n        })\r\n\r\n        this.service.getDespatchPdfsMultiple(ids.map(p => p.id)).subscribe(data => {\r\n            debugger;\r\n            const byteCharacters = atob(data);\r\n            const byteNumbers = new Array(byteCharacters.length);\r\n\r\n            for (let i = 0; i < byteCharacters.length; i++) {\r\n                byteNumbers[i] = byteCharacters.charCodeAt(i);\r\n            }\r\n\r\n            const byteArray = new Uint8Array(byteNumbers);\r\n            const blob = new Blob([byteArray], { type: 'application/zip' });\r\n\r\n            // İndirme\r\n            const url = window.URL.createObjectURL(blob);\r\n            const a = document.createElement('a');\r\n            a.href = url;\r\n            a.download = 'Irsaliyeler-' + this.getZipDate() + '.zip';\r\n            a.click();\r\n\r\n            window.URL.revokeObjectURL(url);\r\n        });\r\n        debugger;\r\n\r\n    }\r\n\r\n    getZipDate() {\r\n        const date = new Date();\r\n\r\n        // Gün, Ay, Yıl, Saat, Dakika, Saniye formatında manuel düzenleme\r\n        const day = String(date.getDate()).padStart(2, '0');\r\n        const month = String(date.getMonth() + 1).padStart(2, '0');\r\n        const year = date.getFullYear();\r\n        const hours = String(date.getHours()).padStart(2, '0');\r\n        const minutes = String(date.getMinutes()).padStart(2, '0');\r\n        const seconds = String(date.getSeconds()).padStart(2, '0');\r\n\r\n        return `${year}.${month}.${day}-${hours}.${minutes}.${seconds}`;\r\n    }\r\n\r\n    getReceiptAdvicePreview(record) {\r\n        debugger;\r\n        this.service.getReceiptAdvicePreview(record.id,).subscribe(despatch => {\r\n            const source = `data:text/html;base64,${despatch.previewHTML}`;\r\n            //this.hitSharedService.previewFile(despatch.previewHTML);\r\n\r\n            const newTab = window.open();\r\n            newTab.document.title = record.id\r\n            newTab.document.body.innerHTML = `<iframe src=\"${source}\" width=\"100%\" height=\"100%\" style=\"border:none;\"></iframe>`;\r\n        });\r\n    }\r\n}","<abp-page [title]=\"'eDonusum::Despatches' | abpLocalization\">\r\n  <abp-page-toolbar-container class=\"col\">\r\n    <div class=\"text-lg-end pt-2\">\r\n      <!-- <button\r\n            class=\"btn btn-primary btn-sm mx-2\"\r\n            type=\"button\"\r\n            [disabled]=\"isExportToExcelBusy\"\r\n            (click)=\"exportToExcel()\"\r\n          >\r\n            {{ 'eDonusum::ExportToExcel' | abpLocalization }}\r\n          </button>\r\n     -->\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"downloadPDFMultiple()\">\r\n        <i class=\"fa fa-download me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::DownloadPDFMultiple' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendDespatchMultiple()\">\r\n        <i class=\"fa fa-envelope me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::AddToQueue' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"getDespatchResponses()\">\r\n        <i class=\"fa fa-question me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::CheckResponses' | abpLocalization }}\r\n      </button>\r\n      <!-- <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendInvoiceToEntegrator()\">\r\n        <i class=\"fa fa-envelope me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::SendToEntegratorManual' | abpLocalization }}\r\n      </button>\r\n      <button *abpPermission=\"'eDonusum.Despatches.Create'\" class=\"btn btn-xs btn-warning\" type=\"button\"\r\n        (click)=\"getInvoicesFromConnector()\">\r\n        <i class=\"fa fa-plus me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::GetFromConnectorManual' | abpLocalization }}\r\n      </button> -->\r\n\r\n    </div>\r\n  </abp-page-toolbar-container>\r\n  <p>Gönderimi tamamlanan ve gönderilmesi beklenen irsaliyeleri listeleyen ekran</p>\r\n\r\n  <div class=\"card\">\r\n    <div class=\"card-body\">\r\n      <dx-data-grid #dxDespatchInstance [dataSource]=\"despatchesDataSource\" [showRowLines]=\"true\" [showBorders]=\"true\"\r\n        [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\" [allowColumnResizing]=\"true\"\r\n        columnResizingMode=\"widget\" [allowColumnReordering]=\"true\" [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"true\"\r\n        [rowAlternationEnabled]=\"true\" style=\"height: 75vh;\">\r\n        <dxo-pager [visible]=\"true\" [showInfo]=\"true\" [allowedPageSizes]=\"[50,100,200]\" [showNavigationButtons]=\"true\"\r\n          [showPageSizeSelector]=\"true\">\r\n        </dxo-pager>\r\n        <dxo-paging [pageSize]=\"50\"></dxo-paging>\r\n        <dxo-selection mode=\"multiple\" selectAllMode=\"page\" showCheckBoxesMode=\"always\">\r\n        </dxo-selection>\r\n        <dxo-column-chooser [allowSearch]=\"true\" [enabled]=\"true\" mode=\"select\"></dxo-column-chooser>\r\n        <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n        <dxo-group-panel [visible]=\"true\" [allowColumnDragging]=\"true\"></dxo-group-panel>\r\n        <dxo-grouping #expand [autoExpandAll]=\"false\" [allowCollapsing]=\"true\"\r\n          [contextMenuEnabled]=\"true\"></dxo-grouping>\r\n        <dxo-header-filter [allowSearch]=\"true\" [visible]=\"true\"></dxo-header-filter>\r\n        <dxo-filter-row [visible]=\"true\"></dxo-filter-row>\r\n        <dxo-export [enabled]=\"true\" [allowExportSelectedData]=\"false\"></dxo-export>\r\n        <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n        <dxo-filter-builder [allowHierarchicalFields]=\"true\"></dxo-filter-builder>\r\n        <dxo-filter-panel [visible]=\"true\"></dxo-filter-panel>\r\n        <dxo-sorting mode=\"single\"></dxo-sorting>\r\n        <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n        <dxi-column [fixed]=\"true\" dataField=\"id\" width=\"120\" [allowGrouping]=\"false\" [allowFiltering]=\"false\"\r\n          [allowHeaderFiltering]=\"false\" [allowHiding]=\"false\" [allowReordering]=\"false\"\r\n          cellTemplate=\"operationTemplate\" caption=\"{{ 'AbpUi::Actions' | abpLocalization }}\">\r\n          <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n            <div ngbDropdown container=\"body\" class=\"d-inline-block\">\r\n              <button class=\"btn btn-primary btn-sm dropdown-toggle\" data-toggle=\"dropdown\" aria-haspopup=\"true\"\r\n                ngbDropdownToggle [disabled]=\"disabledIdColumn\">\r\n                <i class=\"fa fa-cog mr-1\" aria-hidden=\"true\"></i>\r\n                {{ 'AbpUi::Actions' | abpLocalization }}\r\n              </button>\r\n              <div ngbDropdownMenu>\r\n                <!-- <button ngbDropdownItem (click)=\"update(row.data)\">\r\n                    <i class=\"fa fa-edit\" aria-hidden=\"true\"></i> {{ 'AbpUi::Edit' | abpLocalization }}\r\n                  </button>\r\n                  <button ngbDropdownItem (click)=\"delete(row.data)\">\r\n                    <i class=\"fa fa-trash\" aria-hidden=\"true\"></i> {{ 'AbpUi::Delete' | abpLocalization }}\r\n                  </button> -->\r\n                <button ngbDropdownItem (click)=\"sendDespatchSingle(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-envelope\" aria-hidden=\"true\"></i> {{ 'eDonusum::AddToQueue' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"setDespatchCancelWithOpen(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i> {{ 'eDonusum::SetCancelWithOpen' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"setDespatchCancelWithRevise(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i> {{ 'eDonusum::SetCancelWithRevise' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"listDespatchReceiverPK(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-pencil\" aria-hidden=\"true\"></i> {{ 'eDonusum::SelectReceiverPK' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"listActiveSeries(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-tasks\" aria-hidden=\"true\"></i> {{ 'eDonusum::SelectSerialForDocument' |\r\n                  abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchView(row.data)\"\r\n                  *ngIf=\"row.data.status == 300 || row.data.status == 340 || row.data.status == 380 || row.data.status == 700\">\r\n                  <i class=\"fa fa-eye\" aria-hidden=\"true\"></i> {{ 'eDonusum::GetPDFView' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchPreview(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::Preview' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getDespatchXML(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::PreviewXML' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"showAllFiles(row.data)\"\r\n                  *ngIf=\"row.data.status == 300 || row.data.status == 340 || row.data.status == 380 || row.data.status == 700\">\r\n                  <i class=\"fa fa-search\" aria-hidden=\"true\"></i> {{ 'eDonusum::ShowAllFiles' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getReceiptAdvicePreview(row.data)\" *ngIf=\"row.data.status == 700\">\r\n                  <i class=\"fa fa-envelope\" aria-hidden=\"true\"></i> {{ 'eDonusum::ShowResponse' | abpLocalization }}\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"issueDate\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::IssueDate'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"resourceDocEntry\"\r\n          caption=\"{{'eDonusum::ResourceDocEntry'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"resourceDocNum\"\r\n          caption=\"{{'eDonusum::ResourceDocNum'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"despatchId\" caption=\"{{'eDonusum::DespatchId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column cellTemplate=\"docTypeTemplate\" dataField=\"resourceDocType\"\r\n          caption=\"{{'eDonusum::ResourceDocType'|abpLocalization}}\">\r\n        </dxi-column>\r\n        <div *dxTemplate=\"let data of 'docTypeTemplate'\">\r\n          {{getDocObjectName(data.data)}}\r\n        </div>\r\n        <dxi-column dataField=\"deliveryCustomerPartyName\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyName'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"deliveryCustomerPartyVknTckn\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyVknTckn'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"status\" caption=\"{{'eDonusum::Status'|abpLocalization}}\">\r\n          <dxo-lookup [dataSource]=\"despatchStatusLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"profileId\" caption=\"{{'eDonusum::DespatchProfileId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"despatchAdviceTypeCode\"\r\n          caption=\"{{'eDonusum::DespatchAdviceTypeCode'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"receiverResponse\" caption=\"{{'eDonusum::ReceiverResponse'|abpLocalization}}\"\r\n          cellTemplate=\"iconTemplate\">\r\n          <dxo-lookup [dataSource]=\"despatchReceiverResponseLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <div *dxTemplate=\"let data of 'iconTemplate'\">\r\n          <i [ngClass]=\"getIconClass(data.data.receiverResponse)\"\r\n            [ngStyle]=\"{'color':data.data.receiverResponse == '1' ? 'green' : data.data.receiverResponse == '2' ? 'red' : data.data.receiverResponse == '3' ? 'orange' : 'gray'}\"></i>\r\n          {{getReceiverResponseName(data.data.receiverResponse)}}\r\n\r\n        </div>\r\n\r\n        <dxi-column dataField=\"receiverResponseDesc\"\r\n          caption=\"{{'eDonusum::ReceiverResponseDesc'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"documentCurrencyCode\" caption=\"{{'eDonusum::DocCurrency'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedReceiverPK\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::SelectedReceiverPK'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedDespatchSerial\"\r\n          caption=\"{{'eDonusum::SelectedDespatchSerial'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"uuId\" caption=\"{{'eDonusum::UuId'|abpLocalization}}\"></dxi-column>\r\n      </dx-data-grid>\r\n    </div>\r\n  </div>\r\n</abp-page>\r\n\r\n<abp-modal [busy]=\"isFileModalBusy\" [(visible)]=\"isFileModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{ 'eDonusum::DespatchFiles' | abpLocalization }}\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxDespatchFileInstance [dataSource]=\"despatchFilesDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [fixed]=\"true\" dataField=\"id\" width=\"120\" [allowGrouping]=\"false\" [allowFiltering]=\"false\"\r\n                  [allowHeaderFiltering]=\"false\" [allowHiding]=\"false\" [allowReordering]=\"false\"\r\n                  cellTemplate=\"operationTemplate\" caption=\"{{ 'AbpUi::Actions' | abpLocalization }}\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <div ngbDropdown container=\"body\" class=\"d-inline-block\">\r\n                      <button class=\"btn btn-primary btn-sm dropdown-toggle\" data-toggle=\"dropdown\" aria-haspopup=\"true\"\r\n                        ngbDropdownToggle [disabled]=\"disabledIdColumn\">\r\n                        <i class=\"fa fa-cog mr-1\" aria-hidden=\"true\"></i>\r\n                        {{ 'AbpUi::Actions' | abpLocalization }}\r\n                      </button>\r\n                      <div ngbDropdownMenu>\r\n                        <button ngbDropdownItem (click)=\"DownloadFile(row.data)\">\r\n                          <i class=\"fa fa-download\" aria-hidden=\"true\"></i> {{ 'eDonusum::Download' | abpLocalization\r\n                          }}\r\n                        </button>\r\n                      </div>\r\n                    </div>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column [allowEditing]=\"false\" dataField=\"extraItem\" caption=\"{{'eDonusum::Name'|abpLocalization}}\">\r\n                  <dxo-lookup [dataSource]=\"despatchFileNameLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n                  </dxo-lookup>\r\n                </dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>\r\n\r\n<abp-modal [busy]=\"isSerialModalBusy\" [(visible)]=\"isSerialModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      Belge Seri Seçimi\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxDespatchSerialInstance [dataSource]=\"despatchSerialDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [width]=\"80\" cellTemplate=\"operationTemplate\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <button class=\"btn btn-primary btn-sm\" (click)=\"selectDespatchSerial(row.data)\">\r\n                      <i class=\"fa fa-check\" aria-hidden=\"true\"></i> Seç\r\n                    </button>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column dataField=\"Seri\" caption=\"Seri\"></dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>\r\n\r\n<abp-modal [busy]=\"isPKModalBusy\" [(visible)]=\"isPKModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{pkModalSelectedDespatchResourceDocEntry}} {{ 'eDonusum::ReceiverPKS' | abpLocalization }}\r\n    </h3>\r\n  </ng-template>\r\n\r\n  <ng-template #abpBody>\r\n    <div class=\"container-fluid\">\r\n      <div class=\"row\">\r\n        <div class=\"col-md\">\r\n          <div class=\"card\">\r\n            <div class=\"card-body\">\r\n              <dx-data-grid #dxReceiverPKSInstance [dataSource]=\"despatchReceiverPKDataSource\" [showRowLines]=\"true\"\r\n                [showBorders]=\"true\" [remoteOperations]=\"true\" [hoverStateEnabled]=\"true\" [repaintChangesOnly]=\"true\"\r\n                [allowColumnResizing]=\"true\" columnResizingMode=\"widget\" [allowColumnReordering]=\"true\"\r\n                [columnAutoWidth]=\"true\" [columnHidingEnabled]=\"false\" [rowAlternationEnabled]=\"true\"\r\n                style=\"height: 50vh;\">\r\n                <dxo-column-fixing [enabled]=\"true\"></dxo-column-fixing>\r\n                <dxo-sorting mode=\"single\"></dxo-sorting>\r\n                <dxo-scrolling mode=\"horizontal\" showScrollbar=\"always\"></dxo-scrolling>\r\n                <dxi-column [width]=\"80\" cellTemplate=\"operationTemplate\">\r\n                  <div *dxTemplate=\"let row of 'operationTemplate'\">\r\n                    <button class=\"btn btn-primary btn-sm\" (click)=\"selectPKAddress(row.data)\">\r\n                      <i class=\"fa fa-check\" aria-hidden=\"true\"></i> Seç\r\n                    </button>\r\n                  </div>\r\n                </dxi-column>\r\n                <dxi-column dataField=\"Adres\" caption=\"Adres\"></dxi-column>\r\n              </dx-data-grid>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-template>\r\n\r\n  <ng-template #abpFooter>\r\n    <button type=\"button\" class=\"btn btn-secondary\" abpClose>\r\n      {{ 'AbpUi::Cancel' | abpLocalization }}\r\n    </button>\r\n  </ng-template>\r\n</abp-modal>"]}