@hitsoft/e-donusum 1.0.76 → 1.0.77

package/esm2020/lib/components/hit-invoices/hit-invoice.component.mjs

@@ -210,22 +210,21 @@ export class HitInvoiceComponent {
         debugger;
         this.invoiceService.getInvoicePreview(record.id, record.resourceDocType).subscribe(fatura => {
             const source = `data:text/html;base64,${fatura.previewHTML}`;
-            this.hitSharedService.previewFile(fatura.previewHTML);
-            /* 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(fatura.previewHTML);
+            const newTab = window.open();
+            newTab.document.title = record.id;
+            newTab.document.body.innerHTML = `<iframe src="${source}" width="100%" height="100%" style="border:none;"></iframe>`;
         });
     }
     getInvoiceXML(record) {
         debugger;
         this.invoiceService.getXMLPreview(record.id, record.resourceDocType).subscribe(fatura => {
             const source = `data:${fatura.mimeType};base64,${fatura.content}`;
-            this.hitSharedService.previewFile(fatura.content);
-            /*const link = document.createElement('a');
+            //this.hitSharedService.previewFile(fatura.content);
+            const link = document.createElement('a');
             link.href = source;
             link.download = `${fatura.filename}`;
-            link.click();*/
+            link.click();
         });
     }
     getReceiverResponseName(responseId) {
@@ -253,11 +252,11 @@ export class HitInvoiceComponent {
     DownloadFile(record) {
         this.invoiceService.downloadFileById(record.contentMasterId).subscribe(item => {
             const source = `data:${item.mimeType};base64,${item.content}`;
-            this.hitSharedService.previewFile(item.content);
-            /*const link = document.createElement('a');
+            //this.hitSharedService.previewFile(item.content);
+            const link = document.createElement('a');
             link.href = source;
             link.download = `${item.filename}`;
-            link.click();*/
+            link.click();
         });
     }
 }
@@ -279,4 +278,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                 type: ViewChild,
                 args: ['dxInvoiceSerialInstance', { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit-invoice.component.js","sourceRoot":"","sources":["../../../../../../projects/e-donusum/src/lib/components/hit-invoices/hit-invoice.component.ts","../../../../../../projects/e-donusum/src/lib/components/hit-invoices/hit-invoice.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 { HitInvoiceService } from '../../hit-proxy/hit-invoices/hit-invoice.service';\r\nimport { HitFileDocumentTypeService } from '../../hit-proxy/hit-file-document-type/hit-file-document-type.service';\r\nimport { HitGibPartnerPkService } from '../../hit-proxy/hit-gib-partner-pks/hit-gib-partner-pk.service';\r\nimport { ToasterService } from '@abp/ng.theme.shared';\r\nimport { HitDocumentSerialService } from '../../hit-proxy/hit-document-serials/hit-document-serial.service';\r\nimport { Confirmation, ConfirmationService } from '@abp/ng.theme.shared';\r\nimport { HitSharedService } from '../../hit-proxy/shared/hit-shared.service';\r\n\r\n@Component({\r\n    selector: 'lib-invoice',\r\n    changeDetection: ChangeDetectionStrategy.Default,\r\n    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],\r\n    templateUrl: './hit-invoice.component.html',\r\n    styles: [],\r\n})\r\nexport class HitInvoiceComponent implements OnInit {\r\n    @ViewChild('dxInvoiceInstance', { static: false }) dxInvoiceInstance: DxDataGridComponent\r\n    @ViewChild('dxInvoiceFileInstance', { static: false }) dxInvoiceFileInstance: DxDataGridComponent\r\n    @ViewChild('dxReceiverPKSInstance', { static: false }) dxReceiverPKSInstance: DxDataGridComponent\r\n    @ViewChild('dxInvoiceSerialInstance', { static: false }) dxInvoiceSerialInstance: DxDataGridComponent\r\n\r\n    invoicesDataSource: any\r\n    invoiceStatusLookup: any\r\n    invoiceFileNameLookup: any\r\n    invoiceReceiverResponseLookup: any\r\n    invoiceObjectsEnumLookup: any\r\n    invoiceFilesDataSource: any\r\n    invoiceReceiverPKDataSource: any\r\n    invoiceSerialDataSource: any\r\n\r\n    isPreviewModalOpen = false;\r\n    isPreviewModalBusy = false;\r\n\r\n    isFileModalOpen = false;\r\n    isFileModalBusy = false;\r\n\r\n    isPKModalOpen = false;\r\n    isPKModalBusy = false;\r\n    pkModalSelectedInvoiceId: any;\r\n    pkModalSelectedInvoiceResourceDocEntry: any;\r\n\r\n    isSerialModalOpen = false;\r\n    isSerialModalBusy = false;\r\n    serialModalSelectedInvoiceId: any;\r\n    serialModalSelectedInvoiceResourceDocEntry: any;\r\n\r\n    selectedInvoiceIds: string[];\r\n\r\n    faturaOnizleme: any;\r\n\r\n    constructor(\r\n        public readonly list: ListService,\r\n        private readonly invoiceService: HitInvoiceService,\r\n        private readonly gibPartnerPkService: HitGibPartnerPkService,\r\n        private readonly fileDocumentTypeService: HitFileDocumentTypeService,\r\n        private readonly hitDocumentSerialService: HitDocumentSerialService,\r\n        private readonly toasterService: ToasterService,\r\n        private readonly confirmation: ConfirmationService,\r\n        private readonly hitSharedService: HitSharedService\r\n    ) { }\r\n\r\n    ngOnInit(): void {\r\n        this.invoicesDataSource = this.invoiceService.LoadInvoices;\r\n        this.invoiceService.getStatuses().subscribe(list => {\r\n            this.invoiceStatusLookup = list;\r\n        });\r\n        this.invoiceService.getReceiverResponses().subscribe(list => {\r\n            this.invoiceReceiverResponseLookup = list;\r\n        })\r\n        this.invoiceService.getSapObjects().subscribe(list => {\r\n            this.invoiceObjectsEnumLookup = list;\r\n        })\r\n        this.fileDocumentTypeService.getFileDocumentTypes().subscribe(list => {\r\n            debugger;\r\n            this.invoiceFileNameLookup = list;\r\n        })\r\n    }\r\n    sendInvoiceSingle(record) {\r\n        let ids: string[] = [record.id];\r\n        debugger;\r\n        if (isNullOrEmpty(record.selectedInvoiceSerial)) {\r\n            debugger;\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.invoiceService.sendInvoiceById(ids).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).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n        }\r\n    }\r\n\r\n    setInvoiceCancelWithOpen(record) {\r\n\r\n        this.invoiceService.setInvoiceCancelBydId(record.id, 1).subscribe(() => {\r\n            this.dxInvoiceInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n    setInvoiceCancelWithRevise(record) {\r\n\r\n        this.invoiceService.setInvoiceCancelBydId(record.id, 6).subscribe(() => {\r\n            this.dxInvoiceInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    listReceiverPK(record) {\r\n        debugger;\r\n        this.gibPartnerPkService.GetCustomerActivePKS(record.accountingCustomerPartyVknTckn, 1).subscribe(pks => {\r\n            this.invoiceReceiverPKDataSource = pks.map(item => ({ Adres: item }));;\r\n            this.pkModalSelectedInvoiceId = record.id;\r\n            this.pkModalSelectedInvoiceResourceDocEntry = 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(0).subscribe(serials => {\r\n            this.invoiceSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.selectedInvoiceIds = [record.id];\r\n            this.isSerialModalOpen = true;\r\n        })\r\n    }\r\n\r\n    listActiveSeriesForMultiple() {\r\n        this.hitDocumentSerialService.ListActiveSeriesForDocument(0).subscribe(serials => {\r\n            this.invoiceSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.selectedInvoiceIds = this.dxInvoiceInstance.instance.getVisibleRows().filter(i => i.isSelected == true).map(p => p.data.id);\r\n            this.isSerialModalOpen = true;\r\n        })\r\n    }\r\n\r\n    selectInvoiceSerial(record) {\r\n        this.invoiceService.updateInvoiceSerial(this.selectedInvoiceIds, record.Seri).subscribe(() => {\r\n            this.isSerialModalOpen = false;\r\n            this.toasterService.success(\"Belge serileri başarıyla seçildi.\");\r\n            this.dxInvoiceInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    selectPKAddress(record) {\r\n        console.log(record.Adres, this.pkModalSelectedInvoiceId, this.pkModalSelectedInvoiceResourceDocEntry)\r\n        this.invoiceService.updateInvoiceReceiver(this.pkModalSelectedInvoiceId, record.Adres).subscribe(() => {\r\n            this.isPKModalOpen = false;\r\n            this.dxInvoiceInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    downloadPDFMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\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        this.invoiceService.getInvoicePdfsMultiple(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 = 'Faturalar-' + 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    sendInvoiceMultiple() {\r\n        debugger;\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\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    sendInvoiceToEntegrator() {\r\n        this.invoiceService.sendInvoiceToEntegrator().subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoicesFromConnector() {\r\n        this.invoiceService.getInvoicesFromConnector().subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoiceResponses() {\r\n        this.invoiceService.getInvoiceResponses(new Date().toISOString(), new Date().toISOString()).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoiceView(record) {\r\n        this.invoiceService.getInvoiceView(record.uuId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\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    showAllFiles(record) {\r\n        this.invoiceFilesDataSource = this.invoiceService.LoadInvoiceFiles(record.uuId)\r\n        this.isFileModalOpen = true;\r\n    }\r\n\r\n    getInvoicePreview(record) {\r\n        debugger;\r\n        this.invoiceService.getInvoicePreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:text/html;base64,${fatura.previewHTML}`;\r\n            this.hitSharedService.previewFile(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\r\n    getInvoiceXML(record) {\r\n        debugger;\r\n        this.invoiceService.getXMLPreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:${fatura.mimeType};base64,${fatura.content}`;\r\n            this.hitSharedService.previewFile(fatura.content);\r\n            /*const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${fatura.filename}`;\r\n            link.click();*/\r\n        });\r\n    }\r\n\r\n    getReceiverResponseName(responseId) {\r\n        const response = this.invoiceReceiverResponseLookup.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    getDocObjectName(data) {\r\n        return ((data.isDraft ? \"Taslak \" : \"\") + this.invoiceObjectsEnumLookup.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        return \"\";\r\n    }\r\n\r\n    DownloadFile(record) {\r\n        this.invoiceService.downloadFileById(record.contentMasterId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\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","<!-- eslint-disable @angular-eslint/template/eqeqeq -->\r\n<abp-page [title]=\"'eDonusum::Invoices' | 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.Invoices.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"listActiveSeriesForMultiple()\">\r\n        <i class=\"fa fa-tasks me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::SelectSerialMultiple' | abpLocalization }}\r\n      </button>\r\n       <button *abpPermission=\"'eDonusum.Invoices.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.Invoices.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendInvoiceMultiple()\">\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.Invoices.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"getInvoiceResponses()\">\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.Invoices.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.Invoices.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 faturaları listeleyen ekran</p>\r\n  <div class=\"card\">\r\n    <div class=\"card-body\">\r\n      <dx-data-grid #dxInvoiceInstance [dataSource]=\"invoicesDataSource\" [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)=\"sendInvoiceSingle(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)=\"setInvoiceCancelWithOpen(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)=\"setInvoiceCancelWithRevise(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)=\"listReceiverPK(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)=\"getInvoiceView(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)=\"getInvoicePreview(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-eye\" aria-hidden=\"true\"></i> {{ 'eDonusum::Preview' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getInvoiceXML(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              </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 dataType=\"number\" dataField=\"resourceDocEntry\"\r\n          caption=\"{{'eDonusum::ResourceDocEntry'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataType=\"number\" dataField=\"resourceDocNum\"\r\n          caption=\"{{'eDonusum::ResourceDocNum'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"invoiceId\" caption=\"{{'eDonusum::InvoiceId'|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=\"accountingCustomerPartyName\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyName'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"accountingCustomerPartyVknTckn\"\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]=\"invoiceStatusLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"profileId\" caption=\"{{'eDonusum::ProfileId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"invoiceTypeCode\" caption=\"{{'eDonusum::InvoiceTypeCode'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"legalMonetaryTotalPayableAmount\" caption=\"{{'eDonusum::PayableAmount'|abpLocalization}}\"\r\n          dataType=\"number\" format=\"#,##0.00\"></dxi-column>\r\n        <dxi-column dataField=\"documentCurrencyCode\" caption=\"{{'eDonusum::DocCurrency'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"receiverResponse\" caption=\"{{'eDonusum::ReceiverResponse'|abpLocalization}}\"\r\n          cellTemplate=\"iconTemplate\">\r\n          <dxo-lookup [dataSource]=\"invoiceReceiverResponseLookup\" 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' : 'gray'}\"></i>\r\n          {{getReceiverResponseName(data.data.receiverResponse)}}\r\n        </div>\r\n        <dxi-column dataField=\"receiverResponseDesc\"\r\n          caption=\"{{'eDonusum::ReceiverResponseDesc'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedReceiverPK\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::SelectedReceiverPK'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedInvoiceSerial\"\r\n          caption=\"{{'eDonusum::SelectedInvoiceSerial'|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::InvoiceFiles' | 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 #dxInvoiceFileInstance [dataSource]=\"invoiceFilesDataSource\" [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]=\"invoiceFileNameLookup\" 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]=\"isPKModalBusy\" [(visible)]=\"isPKModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{pkModalSelectedInvoiceResourceDocEntry}} {{ '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]=\"invoiceReceiverPKDataSource\" [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>\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 #dxInvoiceSerialInstance [dataSource]=\"invoiceSerialDataSource\" [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)=\"selectInvoiceSerial(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]=\"isModalBusy\" [(visible)]=\"isModalOpen\">\r\n    <ng-template #abpHeader>\r\n      <h3>\r\n        {{ (selected ? 'AbpUi::Edit' : 'eDonusum::NewInvoice') | abpLocalization }}\r\n      </h3>\r\n    </ng-template>\r\n  \r\n    <ng-template #abpBody>\r\n      <form [formGroup]=\"form\" id=\"invoice\" (ngSubmit)=\"submitForm()\" validateOnSubmit>\r\n        <div class=\"mt-2 fade-in-top\">\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-ubl-version-id\">\r\n              {{ 'eDonusum::UblVersionId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-ubl-version-id\"\r\n              formControlName=\"ublVersionId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n              autofocus\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-customization-id\">\r\n              {{ 'eDonusum::CustomizationId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-customization-id\"\r\n              formControlName=\"customizationId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-profile-id\">\r\n              {{ 'eDonusum::ProfileId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-profile-id\"\r\n              formControlName=\"profileId\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-id\">\r\n              {{ 'eDonusum::InvoiceId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-id\"\r\n              formControlName=\"invoiceId\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"form-check mb-3\">\r\n            <input\r\n              type=\"checkbox\"\r\n              id=\"invoice-copy-indicator\"\r\n              formControlName=\"copyIndicator\"\r\n              class=\"form-check-input\"\r\n            />\r\n  \r\n            <label for=\"invoice-copy-indicator\" class=\"form-check-label\">\r\n              {{ 'eDonusum::CopyIndicator' | abpLocalization }}\r\n            </label>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-uu-id\">\r\n              {{ 'eDonusum::UuId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input id=\"invoice-uu-id\" formControlName=\"uuId\" class=\"form-control\" maxlength=\"64\" />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-issue-date\">\r\n              {{ 'eDonusum::IssueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-issue-date\"\r\n                formControlName=\"issueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #issueDateInput\r\n                #issueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"issueDateDatepicker.open()\"\r\n                (keyup.space)=\"issueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"issueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    issueDateDatepicker.writeValue(null);\r\n                    issueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-issue-time\">\r\n              {{ 'eDonusum::IssueTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-issue-time\"\r\n                formControlName=\"issueTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #issueTimeInput\r\n                #issueTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"issueTimeDatepicker.open()\"\r\n                (keyup.space)=\"issueTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"issueTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    issueTimeDatepicker.writeValue(null);\r\n                    issueTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-type-code\">\r\n              {{ 'eDonusum::InvoiceTypeCode' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-type-code\"\r\n              formControlName=\"invoiceTypeCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-document-currency-code\">\r\n              {{ 'eDonusum::DocumentCurrencyCode' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-document-currency-code\"\r\n              formControlName=\"documentCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-currency-code\">\r\n              {{ 'eDonusum::TaxCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-currency-code\"\r\n              formControlName=\"taxCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-currency-code\">\r\n              {{ 'eDonusum::PricingCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-currency-code\"\r\n              formControlName=\"pricingCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-currency-code\">\r\n              {{ 'eDonusum::PaymentCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-currency-code\"\r\n              formControlName=\"paymentCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-alternative-currency-code\">\r\n              {{ 'eDonusum::PaymentAlternativeCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-currency-code\"\r\n              formControlName=\"paymentAlternativeCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-cost\">\r\n              {{ 'eDonusum::AccountingCost' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-cost\"\r\n              formControlName=\"accountingCost\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-line-count-numeric\">\r\n              {{ 'eDonusum::LineCountNumeric' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-line-count-numeric\"\r\n              formControlName=\"lineCountNumeric\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-start-date\">\r\n              {{ 'eDonusum::InvoicePeriodStartDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-start-date\"\r\n                formControlName=\"invoicePeriodStartDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodStartDateInput\r\n                #invoicePeriodStartDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodStartDateDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodStartDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodStartDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodStartDateDatepicker.writeValue(null);\r\n                    invoicePeriodStartDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-start-time\">\r\n              {{ 'eDonusum::InvoicePeriodStartTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-start-time\"\r\n                formControlName=\"invoicePeriodStartTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodStartTimeInput\r\n                #invoicePeriodStartTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodStartTimeDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodStartTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodStartTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodStartTimeDatepicker.writeValue(null);\r\n                    invoicePeriodStartTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-end-date\">\r\n              {{ 'eDonusum::InvoicePeriodEndDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-end-date\"\r\n                formControlName=\"invoicePeriodEndDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodEndDateInput\r\n                #invoicePeriodEndDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodEndDateDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodEndDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodEndDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodEndDateDatepicker.writeValue(null);\r\n                    invoicePeriodEndDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-end-time\">\r\n              {{ 'eDonusum::InvoicePeriodEndTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-end-time\"\r\n                formControlName=\"invoicePeriodEndTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodEndTimeInput\r\n                #invoicePeriodEndTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodEndTimeDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodEndTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodEndTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodEndTimeDatepicker.writeValue(null);\r\n                    invoicePeriodEndTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-duration-measure\">\r\n              {{ 'eDonusum::InvoicePeriodDurationMeasure' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-duration-measure\"\r\n                formControlName=\"invoicePeriodDurationMeasure\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodDurationMeasureInput\r\n                #invoicePeriodDurationMeasureDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodDurationMeasureDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodDurationMeasureDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodDurationMeasureInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodDurationMeasureDatepicker.writeValue(null);\r\n                    invoicePeriodDurationMeasureDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-description\">\r\n              {{ 'eDonusum::InvoicePeriodDescription' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-period-description\"\r\n              formControlName=\"invoicePeriodDescription\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-id\">\r\n              {{ 'eDonusum::OrderReferenceId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-id\"\r\n              formControlName=\"orderReferenceId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-sales-order-id\">\r\n              {{ 'eDonusum::OrderReferenceSalesOrderId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-sales-order-id\"\r\n              formControlName=\"orderReferenceSalesOrderId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-issue-date\">\r\n              {{ 'eDonusum::OrderReferenceIssueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-order-reference-issue-date\"\r\n                formControlName=\"orderReferenceIssueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #orderReferenceIssueDateInput\r\n                #orderReferenceIssueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"orderReferenceIssueDateDatepicker.open()\"\r\n                (keyup.space)=\"orderReferenceIssueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"orderReferenceIssueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    orderReferenceIssueDateDatepicker.writeValue(null);\r\n                    orderReferenceIssueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-order-type-code\">\r\n              {{ 'eDonusum::OrderReferenceOrderTypeCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-order-type-code\"\r\n              formControlName=\"orderReferenceOrderTypeCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-name\">\r\n              {{ 'eDonusum::AccountingSupplierPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-name\"\r\n              formControlName=\"accountingSupplierPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-scheme-id\">\r\n              {{ 'eDonusum::AccountingSupplierPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-scheme-id\"\r\n              formControlName=\"accountingSupplierPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-vkn-tckn\">\r\n              {{ 'eDonusum::AccountingSupplierPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-vkn-tckn\"\r\n              formControlName=\"accountingSupplierPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-name\">\r\n              {{ 'eDonusum::AccountingCustomerPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-name\"\r\n              formControlName=\"accountingCustomerPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-scheme-id\">\r\n              {{ 'eDonusum::AccountingCustomerPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-scheme-id\"\r\n              formControlName=\"accountingCustomerPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-vkn-tckn\">\r\n              {{ 'eDonusum::AccountingCustomerPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-vkn-tckn\"\r\n              formControlName=\"accountingCustomerPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-name\">\r\n              {{ 'eDonusum::BuyerCustomerPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-name\"\r\n              formControlName=\"buyerCustomerPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-scheme-id\">\r\n              {{ 'eDonusum::BuyerCustomerPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-scheme-id\"\r\n              formControlName=\"buyerCustomerPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-vkn-tckn\">\r\n              {{ 'eDonusum::BuyerCustomerPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-vkn-tckn\"\r\n              formControlName=\"buyerCustomerPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-name\">\r\n              {{ 'eDonusum::SellerSupplierPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-name\"\r\n              formControlName=\"sellerSupplierPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-scheme-id\">\r\n              {{ 'eDonusum::SellerSupplierPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-scheme-id\"\r\n              formControlName=\"sellerSupplierPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-vkn-tckn\">\r\n              {{ 'eDonusum::SellerSupplierPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-vkn-tckn\"\r\n              formControlName=\"sellerSupplierPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-name\">\r\n              {{ 'eDonusum::TaxRepresentativePartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-name\"\r\n              formControlName=\"taxRepresentativePartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-scheme-id\">\r\n              {{ 'eDonusum::TaxRepresentativePartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-scheme-id\"\r\n              formControlName=\"taxRepresentativePartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-vkn-tckn\">\r\n              {{ 'eDonusum::TaxRepresentativePartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-vkn-tckn\"\r\n              formControlName=\"taxRepresentativePartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::TaxExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-exchange-rate-source-currency-code\"\r\n              formControlName=\"taxExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::TaxExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-exchange-rate-target-currency-code\"\r\n              formControlName=\"taxExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::TaxExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-tax-exchange-rate-calculation-rate\"\r\n              formControlName=\"taxExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-date\">\r\n              {{ 'eDonusum::TaxExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-tax-exchange-rate-date\"\r\n                formControlName=\"taxExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #taxExchangeRateDateInput\r\n                #taxExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"taxExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"taxExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"taxExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    taxExchangeRateDateDatepicker.writeValue(null);\r\n                    taxExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::PricingExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-exchange-rate-source-currency-code\"\r\n              formControlName=\"pricingExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::PricingExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-exchange-rate-target-currency-code\"\r\n              formControlName=\"pricingExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::PricingExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-pricing-exchange-rate-calculation-rate\"\r\n              formControlName=\"pricingExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-date\">\r\n              {{ 'eDonusum::PricingExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-pricing-exchange-rate-date\"\r\n                formControlName=\"pricingExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #pricingExchangeRateDateInput\r\n                #pricingExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"pricingExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"pricingExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"pricingExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    pricingExchangeRateDateDatepicker.writeValue(null);\r\n                    pricingExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::PaymentExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-exchange-rate-source-currency-code\"\r\n              formControlName=\"paymentExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::PaymentExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-exchange-rate-target-currency-code\"\r\n              formControlName=\"paymentExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::PaymentExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-payment-exchange-rate-calculation-rate\"\r\n              formControlName=\"paymentExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-date\">\r\n              {{ 'eDonusum::PaymentExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-exchange-rate-date\"\r\n                formControlName=\"paymentExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentExchangeRateDateInput\r\n                #paymentExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentExchangeRateDateDatepicker.writeValue(null);\r\n                    paymentExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-source-currency-code\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-exchange-rate-source-currency-code\"\r\n              formControlName=\"paymentAlternativeExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-target-currency-code\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-exchange-rate-target-currency-code\"\r\n              formControlName=\"paymentAlternativeExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-calculation-rate\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-payment-alternative-exchange-rate-calculation-rate\"\r\n              formControlName=\"paymentAlternativeExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-alternative-exchange-rate-date\">\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-alternative-exchange-rate-date\"\r\n                formControlName=\"paymentAlternativeExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentAlternativeExchangeRateDateInput\r\n                #paymentAlternativeExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentAlternativeExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentAlternativeExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentAlternativeExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentAlternativeExchangeRateDateDatepicker.writeValue(null);\r\n                    paymentAlternativeExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-line-extension-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalLineExtensionAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-line-extension-amount\"\r\n              formControlName=\"legalMonetaryTotalLineExtensionAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-tax-exclusive-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalTaxExclusiveAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-tax-exclusive-amount\"\r\n              formControlName=\"legalMonetaryTotalTaxExclusiveAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-tax-inclusive-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalTaxInclusiveAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-tax-inclusive-amount\"\r\n              formControlName=\"legalMonetaryTotalTaxInclusiveAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-allowance-total-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalAllowanceTotalAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-allowance-total-amount\"\r\n              formControlName=\"legalMonetaryTotalAllowanceTotalAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-charge-total-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalChargeTotalAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-charge-total-amount\"\r\n              formControlName=\"legalMonetaryTotalChargeTotalAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-payable-rounding-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalPayableRoundingAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-payable-rounding-amount\"\r\n              formControlName=\"legalMonetaryTotalPayableRoundingAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-payable-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalPayableAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-payable-amount\"\r\n              formControlName=\"legalMonetaryTotalPayableAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-terms-note\">\r\n              {{ 'eDonusum::PaymentTermsNote' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-terms-note\"\r\n              formControlName=\"paymentTermsNote\"\r\n              class=\"form-control\"\r\n              maxlength=\"512\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-terms-payment-due-date\">\r\n              {{ 'eDonusum::PaymentTermsPaymentDueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-terms-payment-due-date\"\r\n                formControlName=\"paymentTermsPaymentDueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentTermsPaymentDueDateInput\r\n                #paymentTermsPaymentDueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentTermsPaymentDueDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentTermsPaymentDueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentTermsPaymentDueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentTermsPaymentDueDateDatepicker.writeValue(null);\r\n                    paymentTermsPaymentDueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cust-inv-id\">\r\n              {{ 'eDonusum::CustInvId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cust-inv-id\"\r\n              formControlName=\"custInvId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"form-check mb-3\">\r\n            <input\r\n              type=\"checkbox\"\r\n              id=\"invoice-is-canceled\"\r\n              formControlName=\"isCanceled\"\r\n              class=\"form-check-input\"\r\n            />\r\n  \r\n            <label for=\"invoice-is-canceled\" class=\"form-check-label\">\r\n              {{ 'eDonusum::IsCanceled' | abpLocalization }}\r\n            </label>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cancel-code\">\r\n              {{ 'eDonusum::CancelCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cancel-code\"\r\n              formControlName=\"cancelCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cancel-description\">\r\n              {{ 'eDonusum::CancelDescription' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cancel-description\"\r\n              formControlName=\"cancelDescription\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-resource-doc-type\">\r\n              {{ 'eDonusum::ResourceDocType' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-resource-doc-type\"\r\n              formControlName=\"resourceDocType\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-resource-doc-entry\">\r\n              {{ 'eDonusum::ResourceDocEntry' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-resource-doc-entry\"\r\n              formControlName=\"resourceDocEntry\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-status\">\r\n              {{ 'eDonusum::Status' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input type=\"number\" id=\"invoice-status\" formControlName=\"status\" class=\"form-control\" />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-receiver-response\">\r\n              {{ 'eDonusum::ReceiverResponse' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-receiver-response\"\r\n              formControlName=\"receiverResponse\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-receiver-response-desc\">\r\n              {{ 'eDonusum::ReceiverResponseDesc' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-receiver-response-desc\"\r\n              formControlName=\"receiverResponseDesc\"\r\n              class=\"form-control\"\r\n              maxlength=\"1024\"\r\n            />\r\n          </div>\r\n        </div>\r\n      </form>\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  \r\n      <abp-button iconClass=\"fa fa-check\" buttonType=\"submit\" formName=\"invoice\">\r\n        {{ 'AbpUi::Save' | abpLocalization }}\r\n      </abp-button>\r\n    </ng-template>\r\n  </abp-modal> -->"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit-invoice.component.js","sourceRoot":"","sources":["../../../../../../projects/e-donusum/src/lib/components/hit-invoices/hit-invoice.component.ts","../../../../../../projects/e-donusum/src/lib/components/hit-invoices/hit-invoice.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 { HitInvoiceService } from '../../hit-proxy/hit-invoices/hit-invoice.service';\r\nimport { HitFileDocumentTypeService } from '../../hit-proxy/hit-file-document-type/hit-file-document-type.service';\r\nimport { HitGibPartnerPkService } from '../../hit-proxy/hit-gib-partner-pks/hit-gib-partner-pk.service';\r\nimport { ToasterService } from '@abp/ng.theme.shared';\r\nimport { HitDocumentSerialService } from '../../hit-proxy/hit-document-serials/hit-document-serial.service';\r\nimport { Confirmation, ConfirmationService } from '@abp/ng.theme.shared';\r\nimport { HitSharedService } from '../../hit-proxy/shared/hit-shared.service';\r\n\r\n@Component({\r\n    selector: 'lib-invoice',\r\n    changeDetection: ChangeDetectionStrategy.Default,\r\n    providers: [ListService, { provide: NgbDateAdapter, useClass: DateAdapter }],\r\n    templateUrl: './hit-invoice.component.html',\r\n    styles: [],\r\n})\r\nexport class HitInvoiceComponent implements OnInit {\r\n    @ViewChild('dxInvoiceInstance', { static: false }) dxInvoiceInstance: DxDataGridComponent\r\n    @ViewChild('dxInvoiceFileInstance', { static: false }) dxInvoiceFileInstance: DxDataGridComponent\r\n    @ViewChild('dxReceiverPKSInstance', { static: false }) dxReceiverPKSInstance: DxDataGridComponent\r\n    @ViewChild('dxInvoiceSerialInstance', { static: false }) dxInvoiceSerialInstance: DxDataGridComponent\r\n\r\n    invoicesDataSource: any\r\n    invoiceStatusLookup: any\r\n    invoiceFileNameLookup: any\r\n    invoiceReceiverResponseLookup: any\r\n    invoiceObjectsEnumLookup: any\r\n    invoiceFilesDataSource: any\r\n    invoiceReceiverPKDataSource: any\r\n    invoiceSerialDataSource: any\r\n\r\n    isPreviewModalOpen = false;\r\n    isPreviewModalBusy = false;\r\n\r\n    isFileModalOpen = false;\r\n    isFileModalBusy = false;\r\n\r\n    isPKModalOpen = false;\r\n    isPKModalBusy = false;\r\n    pkModalSelectedInvoiceId: any;\r\n    pkModalSelectedInvoiceResourceDocEntry: any;\r\n\r\n    isSerialModalOpen = false;\r\n    isSerialModalBusy = false;\r\n    serialModalSelectedInvoiceId: any;\r\n    serialModalSelectedInvoiceResourceDocEntry: any;\r\n\r\n    selectedInvoiceIds: string[];\r\n\r\n    faturaOnizleme: any;\r\n\r\n    constructor(\r\n        public readonly list: ListService,\r\n        private readonly invoiceService: HitInvoiceService,\r\n        private readonly gibPartnerPkService: HitGibPartnerPkService,\r\n        private readonly fileDocumentTypeService: HitFileDocumentTypeService,\r\n        private readonly hitDocumentSerialService: HitDocumentSerialService,\r\n        private readonly toasterService: ToasterService,\r\n        private readonly confirmation: ConfirmationService,\r\n        private readonly hitSharedService: HitSharedService\r\n    ) { }\r\n\r\n    ngOnInit(): void {\r\n        this.invoicesDataSource = this.invoiceService.LoadInvoices;\r\n        this.invoiceService.getStatuses().subscribe(list => {\r\n            this.invoiceStatusLookup = list;\r\n        });\r\n        this.invoiceService.getReceiverResponses().subscribe(list => {\r\n            this.invoiceReceiverResponseLookup = list;\r\n        })\r\n        this.invoiceService.getSapObjects().subscribe(list => {\r\n            this.invoiceObjectsEnumLookup = list;\r\n        })\r\n        this.fileDocumentTypeService.getFileDocumentTypes().subscribe(list => {\r\n            debugger;\r\n            this.invoiceFileNameLookup = list;\r\n        })\r\n    }\r\n    sendInvoiceSingle(record) {\r\n        let ids: string[] = [record.id];\r\n        debugger;\r\n        if (isNullOrEmpty(record.selectedInvoiceSerial)) {\r\n            debugger;\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.invoiceService.sendInvoiceById(ids).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).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n        }\r\n    }\r\n\r\n    setInvoiceCancelWithOpen(record) {\r\n\r\n        this.invoiceService.setInvoiceCancelBydId(record.id, 1).subscribe(() => {\r\n            this.dxInvoiceInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n    setInvoiceCancelWithRevise(record) {\r\n\r\n        this.invoiceService.setInvoiceCancelBydId(record.id, 6).subscribe(() => {\r\n            this.dxInvoiceInstance.instance.refresh()\r\n            this.toasterService.success(\"Belge başarıyla iptale çekilerek, kaynakta güncellendi.\");\r\n        });\r\n    }\r\n\r\n    listReceiverPK(record) {\r\n        debugger;\r\n        this.gibPartnerPkService.GetCustomerActivePKS(record.accountingCustomerPartyVknTckn, 1).subscribe(pks => {\r\n            this.invoiceReceiverPKDataSource = pks.map(item => ({ Adres: item }));;\r\n            this.pkModalSelectedInvoiceId = record.id;\r\n            this.pkModalSelectedInvoiceResourceDocEntry = 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(0).subscribe(serials => {\r\n            this.invoiceSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.selectedInvoiceIds = [record.id];\r\n            this.isSerialModalOpen = true;\r\n        })\r\n    }\r\n\r\n    listActiveSeriesForMultiple() {\r\n        this.hitDocumentSerialService.ListActiveSeriesForDocument(0).subscribe(serials => {\r\n            this.invoiceSerialDataSource = serials.map(item => ({ Seri: item }));;\r\n            this.selectedInvoiceIds = this.dxInvoiceInstance.instance.getVisibleRows().filter(i => i.isSelected == true).map(p => p.data.id);\r\n            this.isSerialModalOpen = true;\r\n        })\r\n    }\r\n\r\n    selectInvoiceSerial(record) {\r\n        this.invoiceService.updateInvoiceSerial(this.selectedInvoiceIds, record.Seri).subscribe(() => {\r\n            this.isSerialModalOpen = false;\r\n            this.toasterService.success(\"Belge serileri başarıyla seçildi.\");\r\n            this.dxInvoiceInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    selectPKAddress(record) {\r\n        console.log(record.Adres, this.pkModalSelectedInvoiceId, this.pkModalSelectedInvoiceResourceDocEntry)\r\n        this.invoiceService.updateInvoiceReceiver(this.pkModalSelectedInvoiceId, record.Adres).subscribe(() => {\r\n            this.isPKModalOpen = false;\r\n            this.dxInvoiceInstance.instance.refresh()\r\n        })\r\n    }\r\n\r\n    downloadPDFMultiple() {\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\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        this.invoiceService.getInvoicePdfsMultiple(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 = 'Faturalar-' + 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    sendInvoiceMultiple() {\r\n        debugger;\r\n        let ids: Array<{ id: string, selectedSerial: string }> = [];\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    sendInvoiceToEntegrator() {\r\n        this.invoiceService.sendInvoiceToEntegrator().subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoicesFromConnector() {\r\n        this.invoiceService.getInvoicesFromConnector().subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoiceResponses() {\r\n        this.invoiceService.getInvoiceResponses(new Date().toISOString(), new Date().toISOString()).subscribe(() => this.dxInvoiceInstance.instance.refresh());\r\n    }\r\n\r\n    getInvoiceView(record) {\r\n        this.invoiceService.getInvoiceView(record.uuId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\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    showAllFiles(record) {\r\n        this.invoiceFilesDataSource = this.invoiceService.LoadInvoiceFiles(record.uuId)\r\n        this.isFileModalOpen = true;\r\n    }\r\n\r\n    getInvoicePreview(record) {\r\n        debugger;\r\n        this.invoiceService.getInvoicePreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:text/html;base64,${fatura.previewHTML}`;\r\n            //this.hitSharedService.previewFile(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\r\n    getInvoiceXML(record) {\r\n        debugger;\r\n        this.invoiceService.getXMLPreview(record.id, record.resourceDocType).subscribe(fatura => {\r\n            const source = `data:${fatura.mimeType};base64,${fatura.content}`;\r\n            //this.hitSharedService.previewFile(fatura.content);\r\n            const link = document.createElement('a');\r\n            link.href = source;\r\n            link.download = `${fatura.filename}`;\r\n            link.click();\r\n        });\r\n    }\r\n\r\n    getReceiverResponseName(responseId) {\r\n        const response = this.invoiceReceiverResponseLookup.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    getDocObjectName(data) {\r\n        return ((data.isDraft ? \"Taslak \" : \"\") + this.invoiceObjectsEnumLookup.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        return \"\";\r\n    }\r\n\r\n    DownloadFile(record) {\r\n        this.invoiceService.downloadFileById(record.contentMasterId).subscribe(item => {\r\n            const source = `data:${item.mimeType};base64,${item.content}`;\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","<!-- eslint-disable @angular-eslint/template/eqeqeq -->\r\n<abp-page [title]=\"'eDonusum::Invoices' | 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.Invoices.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"listActiveSeriesForMultiple()\">\r\n        <i class=\"fa fa-tasks me-1\" aria-hidden=\"true\"></i>\r\n        {{ 'eDonusum::SelectSerialMultiple' | abpLocalization }}\r\n      </button>\r\n       <button *abpPermission=\"'eDonusum.Invoices.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.Invoices.Create'\" class=\"btn btn-primary btn-sm\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"sendInvoiceMultiple()\">\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.Invoices.Create'\" class=\"btn btn-xs btn-success\" type=\"button\"\r\n        style=\"margin-right: 5px;\" (click)=\"getInvoiceResponses()\">\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.Invoices.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.Invoices.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 faturaları listeleyen ekran</p>\r\n  <div class=\"card\">\r\n    <div class=\"card-body\">\r\n      <dx-data-grid #dxInvoiceInstance [dataSource]=\"invoicesDataSource\" [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)=\"sendInvoiceSingle(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)=\"setInvoiceCancelWithOpen(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)=\"setInvoiceCancelWithRevise(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)=\"listReceiverPK(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)=\"getInvoiceView(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)=\"getInvoicePreview(row.data)\" *ngIf=\"row.data.status == 100\">\r\n                  <i class=\"fa fa-eye\" aria-hidden=\"true\"></i> {{ 'eDonusum::Preview' | abpLocalization }}\r\n                </button>\r\n                <button ngbDropdownItem (click)=\"getInvoiceXML(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              </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 dataType=\"number\" dataField=\"resourceDocEntry\"\r\n          caption=\"{{'eDonusum::ResourceDocEntry'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataType=\"number\" dataField=\"resourceDocNum\"\r\n          caption=\"{{'eDonusum::ResourceDocNum'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"invoiceId\" caption=\"{{'eDonusum::InvoiceId'|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=\"accountingCustomerPartyName\"\r\n          caption=\"{{'eDonusum::AccountingCustomerPartyName'|abpLocalization}}\" aria-hidden=\"true\"></dxi-column>\r\n        <dxi-column dataField=\"accountingCustomerPartyVknTckn\"\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]=\"invoiceStatusLookup\" valueExpr=\"id\" displayExpr=\"displayName\">\r\n          </dxo-lookup>\r\n        </dxi-column>\r\n        <dxi-column dataField=\"profileId\" caption=\"{{'eDonusum::ProfileId'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"invoiceTypeCode\" caption=\"{{'eDonusum::InvoiceTypeCode'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"legalMonetaryTotalPayableAmount\" caption=\"{{'eDonusum::PayableAmount'|abpLocalization}}\"\r\n          dataType=\"number\" format=\"#,##0.00\"></dxi-column>\r\n        <dxi-column dataField=\"documentCurrencyCode\" caption=\"{{'eDonusum::DocCurrency'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"receiverResponse\" caption=\"{{'eDonusum::ReceiverResponse'|abpLocalization}}\"\r\n          cellTemplate=\"iconTemplate\">\r\n          <dxo-lookup [dataSource]=\"invoiceReceiverResponseLookup\" 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' : 'gray'}\"></i>\r\n          {{getReceiverResponseName(data.data.receiverResponse)}}\r\n        </div>\r\n        <dxi-column dataField=\"receiverResponseDesc\"\r\n          caption=\"{{'eDonusum::ReceiverResponseDesc'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedReceiverPK\" dataType=\"date\"\r\n          caption=\"{{'eDonusum::SelectedReceiverPK'|abpLocalization}}\"></dxi-column>\r\n        <dxi-column dataField=\"selectedInvoiceSerial\"\r\n          caption=\"{{'eDonusum::SelectedInvoiceSerial'|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::InvoiceFiles' | 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 #dxInvoiceFileInstance [dataSource]=\"invoiceFilesDataSource\" [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]=\"invoiceFileNameLookup\" 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]=\"isPKModalBusy\" [(visible)]=\"isPKModalOpen\" [options]=\"{ size: 'lg' }\">\r\n  <ng-template #abpHeader>\r\n    <h3>\r\n      {{pkModalSelectedInvoiceResourceDocEntry}} {{ '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]=\"invoiceReceiverPKDataSource\" [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>\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 #dxInvoiceSerialInstance [dataSource]=\"invoiceSerialDataSource\" [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)=\"selectInvoiceSerial(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]=\"isModalBusy\" [(visible)]=\"isModalOpen\">\r\n    <ng-template #abpHeader>\r\n      <h3>\r\n        {{ (selected ? 'AbpUi::Edit' : 'eDonusum::NewInvoice') | abpLocalization }}\r\n      </h3>\r\n    </ng-template>\r\n  \r\n    <ng-template #abpBody>\r\n      <form [formGroup]=\"form\" id=\"invoice\" (ngSubmit)=\"submitForm()\" validateOnSubmit>\r\n        <div class=\"mt-2 fade-in-top\">\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-ubl-version-id\">\r\n              {{ 'eDonusum::UblVersionId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-ubl-version-id\"\r\n              formControlName=\"ublVersionId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n              autofocus\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-customization-id\">\r\n              {{ 'eDonusum::CustomizationId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-customization-id\"\r\n              formControlName=\"customizationId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-profile-id\">\r\n              {{ 'eDonusum::ProfileId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-profile-id\"\r\n              formControlName=\"profileId\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-id\">\r\n              {{ 'eDonusum::InvoiceId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-id\"\r\n              formControlName=\"invoiceId\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"form-check mb-3\">\r\n            <input\r\n              type=\"checkbox\"\r\n              id=\"invoice-copy-indicator\"\r\n              formControlName=\"copyIndicator\"\r\n              class=\"form-check-input\"\r\n            />\r\n  \r\n            <label for=\"invoice-copy-indicator\" class=\"form-check-label\">\r\n              {{ 'eDonusum::CopyIndicator' | abpLocalization }}\r\n            </label>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-uu-id\">\r\n              {{ 'eDonusum::UuId' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input id=\"invoice-uu-id\" formControlName=\"uuId\" class=\"form-control\" maxlength=\"64\" />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-issue-date\">\r\n              {{ 'eDonusum::IssueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-issue-date\"\r\n                formControlName=\"issueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #issueDateInput\r\n                #issueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"issueDateDatepicker.open()\"\r\n                (keyup.space)=\"issueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"issueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    issueDateDatepicker.writeValue(null);\r\n                    issueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-issue-time\">\r\n              {{ 'eDonusum::IssueTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-issue-time\"\r\n                formControlName=\"issueTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #issueTimeInput\r\n                #issueTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"issueTimeDatepicker.open()\"\r\n                (keyup.space)=\"issueTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"issueTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    issueTimeDatepicker.writeValue(null);\r\n                    issueTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-type-code\">\r\n              {{ 'eDonusum::InvoiceTypeCode' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-type-code\"\r\n              formControlName=\"invoiceTypeCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-document-currency-code\">\r\n              {{ 'eDonusum::DocumentCurrencyCode' | abpLocalization }} *\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-document-currency-code\"\r\n              formControlName=\"documentCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-currency-code\">\r\n              {{ 'eDonusum::TaxCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-currency-code\"\r\n              formControlName=\"taxCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-currency-code\">\r\n              {{ 'eDonusum::PricingCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-currency-code\"\r\n              formControlName=\"pricingCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-currency-code\">\r\n              {{ 'eDonusum::PaymentCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-currency-code\"\r\n              formControlName=\"paymentCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-alternative-currency-code\">\r\n              {{ 'eDonusum::PaymentAlternativeCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-currency-code\"\r\n              formControlName=\"paymentAlternativeCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-cost\">\r\n              {{ 'eDonusum::AccountingCost' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-cost\"\r\n              formControlName=\"accountingCost\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-line-count-numeric\">\r\n              {{ 'eDonusum::LineCountNumeric' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-line-count-numeric\"\r\n              formControlName=\"lineCountNumeric\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-start-date\">\r\n              {{ 'eDonusum::InvoicePeriodStartDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-start-date\"\r\n                formControlName=\"invoicePeriodStartDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodStartDateInput\r\n                #invoicePeriodStartDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodStartDateDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodStartDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodStartDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodStartDateDatepicker.writeValue(null);\r\n                    invoicePeriodStartDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-start-time\">\r\n              {{ 'eDonusum::InvoicePeriodStartTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-start-time\"\r\n                formControlName=\"invoicePeriodStartTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodStartTimeInput\r\n                #invoicePeriodStartTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodStartTimeDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodStartTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodStartTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodStartTimeDatepicker.writeValue(null);\r\n                    invoicePeriodStartTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-end-date\">\r\n              {{ 'eDonusum::InvoicePeriodEndDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-end-date\"\r\n                formControlName=\"invoicePeriodEndDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodEndDateInput\r\n                #invoicePeriodEndDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodEndDateDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodEndDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodEndDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodEndDateDatepicker.writeValue(null);\r\n                    invoicePeriodEndDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-end-time\">\r\n              {{ 'eDonusum::InvoicePeriodEndTime' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-end-time\"\r\n                formControlName=\"invoicePeriodEndTime\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodEndTimeInput\r\n                #invoicePeriodEndTimeDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodEndTimeDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodEndTimeDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodEndTimeInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodEndTimeDatepicker.writeValue(null);\r\n                    invoicePeriodEndTimeDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-duration-measure\">\r\n              {{ 'eDonusum::InvoicePeriodDurationMeasure' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-invoice-period-duration-measure\"\r\n                formControlName=\"invoicePeriodDurationMeasure\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #invoicePeriodDurationMeasureInput\r\n                #invoicePeriodDurationMeasureDatepicker=\"ngbDatepicker\"\r\n                (click)=\"invoicePeriodDurationMeasureDatepicker.open()\"\r\n                (keyup.space)=\"invoicePeriodDurationMeasureDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"invoicePeriodDurationMeasureInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    invoicePeriodDurationMeasureDatepicker.writeValue(null);\r\n                    invoicePeriodDurationMeasureDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-invoice-period-description\">\r\n              {{ 'eDonusum::InvoicePeriodDescription' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-invoice-period-description\"\r\n              formControlName=\"invoicePeriodDescription\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-id\">\r\n              {{ 'eDonusum::OrderReferenceId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-id\"\r\n              formControlName=\"orderReferenceId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-sales-order-id\">\r\n              {{ 'eDonusum::OrderReferenceSalesOrderId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-sales-order-id\"\r\n              formControlName=\"orderReferenceSalesOrderId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-issue-date\">\r\n              {{ 'eDonusum::OrderReferenceIssueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-order-reference-issue-date\"\r\n                formControlName=\"orderReferenceIssueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #orderReferenceIssueDateInput\r\n                #orderReferenceIssueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"orderReferenceIssueDateDatepicker.open()\"\r\n                (keyup.space)=\"orderReferenceIssueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"orderReferenceIssueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    orderReferenceIssueDateDatepicker.writeValue(null);\r\n                    orderReferenceIssueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-order-reference-order-type-code\">\r\n              {{ 'eDonusum::OrderReferenceOrderTypeCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-order-reference-order-type-code\"\r\n              formControlName=\"orderReferenceOrderTypeCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-name\">\r\n              {{ 'eDonusum::AccountingSupplierPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-name\"\r\n              formControlName=\"accountingSupplierPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-scheme-id\">\r\n              {{ 'eDonusum::AccountingSupplierPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-scheme-id\"\r\n              formControlName=\"accountingSupplierPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-supplier-party-vkn-tckn\">\r\n              {{ 'eDonusum::AccountingSupplierPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-supplier-party-vkn-tckn\"\r\n              formControlName=\"accountingSupplierPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-name\">\r\n              {{ 'eDonusum::AccountingCustomerPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-name\"\r\n              formControlName=\"accountingCustomerPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-scheme-id\">\r\n              {{ 'eDonusum::AccountingCustomerPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-scheme-id\"\r\n              formControlName=\"accountingCustomerPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-accounting-customer-party-vkn-tckn\">\r\n              {{ 'eDonusum::AccountingCustomerPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-accounting-customer-party-vkn-tckn\"\r\n              formControlName=\"accountingCustomerPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-name\">\r\n              {{ 'eDonusum::BuyerCustomerPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-name\"\r\n              formControlName=\"buyerCustomerPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-scheme-id\">\r\n              {{ 'eDonusum::BuyerCustomerPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-scheme-id\"\r\n              formControlName=\"buyerCustomerPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-buyer-customer-party-vkn-tckn\">\r\n              {{ 'eDonusum::BuyerCustomerPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-buyer-customer-party-vkn-tckn\"\r\n              formControlName=\"buyerCustomerPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-name\">\r\n              {{ 'eDonusum::SellerSupplierPartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-name\"\r\n              formControlName=\"sellerSupplierPartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-scheme-id\">\r\n              {{ 'eDonusum::SellerSupplierPartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-scheme-id\"\r\n              formControlName=\"sellerSupplierPartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-seller-supplier-party-vkn-tckn\">\r\n              {{ 'eDonusum::SellerSupplierPartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-seller-supplier-party-vkn-tckn\"\r\n              formControlName=\"sellerSupplierPartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-name\">\r\n              {{ 'eDonusum::TaxRepresentativePartyName' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-name\"\r\n              formControlName=\"taxRepresentativePartyName\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-scheme-id\">\r\n              {{ 'eDonusum::TaxRepresentativePartySchemeId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-scheme-id\"\r\n              formControlName=\"taxRepresentativePartySchemeId\"\r\n              class=\"form-control\"\r\n              maxlength=\"8\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-representative-party-vkn-tckn\">\r\n              {{ 'eDonusum::TaxRepresentativePartyVknTckn' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-representative-party-vkn-tckn\"\r\n              formControlName=\"taxRepresentativePartyVknTckn\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::TaxExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-exchange-rate-source-currency-code\"\r\n              formControlName=\"taxExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::TaxExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-tax-exchange-rate-target-currency-code\"\r\n              formControlName=\"taxExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::TaxExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-tax-exchange-rate-calculation-rate\"\r\n              formControlName=\"taxExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-tax-exchange-rate-date\">\r\n              {{ 'eDonusum::TaxExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-tax-exchange-rate-date\"\r\n                formControlName=\"taxExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #taxExchangeRateDateInput\r\n                #taxExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"taxExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"taxExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"taxExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    taxExchangeRateDateDatepicker.writeValue(null);\r\n                    taxExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::PricingExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-exchange-rate-source-currency-code\"\r\n              formControlName=\"pricingExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::PricingExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-pricing-exchange-rate-target-currency-code\"\r\n              formControlName=\"pricingExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::PricingExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-pricing-exchange-rate-calculation-rate\"\r\n              formControlName=\"pricingExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-pricing-exchange-rate-date\">\r\n              {{ 'eDonusum::PricingExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-pricing-exchange-rate-date\"\r\n                formControlName=\"pricingExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #pricingExchangeRateDateInput\r\n                #pricingExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"pricingExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"pricingExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"pricingExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    pricingExchangeRateDateDatepicker.writeValue(null);\r\n                    pricingExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-source-currency-code\">\r\n              {{ 'eDonusum::PaymentExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-exchange-rate-source-currency-code\"\r\n              formControlName=\"paymentExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-target-currency-code\">\r\n              {{ 'eDonusum::PaymentExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-exchange-rate-target-currency-code\"\r\n              formControlName=\"paymentExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-calculation-rate\">\r\n              {{ 'eDonusum::PaymentExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-payment-exchange-rate-calculation-rate\"\r\n              formControlName=\"paymentExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-exchange-rate-date\">\r\n              {{ 'eDonusum::PaymentExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-exchange-rate-date\"\r\n                formControlName=\"paymentExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentExchangeRateDateInput\r\n                #paymentExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentExchangeRateDateDatepicker.writeValue(null);\r\n                    paymentExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-source-currency-code\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateSourceCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-exchange-rate-source-currency-code\"\r\n              formControlName=\"paymentAlternativeExchangeRateSourceCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-target-currency-code\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateTargetCurrencyCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-alternative-exchange-rate-target-currency-code\"\r\n              formControlName=\"paymentAlternativeExchangeRateTargetCurrencyCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"3\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label\r\n              class=\"form-label\"\r\n              for=\"invoice-payment-alternative-exchange-rate-calculation-rate\"\r\n            >\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateCalculationRate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-payment-alternative-exchange-rate-calculation-rate\"\r\n              formControlName=\"paymentAlternativeExchangeRateCalculationRate\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-alternative-exchange-rate-date\">\r\n              {{ 'eDonusum::PaymentAlternativeExchangeRateDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-alternative-exchange-rate-date\"\r\n                formControlName=\"paymentAlternativeExchangeRateDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentAlternativeExchangeRateDateInput\r\n                #paymentAlternativeExchangeRateDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentAlternativeExchangeRateDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentAlternativeExchangeRateDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentAlternativeExchangeRateDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentAlternativeExchangeRateDateDatepicker.writeValue(null);\r\n                    paymentAlternativeExchangeRateDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-line-extension-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalLineExtensionAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-line-extension-amount\"\r\n              formControlName=\"legalMonetaryTotalLineExtensionAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-tax-exclusive-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalTaxExclusiveAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-tax-exclusive-amount\"\r\n              formControlName=\"legalMonetaryTotalTaxExclusiveAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-tax-inclusive-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalTaxInclusiveAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-tax-inclusive-amount\"\r\n              formControlName=\"legalMonetaryTotalTaxInclusiveAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-allowance-total-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalAllowanceTotalAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-allowance-total-amount\"\r\n              formControlName=\"legalMonetaryTotalAllowanceTotalAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-charge-total-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalChargeTotalAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-charge-total-amount\"\r\n              formControlName=\"legalMonetaryTotalChargeTotalAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-payable-rounding-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalPayableRoundingAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-payable-rounding-amount\"\r\n              formControlName=\"legalMonetaryTotalPayableRoundingAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-legal-monetary-total-payable-amount\">\r\n              {{ 'eDonusum::LegalMonetaryTotalPayableAmount' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-legal-monetary-total-payable-amount\"\r\n              formControlName=\"legalMonetaryTotalPayableAmount\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-terms-note\">\r\n              {{ 'eDonusum::PaymentTermsNote' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-payment-terms-note\"\r\n              formControlName=\"paymentTermsNote\"\r\n              class=\"form-control\"\r\n              maxlength=\"512\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-payment-terms-payment-due-date\">\r\n              {{ 'eDonusum::PaymentTermsPaymentDueDate' | abpLocalization }}\r\n            </label>\r\n  \r\n            <div class=\"input-group\" validationTarget>\r\n              <input\r\n                readonly\r\n                id=\"invoice-payment-terms-payment-due-date\"\r\n                formControlName=\"paymentTermsPaymentDueDate\"\r\n                class=\"form-control\"\r\n                ngbDatepicker\r\n                #paymentTermsPaymentDueDateInput\r\n                #paymentTermsPaymentDueDateDatepicker=\"ngbDatepicker\"\r\n                (click)=\"paymentTermsPaymentDueDateDatepicker.open()\"\r\n                (keyup.space)=\"paymentTermsPaymentDueDateDatepicker.open()\"\r\n              />\r\n              <div *ngIf=\"paymentTermsPaymentDueDateInput.value\" class=\"input-group-append\">\r\n                <button\r\n                  class=\"btn btn-link px-2\"\r\n                  type=\"button\"\r\n                  [title]=\"'AbpUi::Clear' | abpLocalization\"\r\n                  (click)=\"\r\n                    paymentTermsPaymentDueDateDatepicker.writeValue(null);\r\n                    paymentTermsPaymentDueDateDatepicker.manualDateChange(null, true)\r\n                  \"\r\n                >\r\n                  <i class=\"fa fa-times\" aria-hidden=\"true\"></i>\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cust-inv-id\">\r\n              {{ 'eDonusum::CustInvId' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cust-inv-id\"\r\n              formControlName=\"custInvId\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"form-check mb-3\">\r\n            <input\r\n              type=\"checkbox\"\r\n              id=\"invoice-is-canceled\"\r\n              formControlName=\"isCanceled\"\r\n              class=\"form-check-input\"\r\n            />\r\n  \r\n            <label for=\"invoice-is-canceled\" class=\"form-check-label\">\r\n              {{ 'eDonusum::IsCanceled' | abpLocalization }}\r\n            </label>\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cancel-code\">\r\n              {{ 'eDonusum::CancelCode' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cancel-code\"\r\n              formControlName=\"cancelCode\"\r\n              class=\"form-control\"\r\n              maxlength=\"16\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-cancel-description\">\r\n              {{ 'eDonusum::CancelDescription' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-cancel-description\"\r\n              formControlName=\"cancelDescription\"\r\n              class=\"form-control\"\r\n              maxlength=\"256\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-resource-doc-type\">\r\n              {{ 'eDonusum::ResourceDocType' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-resource-doc-type\"\r\n              formControlName=\"resourceDocType\"\r\n              class=\"form-control\"\r\n              maxlength=\"32\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-resource-doc-entry\">\r\n              {{ 'eDonusum::ResourceDocEntry' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-resource-doc-entry\"\r\n              formControlName=\"resourceDocEntry\"\r\n              class=\"form-control\"\r\n              maxlength=\"64\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-status\">\r\n              {{ 'eDonusum::Status' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input type=\"number\" id=\"invoice-status\" formControlName=\"status\" class=\"form-control\" />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-receiver-response\">\r\n              {{ 'eDonusum::ReceiverResponse' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              type=\"number\"\r\n              id=\"invoice-receiver-response\"\r\n              formControlName=\"receiverResponse\"\r\n              class=\"form-control\"\r\n            />\r\n          </div>\r\n          <div class=\"mb-3\">\r\n            <label class=\"form-label\" for=\"invoice-receiver-response-desc\">\r\n              {{ 'eDonusum::ReceiverResponseDesc' | abpLocalization }}\r\n            </label>\r\n  \r\n            <input\r\n              id=\"invoice-receiver-response-desc\"\r\n              formControlName=\"receiverResponseDesc\"\r\n              class=\"form-control\"\r\n              maxlength=\"1024\"\r\n            />\r\n          </div>\r\n        </div>\r\n      </form>\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  \r\n      <abp-button iconClass=\"fa fa-check\" buttonType=\"submit\" formName=\"invoice\">\r\n        {{ 'AbpUi::Save' | abpLocalization }}\r\n      </abp-button>\r\n    </ng-template>\r\n  </abp-modal> -->"]}