ValidationController: Korrekturen

WEBSERVICES/ZUGFeRDRESTService/Controllers/ValidationController.cs

@@ -1,18 +1,18 @@
-using System;
+using DigitalData.Modules.Interfaces;
-using System.IO;
-using System.Linq;
-using System.Collections.Generic;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
-using DigitalData.Modules.Interfaces;
-using static DigitalData.Modules.Interfaces.Exceptions;
-using static DigitalData.Modules.Interfaces.ZUGFeRDInterface;
-using static DigitalData.Modules.Interfaces.PropertyValues;
-using System.Data.SqlClient;
 using Microsoft.Extensions.Configuration;
-using System.Xml.Linq;
+using System;
-using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.IO;
+using System.Linq;
 using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using static DigitalData.Modules.Interfaces.Exceptions;
+using static DigitalData.Modules.Interfaces.PropertyValues;
+using static DigitalData.Modules.Interfaces.ZUGFeRDInterface;
 
 namespace ZUGFeRDRESTService.Controllers
 {
@@ -26,6 +26,29 @@ namespace ZUGFeRDRESTService.Controllers
         public const string ADDED_WHO = "ZUGFeRD REST Service";
         public const string MESSAGEID_DOMAIN = "test.wisag.de";
 
+        public const string VALIDATION_SUCCESS = "VALIDATION SUCCESS";
+        public const string REFERENCES_Rejection_30001 = "REFERENCES_Rejection_30001";
+        public const string REFERENCES_Rejection_30002 = "REFERENCES_Rejection_30002";
+        public const string REFERENCES_Rejection_30003_1 = "REFERENCES_Rejection_30003_1";
+        public const string REFERENCES_Rejection_30003_2 = "REFERENCES_Rejection_30003_2";
+        public const string REFERENCES_Rejection_30003_3 = "REFERENCES_Rejection_30003_3";
+        public const string REFERENCES_Rejection_30004_1 = "REFERENCES_Rejection_30004_1";
+        public const string REFERENCES_Rejection_30004_2 = "REFERENCES_Rejection_30004_2";
+        public const string REFERENCES_Rejection_30004_3 = "REFERENCES_Rejection_30004_3";
+        public const string REFERENCES_Rejection_30005_1 = "REFERENCES_Rejection_30005_1";
+        public const string REFERENCES_Rejection_30005_2 = "REFERENCES_Rejection_30005_2";
+        public const string REFERENCES_Rejection_30006 = "REFERENCES_Rejection_30006";
+        public const string REFERENCES_Rejection_30007 = "REFERENCES_Rejection_30007";
+        public const string REFERENCES_Rejection_30007_1 = "REFERENCES_Rejection_30007_1";
+        public const string REFERENCES_Rejection_30008 = "REFERENCES_Rejection_30008";
+        public const string REFERENCES_Rejection_30009 = "REFERENCES_Rejection_30009";
+        public const string REFERENCES_Rejection_30010 = "REFERENCES_Rejection_30010";
+        public const string REFERENCES_Rejection_30011 = "REFERENCES_Rejection_30011";
+        public const string REFERENCES_Rejection_30012 = "REFERENCES_Rejection_30012";
+        public const string AMOUNT_CALC_REJECTION = "AMOUNT_CALC_REJECTION";
+
+        private List<string> _ValidationErrors;
+
         private const int MAX_FILE_SIZE_DEFAULT = 25;
 
         private readonly ZUGFeRDInterface _zugferd;
@@ -83,6 +106,28 @@ namespace ZUGFeRDRESTService.Controllers
 
             _RecjectionMessageList = database.GetRejectionMessageList();
 
+            _ValidationErrors = new List<String>() {
+                REFERENCES_Rejection_30001,
+                REFERENCES_Rejection_30002,
+                REFERENCES_Rejection_30003_1,
+                REFERENCES_Rejection_30003_2,
+                REFERENCES_Rejection_30003_3,
+                REFERENCES_Rejection_30004_1,
+                REFERENCES_Rejection_30004_2,
+                REFERENCES_Rejection_30004_3,
+                REFERENCES_Rejection_30005_1,
+                REFERENCES_Rejection_30005_2,
+                REFERENCES_Rejection_30006,
+                REFERENCES_Rejection_30007,
+                REFERENCES_Rejection_30007_1,
+                REFERENCES_Rejection_30008,
+                REFERENCES_Rejection_30009,
+                REFERENCES_Rejection_30010,
+                REFERENCES_Rejection_30011,
+                REFERENCES_Rejection_30012,
+                AMOUNT_CALC_REJECTION
+            };
+
             _logger.Debug("Validation Controller initialized!");
         }
 
@@ -165,7 +210,6 @@ namespace ZUGFeRDRESTService.Controllers
 
                     if (oFileSizeIsOK == false)
                     {
-                        //throw new ZUGFeRDExecption(ErrorType.FileTooBig, "FileTooBig");
                         throw new ZUGFeRDExecption(ErrorCodes.FileSizeLimitReachedException, _MaxFileSizeInMegabytes.ToString(), string.Empty, "FileTooBig");
                     }
 
@@ -174,6 +218,7 @@ namespace ZUGFeRDRESTService.Controllers
                     if (file.FileName.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
                     {
                         oZugferdResult = _zugferd.ExtractZUGFeRDFileWithGDPicture(oStream);
+                        oZugferdResult.ReceiptFileType = "PDF";
                     }
                     else if (file.FileName.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
                     {
@@ -185,6 +230,7 @@ namespace ZUGFeRDRESTService.Controllers
                         };
 
                         oZugferdResult = _zugferd.SerializeZUGFeRDDocument(oResult);
+                        oZugferdResult.ReceiptFileType = "XML";
                     }
 
                     _logger.Info("Detected Specification was: [{0}]", oZugferdResult.Specification);
@@ -194,7 +240,6 @@ namespace ZUGFeRDRESTService.Controllers
                     if (oFilteredPropertyMap.Count == 0)
                     {
                         _logger.Warn("No properties found in property map for specification [{0}]", oZugferdResult.Specification);
-                        //throw new ZUGFeRDExecption(ErrorType.UnsupportedFormat, "Unsupported Format");
                         throw new ZUGFeRDExecption(ErrorCodes.UnsupportedFerdException, "Unsupported Format");
                     }
                     else
@@ -219,24 +264,21 @@ namespace ZUGFeRDRESTService.Controllers
 
                     if (oPropertyResult.MissingProperties.Count > 0)
                     {
-                        //throw new ZUGFeRDExecption(ErrorType.MissingProperties, "Missing Properties");
                         throw new ZUGFeRDExecption(ErrorCodes.MissingValueException, "Missing Properties");
                     }
 
-                    Tuple<bool, string> oValidateResult = ValidateBuyerOrderReference(oPropertyResult.ValidProperties);
+                    Tuple<bool, string> oValidateResult = ValidateBuyerOrderReference(oPropertyResult.ValidProperties, oZugferdResult);
 
                     if (oValidateResult.Item1 == false)
                     {
-                        //throw new ZUGFeRDExecption(ErrorType.UnknownError, "Unknown Error");
                         throw new ZUGFeRDExecption(ErrorCodes.UnhandledException, "Unknown Error");
                     }
 
                     string oValidateResultString = oValidateResult.Item2;
 
-                    if (oValidateResultString == "ALL REFERENCES CHECKED POSITIVE")
+                    if (oValidateResultString.Equals(VALIDATION_SUCCESS))
                     {
                         string oMessage = "Die hochgeladene Datei ist eine gültige-ZUGFeRD Rechnung";
-
                         _logger.Info($"Responding with message: [{oMessage}]");
 
                         return new ValidationResponse()
@@ -244,10 +286,10 @@ namespace ZUGFeRDRESTService.Controllers
                             status = RESPONSE_OK,
                             message = oMessage
                         };
-                    } else
+                    }
+                    else
                     {
                         string oMessage = oValidateResultString;
-
                         _logger.Info($"Responding with message: [{oMessage}]");
 
                         return new ValidationResponse()
@@ -256,7 +298,8 @@ namespace ZUGFeRDRESTService.Controllers
                             message = oMessage
                         };
                     }
-                };
+                }
+                
             }
             catch (ZUGFeRDExecption ex)
             {
@@ -315,6 +358,8 @@ namespace ZUGFeRDRESTService.Controllers
             }
             catch (ValidationException ex)
             {
+                _logger.Error(ex);
+
                 var rejectionCodeNumber = this.GetRejectionCodeNumber(ex.ErrorCode);
 
                 // Der gesamte Ausgabetext muss anhand des ErrorCodes ermittelt werden 
@@ -348,20 +393,20 @@ namespace ZUGFeRDRESTService.Controllers
             }
         }
 
-        private Tuple<bool, string> ValidateBuyerOrderReference(List<ValidProperty> pProperties)
+        /// <summary>
+        /// Hier wird eine externe Prozedur gerufen, PRCUST_INV_CHECK_FROM_PORTAL,
+        /// die das Ergebnis der Referenzpruefung liefert.
+        /// </summary>
+        private Tuple<bool, string> ValidateBuyerOrderReference(List<ValidProperty> pProperties, ZugferdResult pZugferdResult)
         {
             var oMessageId = GetMessageId();
             _logger.Debug("Created new MessageId: [{0}]", oMessageId);
 
             _logger.Debug("Inserting properties into database.");
-            foreach (var oItem in pProperties)
+            if (!BulkInsertDataToDatabase(oMessageId, pProperties, pZugferdResult))
             {
-                var oResult = InsertPropertyMap(oItem, oMessageId);
+                _logger.Warn("Error while Inserting properties into database!");
-
+                return new Tuple<bool, string>(false, string.Empty);
-                if (oResult == false)
-                {
-                    _logger.Warn("Error while inserting the Property [{0}] into the Database!", oItem.Description);
-                }
             }
 
             _logger.Debug("Calling validation prodecure.");
@@ -377,6 +422,64 @@ namespace ZUGFeRDRESTService.Controllers
                 if (_database.MSSQL.ExecuteNonQuery(oCommand))
                 {
                     string oReturnValue = (string)oCommand.Parameters["@MSG_OUTPUT"].Value;
+
+                    _logger.Debug("Validation Result message from DB: " + oReturnValue);
+
+                    if (oReturnValue.Equals("ALL REFERENCES CHECKED POSITIVE", StringComparison.OrdinalIgnoreCase))
+                    {
+                        _logger.Debug("Validation Success");
+                        oReturnValue = VALIDATION_SUCCESS;
+                    }
+                    else
+                    {
+                        // Gehe durch die möglichen Fehler, und ermittle Rückmeldung
+                        foreach (var oRejectionItem in _ValidationErrors)
+                        {
+                            if (oReturnValue.Contains(oRejectionItem, StringComparison.OrdinalIgnoreCase))
+                            {
+                                _logger.Debug("oRejectionItem match: " + oRejectionItem);
+
+                                var oDbMessage = this.GetRejectionMessage(oRejectionItem);
+
+                                //Jetzt müssen ggf Platzhalter ersetzt werden.
+                                if (oRejectionItem == REFERENCES_Rejection_30003_2) 
+                                {
+                                    string oReplaceParam1 = GetReplaceText1_30003_2(pProperties);
+                                    string oReplaceParam2 = GetReplaceText2_30003_2(pProperties);
+
+                                    oReturnValue = oDbMessage.Replace("@REPLACE_PARAM1", oReplaceParam1);
+                                    oReturnValue = oReturnValue.Replace("@REPLACE_PARAM2", oReplaceParam2);
+
+                                }
+                                else if (oRejectionItem == REFERENCES_Rejection_30003_3)
+                                {
+                                    string oReplaceParam1 = GetReplaceText1_30003_3(pProperties);
+
+                                    oReturnValue = oDbMessage.Replace("@REPLACE_PARAM1", oReplaceParam1);
+                                }
+                                else if (oRejectionItem == REFERENCES_Rejection_30001)
+                                {
+                                    // TODO - BUKR?
+                                    oReturnValue = oDbMessage.Replace("@REPLACE_PARAM1", "9999"); 
+                                }
+                                else
+                                {
+                                    oReturnValue = oDbMessage;
+                                }
+
+                                // Der REJECTION-Code wird in alle Meldungen eingefügt.
+                                if (!string.IsNullOrEmpty(oRejectionItem) && oReturnValue.Contains("@REJECTION_CODE", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    var rejectionCodeNumber = GetRejectionCodeNumber(oRejectionItem);
+                                    oReturnValue = Regex.Replace(oReturnValue, "@REJECTION_CODE", "Ablehnungscode: " + rejectionCodeNumber, RegexOptions.IgnoreCase);
+                                }
+
+                                break;
+                            }
+                        }
+                    }
+
+                    _logger.Debug("Validation terminal Result message: " + oReturnValue);
                     return new Tuple<bool, string>(true, oReturnValue);
 
                 }
@@ -393,65 +496,327 @@ namespace ZUGFeRDRESTService.Controllers
             }
         }
 
+        private string GetReplaceText1_30003_3(List<ValidProperty> pProperties)
+        {
+            string oReplaceParam1 = string.Empty;
+
+            // BuyerOrderReferencedDocument
+            var itemBT13 = pProperties.Where(i => i.TableColumn == "INVOICE_REFERENCE").FirstOrDefault();
+            string valueBt13 = "-";
+            if (itemBT13 != null)
+            {
+                valueBt13 = string.IsNullOrEmpty(itemBT13.Value) ? "-" : itemBT13.Value;
+            }
+            oReplaceParam1 += "<li>[BuyerOrderReferencedDocument] (BT-13) = [" + valueBt13 + "]</li>";
+
+
+            // BuyerReference
+            var itemBT10 = pProperties.Where(i => i.TableColumn == "INVOICE_REFERENCE3").FirstOrDefault();
+            string valueBt10 = "-";
+            if (itemBT10 != null)
+            {
+                valueBt10 = string.IsNullOrEmpty(itemBT10.Value) ? "-" : itemBT10.Value;
+            }
+            oReplaceParam1 += "<li>[BuyerReference] (BT-10) = [" + valueBt10 + "]</li>";
+
+
+            // CostCenter
+            var itemBT19 = pProperties.Where(i => i.TableColumn == "INVOICE_COST_CENTER").FirstOrDefault();
+            string valueBt19 = "-";
+            if (itemBT19 != null)
+            {
+                valueBt19 = string.IsNullOrEmpty(itemBT19.Value) ? "-" : itemBT19.Value;
+            }
+            oReplaceParam1 += "<li>[CostCenter] (BT-19) = [" + valueBt19 + "]</li>";
+
+            // BuyerID
+            var itemBT46 = pProperties.Where(i => i.TableColumn == "INVOICE_BUYER_ID").FirstOrDefault();
+            string valueBt46 = "-";
+            if (itemBT46 != null)
+            {
+                valueBt46 = string.IsNullOrEmpty(itemBT46.Value) ? "-" : itemBT46.Value;
+            }
+            oReplaceParam1 += "<li>[BuyerTradeParty] (BT-46) = [" + valueBt46 + "]</li>";
+
+            oReplaceParam1 = "<ul>" + oReplaceParam1 + "</ul>";
+            _logger.Debug("oReplaceParam1-Text: " + oReplaceParam1);
+
+            return oReplaceParam1;
+        }
+
+        private string GetReplaceText2_30003_2(List<ValidProperty> pProperties)
+        {
+            string oReplaceParam2 = string.Empty;
+
+            // BuyerTradeParty.Name
+            var itemBT44 = pProperties.Where(i => i.TableColumn == "INVOICE_BUYER_NAME").FirstOrDefault();
+            string valueBt44 = "-";
+            if (itemBT44 != null)
+            {
+                valueBt44 = string.IsNullOrEmpty(itemBT44.Value) ? "-" : itemBT44.Value;
+            }
+            oReplaceParam2 += "<li>[BuyerTradeParty.Name] (BT-44) = [" + valueBt44 + "]</li>";
+
+            // BuyerTradeParty.PostalTradeAddress.LineTwo
+            var itemBT51 = pProperties.Where(i => i.TableColumn == "INVOICE_BUYER_ADRESS2").FirstOrDefault();
+            string valueBt51 = "-";
+            if (itemBT51 != null)
+            {
+                valueBt51 = string.IsNullOrEmpty(itemBT51.Value) ? "-" : itemBT51.Value;
+            }
+            oReplaceParam2 += "<li>[BuyerTradeParty.PostalTradeAddress.LineTwo] (BT-51) = [" + valueBt51 + "]</li>";
+
+            oReplaceParam2 = "<ul>" + oReplaceParam2 + "</ul>";
+            _logger.Debug("oReplaceParam2-Text: " + oReplaceParam2);
+
+            return oReplaceParam2;
+        }
+
+        private string GetReplaceText1_30003_2(List<ValidProperty> pProperties)
+        {
+            string oReplaceParam1 = string.Empty;
+
+            // BuyerOrderReferencedDocument
+            var itemBT13 = pProperties.Where(i => i.TableColumn == "INVOICE_REFERENCE").FirstOrDefault();
+            string valueBt13 = "-";
+            if (itemBT13 != null)
+            {
+                valueBt13 = string.IsNullOrEmpty(itemBT13.Value) ? "-" : itemBT13.Value;
+            }
+            oReplaceParam1 += "<li>[BuyerOrderReferencedDocument] (BT-13) = [" + valueBt13 + "]</li>";
+
+
+            // BuyerReference
+            var itemBT10 = pProperties.Where(i => i.TableColumn == "INVOICE_REFERENCE3").FirstOrDefault();
+            string valueBt10 = "-";
+            if (itemBT10 != null)
+            {
+                valueBt10 = string.IsNullOrEmpty(itemBT10.Value) ? "-" : itemBT10.Value;
+            }
+            oReplaceParam1 += "<li>[BuyerReference] (BT-10) = [" + valueBt10 + "]</li>";
+
+
+            // CostCenter
+            var itemBT19 = pProperties.Where(i => i.TableColumn == "INVOICE_COST_CENTER").FirstOrDefault();
+            string valueBt19 = "-";
+            if (itemBT19 != null)
+            {
+                valueBt19 = string.IsNullOrEmpty(itemBT19.Value) ? "-" : itemBT19.Value;
+            }
+            oReplaceParam1 += "<li>[CostCenter] (BT-19) = [" + valueBt19 + "]</li>";
+
+            oReplaceParam1 = "<ul>" + oReplaceParam1 + "</ul>";
+            _logger.Debug("oReplaceParam1-Text: " + oReplaceParam1);
+
+            return oReplaceParam1;
+        }
+
         public string GetMessageId()
         {
             return $"{Guid.NewGuid()}@{MESSAGEID_DOMAIN}";
         }
 
-        public bool InsertPropertyMap(ValidProperty pProperty, string pMessageId)
+        private bool BulkInsertDataToDatabase(string pMessageId, List<ValidProperty> pProperties, ZugferdResult pZugferdResult)
+        {
+            if (string.IsNullOrEmpty(pMessageId)) 
+            {
+                return false;
+            }
+
+            if (!DeleteExistingPropertyValues(pMessageId)) 
+            {
+                return false;
+            }
+
+            DataTable oDataTable = PrepareDataTable(pMessageId, pProperties, pZugferdResult);
+
+            // ColumnList initialisieren
+            List<string> oColumnNames = new List<string> {
+                    "REFERENCE_GUID",
+                    "ITEM_DESCRIPTION",
+                    "ITEM_VALUE",
+                    "GROUP_COUNTER",
+                    "SPEC_NAME",
+                    "IS_REQUIRED"
+                 };
+
+            bool oBulkResult = BulkInsert(oDataTable, "TBEDMI_ITEM_VALUE", oColumnNames);
+
+            if (!oBulkResult)
+            {
+                _logger.Error("Bulk Insert for MessageId [{0}] failed!", pMessageId);
+                return false;
+            }
+
+            _logger.Info("Bulk Insert finished. [{0}] rows inserted for MessageId [{1}].", oDataTable.Rows.Count, pMessageId);
+            return true;
+        }
+
+        private bool BulkInsert(DataTable pDataTable, string pDestinationTable, List<string> pColumnNames)
+        {
+            using (var oSqlBulkCopy = new SqlBulkCopy(_database.MSSQL.GetConnection()))
+            {
+                oSqlBulkCopy.DestinationTableName = pDestinationTable;
+                foreach (var columnItem in pColumnNames)
+                {
+                    oSqlBulkCopy.ColumnMappings.Add(new SqlBulkCopyColumnMapping(columnItem, columnItem));
+                }
+
+                try
+                {
+                    oSqlBulkCopy.WriteToServer(pDataTable);
+                }
+                catch (Exception ex)
+                {
+                    _logger.Error(ex);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private DataTable PrepareDataTable(string pMessageId, List<ValidProperty> pProperties, ZugferdResult pDocument)
+        {
+            DataTable oDataTable = new DataTable();
+            oDataTable.Columns.Add(new DataColumn("REFERENCE_GUID", typeof(string)));
+            oDataTable.Columns.Add(new DataColumn("ITEM_DESCRIPTION", typeof(string)));
+            oDataTable.Columns.Add(new DataColumn("ITEM_VALUE", typeof(string)));
+            oDataTable.Columns.Add(new DataColumn("GROUP_COUNTER", typeof(Int32)));
+            oDataTable.Columns.Add(new DataColumn("SPEC_NAME", typeof(string)));
+            oDataTable.Columns.Add(new DataColumn("IS_REQUIRED", typeof(bool)));
+
+            // Erste Zeile enthält die Spezifikation
+            DataRow oFirstRow = oDataTable.NewRow();
+            oFirstRow["REFERENCE_GUID"] = pMessageId;
+            oFirstRow["ITEM_DESCRIPTION"] = "Verwendete Spezifikation der E-Rechnung";
+            oFirstRow["ITEM_VALUE"] = pDocument.Specification;
+            oFirstRow["GROUP_COUNTER"] = 0;
+            oFirstRow["SPEC_NAME"] = "ZUGFERD_SPECIFICATION";
+            oFirstRow["IS_REQUIRED"] = false;
+
+            _logger.Debug("Mapping Property [ZUGFERD_SPECIFICATION] with value [{0}]", pDocument.Specification);
+            oDataTable.Rows.Add(oFirstRow);
+
+            //' Zweite Zeile enthält das verwendete XML Schema
+            DataRow oSecondRow = oDataTable.NewRow();
+            oSecondRow["REFERENCE_GUID"] = pMessageId;
+            oSecondRow["ITEM_DESCRIPTION"] = "Verwendetes XML-Schema (XSD) der E-Rechnung";
+            oSecondRow["ITEM_VALUE"] = pDocument.UsedXMLSchema;
+            oSecondRow["GROUP_COUNTER"] = 0;
+            oSecondRow["SPEC_NAME"] = "ZUGFERD_XML_SCHEMA";
+            oSecondRow["IS_REQUIRED"] = false;
+
+            _logger.Debug("Mapping Property [ZUGFERD_XML_SCHEMA] with value [{0}]", pDocument.UsedXMLSchema);
+            oDataTable.Rows.Add(oSecondRow);
+
+            //' Dritte Zeile enthält das verwendete Datei-Format des Belegs (PDF/XML)
+            if (pDocument.ReceiptFileType != null)
+            {
+                DataRow oThirdRow = oDataTable.NewRow();
+                oThirdRow["REFERENCE_GUID"] = pMessageId;
+                oThirdRow["ITEM_DESCRIPTION"] = "Dateityp der E-Rechnung";
+                oThirdRow["ITEM_VALUE"] = pDocument.ReceiptFileType;
+                oThirdRow["GROUP_COUNTER"] = 0;
+                oThirdRow["SPEC_NAME"] = "RECEIPT_FILE_TYPE";
+                oThirdRow["IS_REQUIRED"] = false;
+
+                _logger.Debug("Mapping Property [RECEIPT_FILE_TYPE] with value [{0}]", pDocument.ReceiptFileType);
+                oDataTable.Rows.Add(oThirdRow);
+            }
+
+            foreach (var propertyItem in pProperties)
+            {
+
+                // ItemType = 3 => eingebettete Datei, nicht den base64 speichern
+                if (propertyItem.ItemType == 3)
+                {
+                    continue;
+                }
+
+                // ItemType = 0 (normale texte) dürfen nicht leer sein - leere Werte werden überlesen
+                if (propertyItem.ItemType == 0 && string.IsNullOrEmpty(propertyItem.Value))
+                {
+                    continue;
+                }
+
+                // If GroupCounter is -1, it means this is a default property that can only occur once.
+                // Set the actual inserted value to 0
+                var oGroupCounterValue = propertyItem.GroupCounter < 0 ? 0 : propertyItem.GroupCounter;
+
+                if (propertyItem.Value.Length > 4000)
+                {
+                    _logger.Warn("Value for field [{0}] is longer than 4000 characters, will be truncated!", propertyItem.TableColumn);
+                    propertyItem.Value = propertyItem.Value.Substring(0, 4000);
+                }
+
+                // Description mit BT-Feld aufbereiten
+                var betterDescription = propertyItem.Description;
+                if (!string.IsNullOrEmpty(propertyItem.EN16931_ID))
+                {
+                    betterDescription = propertyItem.EN16931_ID + " (" + propertyItem.Description + ")";
+                }
+
+                DataRow newRow = oDataTable.NewRow();
+                newRow["REFERENCE_GUID"] = pMessageId;
+                newRow["ITEM_DESCRIPTION"] = betterDescription;
+                newRow["ITEM_VALUE"] = propertyItem.Value;
+                newRow["GROUP_COUNTER"] = oGroupCounterValue;
+                newRow["SPEC_NAME"] = propertyItem.TableColumn;
+                newRow["IS_REQUIRED"] = propertyItem.IsRequired;
+
+                _logger.Debug("Mapping Property [{0}] with value [{1}]", propertyItem.TableColumn, propertyItem.Value);
+                oDataTable.Rows.Add(newRow);
+            }
+
+            return oDataTable;
+        }
+
+        public bool DeleteExistingPropertyValues(string pMessageId)
         {
             try
             {
-                if (pProperty.ItemType == 3)
+                var delItemValueSQL = "DELETE FROM TBEDMI_ITEM_VALUE WHERE REFERENCE_GUID = '" + pMessageId + "';";
+                var oCommand = new SqlCommand(delItemValueSQL);
+                var retValue = _database.MSSQL.ExecuteNonQuery(oCommand);
+
+                if (!retValue)
                 {
-                    // Wir speichern keine Attachment-Werte in die DB
+                    _logger.Warn("DELETE FROM TBEDMI_ITEM_VALUE NOT successfull");
-                    return true;
+                    return false;
                 }
 
-                if (pProperty.ItemType == 0 && string.IsNullOrEmpty(pProperty.Value.ToString()))
+                _logger.Debug("DELETE FROM TBEDMI_ITEM_VALUE successfull");
-                {
-                    // Leere Texte speichern wir nicht in der DB
-                    return true;
-                }
-
-                var oSql = $"INSERT INTO {pProperty.TableName} " +
-                    "(REFERENCE_GUID, ITEM_DESCRIPTION, ITEM_VALUE, CREATEDWHO, SPEC_NAME, GROUP_COUNTER, IS_REQUIRED) VALUES " +
-                    "(@REFERENCE_GUID, @ITEM_DESCRIPTION, @ITEM_VALUE, @CREATEDWHO, @SPEC_NAME, @GROUP_COUNTER, @IS_REQUIRED)";
-
-                string itemValue = string.Empty;
-                if (pProperty.Value.Length > 4000)
-                {
-                    itemValue = pProperty.Value.Substring(1, 4000);
-                    _logger.Warn("Value for field [{0}] is longer than 4000 characters, will be truncated!", pProperty.TableColumn);
-                }
-                else
-                {
-                    itemValue = pProperty.Value;
-                }
-                
-                var oParams = new SqlParameter[]
-                {
-                    new SqlParameter("@REFERENCE_GUID", pMessageId),
-                    new SqlParameter("@ITEM_DESCRIPTION", pProperty.Description),
-                    new SqlParameter("@ITEM_VALUE", itemValue.Replace("'", "''")),
-                    new SqlParameter("@CREATEDWHO", ADDED_WHO),
-                    new SqlParameter("@GROUP_COUNTER", pProperty.GroupCounter),
-                    new SqlParameter("@SPEC_NAME", pProperty.TableColumn),
-                    new SqlParameter("@IS_REQUIRED", pProperty.IsRequired)
-                };
-
-                var oCommand = new SqlCommand(oSql);
-                oCommand.Parameters.AddRange(oParams);
-
-                return _database.MSSQL.ExecuteNonQuery(oCommand);
             }
             catch (Exception ex)
             {
                 _logger.Error(ex);
                 return false;
             }
+
+            try
+            {
+                var delItemFilesSQL = "DELETE FROM TBEDMI_ITEM_FILES WHERE REFERENCE_GUID = '" + pMessageId + "';";
+                var oCommand = new SqlCommand(delItemFilesSQL);
+                var retValue = _database.MSSQL.ExecuteNonQuery(oCommand);
+
+                if (!retValue)
+                {
+                    _logger.Warn("DELETE FROM TBEDMI_ITEM_FILES NOT successfull");
+                    return false;
+                }
+                _logger.Debug("DELETE FROM TBEDMI_ITEM_FILES successfull");
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex);
+                return false;
+            }
+
+            return true;
         }
 
+        
         /// <summary>
         /// Ermittelt die Ausgabe-nachricht für einen Fehlercode 
         /// </summary>
@@ -463,7 +828,25 @@ namespace ZUGFeRDRESTService.Controllers
 
             // Sprache wird man vielleicht mal auswählen können
             var language = "de-DE";
-            var searchTitle = "ZUGFERD_Rejection_" + pErrorCode + "_Web";
+            var searchTitle = string.Empty;
+
+            if (pErrorCode.Contains("2000"))
+            {
+                searchTitle = "ZUGFERD_Rejection_" + pErrorCode + "_Web";
+            }
+            else if (pErrorCode.Contains("REFERENCES_Rejection_3000"))
+            {
+                searchTitle = pErrorCode + "_Web";
+            }
+            else if (pErrorCode.Contains("AMOUNT_CALC"))
+            {
+                searchTitle = "AMOUNT_CALC_REJECTION_Web";
+            }
+            else
+            {
+                // else-Fall muss noch geklärt werden.
+                searchTitle = "AMOUNT_CALC_REJECTION_Web";
+            }
 
             var messageItem = _RecjectionMessageList.Where(i => i.Title.Equals(searchTitle, StringComparison.OrdinalIgnoreCase) && i.Language.Equals(language, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
             if (messageItem != null)
@@ -508,5 +891,16 @@ namespace ZUGFeRDRESTService.Controllers
                     return "20010";
             }
         }
+
+        private string GetRejectionCodeNumber(string rejectionCode)
+        {
+            if (rejectionCode.StartsWith("REFERENCES_Rejection_"))
+            {
+                var retValue = rejectionCode.Replace("REFERENCES_Rejection_", "");
+                return retValue;
+            }
+
+            return rejectionCode;
+        }
     }
 }

WEBSERVICES/ZUGFeRDRESTService/appsettings.Development.json

@@ -20,11 +20,11 @@
     },
 	"Zugferd": {
       "AllowZugferd10": true,
-      "AllowZugferd2x": false,
+      "AllowZugferd2x": true,
-      "AllowZugferd23x": false,
+      "AllowZugferd23x": true,
-      "AllowFacturX": false,
+      "AllowFacturX": true,
-      "AllowXRechnung": false,
+      "AllowXRechnung": true,
-      "AllowPeppolBISBill3x": false
+      "AllowPeppolBISBill3x": true
     },
     "GDPictureVersion": "",
     "MaxFileSizeInMegabytes": 25