public static void CreateCorrectiveDocument(XElement source, CommercialDocument destination)
{
Guid sourceDocumentId = new Guid(source.Element("correctedDocumentId").Value);
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
ICollection <Guid> previousDocumentsId = mapper.GetCommercialCorrectiveDocumentsId(sourceDocumentId);
CommercialDocument sourceDocument = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, sourceDocumentId);
CommercialDocument lastDoc = sourceDocument;
foreach (Guid corrId in previousDocumentsId)
{
CommercialDocument correctiveDoc = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, corrId);
CommercialCorrectiveDocumentFactory.RelateTwoCorrectiveDocuments(lastDoc, correctiveDoc, true);
lastDoc = correctiveDoc;
}
CommercialCorrectiveDocumentFactory.CalculateDocumentsAfterCorrection(lastDoc);
CommercialCorrectiveDocumentFactory.CreateNextCorrectiveDocument(lastDoc, destination);
DuplicableAttributeFactory.DuplicateAttributes(lastDoc, destination);
var salesOrderRelation = sourceDocument.Relations.Where(r => r.RelationType == DocumentRelationType.SalesOrderToInvoice).FirstOrDefault();
if (salesOrderRelation != null) //dokument jest do ZS wiec korekte tez tam podpinamy
{
var relation = destination.Relations.CreateNew();
relation.RelationType = DocumentRelationType.SalesOrderToCorrectiveCommercialDocument;
relation.RelatedDocument = salesOrderRelation.RelatedDocument;
}
}
public static void CreateOutcomeShiftFromWarehouseDocument(XElement source, WarehouseDocument destination)
{
/*
* <root>
* <warehouseDocumentId>GUID</warehouseDocumentId>
* </root>
*/
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
WarehouseDocument incomeDocument = (WarehouseDocument)mapper.LoadBusinessObject(BusinessObjectType.WarehouseDocument, new Guid(source.Element("warehouseDocumentId").Value));
destination.WarehouseId = incomeDocument.WarehouseId;
//create lines
foreach (var incLine in incomeDocument.Lines)
{
WarehouseDocumentLine line = destination.Lines.CreateNew();
line.ItemId = incLine.ItemId;
line.ItemName = incLine.ItemName;
line.Quantity = incLine.Quantity;
line.UnitId = incLine.UnitId;
line.ItemTypeId = incLine.ItemTypeId;
}
//Duplicate attributes
DuplicableAttributeFactory.DuplicateAttributes(incomeDocument, destination);
}
public static void GenerateSalesOrderFromBill(XElement source, CommercialDocument destination)
{
Guid docId = new Guid(source.Element("salesDocumentId").Value);
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
CommercialDocument doc = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, docId);
SalesOrderFactory.CopyLinesToSalesOrder(doc, destination);
}
public static void GeneratePurchaseInvoiceFromMultipleSalesOrders(XElement source, CommercialDocument destination)
{
/*
* robimy fakture zakupową na pozycje usługowe
*/
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
List <CommercialDocument> soDocs = new List <CommercialDocument>();
CalculationType?calcType = CalculationType.Net;
destination.CalculationType = calcType.Value;
foreach (XElement soId in source.Elements("salesOrderId"))
{
Guid docId = new Guid(soId.Value);
var exists = soDocs.Where(d => d.Id.Value == docId).FirstOrDefault();
if (exists != null)
{
continue;
}
CommercialDocument doc = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, docId);
soDocs.Add(doc);
}
//kopiujemy atrybuty jezeli sa jakies takie
DuplicableAttributeFactory.DuplicateAttributes(soDocs, destination);
XElement tagXml = new XElement("salesOrders");
foreach (CommercialDocument salesOrder in soDocs)
{
//Dla dokumentu zakupowego nie ma ograniczenia
//if (salesOrder.Relations.Where(rr => rr.RelationType == DocumentRelationType.SalesOrderToInvoice).FirstOrDefault() != null)
// throw new ClientException(ClientExceptionId.UnableToCreateInvoiceToSalesOrder, null, "orderNumber:" + salesOrder.Number.FullNumber);
SalesOrderFactory.CopyLinesFromSalesOrder(salesOrder, destination, true, false, true, false);
tagXml.Add(new XElement("salesOrder", new XAttribute("id", salesOrder.Id.ToUpperString()), new XAttribute("version", salesOrder.Version.ToUpperString())));
}
destination.Calculate();
destination.Tag = tagXml.ToString(SaveOptions.DisableFormatting);
}
internal void CheckDoesRealizeClosedSalesOrder(DocumentCoordinator coordinator)
{
//to ma działać tylko dla RW i tylko gdy jest on zapisywany bezpośrednio a nie jako powiązany dokument
if (!this.IsNew &&
this.WarehouseDirection == Enums.WarehouseDirection.Outcome &&
!this.HasAnyCommercialCommercialWarehouseRelations)
{
DocumentMapper mapper =
(DocumentMapper)DependencyContainerManager.Container.Get <DocumentMapper>();
IEnumerable <Document> relatedSalesOrders = this.Relations.GetRelatedDocuments(DocumentRelationType.SalesOrderToWarehouseDocument);
foreach (Document relatedSalesOrder in relatedSalesOrders)
{
CommercialDocument salesOrder = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, relatedSalesOrder.Id.Value);
if (relatedSalesOrder.Id.HasValue && SalesOrderFactory.IsSalesOrderClosed(salesOrder))
{
throw new ClientException(ClientExceptionId.DocumentEditForbiddenRelatedSalesOrderClosed);
}
}
}
}
public void Execute(Document document)
{
if (document.IsBeforeSystemStart)
{
return;
}
if (document.Source != null &&
(document.Source.Attribute("type").Value == "order" || document.CheckSourceType(SourceType.SalesOrderRealization)))
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
CommercialDocument order = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(document.Source.Attribute("commercialDocumentId").Value));
List <WarehouseDocument> warehouses = new List <WarehouseDocument>();
warehouses.Add((WarehouseDocument)document);
CommercialWarehouseDocumentFactory.RelateWarehousesLinesToOrderLines(warehouses, order, document.Source, true, false);
/*if (SalesOrderFactory.TryCloseSalesOrder(order))
* document.AddRelatedObject(order);*/
}
else if (document.Source != null && document.Source.Attribute("type").Value == "multipleReservations")
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
List <CommercialDocument> reservations = new List <CommercialDocument>();
foreach (var orderXml in document.Source.Elements())
{
CommercialDocument order = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(orderXml.Value));
reservations.Add(order);
}
List <WarehouseDocument> warehouses = new List <WarehouseDocument>();
warehouses.Add((WarehouseDocument)document);
CommercialWarehouseDocumentFactory.RelateWarehousesLinesToMultipleOrdersLines(warehouses, reservations, true, false);
}
}
public static void CreateCorrectiveDocument(XElement source, WarehouseDocument destination)
{
Guid sourceDocumentId = new Guid(source.Element("correctedDocumentId").Value);
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
WarehouseDocument sourceDocument = (WarehouseDocument)mapper.LoadBusinessObject(BusinessObjectType.WarehouseDocument, sourceDocumentId);
WarehouseDirection direction = sourceDocument.WarehouseDirection;
if (ConfigurationMapper.Instance.PreventDocumentCorrectionBeforeSystemStart &&
sourceDocument.IsBeforeSystemStart)
{
throw new ClientException(ClientExceptionId.DocumentCorrectionBeforeSystemStartError);
}
destination.Contractor = sourceDocument.Contractor;
destination.WarehouseId = sourceDocument.WarehouseId;
DuplicableAttributeFactory.DuplicateAttributes(sourceDocument, destination);
foreach (WarehouseDocumentLine line in sourceDocument.Lines.Children)
{
WarehouseDocumentLine correctedLine = mapper.GetWarehouseDocumentLineAfterCorrection(line, direction);
if (correctedLine != null)
{
destination.Lines.AppendChild(correctedLine);
}
}
if (destination.Lines.Children.Count == 0)
{
throw new ClientException(ClientExceptionId.FullyCorrectedCorrectionError);
}
destination.InitialCorrectedDocument = sourceDocument;
}
public static void UpdateFinancialDocumentsInCommercialDocument(CommercialDocument document)
{
if (document == null)
{
return;
}
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
ICollection <Guid> financialIdCol = mapper.GetRelatedFinancialDocumentsId(document.Id.Value);
//wczytujemy i laczymy dokumenty po paymentach
foreach (Guid id in financialIdCol)
{
FinancialDocument fDoc = null;
try
{
fDoc = (FinancialDocument)mapper.LoadBusinessObject(BusinessObjectType.FinancialDocument, id);
}
catch (ClientException ex)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:126");
if (ex.Id == ClientExceptionId.ObjectNotFound)
{
continue;
}
}
document.AddRelatedObject(fDoc);
//aktualizujemy dane kursu na dokumencie finansowym i na jego platnosciach
fDoc.ExchangeDate = document.ExchangeDate;
fDoc.ExchangeRate = document.ExchangeRate;
fDoc.ExchangeScale = document.ExchangeScale;
foreach (Payment payment in fDoc.Payments)
{
payment.ExchangeDate = document.ExchangeDate;
payment.ExchangeRate = document.ExchangeRate;
payment.ExchangeScale = document.ExchangeScale;
}
var settlements = from p in document.Payments.Children
from s in p.Settlements.Children
select s;
foreach (PaymentSettlement settlement in settlements)
{
Payment pt = fDoc.Payments.Children.Where(x => x.Id.Value == settlement.RelatedPayment.Id.Value).FirstOrDefault();
if (pt != null)
{
settlement.RelatedPayment = pt;
if (settlement.AlternateVersion != null)
{
((PaymentSettlement)settlement.AlternateVersion).RelatedPayment = pt;
}
}
}
//replace deleted payments/settlements
if (document.AlternateVersion != null)
{
CommercialDocument alternateDocument = (CommercialDocument)document.AlternateVersion;
var deletedSettlements = from p in alternateDocument.Payments.Children
from s in p.Settlements.Children
where p.AlternateVersion == null
select s;
foreach (PaymentSettlement settlement in deletedSettlements)
{
Payment pt = fDoc.Payments.Children.Where(x => x.Id.Value == settlement.RelatedPayment.Id.Value).FirstOrDefault();
if (pt != null)
{
settlement.RelatedPayment = pt;
}
}
}
}
if (!FinancialDocumentFactory.IsFinancialToCommercialRelationOneToOne(document))
{
throw new ClientException(ClientExceptionId.AutomaticFinancialDocumentUpdateException);
}
//aktualizujemy
foreach (Payment payment in document.Payments.Children.Where(p => p.Status == BusinessObjectStatus.Modified))
{
Payment alternatePayment = (Payment)payment.AlternateVersion;
string cntId, altercntId;
cntId = payment.Contractor != null?payment.Contractor.Id.ToString() : "brak";
altercntId = alternatePayment.Contractor != null?alternatePayment.Contractor.Id.ToString() : "brak";
//Jeśli zmienia się kontrhent to należy zmienić dowiązany dokument handlowy
if (payment.PaymentMethodId.Value == alternatePayment.PaymentMethodId.Value &&
!(cntId != altercntId)) //zmienila sie wartosc
{
PaymentSettlement settlement = payment.Settlements.Children.FirstOrDefault();
if (settlement != null)
{
settlement.Amount = Math.Abs(payment.Amount);
decimal difference = Math.Abs(Math.Abs(payment.Amount) - Math.Abs(settlement.RelatedPayment.Amount));
if ((settlement.RelatedPayment.Amount + difference) * settlement.RelatedPayment.Direction == -payment.Amount * payment.Direction)
{
settlement.RelatedPayment.Amount += difference;
}
else
{
settlement.RelatedPayment.Amount -= difference;
}
((FinancialDocument)settlement.RelatedPayment.Parent).Amount = settlement.RelatedPayment.Amount;
settlement.RelatedPayment.Amount = settlement.RelatedPayment.Amount;
settlement.RelatedPayment.Settlements.Where(s => s.Id.Value == settlement.Id.Value).First().Amount = settlement.RelatedPayment.Amount;
}
}
else //zmienila sie forma platnosci
{
//anulujemy powiazany dokument finansowy jezeli:
//1) powiazanie jest na pelna sume
//2) dokument istnieje (nie rozliczamy nic z innego oddzialu
//3) powiazany dokument ma taki sam typ jaki jaki generowala stara forma platnosci
if (payment.Settlements.Children.Count > 0)
{
//1
if (payment.Settlements.Children.Count != 1)
{
throw new ClientException(ClientExceptionId.AutomaticFinancialDocumentUpdateException);
}
if (alternatePayment.Amount != payment.Settlements.Children.First().Amount)
{
throw new ClientException(ClientExceptionId.AutomaticFinancialDocumentUpdateException);
}
//2
FinancialDocument fDoc = (FinancialDocument)payment.Settlements.Children.First().RelatedPayment.Parent;
if (fDoc == null)
{
throw new ClientException(ClientExceptionId.AutomaticFinancialDocumentUpdateException);
}
//3
FinancialRegister reg = DictionaryMapper.Instance.GetFinancialRegisterForSpecifiedPaymentMethod(alternatePayment.PaymentMethodId.Value, SessionManager.User.BranchId, alternatePayment.PaymentCurrencyId);
if (reg == null || (reg.IncomeDocumentTypeId != fDoc.DocumentTypeId && reg.OutcomeDocumentTypeId != fDoc.DocumentTypeId))
{
throw new ClientException(ClientExceptionId.AutomaticFinancialDocumentUpdateException);
}
//warunki spelnione, mozna anulowac
DocumentStatusChangeLogic.CancelFinancialDocument(fDoc);
payment.Settlements.RemoveAll();
}
FinancialDocumentFactory.GenerateFinancialDocumentToPayment(payment, document);
}
}
}
public static void GenerateInvoiceFromMultipleSalesOrders(XElement source, CommercialDocument destination)
{
/*
* <source type="multipleSalesOrders">
* <salesOrderId>{documentId}</salesOrderId>
* <salesOrderId>{documentId}</salesOrderId>
* <salesOrderId>{documentId}</salesOrderId>
* .........
* </source>
*/
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
List <CommercialDocument> soDocs = new List <CommercialDocument>();
CalculationType?calcType = null;
foreach (XElement soId in source.Elements("salesOrderId"))
{
Guid docId = new Guid(soId.Value);
var exists = soDocs.Where(d => d.Id.Value == docId).FirstOrDefault();
if (exists != null)
{
continue;
}
CommercialDocument doc = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, docId);
soDocs.Add(doc);
if (calcType == null)
{
calcType = doc.CalculationType;
}
else if (calcType.Value != doc.CalculationType)
{
throw new ClientException(ClientExceptionId.DifferentCalculationTypes);
}
}
if (calcType.Value != destination.CalculationType && destination.DocumentType.CommercialDocumentOptions.AllowCalculationTypeChange)
{
destination.CalculationType = calcType.Value;
}
//sprawdzamy czy dok. zrodlowe maja wspolnego kontrahenta. jezeli tak to kopiujemy go na fakture
bool copyContractor = true;
//jezeli gdzies nie ma kontrahenta to nie kopiujemy
var emptyContractor = soDocs.Where(w => w.Contractor == null).FirstOrDefault();
if (emptyContractor != null)
{
copyContractor = false;
}
if (copyContractor)
{
var differentContractor = soDocs.Where(ww => ww.Contractor.Id.Value != soDocs[0].Contractor.Id.Value).FirstOrDefault();
if (differentContractor != null)
{
copyContractor = false;
}
}
if (copyContractor)
{
destination.Contractor = soDocs[0].Contractor;
if (destination.Contractor != null)
{
var address = destination.Contractor.Addresses.GetBillingAddress();
if (address != null)
{
destination.ContractorAddressId = address.Id.Value;
}
}
}
//kopiujemy atrybuty jezeli sa jakies takie
DuplicableAttributeFactory.DuplicateAttributes(soDocs, destination);
XElement tagXml = new XElement("salesOrders");
foreach (CommercialDocument salesOrder in soDocs)
{
if (salesOrder.Relations.Where(rr => rr.RelationType == DocumentRelationType.SalesOrderToInvoice).FirstOrDefault() != null)
{
throw new ClientException(ClientExceptionId.UnableToCreateInvoiceToSalesOrder, null, "orderNumber:" + salesOrder.Number.FullNumber);
}
SalesOrderFactory.CopyLinesFromSalesOrder(salesOrder, destination, true, false, true, true);
tagXml.Add(new XElement("salesOrder", new XAttribute("id", salesOrder.Id.ToUpperString()), new XAttribute("version", salesOrder.Version.ToUpperString())));
}
destination.Calculate();
destination.Tag = tagXml.ToString(SaveOptions.DisableFormatting);
}
public static void GeneratePrepaymentDocument(XElement source, CommercialDocument destination)
{
/*
* <source type="salesOrder">
* <salesOrderId>{documentId}</salesOrderId>
* <processObject>prepaidInvoice</processObject>
* <closeOrder>false</closeOrder>
* </source>
*/
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
bool closeOrder = false;
if (source.Element("closeOrder") != null && source.Element("closeOrder").Value.ToUpperInvariant() == "TRUE")
{
closeOrder = true;
}
CommercialDocument salesOrder = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(source.Element("salesOrderId").Value));
SalesOrderFactory.CheckIfSalesOrderHasWarehouseDocumentsWithInvoices(salesOrder, closeOrder);
SalesOrderSettlements salesOrderSettlements = new SalesOrderSettlements();
salesOrderSettlements.LoadSalesOrder(salesOrder);
XElement settledAmount = mapper.GetSalesOrderSettledAmount(salesOrder.Id.Value);
salesOrderSettlements.LoadPrepaids(settledAmount);
destination.SalesOrderSettlements = salesOrderSettlements;
string processType = salesOrder.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value;
string processObject = source.Element("processObject").Value;
bool isSimulated = processObject == "simulatedInvoice";
bool hasProtocole = source.Element("protocole") != null && source.Element("protocole").Value == "true";
ProcessManager.Instance.AppendProcessAttributes(destination, processType, processObject, null, null);
DuplicableAttributeFactory.DuplicateAttributes(salesOrder, destination);
if (isSimulated && hasProtocole)
{
destination.Attributes.GetOrCreateNew(DocumentFieldName.Attribute_IsSimulateSettlementInvoiceWithProtocole).Value.Value = "1";
}
//sprawdzamy czy dokumenty zrodlowe maja zgodne sposoby liczenia
if (salesOrder.CalculationType != destination.CalculationType && destination.DocumentType.CommercialDocumentOptions.AllowCalculationTypeChange)
{
destination.CalculationType = salesOrder.CalculationType;
}
if (salesOrder.Contractor != null)
{
destination.Contractor = (Contractor)salesOrder.Contractor;
}
if (salesOrder.ContractorAddressId != null)
{
destination.ContractorAddressId = salesOrder.ContractorAddressId;
}
int prepaidDocuments = 0;
prepaidDocuments = salesOrder.Relations.Where(r => r.RelationType == DocumentRelationType.SalesOrderToInvoice).Count();
destination.Tag = prepaidDocuments.ToString(CultureInfo.InvariantCulture);
/* teraz wybieramy odpowiednia sciezke algorytmu. mamy takie mozliwosc:
* 1) wystawiamy zaliczke
* - w takiej sytuacji wybieramy id towaru zaliczkowego dla kazdej ze stawek vat i wpisujemy tam wartosci nierozliczone
* 2) wystawiamy fakture rozliczajaca (closeOrder == true) podczas gdy mamy zaliczki (prepaidDocuments > 0)
* - kopiujemy wszystkie pozycje z ZS 1:1, a tabele vat pomniejszamy o sume zaliczek
* 3) wystawiamy fakture rozliczajaca (closeOrder == true) i nie mamy dokumentow zaliczkowych (prepaidDocuments == 0)
* - w takim przypadku zamowienie sprzedazowe traktujemy jako proforme, kopiujemy wszystkie pozycje i tabele vat bez zmian i tyle
*/
//wstawiamy odpowiedni towar na zaliczke + ustawiamy odpowiednai wartosc
int stage = 0;
if (closeOrder)
{
stage = 0;
}
else if (prepaidDocuments == 0)
{
stage = 1;
}
else if (prepaidDocuments == 1)
{
stage = 2;
}
else if (prepaidDocuments == 2)
{
stage = 3;
}
else if (prepaidDocuments >= 3)
{
stage = 4;
}
List <Guid> items = new List <Guid>(2);
ICollection <SalesOrderSettlement> unsettledValues = salesOrderSettlements.GetUnsettledValues();
foreach (var v in salesOrder.VatTableEntries.GetVatRates())
{
items.Add(ProcessManager.Instance.GetPrepaidItemId(salesOrder, stage, v));
}
XDocument xml = DependencyContainerManager.Container.Get <ItemMapper>().GetItemsDetailsForDocument(false, null, null, items);
if (closeOrder)
{
SalesOrderFactory.CopyLinesFromSalesOrder(salesOrder, destination, false, true, false, true);
destination.Calculate();
//Ostatnia rata pchamy do atrybutu zeby wydruk fiskalny wiedzial co ma wydrukowac
if (destination.CalculationType == CalculationType.Gross && !isSimulated)
{
XElement fiscalLines = new XElement("fiscalLines");
foreach (var v in unsettledValues)
{
XElement itemXml = xml.Root.Elements().Where(i => i.Attribute("id").Value == ProcessManager.Instance.GetPrepaidItemId(salesOrder, stage, v.VatRateId).ToUpperString()).First();
XElement fiscalLine = new XElement("fiscalLine");
fiscalLine.Add(new XElement("itemName", itemXml.Attribute("name").Value));
fiscalLine.Add(new XElement("quantity", "1"));
fiscalLine.Add(new XElement("vatRateId", itemXml.Attribute("vatRateId").Value));
fiscalLine.Add(new XElement("grossPrice", v.GrossValue.ToString(CultureInfo.InvariantCulture)));
fiscalLine.Add(new XElement("grossValue", v.GrossValue.ToString(CultureInfo.InvariantCulture)));
fiscalLine.Add(new XElement("unitId", itemXml.Attribute("unitId").Value));
fiscalLines.Add(fiscalLine);
}
var attribute = destination.Attributes.CreateNew(DocumentFieldName.Attribute_FiscalPrepayment);
attribute.Value = fiscalLines;
}
if (prepaidDocuments > 0) // *2)
{
decimal maxDifference = ProcessManager.Instance.GetMaxSettlementDifference(salesOrder);
foreach (var v in salesOrderSettlements.Prepaids)
{
if (v.NetValue > 0 || v.GrossValue > 0 || v.VatValue > 0)
{
var vt = destination.VatTableEntries.Where(t => t.VatRateId == v.VatRateId).FirstOrDefault();
var prepaidVt = destination.VatTableEntries.CreateNewAfter(vt, v.VatRateId);
prepaidVt.VatRateId = v.VatRateId;
prepaidVt.NetValue = -v.NetValue;
prepaidVt.GrossValue = -v.GrossValue;
prepaidVt.VatValue = -v.VatValue;
decimal vtNetValue = 0;
decimal vtGrossValue = 0;
decimal vtVatValue = 0;
if (vt != null)
{
vtNetValue = vt.NetValue;
vtGrossValue = vt.GrossValue;
vtVatValue = vt.VatValue;
}
decimal grossBalance = vtGrossValue + prepaidVt.GrossValue;
decimal netBalance = vtNetValue + prepaidVt.NetValue;
decimal vatBalance = vtVatValue + prepaidVt.VatValue;
SalesOrderBalanceValidator validator =
new SalesOrderBalanceValidator(maxDifference, grossBalance, netBalance, vatBalance);
if (validator.IsIllegalOverPayment)
{
throw new ClientException(ClientExceptionId.SalesOrderSettlementOverpaidError, null, "value:" + (-grossBalance).ToString(CultureInfo.InvariantCulture).Replace('.', ',')); //nadpłata powyżej granicy błędu
}
else if (validator.IsAcceptableOverPayment) //czyli mamy nadplate w granicy bledu
{
prepaidVt.NetValue = -vtNetValue;
prepaidVt.GrossValue = -vtGrossValue;
prepaidVt.VatValue = -vtVatValue;
}
}
}
}
else
{
throw new ClientException(ClientExceptionId.UnableToCreateSettlementDocument3);
}
decimal netValue = 0;
decimal grossValue = 0;
decimal vatValue = 0;
foreach (var vt in destination.VatTableEntries)
{
netValue += vt.NetValue;
grossValue += vt.GrossValue;
vatValue += vt.VatValue;
}
destination.NetValue = netValue;
destination.GrossValue = grossValue;
destination.VatValue = vatValue;
destination.DisableLinesChange = DisableDocumentChangeReason.LINES_SETTLEMENT_INVOICE;
if (!isSimulated)
{
var attr = destination.Attributes.CreateNew(DocumentFieldName.Attribute_IsSettlementDocument);
attr.Value.Value = "1";
}
}
else //1) wystawiamy zaliczke
{
foreach (XElement itemXml in xml.Root.Elements("item"))
{
CommercialDocumentLine line = destination.Lines.CreateNew();
line.ItemId = new Guid(itemXml.Attribute("id").Value);
Guid vatRateId = new Guid(itemXml.Attribute("vatRateId").Value);
if (itemXml.Attribute("code") != null)
{
line.ItemCode = itemXml.Attribute("code").Value;
}
line.UnitId = new Guid(itemXml.Attribute("unitId").Value);
line.VatRateId = vatRateId;
line.ItemVersion = new Guid(itemXml.Attribute("version").Value);
line.Quantity = 1;
line.ItemName = itemXml.Attribute("name").Value;
}
destination.Calculate();
}
}
public void Execute(Document document)
{
if (document.IsBeforeSystemStart)
{
return;
}
CommercialDocument commercialDocument = document as CommercialDocument;
#region Outcome From Sales
if (this.method == OutcomeFromSalesMethod)
{
//Pobranie konfiguracji dla typu dokumentu
XElement configurationSettings = commercialDocument.DocumentType.Options;
String templateName;
try
{
templateName = (string)configurationSettings.Descendants("generateDocument").Attributes("templateName").Single();
}
catch (Exception)
{
//RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:4");
templateName = "externalOutcome";
}
ICollection <WarehouseDocument> warehouses = CommercialWarehouseDocumentFactory.Generate(commercialDocument, templateName, true, false);
if (warehouses.Count > 0)
{
CommercialWarehouseDocumentFactory.RelateCommercialLinesToWarehousesLines(commercialDocument, warehouses, false, false, true, false);
XElement source = document.Source;
if (source != null && (source.Attribute("type").Value == "order" || source.Attribute("type").Value == SourceType.SalesOrderRealization))
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
CommercialDocument order = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(source.Attribute("commercialDocumentId").Value));
CommercialWarehouseDocumentFactory.RelateWarehousesLinesToOrderLines(warehouses, order, commercialDocument.Source, true, false);
/*if (SalesOrderFactory.TryCloseSalesOrder(order))
* commercialDocument.AddRelatedObject(order);*/
}
else if (source != null && source.Attribute("type").Value == "multipleReservations")
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
List <CommercialDocument> reservations = new List <CommercialDocument>();
foreach (var orderXml in source.Elements().Where(e => e.Name != "extraParams"))
{
CommercialDocument order = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(orderXml.Value));
reservations.Add(order);
}
CommercialWarehouseDocumentFactory.RelateWarehousesLinesToMultipleOrdersLines(warehouses, reservations, true, false);
}
}
}
#endregion
#region Income From Purchase
else if (this.method == IncomeFromPurchaseMethod)
{
ICollection <WarehouseDocument> warehouses = CommercialWarehouseDocumentFactory.Generate(commercialDocument, "externalIncome", true, false);
if (warehouses.Count > 0)
{
CommercialWarehouseDocumentFactory.RelateCommercialLinesToWarehousesLines(commercialDocument, warehouses, true, false, true, false);
XElement source = document.Source;
if (source != null && source.Attribute("type").Value == "order")
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
CommercialDocument order = (CommercialDocument)mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, new Guid(source.Attribute("commercialDocumentId").Value));
CommercialWarehouseDocumentFactory.RelateWarehousesLinesToOrderLines(warehouses, order, commercialDocument.Source, true, false);
}
}
}
#endregion
else if (this.method == FinancialFromCommercialMethod)
{
//Warunek na istnienie jakiego kolwiek settlementu, bez tego nie chciał się dogenerować dokument finansowy
//Błąd mówił o niejednoznacznych relacjach uniemożliwiających zaktualizowanie dokumentu finansowego
bool cos = commercialDocument.Payments.Any(p => p.Settlements.Children.Count > 0);
if (document.IsNew || !cos)
{
FinancialDocumentFactory.GenerateFinancialDocumentToCommercialDocument(commercialDocument);
}
else
{
FinancialDocumentFactory.UpdateFinancialDocumentsInCommercialDocument(commercialDocument);
}
}
}