private void CorrectDocumentConsistency(FinancialDocument document)
{
foreach (Payment payment in document.Payments)
{
payment.ExchangeDate = document.ExchangeDate;
payment.ExchangeRate = document.ExchangeRate;
payment.ExchangeScale = document.ExchangeScale;
if (!payment.IsNew)
{
continue;
}
payment.PaymentCurrencyId = document.DocumentCurrencyId;
payment.SystemCurrencyId = document.SystemCurrencyId;
payment.Contractor = document.Contractor;
payment.ContractorAddressId = document.ContractorAddressId;
payment.Date = document.IssueDate;
payment.DueDate = document.IssueDate;
foreach (PaymentSettlement s in payment.Settlements.Children)
{
s.Date = document.IssueDate;
s.Amount = payment.Amount;
}
}
}
/// <summary>
/// Creates new <see cref="Payment"/> according to the document's defaults and attaches it to the parent <see cref="Document"/>.
/// </summary>
/// <returns>A new <see cref="Payment"/>.</returns>
public override Payment CreateNew()
{
//create new Payment object and attach it to the element
Document parent = (Document)this.Parent;
Payment payment = new Payment(parent);
payment.Order = this.Children.Count + 1;
DocumentCategory dc = parent.DocumentType.DocumentCategory;
CommercialDocument commercialDocument = this.Parent as CommercialDocument;
FinancialDocument financialDocument = this.Parent as FinancialDocument;
if (dc == DocumentCategory.Sales || dc == DocumentCategory.SalesCorrection)
{
payment.Direction = -1;
}
else if (dc == DocumentCategory.Purchase || dc == DocumentCategory.PurchaseCorrection)
{
payment.Direction = 1;
}
else if (dc == DocumentCategory.Financial)
{
FinancialDirection fdc = parent.DocumentType.FinancialDocumentOptions.FinancialDirection;
if (fdc == FinancialDirection.Income)
{
payment.Direction = 1;
}
else
{
payment.Direction = -1;
}
}
//Copy payment contractor from source if exists
if (this.PaymentContainingSourceDocument != null &&
this.PaymentContainingSourceDocument.Payments != null &&
this.PaymentContainingSourceDocument.Payments.Children.Count >= payment.Order)
{
Payment sourcePayment = this.PaymentContainingSourceDocument.Payments[payment.Order - 1];
payment.Contractor = sourcePayment.Contractor;
payment.ContractorAddressId = sourcePayment.ContractorAddressId;
}
else if (commercialDocument != null)
{
payment.Contractor = commercialDocument.Contractor;
payment.ContractorAddressId = commercialDocument.ContractorAddressId;
}
else if (financialDocument != null)
{
payment.Contractor = financialDocument.Contractor;
payment.ContractorAddressId = financialDocument.ContractorAddressId;
}
//add the attribute to the collection
this.Children.Add(payment);
return(payment);
}
private void ExecuteCustomLogic(FinancialDocument document)
{
List <Guid> salesOrders = new List <Guid>();
foreach (var payment in document.Payments)
{
if (payment.SalesOrderId != null)
{
var relation = document.Relations.CreateNew(BusinessObjectStatus.New);
relation.RelationType = DocumentRelationType.SalesOrderToOutcomeFinancialDocument;
relation.RelatedDocument = new CommercialDocument()
{
Id = payment.SalesOrderId.Value
};
relation.DecimalValue = payment.Amount;
if (!salesOrders.Contains(payment.SalesOrderId.Value))
{
salesOrders.Add(payment.SalesOrderId.Value);
CommercialDocument salesOrder = (CommercialDocument)this.mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, payment.SalesOrderId.Value);
DuplicableAttributeFactory.DuplicateAttributes(salesOrder, document);
}
}
}
this.MergePayments(document);
this.CreateOrUpdateNegativePayment(document);
}
private string MergeDescriptions(FinancialDocument document)
{
string mergedText = String.Empty;
string previousText = null;
foreach (var line in document.Payments)
{
if (line.Amount < 0 || line.Description == null)
{
continue;
}
//mergujemy text
if (previousText == null)
{
mergedText = line.Description;
if (line.IsNew)
{
mergedText += this.AmountToStr(line.Amount);
}
}
else
{
string[] previous = previousText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
string[] current = line.Description.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int min = Math.Min(previous.Length, current.Length);
for (int i = 0; i < min; i++)
{
if (previous[i] != current[i])
{
mergedText += ", ";
for (int u = i; u < current.Length; u++)
{
mergedText += current[u];
if (u + 1 < current.Length)
{
mergedText += " ";
}
}
break;
}
}
mergedText += this.AmountToStr(line.Amount);
}
previousText = line.Description;
}
return(mergedText);
}
public static void BindCashOutcomeDocumentToSalesOrder(XElement source, FinancialDocument destination)
{
/*
* <source type="salesOrder">
* <salesOrderId>{documentId}</salesOrderId>
* </source>
*/
var payment = destination.Payments.CreateNew();
payment.Description = "Za fakturę nr: ";
payment.SalesOrderId = new Guid(source.Element("salesOrderId").Value);
}
public static void CancelFinancialDocument(FinancialDocument document)
{
document.Relations.RemoveAll();
document.DocumentStatus = DocumentStatus.Canceled;
foreach (Payment pt in document.Payments.Children)
{
pt.Settlements.RemoveAll();
pt.Direction = 0;
pt.ForceSave = true;//napewno trzeba ten stan zapisać
}
}
private void CreateOrUpdateNegativePayment(FinancialDocument document)
{
Guid?payerId = document.DocumentType.FinancialDocumentOptions.PayerId;
if (payerId == null)
{
return;
}
Payment negativePayment = document.Payments.Where(p => p.Amount < 0).FirstOrDefault();
if (negativePayment == null)
{
negativePayment = document.Payments.CreateNew(BusinessObjectStatus.New);
ContractorMapper contractorMapper = DependencyContainerManager.Container.Get <ContractorMapper>();
Contractor payer = (Contractor)contractorMapper.LoadBusinessObject(BusinessObjectType.Contractor, payerId.Value);
negativePayment.Contractor = payer;
var addr = payer.Addresses.GetDefaultAddress();
if (addr != null)
{
negativePayment.ContractorAddressId = addr.Id.Value;
}
negativePayment.Direction = document.Payments[0].Direction;
negativePayment.PaymentCurrencyId = document.DocumentCurrencyId;
negativePayment.SystemCurrencyId = document.SystemCurrencyId;
negativePayment.ExchangeDate = document.ExchangeDate;
negativePayment.ExchangeRate = document.ExchangeRate;
negativePayment.ExchangeScale = document.ExchangeScale;
negativePayment.Date = document.IssueDate;
negativePayment.DueDate = document.IssueDate;
}
if (!ConfigurationMapper.Instance.OnePositionFinancialDocuments)
{
negativePayment.Description = this.MergeDescriptions(document);
}
else
{
negativePayment.Description = document.Payments[0].Description;
}
string beginning = "Za dokument: ";
if (negativePayment.Description.StartsWith(beginning))
{
negativePayment.Description = negativePayment.Description.Substring(beginning.Length);
}
negativePayment.Amount = -document.Payments.Where(pp => pp.Amount > 0).Sum(a => a.Amount);
}
private void ValidateAfterSave(FinancialDocument document)
{
#region Blokada zejścia ze stanem finansowym poniżej 0
FinancialRegister financialRegister = DictionaryMapper.Instance.GetFinancialRegister(document.FinancialReport.FinancialRegisterId);
if (financialRegister.ValidateBalanceBelowZero)
{
if (this.mapper.GetFinancialReportBalance(document.FinancialReport.FinancialRegisterId) < 0)
{
throw new ClientException(ClientExceptionId.FinancialRegisterBalanceBelowZero);
}
}
#endregion
}
private void MergePayments(FinancialDocument document)
{
if (!ConfigurationMapper.Instance.OnePositionFinancialDocuments)
{
return;
}
string mergedText = this.MergeDescriptions(document);
List <Payment> paymentsToDelete = new List <Payment>();
Payment firstPayment = null;
foreach (var line in document.Payments)
{
if (line.Amount < 0)
{
continue;
}
//a tutaj sumujemy wartosci i przepisujemy rozliczenia
if (firstPayment == null)
{
firstPayment = line;
}
else
{
paymentsToDelete.Add(line);
firstPayment.Amount += line.Amount;
foreach (var settlement in line.Settlements)
{
var newSettlement = firstPayment.Settlements.CreateNew();
newSettlement.Amount = settlement.Amount;
newSettlement.RelatedPayment = new Payment(newSettlement)
{
Id = settlement.RelatedPayment.Id.Value
};
}
}
}
foreach (var pt in paymentsToDelete)
{
document.Payments.Remove(pt);
}
firstPayment.Description = mergedText;
}
private void ValidateDuringTransaction(FinancialDocument document)
{
FinancialRegister financialRegister = DictionaryMapper.Instance.GetFinancialRegister(document.FinancialReport.FinancialRegisterId);
//Sprawdzenie czy stanowisko ma uprawnienia do dodawania określonych płatności do raportu finansowego na wybranym rejestrze
if (!financialRegister.IsAllowedByProfile())
{
throw new ClientException(ClientExceptionId.UnableToIssueFinancialDocument4);
}
Guid?openedReportId = this.mapper.GetOpenedFinancialReportId(document.FinancialReport.FinancialRegisterId);
if (openedReportId == null)
{
throw new ClientException(ClientExceptionId.OpenedFinancialReportDoesNotExist);
}
else if (openedReportId.Value != document.FinancialReport.Id.Value)
{
throw new ClientException(ClientExceptionId.UnableToIssueDocumentToClosedFinancialReport);
}
XElement dates = this.mapper.GetFinancialReportsDate(document.FinancialReport.FinancialRegisterId);
DateTime openedReportCreationDate = DateTime.Parse(dates.Element("openedReportCreationDate").Value, CultureInfo.InvariantCulture);
DateTime?nextReportCreationDate = null;
if (dates.Element("nextReportCreationDate") != null)
{
nextReportCreationDate = DateTime.Parse(dates.Element("nextReportCreationDate").Value, CultureInfo.InvariantCulture);
}
if (document.IssueDate < openedReportCreationDate)
{
throw new ClientException(ClientExceptionId.UnableToIssueFinancialDocument);
}
if (nextReportCreationDate != null && document.IssueDate >= nextReportCreationDate.Value)
{
throw new ClientException(ClientExceptionId.UnableToIssueFinancialDocument2);
}
}
private void ExecuteLogicDuringTransaction(FinancialDocument document)
{
//doczytujemy wszystkie platnosci ktore mamy powiazac wraz z ich pozostalymi rozliczeniami
var paymentsToSettle = (from pt in document.Payments.Children
from s in pt.Settlements.Children
where s.Status == BusinessObjectStatus.New ||
s.Status == BusinessObjectStatus.Modified
select s.RelatedPayment.Id.Value).Distinct();
//kopiujemy to do listy bo jak linq w locie iteruje to man sie potem w locie zmieni wartosc
List <Guid> paymentsToSettleList = paymentsToSettle.ToList();
var settlementsToReplace = from pt in document.Payments.Children
from s in pt.Settlements.Children
where s.Status == BusinessObjectStatus.New ||
s.Status == BusinessObjectStatus.Modified
select s;
//j.w.
List <PaymentSettlement> settlementsToReplaceList = settlementsToReplace.ToList();
FinancialDocumentLogic.ReplaceAndValidatePayments(document.Payments.Children, paymentsToSettleList, settlementsToReplaceList);
}
public XDocument SaveBusinessObject(FinancialDocument document)
{
DictionaryMapper.Instance.CheckForChanges();
this.CorrectDocumentConsistency(document);
//Bezwarunkowo skopiuj kontrahenta z dokumentu do płatności.
document.Payments.CopyDocumentContractor();
//load alternate version
if (!document.IsNew)
{
IBusinessObject alternateBusinessObject = this.mapper.LoadBusinessObject(document.BOType, document.Id.Value);
document.SetAlternateVersion(alternateBusinessObject);
}
//validate
document.Validate();
this.ExecuteCustomLogic(document);
//update status
document.UpdateStatus(true);
if (document.AlternateVersion != null)
{
document.AlternateVersion.UpdateStatus(false);
}
SqlConnectionManager.Instance.BeginTransaction();
try
{
DictionaryMapper.Instance.CheckForChanges();
this.mapper.CheckBusinessObjectVersion(document);
DocumentLogicHelper.AssignNumber(document, this.mapper);
this.ExecuteLogicDuringTransaction(document);
this.ValidateDuringTransaction(document);
//Make operations list
XDocument operations = XDocument.Parse("<root/>");
document.SaveChanges(operations);
if (document.AlternateVersion != null)
{
document.AlternateVersion.SaveChanges(operations);
}
bool generateComPackage = false;
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
this.mapper.UpdateDictionaryIndex(document);
generateComPackage = true;
}
Coordinator.LogSaveBusinessObjectOperation();
document.SaveRelatedObjects();
operations = XDocument.Parse("<root/>");
document.SaveRelations(operations);
if (document.AlternateVersion != null)
{
((FinancialDocument)document.AlternateVersion).SaveRelations(operations);
}
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
generateComPackage = true;
}
this.ValidateAfterSave(document);
this.mapper.UpdateDocumentInfoOnPayments(document);
this.mapper.DeleteDocumentAccountingData(document);
if (generateComPackage)
{
this.mapper.CreateCommunicationXml(document);
if (operations.Root.HasElements)
{
this.mapper.CreateCommunicationXmlForDocumentRelations(operations); //generowanie paczek dla relacji dokumentow
}
}
XDocument returnXml = XDocument.Parse(String.Format(CultureInfo.InvariantCulture, "<root><id>{0}</id></root>", document.Id.ToUpperString()));
//Custom validation
this.mapper.ExecuteOnCommitValidationCustomProcedure(document);
if (this.coordinator.CanCommitTransaction)
{
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
return(returnXml);
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:65");
Coordinator.ProcessSqlException(sqle, document.BOType, this.coordinator.CanCommitTransaction);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:66");
if (this.coordinator.CanCommitTransaction)
{
SqlConnectionManager.Instance.RollbackTransaction();
}
throw;
}
}
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);
}
}
}
private static void GenerateFinancialDocumentToPayment(Payment payment, CommercialDocument document)
{
DocumentMapper mapper = DependencyContainerManager.Container.Get <DocumentMapper>();
using (DocumentCoordinator coordinator = new DocumentCoordinator(false, false))
{
PaymentMethod paymentMethod = DictionaryMapper.Instance.GetPaymentMethod(payment.PaymentMethodId.Value);
Guid branchId = SessionManager.User.BranchId;
if (DictionaryMapper.Instance.IsPaymentMethodSupportedByRegister(paymentMethod.Id.Value, branchId))
{
FinancialRegister register = DictionaryMapper.Instance.GetFinancialRegisterForSpecifiedPaymentMethod(paymentMethod.Id.Value, branchId, payment.PaymentCurrencyId);
if (register == null)
{
throw new ClientException(ClientExceptionId.UnableToIssueFinancialDocument3);
}
FinancialDirection direction = FinancialDocumentFactory.GetFinancialDirectionForPayment(document, payment);
Guid?reportId = mapper.GetOpenedFinancialReportId(register.Id.Value);
if (reportId == null)
{
throw new ClientException(ClientExceptionId.UnableToIssueDocumentToClosedFinancialReport);
}
FinancialDocument financialDoc = new FinancialDocument();
financialDoc.RelatedCommercialDocument = document;
coordinator.TrySaveProfileIdAttribute(financialDoc);
if (direction == FinancialDirection.Income)
{
financialDoc.DocumentTypeId = register.IncomeDocumentTypeId;
financialDoc.Number.NumberSettingId = register.IncomeNumberSettingId;
}
else
{
financialDoc.DocumentTypeId = register.OutcomeDocumentTypeId;
financialDoc.Number.NumberSettingId = register.OutcomeNumberSettingId;
}
financialDoc.Contractor = payment.Contractor;
financialDoc.ContractorAddressId = payment.ContractorAddressId;
FinancialReport report = new FinancialReport();
report.Id = reportId;
report.FinancialRegisterId = register.Id.Value;
financialDoc.FinancialReport = report;
financialDoc.DocumentStatus = DocumentStatus.Committed;
DuplicableAttributeFactory.DuplicateAttributes(document, financialDoc);
Payment pt = financialDoc.Payments.CreateNew();
pt.Amount = Math.Abs(payment.Amount);
pt.ExchangeRate = financialDoc.ExchangeRate = document.ExchangeRate;
pt.ExchangeScale = financialDoc.ExchangeScale = document.ExchangeScale;
pt.ExchangeDate = financialDoc.ExchangeDate = document.ExchangeDate;
financialDoc.Amount = pt.Amount;
financialDoc.DocumentCurrencyId = payment.PaymentCurrencyId;
PaymentSettlement settlement = pt.Settlements.CreateNew();
settlement.IsAutoGenerated = true;
settlement.RelatedPayment = payment;
settlement.Amount = pt.Amount;
document.AddRelatedObject(financialDoc);
}
}
}
public static Document DeserializeRelatedDocument(DocumentRelation relation, XElement relatedDocument)
{
Document parent = (Document)relation.Parent;
DocumentRelationType relationType = relation.RelationType;
Document retDocument = null;
if (relatedDocument == null)
{
throw new ClientException(ClientExceptionId.IncompleteRelation);
}
switch (relationType)
{
case DocumentRelationType.SalesDocumentToSimulatedInvoice:
case DocumentRelationType.InvoiceToBill:
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
break;
case DocumentRelationType.ServiceToOutcomeShift:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ServiceToInvoice:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ServiceToInternalOutcome:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ComplaintToInternalOutcome:
if (parent.BOType == BusinessObjectType.ComplaintDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ComplaintDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.InventoryToWarehouse:
if (parent.BOType == BusinessObjectType.InventoryDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new InventoryDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.SalesOrderToInvoice:
case DocumentRelationType.SalesOrderToCorrectiveCommercialDocument:
case DocumentRelationType.SalesOrderToSimulatedInvoice:
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
break;
case DocumentRelationType.SalesOrderToWarehouseDocument:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.SalesOrderToOutcomeFinancialDocument:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new FinancialDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ProductionOrderToIncome:
case DocumentRelationType.ProductionOrderToOutcome:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
default:
throw new InvalidOperationException("Unknown DocumentRelationType");
}
return(retDocument);
}
public void ChangeDocumentStatus(Document document, DocumentStatus requestedStatus)
{
WarehouseDocument warehouseDocument = document as WarehouseDocument;
FinancialDocument financialDocument = document as FinancialDocument;
ServiceDocument serviceDocument = document as ServiceDocument;
InventoryDocument inventoryDocument = document as InventoryDocument;
ComplaintDocument complaintDocument = document as ComplaintDocument;
CommercialDocument commercialDocument = document as CommercialDocument;
DocumentStatus actualStatus = document.DocumentStatus;
Guid documentId = document.Id.Value;
bool useStandardCancelProcessing = false;
#region MM+
if (warehouseDocument != null && warehouseDocument.WarehouseDirection == WarehouseDirection.IncomeShift) //MM+
{
if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Committed)
{
warehouseDocument.DocumentStatus = DocumentStatus.Committed;
warehouseDocument.IssueDate = SessionManager.VolatileElements.CurrentDateTime;
foreach (WarehouseDocumentLine line in warehouseDocument.Lines.Children)
{
line.Direction = 1;
line.IncomeDate = SessionManager.VolatileElements.CurrentDateTime;
}
this.coordinator.SaveBusinessObject(warehouseDocument);
}
else if ((actualStatus == DocumentStatus.Committed || actualStatus == DocumentStatus.Saved) && requestedStatus == DocumentStatus.Canceled)
{
useStandardCancelProcessing = true;
}
}
#endregion
#region MM-
else if (warehouseDocument != null && warehouseDocument.WarehouseDirection == WarehouseDirection.OutcomeShift) //MM-
{
if (actualStatus == DocumentStatus.Committed && requestedStatus == DocumentStatus.Canceled)
{
useStandardCancelProcessing = true;
foreach (var line in warehouseDocument.Lines)
{
line.IncomeOutcomeRelations.RemoveAll();
}
}
}
#endregion
#region FinancialDocument
else if (financialDocument != null)
{
if (actualStatus == DocumentStatus.Committed && requestedStatus == DocumentStatus.Canceled)
{
DocumentStatusChangeLogic.CancelFinancialDocument(financialDocument);
this.coordinator.SaveBusinessObject(financialDocument);
}
}
#endregion
#region WarehouseDocumentCorrection
else if (warehouseDocument != null && (warehouseDocument.DocumentType.DocumentCategory == DocumentCategory.IncomeWarehouseCorrection ||
warehouseDocument.DocumentType.DocumentCategory == DocumentCategory.OutcomeWarehouseCorrection))
{
SqlConnectionManager.Instance.BeginTransaction();
try
{
if (ConfigurationMapper.Instance.IsWmsEnabled)
{
DependencyContainerManager.Container.Get <WarehouseMapper>().DeleteShiftsForDocument(warehouseDocument.Id.Value);
}
this.mapper.CancelWarehouseDocument(warehouseDocument.Id.Value);
Coordinator.LogSaveBusinessObjectOperation();
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:59");
Coordinator.ProcessSqlException(sqle, document.BOType, true);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:60");
SqlConnectionManager.Instance.RollbackTransaction();
throw;
}
}
#endregion
#region ServiceDocument
else if (serviceDocument != null)
{
if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Canceled)
{
using (DocumentCoordinator c = new DocumentCoordinator(false, true))
{
c.CancelServiceDocument(serviceDocument);
}
}
}
#endregion
#region InventoryDocument
else if (inventoryDocument != null)
{
if (actualStatus == DocumentStatus.Saved && (requestedStatus == DocumentStatus.Committed || requestedStatus == DocumentStatus.Canceled))
{
inventoryDocument.DocumentStatus = requestedStatus;
using (DocumentCoordinator c = new DocumentCoordinator(false, true))
{
c.SaveBusinessObject(inventoryDocument);
}
}
}
#endregion
#region ComplaintDocument
else if (complaintDocument != null)
{
if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Canceled)
{
SqlConnectionManager.Instance.BeginTransaction();
this.coordinator.CanCommitTransaction = false;
foreach (DocumentRelation relation in complaintDocument.Relations)
{
if (relation.RelationType == DocumentRelationType.ComplaintToInternalIncome ||
relation.RelationType == DocumentRelationType.ComplaintToInternalOutcome)
{
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
XDocument xml = new XDocument(new XElement("root"));
xml.Root.Add(new XElement("warehouseDocumentId", relation.RelatedDocument.Id.ToUpperString()));
xml.Root.Add(new XElement("status", "-20"));
c.ChangeDocumentStatus(xml);
}
}
}
complaintDocument.DocumentStatus = DocumentStatus.Canceled;
complaintDocument.Attributes[DocumentFieldName.Attribute_ProcessState].Value.Value = "closed";
try
{
this.coordinator.SaveBusinessObject(complaintDocument);
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:61");
Coordinator.ProcessSqlException(sqle, document.BOType, this.coordinator.CanCommitTransaction);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:62");
SqlConnectionManager.Instance.RollbackTransaction();
throw;
}
}
else if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Committed)
{
if (complaintDocument.DocumentOptions.Where(o => o is CloseProcessOption).FirstOrDefault() == null)
{
complaintDocument.DocumentOptions.Add(new CloseProcessOption());
}
this.coordinator.SaveBusinessObject(complaintDocument);
}
}
#endregion
#region SalesOrder
else if (commercialDocument != null && commercialDocument.DocumentType.DocumentCategory == DocumentCategory.SalesOrder)
{
if (actualStatus == DocumentStatus.Committed && requestedStatus == DocumentStatus.Saved) //anulowanie rozliczenia
{
SalesOrderFactory.OpenSalesOrder(commercialDocument);
commercialDocument.Attributes.Remove(commercialDocument.Attributes[DocumentFieldName.Attribute_SettlementDate]);
commercialDocument.DocumentStatus = DocumentStatus.Saved;
}
else if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Canceled)
{
commercialDocument.Attributes[DocumentFieldName.Attribute_ProcessState].Value.Value = "canceled";
commercialDocument.DocumentStatus = DocumentStatus.Canceled;
foreach (CommercialDocumentLine line in commercialDocument.Lines.Children)
{
line.CommercialDirection = 0;
line.OrderDirection = 0;
line.CommercialWarehouseRelations.RemoveAll();
}
}
else if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Committed)
{
bool result = SalesOrderFactory.TryCloseSalesOrder(commercialDocument);
if (!result)
{
throw new ClientException(ClientExceptionId.ErrorClosingSalesOrder);
}
}
this.coordinator.SaveBusinessObject(document);
}
#endregion
#region ProductionOrder
else if (commercialDocument != null && commercialDocument.DocumentType.DocumentCategory == DocumentCategory.ProductionOrder)
{
if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Committed)
{
commercialDocument.Attributes[DocumentFieldName.Attribute_ProcessState].Value.Value = "closed";
commercialDocument.DocumentStatus = DocumentStatus.Committed;
}
else if (actualStatus == DocumentStatus.Saved && requestedStatus == DocumentStatus.Canceled)
{
commercialDocument.Attributes[DocumentFieldName.Attribute_ProcessState].Value.Value = "canceled";
commercialDocument.DocumentStatus = DocumentStatus.Canceled;
}
this.coordinator.SaveBusinessObject(document);
}
#endregion
else if (actualStatus == DocumentStatus.Committed && requestedStatus == DocumentStatus.Canceled)
{
useStandardCancelProcessing = true;
}
//standardowa część anulowania dokumentu
if (useStandardCancelProcessing)
{
SqlConnectionManager.Instance.BeginTransaction();
this.coordinator.CanCommitTransaction = false;
document.DocumentStatus = DocumentStatus.Canceled;
if (document.BOType == BusinessObjectType.CommercialDocument)
{
commercialDocument.ValidateSalesOrderRealizedLines(false); //muszę najpierw sprawdzić są pow. z ZS bo potem usuwam atrybut
this.ResetCommercialDocumentLinesFlags(commercialDocument);
}
else
{
warehouseDocument.CheckDoesRealizeClosedSalesOrder(coordinator); //sprawdzenie przed usunięciem relacji
this.ResetWarehouseDocumentLinesFlags(warehouseDocument);
}
document.Relations.RemoveAll();
try
{
this.coordinator.SaveBusinessObject(document);
if (document.BOType == BusinessObjectType.CommercialDocument)
{
this.mapper.UnrelateCommercialDocumentFromWarehouseDocuments(documentId);
}
else
{
this.mapper.DeleteWarehouseDocumentRelations((WarehouseDocument)document);
}
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:63");
Coordinator.ProcessSqlException(sqle, document.BOType, this.coordinator.CanCommitTransaction);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:64");
SqlConnectionManager.Instance.RollbackTransaction();
throw;
}
}
}
