private void ProcessLocalOutcomeShift(WarehouseDocument document)
{
if (document.Status != BusinessObjectStatus.New && document.Status != BusinessObjectStatus.Modified &&
!document.Attributes.IsAnyChildNew() && !document.Attributes.IsAnyChildModified())
{
return;
}
if (document.IsLocalShift()) //mamy MMke lokalna
{
XElement outcomeShiftDbXml = this.mapper.LoadWarehouseDocumentDbXml(document.Id.Value);
//zeby xml byl zgodny z takim jaki uzywa komunikacja (bo ja bedziemy "emulowac") to musimy na wycenach poustawiac
//ordinal number pozycji ktorych dotycza
foreach (XElement valuation in outcomeShiftDbXml.Element("warehouseDocumentValuation").Elements())
{
string outcomeWarehouseDocumentLineId = valuation.Element("outcomeWarehouseDocumentLineId").Value;
string ordinalNumber = outcomeShiftDbXml.Element("warehouseDocumentLine").Elements().Where(l => l.Element("id").Value == outcomeWarehouseDocumentLineId).First().Element("ordinalNumber").Value;
valuation.Add(new XAttribute("outcomeShiftOrdinalNumber", ordinalNumber));
}
outcomeShiftDbXml.Element("warehouseDocumentValuation").Add(new XAttribute("outcomeShiftId", document.Id.ToUpperString()));
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
c.CreateOrUpdateIncomeShiftDocumentFromOutcomeShift(outcomeShiftDbXml);
c.ValuateIncomeShiftDocument(outcomeShiftDbXml);
}
}
}
public static void CreateInventorySheetToInventoryDocument(InventorySheet destination, XElement source)
{
Guid inventoryDocumentId = new Guid(source.Element("inventoryDocumentId").Value);
destination.InventoryDocumentHeaderId = inventoryDocumentId;
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
InventoryDocument inventoryDocument = (InventoryDocument)c.LoadBusinessObject(BusinessObjectType.InventoryDocument, inventoryDocumentId);
destination.Tag = inventoryDocument.Version.ToUpperString();
destination.OrdinalNumber = inventoryDocument.Sheets.Children.Count + 1;
destination.InventoryDocumentFullNumber = inventoryDocument.Number.FullNumber;
destination.WarehouseId = inventoryDocument.WarehouseId;
}
}
private static void AddShiftPosition(ServiceDocument serviceDocument, Guid sourceWarehouseId, Guid destinationWarehouseId, List <WarehouseDocument> shiftDocumentsList, Guid itemId, decimal quantity, Guid unitId)
{
WarehouseDocument shift = (from doc in shiftDocumentsList
where doc.WarehouseId == sourceWarehouseId &&
doc.Attributes.Children.Where(a => a.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId)
.First().Value.Value.ToUpperInvariant() == destinationWarehouseId.ToUpperString()
select doc).FirstOrDefault();
if (shift == null) //tworzymy takiego szifta
{
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
string processType = serviceDocument.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value;
string template = ProcessManager.Instance.GetDocumentTemplate(serviceDocument, "outcomeShift");
shift = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, template, null);
ProcessManager.Instance.AppendProcessAttributes(shift, processType, "outcomeShift", serviceDocument.Id, DocumentRelationType.ServiceToOutcomeShift);
DuplicableAttributeFactory.DuplicateAttributes(serviceDocument, shift);
serviceDocument.AddRelatedObject(shift);
shiftDocumentsList.Add(shift);
shift.WarehouseId = sourceWarehouseId;
var dstWarehouseId = shift.Attributes[DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId];
if (dstWarehouseId == null)
{
dstWarehouseId = shift.Attributes.CreateNew();
dstWarehouseId.DocumentFieldName = DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId;
}
dstWarehouseId.Value.Value = destinationWarehouseId.ToUpperString();
}
}
//sprawdzamy czy moze juz jest pozycja na ten sam towar. jak jest to edytujemy quantity, jak nie to tworzymy nowa
WarehouseDocumentLine line = shift.Lines.Children.Where(l => l.ItemId == itemId).FirstOrDefault();
if (line == null)
{
line = shift.Lines.CreateNew();
line.ItemId = itemId;
line.UnitId = unitId;
}
line.Quantity += quantity;
}
private static WarehouseDocument GetDocumentFromList(Guid warehouseId, string template, List <WarehouseDocument> list)
{
WarehouseDocument doc = list.Where(d => d.WarehouseId == warehouseId).FirstOrDefault();
if (doc != null)
{
return(doc);
}
else
{
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
doc = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, template, null);
}
doc.WarehouseId = warehouseId;
list.Add(doc);
return(doc);
}
}
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);
}
}
}
}
private void ProcessLocalIncomeShift(WarehouseDocument document)
{
if (document.Status != BusinessObjectStatus.New && document.Status != BusinessObjectStatus.Modified)
{
return;
}
if (document.IsLocalShift()) //mamy MMke lokalna
{
Guid outcomeShiftId = new Guid(document.Attributes.Children.Where(aa => aa.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentId).First().Value.Value);
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
WarehouseDocument outcomeShift = (WarehouseDocument)c.LoadBusinessObject(BusinessObjectType.WarehouseDocument, outcomeShiftId);
var oppositeDocAttr = outcomeShift.Attributes.Children.Where(o => o.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentId).FirstOrDefault();
if (oppositeDocAttr == null)
{
oppositeDocAttr = outcomeShift.Attributes.CreateNew();
oppositeDocAttr.DocumentFieldName = DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentId;
oppositeDocAttr.Value.Value = document.Id.ToUpperString();
}
var oppositeStatusAttr = outcomeShift.Attributes.Children.Where(s => s.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentStatus).FirstOrDefault();
if (oppositeStatusAttr == null)
{
oppositeStatusAttr = outcomeShift.Attributes.CreateNew();
oppositeStatusAttr.DocumentFieldName = DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentStatus;
}
oppositeStatusAttr.Value.Value = ((int)document.DocumentStatus).ToString(CultureInfo.InvariantCulture);
c.SaveBusinessObject(outcomeShift);
}
}
}
private static void UpdateDocumentStatus(XDocument commPkg)
{
using (DocumentCoordinator cord = new DocumentCoordinator(false, false))
{
Guid documentId = new Guid(commPkg.Root.Element("shiftDocumentStatus").Attribute("outcomeShiftId").Value);
WarehouseDocument outcomeShiftDocument = (WarehouseDocument)cord.LoadBusinessObject(Makolab.Fractus.Kernel.Enums.BusinessObjectType.WarehouseDocument, documentId);
DocumentAttrValue oppositeDocStatus = outcomeShiftDocument.Attributes.Children.Where(attr => attr.DocumentFieldName == Makolab.Fractus.Kernel.Enums.DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentStatus).SingleOrDefault();
if (oppositeDocStatus == null)
{
oppositeDocStatus = outcomeShiftDocument.Attributes.CreateNew();
oppositeDocStatus.DocumentFieldName = Makolab.Fractus.Kernel.Enums.DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentStatus;
}
DocumentAttrValue oppositeDocId = outcomeShiftDocument.Attributes.Children.Where(attr => attr.DocumentFieldName == Makolab.Fractus.Kernel.Enums.DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentId).SingleOrDefault();
if (oppositeDocId == null)
{
oppositeDocId = outcomeShiftDocument.Attributes.CreateNew();
oppositeDocId.DocumentFieldName = Makolab.Fractus.Kernel.Enums.DocumentFieldName.ShiftDocumentAttribute_OppositeDocumentId;
oppositeDocId.Value.Value = commPkg.Root.Element("shiftDocumentStatus").Attribute("incomeShiftId").Value;
}
oppositeDocStatus.Value.Value = commPkg.Root.Element("shiftDocumentStatus").Attribute("status").Value;
cord.SaveBusinessObject(outcomeShiftDocument);
}
}
/// <summary>
/// Saves the business object.
/// </summary>
/// <param name="document"><see cref="CommercialDocument"/> to save.</param>
/// <returns>Xml containing result of oper</returns>
public XDocument SaveBusinessObject(InventoryDocument document)
{
DictionaryMapper.Instance.CheckForChanges();
//load alternate version
if (!document.IsNew)
{
IBusinessObject alternateBusinessObject = this.mapper.LoadBusinessObject(document.BOType, document.Id.Value);
document.SetAlternateVersion(alternateBusinessObject);
}
foreach (var sheet in document.Sheets)
{
sheet.SkipLinesSave = true;
InventorySheet alternateSheet = sheet.AlternateVersion as InventorySheet;
if (alternateSheet != null && alternateSheet.DocumentStatus != sheet.DocumentStatus && sheet.DocumentStatus == DocumentStatus.Canceled)
{
//jezeli anulowalismy arkusz z poziomu inwentaryzacji to nalezy caly arkusz wczytac, zmienic jego status i dodac do zapisu zeby
//wykonala sie tez inna jego logika zwiazana ze zmiana statusu
InventorySheet sh = (InventorySheet)this.mapper.LoadBusinessObject(BusinessObjectType.InventorySheet, sheet.Id.Value);
sh.DocumentStatus = DocumentStatus.Canceled;
document.AddRelatedObject(sh);
}
}
//update status
document.UpdateStatus(true);
if (document.AlternateVersion != null)
{
document.AlternateVersion.UpdateStatus(false);
}
document.Validate();
this.ExecuteCustomLogic(document);
this.ExecuteDocumentOptions(document);
//validate
document.Validate();
//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);
//Make operations list
XDocument operations = XDocument.Parse("<root/>");
document.SaveChanges(operations);
if (document.AlternateVersion != null)
{
document.AlternateVersion.SaveChanges(operations);
}
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
if (document.DocumentStatus == DocumentStatus.Committed)
{
this.mapper.CreateCommunicationXml(document);
}
this.mapper.UpdateDictionaryIndex(document);
}
Coordinator.LogSaveBusinessObjectOperation();
foreach (var sheet in document.SheetsToSave)
{
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
c.SaveBusinessObject(sheet);
}
}
if (document.UnblockItems)
{
this.itemMapper.UnblockItems();
}
document.SaveRelatedObjects();
operations = XDocument.Parse("<root/>");
document.SaveRelations(operations);
if (document.AlternateVersion != null)
{
((InventoryDocument)document.AlternateVersion).SaveRelations(operations);
}
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
}
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:72");
Coordinator.ProcessSqlException(sqle, document.BOType, this.coordinator.CanCommitTransaction);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:73");
if (this.coordinator.CanCommitTransaction)
{
SqlConnectionManager.Instance.RollbackTransaction();
}
throw;
}
}
public CorrectiveOutcomeWarehouseDocumentLogic(DocumentCoordinator coordinator)
: base(coordinator)
{
}
public FinancialDocumentLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
/// <summary>
/// Executes the custom logic.
/// </summary>
/// <param name="document">The document to execute custom logic for.</param>
private void ExecuteCustomLogic(CommercialDocument document)
{
//sprawdzamy czy zlecenie/technologia nie posiada pozycji uslugowych
this.mapper.AddItemsToItemTypesCache(document);
var cache = SessionManager.VolatileElements.ItemTypesCache;
//foreach (var line in document.Lines)
//{
// Guid itemTypeId = cache[line.ItemId];
// // Tutaj jest walidacja typów produktów ale nie potrzebnie, usługa w kontekście robocizny, powinna dać się zapisać w
// // procesie produkcyjnym
// if (!DictionaryMapper.Instance.GetItemType(itemTypeId).IsWarehouseStorable)
// throw new ClientException(ClientExceptionId.InvalidItemType);
//}
CommercialDocument alternateDocument = document.AlternateVersion as CommercialDocument;
//zamykanie ZP
if (alternateDocument != null && alternateDocument.DocumentStatus == DocumentStatus.Saved &&
document.DocumentStatus == DocumentStatus.Committed && document.DocumentType.DocumentCategory == DocumentCategory.ProductionOrder)
{
Dictionary <Guid, CommercialDocument> technologies = new Dictionary <Guid, CommercialDocument>();
WarehouseDocument internalOutcome = null;
WarehouseDocument internalIncome = null;
WarehouseDocument internalIncomeByproduct = null;
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
internalOutcome = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, ProcessManager.Instance.GetDocumentTemplate(document, "internalOutcome"), null);
internalIncome = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, ProcessManager.Instance.GetDocumentTemplate(document, "internalIncome"), null);
internalIncomeByproduct = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, ProcessManager.Instance.GetDocumentTemplate(document, "internalIncomeByproduct"), null);
}
ProcessManager.Instance.AppendProcessAttributes(internalIncome, document.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value,
"internalIncome", null, null);
internalIncome.WarehouseId = ProcessManager.Instance.GetProductWarehouse(document);
ProcessManager.Instance.AppendProcessAttributes(internalOutcome, document.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value,
"internalOutcome", null, null);
internalOutcome.WarehouseId = ProcessManager.Instance.GetMaterialWarehouse(document);
ProcessManager.Instance.AppendProcessAttributes(internalIncomeByproduct, document.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value,
"internalIncomeByproduct", null, null);
internalIncomeByproduct.WarehouseId = ProcessManager.Instance.GetByproductWarehouse(document);
//wczytujemy wszystkie technologie
//generujemy jeden wielki RW i PW dla wzsystkich technologii i podczepiamy go do zlecenia produkcyjnego
foreach (CommercialDocumentLine line in document.Lines)
{
var attr = line.Attributes[DocumentFieldName.LineAttribute_ProductionTechnologyName];
Guid technologyId = new Guid(attr.Value.Value);
if (!technologies.ContainsKey(technologyId))
{
CommercialDocument t = (CommercialDocument)this.mapper.LoadBusinessObject(BusinessObjectType.CommercialDocument, technologyId);
technologies.Add(technologyId, t);
}
this.ProcessTechnology(technologies[technologyId], line.Quantity, internalIncome, internalOutcome, internalIncomeByproduct, line.OrdinalNumber);
}
DocumentRelation relation = null;
relation = internalOutcome.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToOutcome;
relation.RelatedDocument = document;
relation = document.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToOutcome;
relation.RelatedDocument = internalOutcome;
relation.DontSave = true;
DuplicableAttributeFactory.DuplicateAttributes(document, internalOutcome);
document.AddRelatedObject(internalOutcome);
relation = internalIncome.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToIncome;
relation.RelatedDocument = document;
relation = document.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToIncome;
relation.RelatedDocument = internalIncome;
relation.DontSave = true;
DuplicableAttributeFactory.DuplicateAttributes(document, internalIncome);
document.AddRelatedObject(internalIncome);
if (internalIncomeByproduct.Lines.Children.Count > 0)
{
relation = internalIncomeByproduct.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToIncome;
relation.RelatedDocument = document;
relation = document.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ProductionOrderToIncome;
relation.RelatedDocument = internalIncomeByproduct;
relation.DontSave = true;
DuplicableAttributeFactory.DuplicateAttributes(document, internalIncomeByproduct);
document.AddRelatedObject(internalIncomeByproduct);
}
}
}
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 WarehouseDocumentLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
/// <summary>
/// Initializes a new instance of the <see cref="CommercialDocumentLogic"/> class.
/// </summary>
/// <param name="coordinator">The parent coordinator.</param>
public ProductionLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
private void ValuateIncomeFromOutcome(IEnumerable <IGrouping <string, DBRow> > shiftLines)
{
XDocument valuationTemplate = XDocument.Parse("<root><warehouseDocumentValuation /></root>");
using (var whDocCoord = new DocumentCoordinator(false, false))
{
foreach (var warehouseDocGroup in shiftLines)
{
WarehouseDocument shift = null;
try
{
shift = (WarehouseDocument)whDocCoord.LoadBusinessObject(Makolab.Fractus.Kernel.Enums.BusinessObjectType.WarehouseDocument,
new Guid(warehouseDocGroup.Key));
}
catch (ClientException) { }
//there is a valuated document in database so we can forward valuation - no document = skip income valuation for this doc
if (shift != null)
{
DocumentAttrValue oppositeWarehouseIdAttr = shift.Attributes.Children.Where(attr => attr.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId).SingleOrDefault();
string oppositeWarehouseId = oppositeWarehouseIdAttr != null ? oppositeWarehouseIdAttr.Value.Value : null;
if (oppositeWarehouseId != null)
{
Warehouse oppositeWarehouse = DictionaryMapper.Instance.GetWarehouse(new Guid(oppositeWarehouseId));
Warehouse warehouse = DictionaryMapper.Instance.GetWarehouse(shift.WarehouseId);
//skip local shift document valuations
if (warehouse.BranchId == oppositeWarehouse.BranchId)
{
continue;
}
// skip valuation in headquarter if not a target branch
if (this.IsHeadquarter == true && DictionaryMapper.Instance.GetBranch(oppositeWarehouse.BranchId).DatabaseId != Makolab.Fractus.Kernel.Mappers.ConfigurationMapper.Instance.DatabaseId)
{
continue;
}
foreach (var valuation in warehouseDocGroup)
{
var whDocLine = shift.Lines.Children.Where(line => line.Id.ToString()
.Equals(valuation.Element("outcomeWarehouseDocumentLineId").Value, StringComparison.OrdinalIgnoreCase))
.SingleOrDefault();
valuation.Xml.Add(new XAttribute("outcomeShiftOrdinalNumber", whDocLine.OrdinalNumber));
}
var valuationPkg = new XDocument(valuationTemplate);
valuationPkg.Root.Element("warehouseDocumentValuation").Add(new XAttribute("outcomeShiftId", shift.Id));
valuationPkg.Root.Element("warehouseDocumentValuation").Add(warehouseDocGroup);
try
{
whDocCoord.ValuateIncomeShiftDocument(valuationPkg.Root);
}
catch (ClientException e)
{
if (e.Id != Makolab.Fractus.Kernel.Enums.ClientExceptionId.ObjectNotFound)
{
throw;
}
}
}
}
}
}
}
public ServiceDocumentLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
public SalesOrderLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
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;
}
}
}
public DocumentStatusChangeLogic(DocumentCoordinator coordinator)
{
this.coordinator = coordinator;
this.mapper = (DocumentMapper)coordinator.Mapper;
}
public InventorySheetLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
private static void ForwardValuations(ICommunicationPackage communicationPackage, XDocument commPkg, ICommunicationPackageRepository repository)
{
var distributedLines = commPkg.Root.Element("warehouseDocumentValuation").Elements("entry")
.Where(
row => row.Element("isDistributed") != null &&
row.Element("isDistributed").Value.Equals("True", StringComparison.OrdinalIgnoreCase) &&
row.Element("warehouseDocumentHeaderId") != null &&
(row.Attribute("action") == null || row.Attribute("action").Value.Equals("delete", StringComparison.OrdinalIgnoreCase) == false))
.GroupBy(row => row.Element("warehouseDocumentHeaderId").Value);
//this valuation is not for shift document, so we don't forward it
if (distributedLines.Count() == 0)
{
return;
}
XDocument valuationTemplate = XDocument.Parse("<root><warehouseDocumentValuation /></root>");
Guid localTransactionId = Guid.NewGuid();
using (var wrapper = repository.Context.ConnectionManager.SynchronizeConnection())
{
SqlConnectionManager.Instance.SetConnection(wrapper.Connection, (SqlTransaction)repository.Context.Transaction);
}
using (var whDocCoord = new DocumentCoordinator(false, false))
{
foreach (var warehouseDocGroup in distributedLines)
{
WarehouseDocument shift = null;
try
{
shift = (WarehouseDocument)whDocCoord.LoadBusinessObject(Makolab.Fractus.Kernel.Enums.BusinessObjectType.WarehouseDocument,
new Guid(warehouseDocGroup.Key));
}
catch (ClientException) { }
//there is a valuated document in database so we can forward valuation - no document = skip valuations for this doc
if (shift != null)
{
string oppositeWarehouseId = (shift.Attributes.Count() > 0 && shift.Attributes.Children.Any(attr => attr.DocumentFieldName == DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId))
? shift.Attributes[DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId].Value.Value
: null;
if (oppositeWarehouseId != null)
{
Warehouse oppositeWarehouse = DictionaryMapper.Instance.GetWarehouse(new Guid(oppositeWarehouseId));
Warehouse warehouse = DictionaryMapper.Instance.GetWarehouse(shift.WarehouseId);
//skip local shift document valuations
if (warehouse.BranchId == oppositeWarehouse.BranchId)
{
continue;
}
foreach (var valuation in warehouseDocGroup)
{
var whDocLine = shift.Lines.Children.Where(line => line.Id.ToString()
.Equals(valuation.Element("outcomeWarehouseDocumentLineId").Value, StringComparison.OrdinalIgnoreCase))
.SingleOrDefault();
valuation.Add(new XAttribute("outcomeShiftOrdinalNumber", whDocLine.OrdinalNumber));
}
var valuationPkg = new XDocument(valuationTemplate);
valuationPkg.Root.Element("warehouseDocumentValuation").Add(new XAttribute("outcomeShiftId", shift.Id));
valuationPkg.Root.Element("warehouseDocumentValuation").Add(warehouseDocGroup);
XmlTransferObject valuationData = new XmlTransferObject
{
DeferredTransactionId = communicationPackage.XmlData.DeferredTransactionId,
Id = Guid.NewGuid(),
LocalTransactionId = localTransactionId,
XmlType = "WarehouseDocumentValuation",
Content = valuationPkg.ToString(SaveOptions.DisableFormatting)
};
ICommunicationPackage pkg = new CommunicationPackage(valuationData);
pkg.DatabaseId = DictionaryMapper.Instance.GetBranch(oppositeWarehouse.BranchId).DatabaseId;
repository.PutToOutgoingQueue(pkg);
}
}
}
}
}
public OutcomeShiftWarehouseDocumentLogic(DocumentCoordinator coordinator)
: base(coordinator)
{
}
private void AddPositionToWarehouseDocument(ComplaintDocument complaintDocument, Guid warehouseId, List <WarehouseDocument> generatedWhDocs, Guid itemId, decimal quantity, Guid unitId, WarehouseDirection direction)
{
WarehouseDocument document = (from whDoc in generatedWhDocs
where whDoc.WarehouseId == warehouseId &&
whDoc.WarehouseDirection == direction
select whDoc).FirstOrDefault();
if (document == null)
{
string documentName = null;
if (direction == WarehouseDirection.Outcome)
{
documentName = "internalOutcome";
}
else
{
documentName = "internalIncome";
}
string template = ProcessManager.Instance.GetDocumentTemplate(complaintDocument, documentName);
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
document = (WarehouseDocument)c.CreateNewBusinessObject(BusinessObjectType.WarehouseDocument, template, null);
document.WarehouseId = warehouseId;
string processType = complaintDocument.Attributes[DocumentFieldName.Attribute_ProcessType].Value.Value;
ProcessManager.Instance.AppendProcessAttributes(document, processType, documentName, null, null);
document.Contractor = complaintDocument.Contractor;
DuplicableAttributeFactory.DuplicateAttributes(complaintDocument, document);
complaintDocument.AddRelatedObject(document);
generatedWhDocs.Add(document);
var relation = complaintDocument.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ComplaintToInternalOutcome;
relation.RelatedDocument = document;
relation = document.Relations.CreateNew();
relation.RelationType = DocumentRelationType.ComplaintToInternalOutcome;
relation.RelatedDocument = complaintDocument;
relation.DontSave = true;
}
}
WarehouseDocumentLine line = document.Lines.Children.Where(l => l.ItemId == itemId).FirstOrDefault();
if (line == null)
{
line = document.Lines.CreateNew();
line.ItemId = itemId;
line.UnitId = unitId;
}
line.Quantity += quantity;
/* sprawdzamy czy jest to rozchod z magazynu wmsowego. jezeli tak to tworzymy shift transaction
* dodajemy nowego shifta zgodnie z tym co jest w complaintDocument.Shifts, potem
* shifta wiazemy z pozycja
*/
if (DictionaryMapper.Instance.GetWarehouse(document.WarehouseId).ValuationMethod == ValuationMethod.DeliverySelection)
{
ShiftTransaction shiftTransaction = document.ShiftTransaction;
if (shiftTransaction == null)
{
shiftTransaction = new ShiftTransaction(null);
document.ShiftTransaction = shiftTransaction;
}
//wyciagamy shifty z complaintDocumenta
var shifts = complaintDocument.AllocationCollection.Allocations.Where(s => s.ItemId == itemId && s.WarehouseId == warehouseId).Select(x => x.AllocationShifts).FirstOrDefault();
decimal quantityToGo = quantity; //kopiujemy shifty na ilosc niewieksza niz na pozycji jest wybrane
foreach (var shift in shifts)
{
if (shift.Quantity == 0)
{
continue;
}
decimal quantityTaken = 0;
if (quantityToGo > shift.Quantity)
{
quantityTaken = shift.Quantity;
}
else //quantityToGo <= shift.Quantity
{
quantityTaken = quantityToGo;
}
shift.Quantity -= quantityTaken;
quantityToGo -= quantityTaken;
if (shift.SourceShiftId != null) //te ktore nie maja sourceShiftId pomijamy bo tutaj takie luzem w ogole nie maja shifta
{
var newShift = shiftTransaction.Shifts.CreateNew();
newShift.ItemId = itemId;
newShift.WarehouseId = warehouseId;
newShift.SourceShiftId = shift.SourceShiftId.Value;
newShift.IncomeWarehouseDocumentLineId = shift.IncomeWarehouseDocumentLineId;
newShift.Quantity = quantityTaken;
newShift.RelatedWarehouseDocumentLine = line;
newShift.LineOrdinalNumber = line.OrdinalNumber;
}
//teraz incomeOutcomeRelation dodajemy
IncomeOutcomeRelation relation = line.IncomeOutcomeRelations.Children.Where(i => i.RelatedLine.Id.Value == shift.IncomeWarehouseDocumentLineId).FirstOrDefault();
if (relation == null)
{
relation = line.IncomeOutcomeRelations.CreateNew();
var incLine = new WarehouseDocumentLine(null);
incLine.Id = shift.IncomeWarehouseDocumentLineId;
relation.RelatedLine = incLine;
}
relation.Quantity += quantityTaken;
if (quantityToGo == 0)
{
break;
}
}
}
}
public ComplaintDocumentLogic(DocumentCoordinator coordinator)
{
this.mapper = (DocumentMapper)coordinator.Mapper;
this.coordinator = coordinator;
}
public IncomeWarehouseDocumentLogic(DocumentCoordinator coordinator)
: base(coordinator)
{
}
