Codebasis als Dateien ins Arbeitsrepo statt als Gitlink

QuellCode/CentronERP war nur als Gitlink (Submodul-Referenz auf 79c1142)
getrackt, ohne .gitmodules und ohne erreichbares Remote. Der
Untersuchungsgegenstand der Versuchsreihe war damit nicht reproduzierbar
gesichert: Ein Klon haette ein leeres Verzeichnis erhalten, und die Belege
der 3.287 Anforderungen waeren nicht ueberpruefbar gewesen.

Umstellung:
- Historie nach c:\DEV\CentronERP_git_snapshot_79c1142 ausgelagert
  (vollstaendig lesbar, enthaelt 79c1142 und Vorgaenger 89ccfd6)
- Gitlink aus dem Index entfernt
- Dateiinhalt aufgenommen: 24.557 Dateien, rund 333 MB

Die verschachtelte .gitignore der Codebasis gilt weiter, Build-Artefakte
bleiben ausgeschlossen. Details in Versuche/Versuch_01/_Codebasis-Nachweis.md

QuellCode/CentronERP/tests/Centron.Tests.EndToEnd/Tests/ReceiptTaxRate/ReceiptTaxRateTest.cs

@@ -0,0 +1,456 @@
+using Centron.BusinessLogic;
+using Centron.BusinessLogic.Administration.Settings;
+using Centron.BusinessLogic.EmployeeArea;
+using Centron.BusinessLogic.Sales.Receipts.DataAndResults;
+using Centron.BusinessLogic.WebServices.Sales.Receipts;
+using Centron.BusinessLogic.WebServices.Warehousing;
+using Centron.Data.Entities.Administration.Logins;
+using Centron.Data.WebServices.Sales.Receipts;
+using Centron.Data.WebServices.Sales.Receipts.DeliveryLists;
+using Centron.Data.WebServices.Sales.Receipts.Invoices;
+using Centron.Data.WebServices.Sales.Receipts.Orders;
+using Centron.Data.WebServices.Warehousing;
+using Centron.Interfaces;
+using Centron.Interfaces.Administration.Environment;
+using Centron.Interfaces.Sales.Receipts;
+using Centron.Interfaces.Sales.Receipts.InsertReceipts;
+using Centron.Tests.EndToEnd.Infrastructure;
+using CentronSoftware.Centron.WebServices.EntitiesWrongPlace.Sales.Receipts.DataAndResults;
+using DevExpress.Utils.Filtering.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using CentronSoftware.Centron.WebServices.Extensions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Centron.Tests.EndToEnd.Tests.ReceiptTaxRate
+{
+    public class ReceiptTaxRateTest : EndToEndTest
+    {
+        public ReceiptTaxRateTest(ITestOutputHelper testOutputHelper) 
+            : base(testOutputHelper)
+        {
+            // Ignore preparation-date because it changes depending on DateTime.Now - when the Test is executed
+            this.Verifier.Settings.IgnoreProperty<ReceiptOrderDTO>(f => f.PreparationDate);
+            this.Verifier.Settings.IgnoreProperty<ReceiptOrderItemDTO>(f => f.PreparationDate);
+
+            this.Verifier.Settings.IgnoreProperty<ReceiptDeliveryListDTO>(f => f.PreparationDate);
+            this.Verifier.Settings.IgnoreProperty<ReceiptDeliveryListItemDTO>(f => f.PreparationDate);
+
+            this.Verifier.Settings.IgnoreProperty<ReceiptInvoiceDTO>(f => f.PreparationDate);
+            this.Verifier.Settings.IgnoreProperty<ReceiptInvoiceItemDTO>(f => f.PreparationDate);
+        }
+
+        const int CurrentTaxRateI3D = 4;
+        const decimal CurrentTaxRate = 19;
+        const int CurrentYear = 2020;
+
+        const int OldTaxRateI3D = 1;
+        const decimal OldTaxRate = 16;
+        const int OldYear = 2002;
+
+        const int ArticleI3D = 4348;
+
+        const int ProductFamilyI3D = 2;
+        
+        const int OldOfferI3D = 3;
+
+        public override void Execute()
+        {
+            this.PrepareDatabase();
+
+            // The database looks like this
+            // We have a active tax (19%) rate 
+            // We also have a previous tax rate (16%) configured that was active until 31.12.2006
+
+            // If we create a invoice with date AFTER 31.12.2006 we should get the new tax rate
+            this.ValidateTaxRateInNewReceiptItemsForDate(CurrentTaxRateI3D, CurrentTaxRate, new DateTime(CurrentYear, month: 1, day: 1));
+            // Also if it was JUST AFTER 31.12.2006 we should get the new tax rate
+            this.ValidateTaxRateInNewReceiptItemsForDate(CurrentTaxRateI3D, CurrentTaxRate, new DateTime(2007, month: 1, day: 1));
+            // But if we create a invoice with date BEFORE 31.12.2006 we should get the old tax rate            
+            this.ValidateTaxRateInNewReceiptItemsForDate(OldTaxRateI3D, OldTaxRate, new DateTime(OldYear, month: 1, day: 1));
+            // If the invoice is on the LAST DATE 31.12.2006, we should get the old tax rate
+            this.ValidateTaxRateInNewReceiptItemsForDate(OldTaxRateI3D, OldTaxRate, new DateTime(2006, month: 12, day: 31)); 
+            // Time component should be ignored
+            this.ValidateTaxRateInNewReceiptItemsForDate(OldTaxRateI3D, OldTaxRate, new DateTime(2006, month: 12, day: 31, hour: 12, minute: 30, second: 12));
+
+            // If the article has the old tax rate, it should still go through the chain, and select the newer tax-rate if needed
+            this.ValidateTaxRateInNewReceiptItemsWithOldTaxRateOnArticle();
+
+            // Forwarding only takes the origin receipt tax rate, if it's a delivery-list or invoice (customer and supplier)
+            // So we expect the new tax rate for the next 2 tests
+            this.ValidateTaxForwarding(CentronObjectKindNumeric.OfferClass, CentronObjectKindNumeric.OrderClass, expectNewTaxRate: true);
+            this.ValidateTaxForwarding(CentronObjectKindNumeric.OrderClass, CentronObjectKindNumeric.DeliveryListClass, expectNewTaxRate: true);
+            // But we expect the old tax rate from the origin receipt for these 2 tests
+            this.ValidateTaxForwarding(CentronObjectKindNumeric.DeliveryListClass, CentronObjectKindNumeric.InvoiceClass, expectNewTaxRate: false);
+            this.ValidateTaxForwarding(CentronObjectKindNumeric.InvoiceClass, CentronObjectKindNumeric.CreditVoucherClass, expectNewTaxRate: false);
+
+            // If the receipt was created in old times with the old tax-rates
+            // And you create a new version, of it (ReceiptBL.CreateNewVersion)
+            // You usually get asked, whether you want to update the receipt date
+            // If you select yes, the tax-rates should get updated to now too
+            this.ValidateCreateNewVersionUpdatesTaxRates();
+
+            // When creating a new version, and updating the date
+            // The tax rates should be updates, as seen in the method before this
+            // BUT, it should respect origin-receipt dates for the tax-calculation
+            // if the tax is forwarded from the origin-receipt, for example delivery-lists forward their tax-rates
+            this.ValidateCreateNewVersionUpdatesTaxRatesButRespectsDeliveryListDate();
+
+            // When the product family updates the tax rates
+            // The product-family duration should be added to the licensedate for tax date calculation
+            this.ValidateTaxRateRespectsProductFamilyLicenseDate();
+        }
+
+        private void PrepareDatabase()
+        {
+            // Oops, I wrote this test using this article I3D
+            // But now when creating and saving a invoice, I notice that this article needs barcodes...
+            // So I deactivate it rather than re-create all the *.expected.txt files again
+            this.Sql($"UPDATE ARTIK SET BarcodeScanen = 0 WHERE I3D = {ArticleI3D}");
+            // And another oops, same with "kommissionieren"
+            this.Sql($"UPDATE ARTIK SET Kommisionieren = 0 WHERE I3D = {ArticleI3D}");
+
+            // Prepare the offer to have old tax rates and old date
+            this.Sql($"UPDATE AngKopf SET Datum = '{OldYear}-01-01' WHERE I3D = {OldOfferI3D}");
+            this.Sql($"UPDATE AngPos SET MwstI3D = {OldTaxRateI3D}, MwstSatz = {OldTaxRate} WHERE AngKopfI3D = {OldOfferI3D} AND MwstI3D IS NOT NULL");
+
+            // Make invoices update their date on new-version
+            this.Sql($"UPDATE Stammdat SET Wert = 2 WHERE I3D = {(int)AppSettingsConst.NewInvoiceVersionUpdateDate}"); // 2 is "ask user"
+            
+            // There is no Bankverbindung for the customer 10022 - but we are creating invoices for him
+            // So we just move the existing Bankverbindung to customer 10022, so he can use it for this test
+            this.Sql("UPDATE dbo.Bankverbindungen SET ObjectI3D = 10022");
+        }
+
+        private void ValidateTaxRateInNewReceiptItemsForDate(int taxRateI3D, decimal taxRate, DateTime date)
+        {
+            var invoice = this.CreateNewReceipt(CentronObjectKindNumeric.InvoiceClass);
+            invoice.Date = date;
+
+            var receiptItem = this.CreateReceiptItem(invoice);
+            this.Verifier.Verify($"ReceiptItems{date:ddMMyyyy_HHmmss}", receiptItem);
+
+            Assert.Equal(taxRateI3D, receiptItem.VATI3D);
+            Assert.Equal(taxRate, receiptItem.VATRate);
+        }
+
+        private void ValidateTaxRateInNewReceiptItemsWithOldTaxRateOnArticle()
+        {
+            this.Sql($"UPDATE ARTIK SET MWStI3D = {OldTaxRateI3D}, Mwst_Satz = {OldTaxRate} WHERE I3D = {ArticleI3D}");
+
+            this.ValidateTaxRateInNewReceiptItemsForDate(CurrentTaxRateI3D, CurrentTaxRate, new DateTime(CurrentYear + 1, month: 1, day: 1));
+
+            this.Sql($"UPDATE ARTIK SET MWStI3D = {CurrentTaxRateI3D}, Mwst_Satz = {CurrentTaxRate} WHERE I3D = {ArticleI3D}");
+        }
+
+        private void ValidateTaxForwarding(CentronObjectKindNumeric originReceiptKind, CentronObjectKindNumeric targetReceiptKind, bool expectNewTaxRate)
+        {
+            var originReceipt = this.CreateNewReceipt(originReceiptKind);
+            originReceipt.Date = new DateTime(year: OldYear, month: 1, day: 1);
+
+            var receiptItem = this.CreateReceiptItem(originReceipt);
+
+            Assert.Equal(OldTaxRateI3D, receiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, receiptItem.VATRate);
+
+            var items = originReceipt.GetReceiptItems();
+            items.Add(receiptItem);
+            originReceipt.SetReceiptItems(items);
+
+            var savedOriginReceipt = this.SaveReceipt(originReceipt);
+
+            var forwardedReceipt = this.ForwardReceipt(targetReceiptKind, savedOriginReceipt);
+            this.Verifier.Verify($"Forwarded{originReceiptKind.GetReceiptShortName()}To{targetReceiptKind.GetReceiptShortName()}", forwardedReceipt);
+
+            int expectedTaxRateI3D = expectNewTaxRate ? CurrentTaxRateI3D : OldTaxRateI3D;
+            decimal expectedTaxRate = expectNewTaxRate ? CurrentTaxRate : OldTaxRate;
+
+            var forwardedReceiptItem = forwardedReceipt.GetReceiptItems().Single(f => f.Kind == ReceiptItemKind.Article);
+            Assert.Equal(forwardedReceiptItem.VATI3D, expectedTaxRateI3D);
+            Assert.Equal(forwardedReceiptItem.VATRate, expectedTaxRate);
+        }
+
+        private void ValidateCreateNewVersionUpdatesTaxRates()
+        {
+            using (var session = new BLSession())
+            {
+                var currentReceiptVersion = session.GetBL<ReceiptWebServiceBL>().GetReceiptByI3D(OldOfferI3D, CentronObjectKindNumeric.OfferClass);
+
+                var currentReceiptItems = currentReceiptVersion.Data
+                    .GetReceiptItems()
+                    .Where(f => f.VATI3D != null).ToList();
+
+                // Ensure that the receipt curently has the old tax rates
+                foreach (var item in currentReceiptItems)
+                {
+                    Assert.Equal(OldTaxRateI3D, item.VATI3D);
+                    Assert.Equal(OldTaxRate, item.VATRate);
+                }
+
+                var newVersionReceipt = this.CreateNewVersion(CentronObjectKindNumeric.OfferClass, OldOfferI3D, updateReceiptDate: true);
+
+                var receiptItems = newVersionReceipt
+                        .GetReceiptItems()
+                        .Where(f => f.VATI3D != null)
+                        .ToList();
+
+                this.Verifier.Verify("ReceiptItemsUpdatedTaxRateAfterNewVersion", receiptItems);
+
+                // It should now have the new tax rates
+                foreach (var item in receiptItems)
+                {
+                    Assert.Equal(CurrentTaxRateI3D, item.VATI3D);
+                    Assert.Equal(CurrentTaxRate, item.VATRate);
+                }
+            }
+        }
+
+        private void ValidateCreateNewVersionUpdatesTaxRatesButRespectsDeliveryListDate()
+        {
+            // Create a old delivery-list
+            var deliveryList = this.CreateNewReceipt(CentronObjectKindNumeric.DeliveryListClass);
+            deliveryList.Date = new DateTime(OldYear, month: 1, day: 1);
+
+            // Create a delivery-list item
+            var deliveryListReceiptItems = deliveryList.GetReceiptItems().ToList();
+            var deliveryListReceiptItem = this.CreateReceiptItem(deliveryList);
+            deliveryListReceiptItems.Add(deliveryListReceiptItem);
+            deliveryList.SetReceiptItems(deliveryListReceiptItems);
+
+            // The delivery-list is old, it should have the old tax-rate
+            Assert.Equal(OldTaxRateI3D, deliveryListReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, deliveryListReceiptItem.VATRate);
+
+            // Save delivery-list
+            var savedDeliveryList = this.SaveReceipt(deliveryList);
+
+
+
+            // Forward the delivery-list to an new invoice
+            var invoice = this.ForwardReceipt(CentronObjectKindNumeric.InvoiceClass, savedDeliveryList);
+            invoice.Date = new DateTime(CurrentYear, month: 1, day: 1);
+
+            // The invoice should take-over the tax-rate from the delivery-list
+            var forwardedInvoiceReceiptItem = invoice.GetReceiptItems().Single(f => f.VATI3D != null);
+            Assert.Equal(OldTaxRateI3D, forwardedInvoiceReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, forwardedInvoiceReceiptItem.VATRate);
+
+            // Create a new invoice-item that should get the new tax-rate
+            var invoiceReceiptItems = invoice.GetReceiptItems().ToList();
+            var createdInvoiceReceiptItem = this.CreateReceiptItem(invoice);
+            Assert.Equal(CurrentTaxRateI3D, createdInvoiceReceiptItem.VATI3D);
+            Assert.Equal(CurrentTaxRate, createdInvoiceReceiptItem.VATRate);
+            invoiceReceiptItems.Add(createdInvoiceReceiptItem);
+            invoice.SetReceiptItems(invoiceReceiptItems);
+
+            // Set tax on the new invoice-item to the old tax-rate, so something will get updated in CreateNewVersion
+            createdInvoiceReceiptItem.VATI3D = OldTaxRateI3D;
+            createdInvoiceReceiptItem.VATRate = OldTaxRate;
+
+            // Save the invoice
+            var savedInvoice = this.SaveReceipt(invoice);
+
+
+
+            // Create new version with date-update
+            var newInvoiceVersion = (ReceiptInvoiceDTO)this.CreateNewVersion(CentronObjectKindNumeric.InvoiceClass, savedInvoice.I3D, updateReceiptDate: true);
+
+            // The forwarded receipt-item should keep the origin-receipt tax-rate
+            forwardedInvoiceReceiptItem = newInvoiceVersion.Items.Single(f => f.VATI3D != null && f.OriginKind != null);
+            Assert.Equal(OldTaxRateI3D, forwardedInvoiceReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, forwardedInvoiceReceiptItem.VATRate);
+
+            // The created receipt-item should get updated and get the current tax-rate
+            createdInvoiceReceiptItem = newInvoiceVersion.Items.Single(f => f.VATI3D != null && f.OriginKind == null);
+            Assert.Equal(CurrentTaxRateI3D, createdInvoiceReceiptItem.VATI3D);
+            Assert.Equal(CurrentTaxRate, createdInvoiceReceiptItem.VATRate);
+
+
+
+            // Create new version WITHOUT date-update
+            newInvoiceVersion = (ReceiptInvoiceDTO)this.CreateNewVersion(CentronObjectKindNumeric.InvoiceClass, savedInvoice.I3D, updateReceiptDate: false);
+
+            // The receipt-items should keep their old values
+            forwardedInvoiceReceiptItem = newInvoiceVersion.Items.Single(f => f.VATI3D != null && f.OriginKind != null);
+            Assert.Equal(OldTaxRateI3D, forwardedInvoiceReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, forwardedInvoiceReceiptItem.VATRate);
+            createdInvoiceReceiptItem = newInvoiceVersion.Items.Single(f => f.VATI3D != null && f.OriginKind == null);
+            Assert.Equal(OldTaxRateI3D, createdInvoiceReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, createdInvoiceReceiptItem.VATRate);
+        }
+        
+        private void ValidateTaxRateRespectsProductFamilyLicenseDate()
+        {
+            // Prepare database
+            this.Sql($"UPDATE ARTIK SET ProduktfamilieI3D = {ProductFamilyI3D} WHERE I3D = {ArticleI3D}");
+            this.Sql($"UPDATE Produktfamilie SET LaufzeitMonate = 36, LaufzeitEndeBestimmtMwSt = 1 WHERE I3D = {ProductFamilyI3D}"); // 3 years
+            
+            // Create a delivery-list
+            var deliveryList = this.CreateNewReceipt(CentronObjectKindNumeric.DeliveryListClass);
+            deliveryList.Date = new DateTime(OldYear, month: 1, day: 1);
+
+            // Create a delivery-list item
+            var deliveryListReceiptItems = deliveryList.GetReceiptItems().ToList();
+            var deliveryListReceiptItem = (ReceiptDeliveryListItemDTO)this.CreateReceiptItem(deliveryList);
+            deliveryListReceiptItems.Add(deliveryListReceiptItem);
+            deliveryList.SetReceiptItems(deliveryListReceiptItems);
+            
+            // Delivery-list item should have old tax-rates, because the LaufzeitMonate of the product-family is not long enough to get the new tax rate
+            // -> OldYear (2002) + 3 = 2005
+            // -> New tax rate is after 31.12.2006
+            Assert.Equal(OldTaxRateI3D, deliveryListReceiptItem.VATI3D);
+            Assert.Equal(OldTaxRate, deliveryListReceiptItem.VATRate);
+            
+            // Now the license-date is 2005, with the 3 more years of the product-family it should get the new tax rate
+            deliveryListReceiptItem.LicenseDate = new DateTime(OldYear + 3, month: 1, day: 1);
+            var updatedTaxRates = this.GetUpdatedTaxRates(deliveryList);
+            Assert.Collection(updatedTaxRates,
+                item1 =>
+                {
+                    Assert.False(item1.UpdateTaxRate);
+                },
+                item2 =>
+                {
+                    Assert.False(item2.UpdateTaxRate);
+                },
+                item3 =>
+                {
+                    Assert.False(item3.UpdateTaxRate);
+                }, 
+                item4 =>
+                {
+                    Assert.True(item4.UpdateTaxRate);
+                    Assert.Equal(CurrentTaxRateI3D, item4.NextTaxRateI3D);
+                    Assert.Equal(CurrentTaxRate, item4.NextTaxRate);
+                });
+            
+            // Reset database
+            this.Sql($"UPDATE ARTIK SET ProduktfamilieI3D = -1 WHERE I3D = {ArticleI3D}");
+        }
+
+        private ReceiptBaseDTO CreateNewReceipt(CentronObjectKindNumeric receiptKind)
+        {
+            using (var session = new BLSession())
+            {
+                var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
+                var result = session.GetBL<ReceiptWebServiceBL>().CreateNewReceipt(receiptKind, new LoggedInUser(user), 10022, new CreateReceiptData(), null, null, true, false, true);
+
+                return result.Data.Receipt;
+            }
+        }
+
+        private ReceiptItemBaseDTO CreateReceiptItem(ReceiptBaseDTO receipt)
+        {
+            using (var session = new BLSession())
+            {
+                var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
+
+                var receiptItemsResult = session.GetBL<ReceiptItemWebServiceBL>().CreateArticleReceiptItems(
+                    receipt,
+                    false,
+                    ArticleI3D,
+                    null,
+                    null,
+                    -1,
+                    new LoggedInUser(user));
+
+                return receiptItemsResult.Data.ReceiptItems.Single(f => f.ArticleI3D == ArticleI3D);
+            }
+        }
+
+        private ReceiptBaseDTO SaveReceipt(ReceiptBaseDTO originReceipt)
+        {
+            using (var session = new BLSession())
+            {
+                var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
+
+                var saveReceiptResult = session.GetBL<ReceiptWebServiceBL>().SaveReceipt(
+                    originReceipt,
+                    user,
+                    new SaveReceiptData { IgnoreCallbacks = true },
+                    autoLockIfNewReceipt: false,
+                    CreatedThroughApplication.WebServices,
+                    receiptTemplateFolderI3D: null);
+                
+                Assert.NotNull(saveReceiptResult.Data.Receipt);
+
+                return saveReceiptResult.Data.Receipt;
+            }
+        }
+
+        private ReceiptBaseDTO ForwardReceipt(CentronObjectKindNumeric targetReceiptKind, ReceiptBaseDTO originReceipt)
+        {
+            using (var session = new BLSession())
+            {
+                var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
+
+                var forwardResult = session.GetBL<ReceiptWebServiceBL>().ForwardReceipt(
+                    targetReceiptKind,
+                    user,
+                    new ForwardReceiptData
+                    {
+                        CreateReceiptData = new CreateReceiptData
+                        {
+                            IgnoreCallbacks = true,
+                        },
+                        CreateReceiptItemsFromExistingItemsData = new List<CreateReceiptItemsFromExistingItemsData>
+                        {
+                            new()
+                            {
+                                IgnoreCallbacks = true,
+                            },
+                        },
+                        IgnoreCallbacks = true
+                    },
+                    new List<ReceiptToForward>
+                    {
+                        new ReceiptToForward
+                        {
+                            ReceiptKind = originReceipt.ReceiptKind,
+                            ReceiptI3D = originReceipt.I3D
+                        }
+                    },
+                    null,
+                    InsertReceiptTakeoverOptions.Reference,
+                    true,
+                    false);
+
+                return forwardResult.Data.Receipt;
+            }
+        }
+
+        private ReceiptBaseDTO CreateNewVersion(CentronObjectKindNumeric receiptKind, int receiptI3D, bool updateReceiptDate)
+        {
+            using (var session = new BLSession())
+            {
+                var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
+
+                var createNewVersionResult = session.GetBL<ReceiptWebServiceBL>().CreateNewVersion(
+                    receiptKind,
+                    receiptI3D,
+                    null,
+                    null,
+                    user,
+                    new CreateNewVersionData
+                    {
+                        UpdateReceiptDate = updateReceiptDate
+                    });
+
+                return createNewVersionResult.Data.Receipt;
+            }
+        }
+
+
+        private List<UpdatedTaxRate> GetUpdatedTaxRates(ReceiptBaseDTO receipt)
+        {
+            using (var session = new BLSession())
+            {
+                return session.GetBL<ReceiptWebServiceBL>().GetUpdatedTaxRates(receipt);
+            }
+        }
+    }
+}