From 4e0b1b0b5fa158e6a3dcb9e2e49c1fd6a90029c3 Mon Sep 17 00:00:00 2001 From: Ralph Soika Date: Tue, 20 Aug 2024 16:50:57 +0200 Subject: [PATCH] import steuerbescheide --- .../SteuerListController.java | 48 + .../SteuerbescheidPlugin.java | 100 + .../ZollListController.java | 97 - .../xml/CargosoftXMLEAkteImportService.java | 262 +- .../src/main/resources/imixs.properties | 4 +- .../section_steuerbescheid_details.xhtml | 51 + .../section_steuerbescheid_invoices.xhtml | 50 + .../alexander/section_zollliste_details.xhtml | 97 - .../xml/EAkteImportTester.java | 116 + .../xml/InvoiceImportTester.java | 13 +- ...C400012650820242452-_20240806164256864.xml | 64 + ...2650820242452-_20240806164256864_DEBUG.xml | 61 + workflow/rechnungsausgang-de-1.0.10.bpmn | 4101 +++++++++++++++++ workflow/steuerbescheid-de-1.0.0.bpmn | 340 +- 14 files changed, 4890 insertions(+), 514 deletions(-) create mode 100644 office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerListController.java create mode 100644 office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerbescheidPlugin.java delete mode 100644 office-alexander-logistics-app/src/main/java/com/alexanderlogistics/ZollListController.java create mode 100644 office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_details.xhtml create mode 100644 office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_invoices.xhtml delete mode 100644 office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_zollliste_details.xhtml create mode 100644 office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/EAkteImportTester.java create mode 100644 office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864.xml create mode 100644 office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864_DEBUG.xml create mode 100644 workflow/rechnungsausgang-de-1.0.10.bpmn diff --git a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerListController.java b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerListController.java new file mode 100644 index 0000000..5b1ce41 --- /dev/null +++ b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerListController.java @@ -0,0 +1,48 @@ +package com.alexanderlogistics; + +import java.io.Serializable; +import java.util.List; + +import org.imixs.workflow.ItemCollection; +import org.imixs.workflow.engine.DocumentService; +import org.imixs.workflow.faces.data.WorkflowController; + +import jakarta.enterprise.context.ConversationScoped; +import jakarta.inject.Inject; +import jakarta.inject.Named; + +/** + * Der SteuerListController dient dazu in einem Stuerbescheid + * die einzelnen Zeilen auszugeben. + * + * @author rsoika + * + */ +@Named("steuerListController") +@ConversationScoped +public class SteuerListController implements Serializable { + + private static final long serialVersionUID = 1L; + + @Inject + DocumentService documentService; + + @Inject + protected WorkflowController workflowController; + + /** + * Gibt die Zeilen aus einem importierten Steuerbeleg (eAkte) zurück + * + * @return + */ + public List getRows() { + + List rows = InvoiceUtil.explodeChildList(workflowController.getWorkitem()); + + return rows; + } + + public ItemCollection loadInvoice(String id) { + return documentService.load(id); + } +} diff --git a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerbescheidPlugin.java b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerbescheidPlugin.java new file mode 100644 index 0000000..e875f66 --- /dev/null +++ b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/SteuerbescheidPlugin.java @@ -0,0 +1,100 @@ +package com.alexanderlogistics; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +import org.imixs.workflow.ItemCollection; +import org.imixs.workflow.engine.DocumentService; +import org.imixs.workflow.engine.plugins.AbstractPlugin; +import org.imixs.workflow.exceptions.PluginException; +import org.imixs.workflow.exceptions.QueryException; + +import jakarta.inject.Inject; + +/** + * Das SteuerbescheidPlugin prüft ob + * + * - die ATC Nummer aus dem Steuerbescheid in einer Ausgangsrechnung gefunden + * wird ($taskID<5990) + * - invoice.atc.number + * - der Betrag "invoice.total.net" + * - die Währung??? + * - die Positionsnummer ??? + * + * + * @author rsoika + * @version 1.0 + * + */ +public class SteuerbescheidPlugin extends AbstractPlugin { + + private static Logger logger = Logger.getLogger(SteuerbescheidPlugin.class.getName()); + + @Inject + protected DocumentService documentService; + + @Inject + KreditorDebitorService kreditorService; + + /** + * Prüft ob der Steuerbetrag abgerechnet ist. + * + * + **/ + @Override + public ItemCollection run(ItemCollection workitem, ItemCollection event) throws PluginException { + + String atcNummer = workitem.getItemValueString("invoice.atc.number"); + logger.info("Verify ATC-Nr.: " + atcNummer); + double amount = workitem.getItemValueDouble("invoice.total.net"); + List invoices = findInvoices(atcNummer); + + // Beträge subtrahieren.... + double saldo = amount; + logger.info("Found " + invoices.size() + " matching invoices..."); + for (ItemCollection invoice : invoices) { + workitem.setItemValueUnique("$workitemRef", invoice.getUniqueID()); + + // suche die Zeile in der die ATC Nummer vorkommt. + List positionen = InvoiceUtil.explodeChildList(invoice); + for (ItemCollection pos : positionen) { + if (atcNummer.equals(pos.getItemValueString("atc.number"))) { + double umsatz = pos.getItemValueDouble("datev.umsatz"); + logger.info("...Umsatz=" + umsatz); + saldo = InvoiceUtil.round(saldo - umsatz); + } + } + + } + + // Stimmt der Betrag? + workitem.setItemValue("invoice.saldo", InvoiceUtil.round(saldo)); + if (amount == saldo) { + // match! + } else { + // no match + } + + return workitem; + } + + /* + * Sucht alle Ausgansrechnungen zu einer ATC Nummer + */ + protected List findInvoices(String atcNumber) { + List result = new ArrayList(); + String query = "(type:workitem OR type:workitemarchive) AND ($taskid:[5000 TO 5990])" + + " AND invoice.atc.number:\"" + atcNumber + "\" " + + " AND $workflowgroup:\"Rechnungsausgang\" "; + try { + result = documentService.find(query, 999, 0, "$created", false); + return result; + } catch (QueryException e) { + logger.severe("Failed to get invoices: " + e.getMessage()); + } + + return result; + } + +} diff --git a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/ZollListController.java b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/ZollListController.java deleted file mode 100644 index da56ed9..0000000 --- a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/ZollListController.java +++ /dev/null @@ -1,97 +0,0 @@ -package com.alexanderlogistics; - -import java.io.Serializable; -import java.util.ArrayList; -import java.util.List; -import java.util.logging.Logger; - -import org.imixs.workflow.ItemCollection; -import org.imixs.workflow.engine.DocumentService; -import org.imixs.workflow.engine.WorkflowService; -import org.imixs.workflow.faces.data.WorkflowController; - -import jakarta.enterprise.context.ConversationScoped; -import jakarta.inject.Inject; -import jakarta.inject.Named; - -/** - * Der ZollListController dient dazu in einer Zoll Liste die Rechnungen - * anzuzeigen, - * für die noch Zollabrechnungen erforderlich sind. - * - * Diese List wird aus einem Abgleich einer Cargosoft Datei erstellt. - * - * @author rsoika - * - */ -@Named("zollListController") -@ConversationScoped -public class ZollListController implements Serializable { - - private static final long serialVersionUID = 1L; - - public static final int TASK_ERSTELLUNG = 1000; - - private static Logger logger = Logger.getLogger(ZollListController.class.getName()); - - private String lastDbtrNumber = null; - - private String currencyFilter = "-"; - private String lastCurrencyFilter = null; - - private List invoiceList = null; - - @Inject - protected WorkflowController workflowController; - - @Inject - protected WorkflowService workflowService; - - @Inject - ZahlungseingangService zahlungseingangService; - - @Inject - protected DocumentService documentService; - - /** - * Diese Methode ist eine Dummy Methode die nur mal 3 Rechnungen simmuliert. - * - * Später wird diese Methode irgend was anderes machen. - * - * - * @return - */ - @SuppressWarnings("unchecked") - public List getInvoices() { - invoiceList = new ArrayList(); - - // dummy1 - - invoiceList.add(new ItemCollection() - .setItemValue("invoice.text", "LA-HOL-2401-002") - .setItemValue("invoice.atc", "ATC400058750120242452") - .setItemValue("dbtr.name", "D18317 Big Belly Solar GmbH") - .setItemValue("invoice.ZOLL", 18.45) - .setItemValue("invoice.EUST", 0) - .setItemValue("invoice.number", "")); - - invoiceList.add(new ItemCollection() - .setItemValue("invoice.text", "LA-HOL-2401-003") - .setItemValue("invoice.atc", "ATC400058750120242450") - .setItemValue("dbtr.name", "D18317 Big Belly Solar GmbH") - .setItemValue("invoice.ZOLL", 100.45) - .setItemValue("invoice.EUST", 0) - .setItemValue("invoice.number", "")); - - invoiceList.add(new ItemCollection() - .setItemValue("invoice.text", "LA-PAP-2401-003") - .setItemValue("invoice.atc", "345345") - .setItemValue("dbtr.name", "D18006 GPI BERLIN GMBH") - .setItemValue("invoice.ZOLL", 253.4) - .setItemValue("invoice.EUST", 0) - .setItemValue("invoice.number", "")); - - return invoiceList; - } - -} diff --git a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/xml/CargosoftXMLEAkteImportService.java b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/xml/CargosoftXMLEAkteImportService.java index e224f86..1f8b116 100644 --- a/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/xml/CargosoftXMLEAkteImportService.java +++ b/office-alexander-logistics-app/src/main/java/com/alexanderlogistics/xml/CargosoftXMLEAkteImportService.java @@ -380,12 +380,23 @@ public class CargosoftXMLEAkteImportService { readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='cs_voucher_number']", workitem, "invoice.number", String.class); + + readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='cs_address_number']", + workitem, "cdtr.number", String.class); + + readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='voucherdate']", + workitem, "invoice.date", Date.class); + readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='currency']", workitem, "invoice.currency", String.class); + + readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='currency_rate']", + workitem, "invoice.rate", Double.class); + readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='total_net_amount']", - workitem, "invoice.total.net", String.class); + workitem, "invoice.total.net", Double.class); readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='total_tax_amount']", - workitem, "invoice.total.tax", String.class); + workitem, "invoice.total.tax", Double.class); readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='reference']", workitem, "invoice.atc.number", String.class); readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='booking_period']", @@ -396,41 +407,12 @@ public class CargosoftXMLEAkteImportService { readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='booking_text']", workitem, "invoice.booking_text", String.class); - // Read rows - readXMLValue(doc, "/CargoSoftEFile/EFile/References/Reference[@type='row_1_cs_filenumber']", - workitem, "invoice.text", String.class); - // verify if invoice is already imported. if (alreadyImported(workitem.getItemValueString("invoice.number"))) { logger.warning("Invoice " + workitem.getItemValueString("invoice.number") + " already imported"); - // return null; + return null; } - // Rechnungssumme errechnen..... - // readXMLValue(doc, - // "/Invoices/Invoice/InvoiceHeader/InvoiceAmount/NetAmount/Amount/Value", - // workitem, "invoice.total.net", Double.class); - // readXMLValue(doc, - // "/Invoices/Invoice/InvoiceHeader/InvoiceAmount/VATInformation/VATAmount/Amount/Value", - // workitem, "invoice.total.tax", Double.class); - // if (!workitem.hasItem("invoice.total.tax")) { - // workitem.setItemValue("invoice.total.tax", 0.0); - // } - // // Total = net + tax - // double _total = workitem.getItemValueDouble("invoice.total.net"); - // _total = _total + workitem.getItemValueDouble("invoice.total.tax"); - // _total = Math.round(_total * 100) / 100.0; - // workitem.setItemValue("invoice.total", _total); - // workitem.setItemValue("invoice.saldo", _total); - - // Bei Gutschrift und Stornorechnung Wert negieren... - // if (isGutschrift(workitem)) { - // workitem.setItemValue("invoice.saldo", - // -workitem.getItemValueDouble("invoice.total")); - // workitem.setItemValue("invoice.total", - // -workitem.getItemValueDouble("invoice.total")); - // } - String cdtrNumber = workitem.getItemValueString("cdtr.number"); if (cdtrNumber.startsWith("K") || cdtrNumber.startsWith("D")) { workitem.setItemValue("cdtr.number", cdtrNumber.substring(1)); @@ -457,17 +439,12 @@ public class CargosoftXMLEAkteImportService { } // Row Positions lesen - // readXMLRows(doc, workitem); + readXMLRows(doc, workitem); // Jetzt noch das Space mapping + workitem.setItemValue("invoice.text", workitem.getItemValueString("invoice.positions")); mahnlaufService.mapInvoiceTextToSpace(workitem, spacePosMappings); - // Rückstellungen ignorieren - // if (isRueckStellung(workitem)) { - // // Ignore invoice! - // return null; - // } - // Finally we attache the pdf file and the XML content to the workitem. attacheFiles(doc, workitem); @@ -478,19 +455,6 @@ public class CargosoftXMLEAkteImportService { return workitem; } - /** - * Prüft ob die Rechnung eine Rückstellung ist also mit R1 bis R8 beginnt - * - * ^R[1-8] . - * - * @param workitem - * @return - */ - private boolean isRueckStellung(ItemCollection workitem) { - String text = workitem.getItemValueString("invoice.text"); - return text.matches(REGEX_IMPORTTEXTPATTERN); - } - /** * Reads a tag value from the xml tree and set the value into the given * workitem. @@ -532,11 +496,19 @@ public class CargosoftXMLEAkteImportService { return; } if (itemType == Double.class && value != null && !value.isEmpty()) { - workitem.setItemValue(itemName, Double.parseDouble(value)); + try { + workitem.setItemValue(itemName, Double.parseDouble(value)); + } catch (NumberFormatException e) { + // no op + } return; } if (itemType == Integer.class && value != null && !value.isEmpty()) { - workitem.setItemValue(itemName, Integer.parseInt(value)); + try { + workitem.setItemValue(itemName, Integer.parseInt(value)); + } catch (NumberFormatException e) { + // no op + } return; } // Default String format @@ -549,106 +521,6 @@ public class CargosoftXMLEAkteImportService { } } - /** - * Reads the positions rows - * - * InvoiceRows/InvoiceRow - * - * Each row has the following items: - * _childitems { - * datev.shzeichen=[H], - * datev.kurs=[0.0], - * datev.basisumsatz=[0.0], - * datev.text=[R LA-PAP-2405-051], - * datev.konto=[3851], - * datev.umsatz=[3307.81], - * datev.wkz=[EUR]}} - * - * @param doc - xml doc - * @param workitem - */ - private void readXMLRows(Document doc, ItemCollection workitem) { - // create XPath... - List childItems = new ArrayList<>(); - - XPathFactory xpathFactory = XPathFactory.newInstance(); - XPath xPath = xpathFactory.newXPath(); - try { - // Compile the XPath expressions - XPathExpression fileNumberExpr = xPath.compile("FileNumber/text()"); - XPathExpression netAmountCurrencyExpr = xPath - .compile("InvoiceAmount/NetAmount/Amount/Currency/Codes/Code[@Type='cs']/text()"); - XPathExpression netAmountValueExpr = xPath.compile("InvoiceAmount/NetAmount/Amount/Value/text()"); - XPathExpression netAmountExchangeRateExpr = xPath - .compile("InvoiceAmount/NetAmount/Amount/ExchangeRate/text()"); - - XPathExpression netActivityTypeExpr = xPath - .compile("InvoiceAmount/ActivityType/Codes/Code[@Type='cs']/text()"); - - NodeList rowList = doc.getElementsByTagName("InvoiceRow"); - double _kurs = 0.0; - double _baseAmount = 0.0; - for (int i = 0; i < rowList.getLength(); i++) { - ItemCollection childItemCol = new ItemCollection(); - Node rowNode = rowList.item(i); - if (rowNode.getNodeType() == Node.ELEMENT_NODE) { - - // Get the FileNumber value - String fileNumber = (String) fileNumberExpr.evaluate(rowNode, XPathConstants.STRING); - childItemCol.setItemValue("datev.text", fileNumber); - - // speichere die Position in invoice.positions zur suche nach dem - // Positionskennzeichen - workitem.appendItemValue("invoice.positions", fileNumber); - - String currency = (String) netAmountCurrencyExpr.evaluate(rowNode, XPathConstants.STRING); - childItemCol.setItemValue("datev.wkz", currency); - // Umsatz - String umsatz = (String) netAmountValueExpr.evaluate(rowNode, XPathConstants.STRING); - double dUmsatz = Double.parseDouble(umsatz); - childItemCol.setItemValue("datev.umsatz", dUmsatz); - // Kurs - String _kursByRow = (String) netAmountExchangeRateExpr.evaluate(rowNode, XPathConstants.STRING); - if (_kursByRow != null && !_kursByRow.isEmpty()) { - Double dKurs = Double.parseDouble(_kursByRow); - _kurs = dKurs; - childItemCol.setItemValue("datev.kurs", dKurs); - // Basisumsatz - if (dKurs != 0) { - double basisUmsatz = dUmsatz / dKurs; - double gerundeterBasisUmsatz = Math.round(basisUmsatz * 100) / 100.0; - - _baseAmount = _baseAmount + gerundeterBasisUmsatz; - - childItemCol.setItemValue("datev.basisumsatz", gerundeterBasisUmsatz); - } - } - - String activityType = (String) netActivityTypeExpr.evaluate(rowNode, XPathConstants.STRING); - childItemCol.setItemValue("category", activityType); - - childItemCol.setItemValue("datev.shzeichen", "H"); - - childItems.add(childItemCol); - } - } - // Update invoice.rate und invoice.base.amount - workitem.setItemValue("invoice.rate", _kurs); - _baseAmount = Math.round(_baseAmount * 100) / 100.0; - workitem.setItemValue("invoice.base.amount", _baseAmount); - - } catch (XPathExpressionException e) { - logger.warning("Unable to read row : " + e.getMessage()); - - } - - // Set child items - InvoiceUtil.implodeChildList(workitem, childItems); - // invoice.text ist erste position - workitem.setItemValue("invoice.text", workitem.getItemValueString("invoice.positions")); - - } - /** * This method attache the pdf file and the XML file to the workitem. * The method removes the file content first form the xml tree and attache the @@ -710,7 +582,7 @@ public class CargosoftXMLEAkteImportService { * @param belegNummer * @return */ - private boolean alreadyImported(String belegNummer) { + protected boolean alreadyImported(String belegNummer) { String sQuery = "((type:workitem OR type:workitemarchive) AND $modelversion:steuerbescheid* AND invoice.number:\"" + belegNummer + "\")"; @@ -725,4 +597,84 @@ public class CargosoftXMLEAkteImportService { } return false; } + + /** + * This helper method reads the references starting with 'Row_' and creates a + * child Workitem for each row. + * + * The method assumes that the rows are starting with the type 'row_n_' where + * 'n' is the row number. + * We start with row 1 and read until we found more rows. + * + * Example: + * + *
{@code
+     *  ... 
+        
+        3591.340
+        0
+        IM-GCA-2408-116
+     * }
+ * + *

+ * The last filenumber text will be transferred into the item 'invoice.text' + * + * @param xml + * @return + * @throws Exception + */ + private void readXMLRows(Document doc, ItemCollection workitem) { + + int row = 1; + // Prepare XPath + XPathFactory xPathFactory = XPathFactory.newInstance(); + XPath xpath = xPathFactory.newXPath(); + try { + List childItems = new ArrayList<>(); + while (true) { + // XPath expression to find all Reference nodes starting with "row_" + logger.info("...read row " + row + "..."); + XPathExpression expr = xpath + .compile("/CargoSoftEFile/EFile/References/Reference[starts-with(@type, 'row_" + row + "_')]"); + NodeList nodeList = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); + if (nodeList != null && nodeList.getLength() > 0) { + logger.info("...debug1 found " + nodeList.getLength() + " matches"); + ItemCollection childItemCol = new ItemCollection(); + for (int i = 0; i < nodeList.getLength(); i++) { + Node node = nodeList.item(i); + String type = node.getAttributes().getNamedItem("type").getNodeValue(); + String value = node.getTextContent(); + + // Identify which field to set + if (type.contains("activity_type")) { + childItemCol.setItemValue("activity.type", value); + } else if (type.contains("amount")) { + try { + childItemCol.setItemValue("amount", Double.parseDouble(value)); + } catch (NumberFormatException e) { + logger.warning("Unable to parse amount: " + e.getMessage()); + } + } else if (type.contains("tax_code")) { + childItemCol.setItemValue("tax.code", value); + } else if (type.contains("cs_filenumber")) { + childItemCol.setItemValue("filenumber", value); + workitem.appendItemValue("invoice.positions", value); + } + } + childItems.add(childItemCol); + // continue with next row + row++; + } else { + // no more rows found + break; + } + } + + // Set child items + InvoiceUtil.implodeChildList(workitem, childItems); + } catch (XPathExpressionException e) { + logger.warning("Unable to read row : " + e.getMessage()); + + } + } } diff --git a/office-alexander-logistics-app/src/main/resources/imixs.properties b/office-alexander-logistics-app/src/main/resources/imixs.properties index 47ce238..fb391ca 100644 --- a/office-alexander-logistics-app/src/main/resources/imixs.properties +++ b/office-alexander-logistics-app/src/main/resources/imixs.properties @@ -2,9 +2,9 @@ # Imixs Lucene Plugin ############################## lucence.indexDir=${imixs-office.IndexDir} -index.fields=txtsearchstring,txtSubject,txtname,txtEmail,txtUserName,namCreator,txtworkflowgroup,txtworkflowstatus,txtWorkflowAbstract,txtWorkflowSummary,txtworkflowhistory,txtspacename,txtprocessname,_subject,_description,_name,_projectnumber,_projectname,_ordernumber,_contractnumber,datDueDate,txtcommentlog,htmldescription,htmldocumentation,dms,dms_names,invoice.number.stripped,_childitems,$file.names,_VENDOR_NAME,dbtr.number,cdtr.number,invoice.positions +index.fields=txtsearchstring,txtSubject,txtname,txtEmail,txtUserName,namCreator,txtworkflowgroup,txtworkflowstatus,txtWorkflowAbstract,txtWorkflowSummary,txtworkflowhistory,txtspacename,txtprocessname,_subject,_description,_name,_projectnumber,_projectname,_ordernumber,_contractnumber,datDueDate,txtcommentlog,htmldescription,htmldocumentation,dms,dms_names,invoice.number.stripped,_childitems,$file.names,_VENDOR_NAME,dbtr.number,cdtr.number,invoice.positions,invoice.atc.number index.fields.analyze=txtUsername -index.fields.noanalyze=type,$UniqueIDRef,$created,$modified,$ModelVersion,$participants,namCreator,$ProcessID,datDate,txtWorkflowGroup,txtemail, datdate, datfrom, datto, numsequencenumber,sequencenumber,dms_count,invoice.number,invoice.number.stripped,invoice.date,invoice.duedate,taxonomy.verteilung.stop,taxonomy.sachpruefung.stop,taxonomy.verteilung.start,taxonomy.sachpruefung.start,taxonomy.buchhaltung.start,taxonomy.buchhaltung.stop,dbtr.number,cdtr.number,payment.date,invoice.total,invoice.currency,invoice.positions,$lasteventdate,payment.type,cdtr.name,document.company +index.fields.noanalyze=type,$UniqueIDRef,$created,$modified,$ModelVersion,$participants,namCreator,$ProcessID,datDate,txtWorkflowGroup,txtemail, datdate, datfrom, datto, numsequencenumber,sequencenumber,dms_count,invoice.number,invoice.number.stripped,invoice.date,invoice.duedate,taxonomy.verteilung.stop,taxonomy.sachpruefung.stop,taxonomy.verteilung.start,taxonomy.sachpruefung.start,taxonomy.buchhaltung.start,taxonomy.buchhaltung.stop,dbtr.number,cdtr.number,payment.date,invoice.total,invoice.currency,invoice.positions,$lasteventdate,payment.type,cdtr.name,document.company,invoice.atc.number index.fields.store=process.name,txtProcessName,txtWorkflowImageURL,payment.date,invoice.number,invoice.date,invoice.duedate index.fields.category=space.name,space.ref,taxonomy.verteilung.stop.by,taxonomy.sachpruefung.stop.by,taxonomy.buchhaltung.stop.by office.search.noanalyze=invoice.number,invoice.number.stripped,invoice.positions diff --git a/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_details.xhtml b/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_details.xhtml new file mode 100644 index 0000000..e2d4357 --- /dev/null +++ b/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_details.xhtml @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PositionsnummerArtSteuerBetrag
+ #{row.item['filenumber']} + + #{row.item['activity.type']} + + #{row.item['tax.code']} + + + + + +
+ + +
+ + + + + +
\ No newline at end of file diff --git a/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_invoices.xhtml b/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_invoices.xhtml new file mode 100644 index 0000000..9254b22 --- /dev/null +++ b/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_steuerbescheid_invoices.xhtml @@ -0,0 +1,50 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RechnungStatus#{message.modified}
+ + #{invoice.item['$workflowsummary']} + + + #{invoice.item['$workflowstatus']} + + + #{message.by} #{userController.getUserName(invoice.item['$editor'])} +
+
+ + + + + +
\ No newline at end of file diff --git a/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_zollliste_details.xhtml b/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_zollliste_details.xhtml deleted file mode 100644 index fa53c3b..0000000 --- a/office-alexander-logistics-app/src/main/webapp/pages/workitems/forms/alexander/section_zollliste_details.xhtml +++ /dev/null @@ -1,97 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PositionsnummerATC-NummerAnmelderZOLL (ER)EUST (ER)Fällig wannEingangsrechnungStatus
- #{invoice.item['invoice.text']} - - #{invoice.item['invoice.atc']} - - #{invoice.item['dbtr.name']} - - #{invoice.item['invoice.zoll']} - - #{invoice.item['invoice.eust']} - - #{invoice.item['invoice.number']} -
- - - - Summary
- - -
- - - - - -
\ No newline at end of file diff --git a/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/EAkteImportTester.java b/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/EAkteImportTester.java new file mode 100644 index 0000000..cf1a458 --- /dev/null +++ b/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/EAkteImportTester.java @@ -0,0 +1,116 @@ +package com.alexanderlogistics.xml; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.io.IOException; +import java.io.InputStream; +import java.util.HashMap; +import java.util.List; + +import javax.xml.transform.TransformerException; +import javax.xml.xpath.XPathExpressionException; + +import org.imixs.workflow.ItemCollection; +import org.imixs.workflow.engine.DocumentService; +import org.imixs.workflow.exceptions.AccessDeniedException; +import org.imixs.workflow.exceptions.ModelException; +import org.imixs.workflow.exceptions.PluginException; +import org.imixs.workflow.exceptions.ProcessingErrorException; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnitRunner; + +import com.alexanderlogistics.InvoiceUtil; +import com.alexanderlogistics.KreditorDebitorService; +import com.alexanderlogistics.mahnlauf.MahnlaufService; + +/** + * Testet den Import Vorgang anhand einer Cargosoft XML Datei + * + * + * + * @author rsoika + */ +@RunWith(MockitoJUnitRunner.class) +public class EAkteImportTester { + + @Spy + @InjectMocks + private CargosoftXMLEAkteImportService service; + + @Mock + private DocumentService documentService; + + @Mock + private KreditorDebitorService kreditorDebitorService; + + @Mock + private MahnlaufService mahnlaufService; + + @Before + public void setUp() { + // Mock protected Methode 'alreadyImported' -> always false + Mockito.when(service.alreadyImported(Mockito.anyString())).thenReturn(false); + } + + /** + * Ein Einfacher test + * + * @throws TransformerException + * @throws XPathExpressionException + * @throws ModelException + * @throws PluginException + * @throws ProcessingErrorException + * @throws AccessDeniedException + * + * @throws Exception + */ + @Test + public void testEAkteBasic() throws Exception { + + ItemCollection source = new ItemCollection(); + String fileName = "Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864_DEBUG.xml"; + byte[] xmlContent = readTestFile("cargosoft/" + fileName); + assertNotNull(xmlContent); + + // Act + ItemCollection result = service.createWorkitem(source, fileName, xmlContent, new HashMap<>()); + + // Assert + assertNotNull(result); + assertEquals("001", result.getItemValueString("mandant.id")); + + // test Rows + List rows = InvoiceUtil.explodeChildList(result); + assertNotNull(rows); + assertEquals(2, rows.size()); + ItemCollection row1 = rows.get(0); + ItemCollection row2 = rows.get(1); + assertEquals("LA-ZEL-2403-004", row1.getItemValueString("filenumber")); + assertEquals("LA-ZEL-2403-00", row2.getItemValueString("filenumber")); + assertEquals("ZOLL", row1.getItemValueString("activity.type")); + assertEquals("EUST", row2.getItemValueString("activity.type")); + + } + + /** + * Hilfsmethode zum einlesen einer xml test datei + * + * @return + * @throws IOException + */ + private byte[] readTestFile(String filename) throws IOException { + // Load the file from the resources folder + ClassLoader classLoader = getClass().getClassLoader(); + InputStream inputStream = classLoader.getResourceAsStream(filename); + byte[] data = inputStream.readAllBytes(); + inputStream.close(); + return data; + } +} diff --git a/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/InvoiceImportTester.java b/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/InvoiceImportTester.java index 0fc11c7..c4c8912 100644 --- a/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/InvoiceImportTester.java +++ b/office-alexander-logistics-app/src/test/java/com/alexanderlogistics/xml/InvoiceImportTester.java @@ -119,6 +119,7 @@ public class InvoiceImportTester { assertNotNull(result); assertEquals("001", result.getItemValueString("mandant.id")); assertEquals("ATC400012650820242452", result.getItemValueString("invoice.atc.number")); + assertEquals(3752.95, result.getItemValueDouble("invoice.total"), 0.0); // test Rows List rows = InvoiceUtil.explodeChildList(result); @@ -129,16 +130,18 @@ public class InvoiceImportTester { assertEquals("EUST", row1.getItemValueString("category")); assertEquals("EUST", row1.getItemValueString("BillingCode")); // test BillingText - List billingTextList = row1.getItemValue("BillingText"); assertEquals(2, billingTextList.size()); // test ATC Number assertEquals("ATC400012650820242452", row1.getItemValueString("atc.number")); + // Umsatz + assertEquals(3591.34, row1.getItemValueDouble("datev.umsatz"), 0.0); ItemCollection row2 = rows.get(1); assertEquals("IM-GCA-2408-116", row2.getItemValueString("datev.text")); assertEquals("SONST", row2.getItemValueString("category")); - + // Umsatz + assertEquals(161.61, row2.getItemValueDouble("datev.umsatz"), 0.0); } /** @@ -151,13 +154,7 @@ public class InvoiceImportTester { // Load the file from the resources folder ClassLoader classLoader = getClass().getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream(filename); - - // Convert the InputStream to a String - // String xmlContent = new String(inputStream.readAllBytes(), - // StandardCharsets.UTF_8); - byte[] data = inputStream.readAllBytes(); - // Optional: Close the InputStream inputStream.close(); return data; } diff --git a/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864.xml b/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864.xml new file mode 100644 index 0000000..03d5dbf --- /dev/null +++ b/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864.xml @@ -0,0 +1,64 @@ + + + + CARGOSOFT + ATLSTB + 20240806164256864 + + 2024-08-06T16:42:56 + + + 2023.2g + ${build.version.number} + + + + + + 2024-08-06T09:55:54 + + ATLAS + STEUERBESCHEID NEU + + + + 1 + Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452.pdf + application/pdf + + 2024-08-07T02:13:27 + + 11FC8B85115554F79215A3138FDBF7C + 78362 + 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 + + + + + + 001 + 254038 + LR + + EUR + + 3591.34 + 161.34 + + ATC400012650820242452 + 202408 + 20240806000000 + ATLAS Steuerbescheid + ZOLL + 3591.340 + 0 + LA-ZEL-2403-004 + EUST + 91.340 + 0 + LA-ZEL-2403-00 + + + diff --git a/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864_DEBUG.xml b/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864_DEBUG.xml new file mode 100644 index 0000000..da3816b --- /dev/null +++ b/office-alexander-logistics-app/src/test/resources/cargosoft/Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452-_20240806164256864_DEBUG.xml @@ -0,0 +1,61 @@ + + + + CARGOSOFT + ATLSTB + 20240806164256864 + + 2024-08-06T16:42:56 + + + 2023.2g + ${build.version.number} + + + + + + 2024-08-06T09:55:54 + + ATLAS + STEUERBESCHEID NEU + + + + 1 + Abgabenbescheid-IM-GCA-2408-116N-001-ATC400012650820242452.pdf + application/pdf + + 2024-08-07T02:13:27 + + 11FC8B85115554F79215A3138FDBF7C + 78362 + + + + + 001 + 254038 + LR + + EUR + + 3591.34 + 161.34 + + ATC400012650820242452 + 202408 + 20240806000000 + ATLAS Steuerbescheid + ZOLL + 3591.340 + 0 + LA-ZEL-2403-004 + EUST + 91.340 + 0 + LA-ZEL-2403-00 + + + \ No newline at end of file diff --git a/workflow/rechnungsausgang-de-1.0.10.bpmn b/workflow/rechnungsausgang-de-1.0.10.bpmn new file mode 100644 index 0000000..1b983d7 --- /dev/null +++ b/workflow/rechnungsausgang-de-1.0.10.bpmn @@ -0,0 +1,4101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + +<itemvalue>$workflowstatus</itemvalue> + +]]> + + + In case you have already made the payment, please disregard this notice. If you require any information regarding your account, please do not hesitate to contact us.

+

Thank you for your cooperation.

+

 

+

Kind regards
Alexander Global Logistics GmbH

+ +]]> + + + + + + + + + + + + + + Task_2 + ExclusiveGateway_1 + StartEvent_1 + IntermediateCatchEvent_6 + EventBasedGateway_1 + IntermediateCatchEvent_13 + IntermediateThrowEvent_11 + IntermediateThrowEvent_8 + IntermediateCatchEvent_1 + IntermediateCatchEvent_5000-20 + Task_8 + Task_6 + Task_5 + IntermediateCatchEvent_23 + IntermediateCatchEvent_27 + EndEvent_1 + EndEvent_3 + EndEvent_2 + IntermediateCatchEvent_3 + ExclusiveGateway_5 + IntermediateCatchEvent_18 + IntermediateCatchEvent_17 + IntermediateCatchEvent_2 + IntermediateCatchEvent_5 + + task_dzaodw + event_Ti0jRg + event_BwVRZg + textAnnotation_cgK8ew + event_nAhsEg + + + IntermediateCatchEvent_22 + Task_7 + Task_1 + IntermediateThrowEvent_12 + Task_3 + IntermediateCatchEvent_4 + EventBasedGateway_3 + EventBasedGateway_4 + IntermediateThrowEvent_1 + IntermediateCatchEvent_29 + IntermediateCatchEvent_9 + IntermediateCatchEvent_21 + Task_4 + IntermediateCatchEvent_14 + ExclusiveGateway_3 + IntermediateThrowEvent_6 + IntermediateCatchEvent_20 + IntermediateCatchEvent_10 + ExclusiveGateway_4 + IntermediateCatchEvent_15 + IntermediateCatchEvent_19 + IntermediateCatchEvent_8 + IntermediateCatchEvent_25 + EventBasedGateway_5 + IntermediateCatchEvent_5005-10 + IntermediateCatchEvent_28 + IntermediateThrowEvent_10 + IntermediateCatchEvent_11 + IntermediateCatchEvent_24 + IntermediateCatchEvent_26 + IntermediateThrowEvent_9 + Task_5005 + IntermediateThrowEvent_7 + IntermediateThrowEvent_4 + IntermediateThrowEvent_5 + IntermediateCatchEvent_16 + + task_Y7VnSQ + event_hICMqQ + task_t0lAhQ + event_OzrjzA + DataObject_2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home]]> + + + + + + + + + + + + false + + + + + + + + + + + + + + + + + + + SequenceFlow_22 + SequenceFlow_27 + + + + SequenceFlow_0 + SequenceFlow_21 + SequenceFlow_20 + SequenceFlow_33 + + + + + + + SequenceFlow_0 + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_38 + SequenceFlow_36 + SequenceFlow_24 + sequenceFlow_IKuaHQ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_38 + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + true + + + + + + + + + + + + + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_33 + SequenceFlow_14 + SequenceFlow_15 + SequenceFlow_39 + SequenceFlow_37 + SequenceFlow_22 + sequenceFlow_btGV1A + sequenceFlow_dexsEw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + + SequenceFlow_20 + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_52 + SequenceFlow_11 + SequenceFlow_47 + sequenceFlow_hfxTSw + + + SequenceFlow_47 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mahnwesen]]> + + + + + + + + + + + + false + + + + SequenceFlow_21 + + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_27 + SequenceFlow_4 + SequenceFlow_18 + SequenceFlow_35 + SequenceFlow_34 + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_59 + SequenceFlow_31 + SequenceFlow_1 + SequenceFlow_44 + SequenceFlow_69 + + + SequenceFlow_61 + + + + SequenceFlow_39 + SequenceFlow_17 + SequenceFlow_65 + SequenceFlow_13 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_52 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_59 + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_3 + SequenceFlow_29 + SequenceFlow_68 + sequenceFlow_1KoKlw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + mahnlauf-de-1.0 +1000 +100 +/pages/workitems/workitem.jsf?id=dunning.ref +]]> + + + + + + + + + + + + false + + + + + + + + + + + + SequenceFlow_4 + + + DataOutput_1 + + + DataOutput_1 + + + + + SequenceFlow_18 + SequenceFlow_25 + SequenceFlow_64 + SequenceFlow_9 + + sequenceFlow_oglT1w + + + + + + + + + + + cdtr.name invoice.number]]> + + + + + + + + + cdtr.name +Rechnungsnummer: invoice.number +Betrag: invoice.total invoice.currency + + +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 +2. Dunning +]]> + + + + + + + + + + + + false + + + + + + + + SequenceFlow_67 + SequenceFlow_29 + + + + + + + + + + + + + + + + cdtr.name invoice.number]]> + + + + + + + + + cdtr.name +Rechnungsnummer: invoice.number +Betrag: invoice.total invoice.currency + + +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 +Last Dunning]]> + + + + + + + + + + + + false + + + + + + + + SequenceFlow_30 + SequenceFlow_31 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + + + + SequenceFlow_42 + SequenceFlow_8 + + + + + + + + + + SequenceFlow_42 + + + + + SequenceFlow_50 + + + + + + + + SequenceFlow_7 + + + + + + + + SequenceFlow_8 + SequenceFlow_10 + SequenceFlow_12 + + + + + + + + + invoice.saldo]]> + + + + + + SequenceFlow_10 + SequenceFlow_11 + + + + (parseFloat(workitem['invoice.saldo'][0]) == parseFloat('0.0')) + + + + + + + + + invoice.saldo]]> + + + + + + SequenceFlow_12 + SequenceFlow_14 + + + + + + + + + + SequenceFlow_16 + + + + + + + + SequenceFlow_17 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home]]> + + + + + + + + + + + + false + + + + + SequenceFlow_34 + SequenceFlow_15 + + + + + + SequenceFlow_25 + + + + + + + + + + + + + + + + + + + cdtr.name invoice.number]]> + + + + + + + + + cdtr.name +Rechnungsnummer: invoice.number +Betrag: invoice.total invoice.currency + + +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + 7 +1. Dunning + +]]> + + + + + + + + + + + + false + + + + + + + + SequenceFlow_35 + SequenceFlow_37 + SequenceFlow_36 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + mahnlauf-de-1.0 +1000 +100 +/pages/workitems/workitem.jsf?id=dunning.ref +]]> + + + + + + + + + + + + false + + + + + + + + + + + + SequenceFlow_41 + + + DataOutput_3 + + + DataOutput_3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + mahnlauf-de-1.0 +1000 +100 +/pages/workitems/workitem.jsf?id=dunning.ref +]]> + + + + + + + + + + + + false + + + + + + + + + + + + + + DataOutput_4 + + + DataOutput_4 + + + sequenceFlow_ZD07Xw + + + + + + + + cdtr.name invoice.number]]> + + + + + + + + + cdtr.name +Rechnungsnummer: invoice.number +Betrag: invoice.total invoice.currency + + +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5]]> + + + + + + + + + + + + false + + + + + + + + SequenceFlow_1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + sequenceFlow_IKuaHQ + sequenceFlow_U0JMVg + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + sequenceFlow_1KoKlw + sequenceFlow_KaO3rw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home + + invoice.reminder + @daily +]]> + + + + + + + + + + + + true + + + + + + + + + + + + + + + + + + + SequenceFlow_44 + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_49 + SequenceFlow_53 + SequenceFlow_57 + SequenceFlow_54 + + + + + Wollen Sie den Vorgang wirklich an Inkasso leiten? +/pages/workitems/workitem.jsf?id=debtcollection.ref]]> + + + + + + + + + SequenceFlow_40 + SequenceFlow_49 + + + DataOutput_5 + + + DataOutput_5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_53 + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_60 + SequenceFlow_61 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + + + + SequenceFlow_54 + SequenceFlow_55 + + + + SequenceFlow_55 + SequenceFlow_56 + SequenceFlow_58 + + + + + + invoice.saldo]]> + + + + + + SequenceFlow_58 + SequenceFlow_60 + + + + + + invoice.saldo]]> + + + + + + SequenceFlow_56 + SequenceFlow_57 + + + + + + + + + + + + + + + + (parseFloat(workitem['invoice.saldo'][0]) == parseFloat('0.0')) + + + + + + + + + + SequenceFlow_40 + + + + + + + + SequenceFlow_62 + + + + + + + + SequenceFlow_63 + + + + + + + + SequenceFlow_64 + + + + + + + + SequenceFlow_65 + + + + + + + + SequenceFlow_24 + SequenceFlow_50 + SequenceFlow_63 + SequenceFlow_67 + + sequenceFlow_Z2zL5g + + + + + + SequenceFlow_68 + SequenceFlow_30 + SequenceFlow_7 + SequenceFlow_62 + + sequenceFlow_i1zqtw + + + + + + SequenceFlow_69 + SequenceFlow_16 + SequenceFlow_70 + + + + + + + SequenceFlow_70 + + + + + + + + + + + + + + + + _subject]]> + + + + + + + + + _amount (Brutto € _amount_brutto) +_description]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home]]> + + + + + + + + + + + + false + + + + + + + SequenceFlow_9 + SequenceFlow_13 + SequenceFlow_5 + + + + + + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_5 + SequenceFlow_19 + + + SequenceFlow_19 + + + + + + + + + + + + + Trigger über ZahlungseingangsSaldoAdapter + + + + + + + Triggered by MahnlaufExecuteAdapter + +Wiedervorlage wird um 7 bzw. 5 Tage erhöht + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_38 + SequenceFlow_36 + SequenceFlow_41 + SequenceFlow_24 + sequenceFlow_U0JMVg + sequenceFlow_Z2zL5g + SequenceFlow_41 + sequenceFlow_30tT9w + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_38 + sequenceFlow_30tT9w + + + + + + + + txtlastcomment]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + SequenceFlow_3 + SequenceFlow_29 + SequenceFlow_68 + sequenceFlow_KaO3rw + sequenceFlow_i1zqtw + sequenceFlow_Giue7g + sequenceFlow_ZD07Xw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ]]> + + + + + + + + + + + + false + + + + SequenceFlow_3 + sequenceFlow_Giue7g + + + + + + + + + + + + + + + + + + + + txtlastcomment]]> + + + + + + + + + true + + + + + + + + + + + + + + + _imginvoice.type invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + + + $workflowgroup - $workflowstatus]]> + sequenceFlow_mDjqOA + sequenceFlow_ZUVE9w + + + + sequenceFlow_mDjqOA + + + + + + + + + + + + + + _subject]]> + + + + + + + + + _amount (Brutto € _amount_brutto) +_description]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + home]]> + + + + + + + + + + + + false + + + + + + + SequenceFlow_13 + sequenceFlow_btGV1A + sequenceFlow_ZUVE9w + sequenceFlow_oglT1w + + + + + + + + + + + + + + + + + + invoice.saldo]]> + + + + + + + sequenceFlow_hfxTSw + sequenceFlow_dexsEw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/workflow/steuerbescheid-de-1.0.0.bpmn b/workflow/steuerbescheid-de-1.0.0.bpmn index dac3b2f..f4bd0e5 100644 --- a/workflow/steuerbescheid-de-1.0.0.bpmn +++ b/workflow/steuerbescheid-de-1.0.0.bpmn @@ -28,6 +28,7 @@ + true @@ -88,54 +89,21 @@ th { font-weight: bold;} IntermediateCatchEvent_3 Task_4 EndEvent_3 - Task_2 - IntermediateCatchEvent_2 - IntermediateCatchEvent_8 DataObject_2 event_XJbC5A textAnnotation_HwSKqQ event_9fS4uw + event_mPDOzA + gateway_u86UTw + gateway_5riVig + gateway_mga6sg sequenceFlow_M5IK7w - - - - invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> - - - true - - - - - - - - - - - - - - - - - - - - - - - $workflowgroup - $workflowstatus]]> - SequenceFlow_1 - SequenceFlow_17 - sequenceFlow_l0egag - SequenceFlow_19 @@ -143,7 +111,7 @@ th { font-weight: bold;} - invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> + invoice.number invoice.booking_text invoice.atc.number]]> @@ -176,13 +144,10 @@ th { font-weight: bold;} $workflowgroup - $workflowstatus]]> sequenceFlow_EzmiPA sequenceFlow_rbVgQA - sequenceFlow_GN53Kg + sequenceFlow_J0GjVg - - invoice.number dbtr.number dbtr.name (invoice.currency invoice.total) ]]> - true @@ -201,45 +166,17 @@ th { font-weight: bold;} + + invoice.number invoice.booking_text invoice.atc.number]]> + $workflowgroup - $workflowstatus]]> - SequenceFlow_18 SequenceFlow_19 + sequenceFlow_oRy3qw - - - - - - - home]]> - - - SequenceFlow_17 - SequenceFlow_18 - - - - - - - - - - - - - - - SequenceFlow_1 - - - - - @@ -268,22 +205,33 @@ th { font-weight: bold;} - - - + + + - - + + + + + + + + + + + - + + + ]]> @@ -300,15 +248,13 @@ th { font-weight: bold;} - sequenceFlow_EzmiPA - sequenceFlow_l0egag + sequenceFlow_DzOb8A + sequenceFlow_hLkSLA + sequenceFlow_oRy3qw - + - - - @@ -332,9 +278,75 @@ Wird täglich über die DATEV OP-Liste importiert]]> - + + + + + + + + + + + + + + + + + + + + + + + + + sequenceFlow_tpBldQ + sequenceFlow_lrR0DQ + + + + sequenceFlow_lrR0DQ + sequenceFlow_KOaBSw + sequenceFlow_hLkSLA + + + + sequenceFlow_EzmiPA + sequenceFlow_tpBldQ + sequenceFlow_DzOb8A + + + + + + + + + + + + + sequenceFlow_GN53Kg + sequenceFlow_J0GjVg + sequenceFlow_KOaBSw + + + + + + + + + + + + + + @@ -345,23 +357,20 @@ Wird täglich über die DATEV OP-Liste importiert]]> - + - + - + - + - + - - - @@ -375,99 +384,120 @@ Wird täglich über die DATEV OP-Liste importiert]]> - - - - - - - - - - - - - + - + - + - + - + - - - - - - - - - - - - - - - - - + + - - - - + + + - + - + - - - - - - - + + + - + - + - - - + + - - + + - - - + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +