protected override void AppsSecure(Security config)
{
base.AppsSecure(config);
var partiallyShipped = new SalesOrderItemShipmentStates(this.Session).PartiallyShipped;
var shipped = new SalesOrderItemShipmentStates(this.Session).Shipped;
var inProcess = new SalesOrderItemStates(this.Session).InProcess;
var cancelled = new SalesOrderItemStates(this.Session).Cancelled;
var rejected = new SalesOrderItemStates(this.Session).Rejected;
var completed = new SalesOrderItemStates(this.Session).Completed;
var finished = new SalesOrderItemStates(this.Session).Finished;
var product = this.Meta.Product;
config.Deny(this.ObjectType, shipped, product);
config.Deny(this.ObjectType, partiallyShipped, product);
var cancel = this.Meta.Cancel;
var reject = this.Meta.Reject;
var delete = this.Meta.Delete;
config.Deny(this.ObjectType, partiallyShipped, delete, cancel, reject);
config.Deny(this.ObjectType, shipped, delete, cancel, reject);
config.Deny(this.ObjectType, completed, delete, cancel, reject);
config.Deny(this.ObjectType, inProcess, delete);
config.Deny(this.ObjectType, cancelled, Operations.Execute, Operations.Write);
config.Deny(this.ObjectType, rejected, Operations.Execute, Operations.Write);
config.Deny(this.ObjectType, completed, Operations.Execute, Operations.Write);
config.Deny(this.ObjectType, finished, Operations.Execute, Operations.Write);
}
public void BaseOnDerive(ObjectOnDerive method)
{
var derivation = method.Derivation;
var salesOrder = this.SalesOrderWhereSalesOrderItem;
var shipped = new ShipmentStates(this.Session()).Shipped;
if (!this.ExistDerivationTrigger)
{
this.DerivationTrigger = Guid.NewGuid();
}
if (this.ExistSerialisedItem && !this.ExistNextSerialisedItemAvailability)
{
derivation.Validation.AssertExists(this, this.Meta.NextSerialisedItemAvailability);
}
if (this.Part != null && this.Part.InventoryItemKind.IsSerialised && this.QuantityOrdered != 1)
{
derivation.Validation.AddError(this, M.SalesOrderItem.QuantityOrdered, ErrorMessages.InvalidQuantity);
}
if (this.Part != null && this.Part.InventoryItemKind.IsNonSerialised && this.QuantityOrdered == 0)
{
derivation.Validation.AddError(this, M.SalesOrderItem.QuantityOrdered, ErrorMessages.InvalidQuantity);
}
if (this.ExistInvoiceItemType && this.InvoiceItemType.MaxQuantity.HasValue && this.QuantityOrdered > this.InvoiceItemType.MaxQuantity.Value)
{
derivation.Validation.AddError(this, M.SalesOrderItem.QuantityOrdered, ErrorMessages.InvalidQuantity);
}
var salesOrderItemShipmentStates = new SalesOrderItemShipmentStates(derivation.Session);
var salesOrderItemPaymentStates = new SalesOrderItemPaymentStates(derivation.Session);
var salesOrderItemInvoiceStates = new SalesOrderItemInvoiceStates(derivation.Session);
var salesOrderItemStates = new SalesOrderItemStates(derivation.Session);
// Shipments
this.QuantityPendingShipment = this.OrderShipmentsWhereOrderItem
.Where(v => v.ExistShipmentItem && !((CustomerShipment)v.ShipmentItem.ShipmentWhereShipmentItem).ShipmentState.Equals(shipped))
.Sum(v => v.Quantity);
this.QuantityShipped = this.OrderShipmentsWhereOrderItem
.Where(v => v.ExistShipmentItem && ((CustomerShipment)v.ShipmentItem.ShipmentWhereShipmentItem).ShipmentState.Equals(shipped))
.Sum(v => v.Quantity);
if (this.SalesOrderItemState.IsInProcess &&
this.ExistPreviousReservedFromNonSerialisedInventoryItem &&
this.ReservedFromNonSerialisedInventoryItem != this.PreviousReservedFromNonSerialisedInventoryItem)
{
derivation.Validation.AddError(this, this.Meta.ReservedFromNonSerialisedInventoryItem, ErrorMessages.ReservedFromNonSerialisedInventoryItem);
}
if (this.ExistSerialisedItem && this.QuantityOrdered != 1)
{
derivation.Validation.AddError(this, this.Meta.QuantityOrdered, ErrorMessages.SerializedItemQuantity);
}
if (this.QuantityOrdered < this.QuantityPendingShipment || this.QuantityOrdered < this.QuantityShipped)
{
derivation.Validation.AddError(this, M.SalesOrderItem.QuantityOrdered, ErrorMessages.SalesOrderItemQuantityToShipNowIsLargerThanQuantityRemaining);
}
if (this.SalesOrderItemInventoryAssignments.FirstOrDefault() != null)
{
this.QuantityCommittedOut = this.SalesOrderItemInventoryAssignments
.SelectMany(v => v.InventoryItemTransactions)
.Where(t => t.Reason.Equals(new InventoryTransactionReasons(this.Session()).Reservation))
.Sum(v => v.Quantity);
}
else
{
this.QuantityCommittedOut = 0;
}
// SalesOrderItem States
if (this.IsValid)
{
if (salesOrder.SalesOrderState.IsProvisional)
{
this.SalesOrderItemState = salesOrderItemStates.Provisional;
}
if (salesOrder.SalesOrderState.IsReadyForPosting &&
(this.SalesOrderItemState.IsProvisional || this.SalesOrderItemState.IsRequestsApproval || this.SalesOrderItemState.IsOnHold))
{
this.SalesOrderItemState = salesOrderItemStates.ReadyForPosting;
}
if (salesOrder.SalesOrderState.IsRequestsApproval &&
(this.SalesOrderItemState.IsProvisional || this.SalesOrderItemState.IsOnHold))
{
this.SalesOrderItemState = salesOrderItemStates.RequestsApproval;
}
if (salesOrder.SalesOrderState.IsAwaitingAcceptance &&
this.SalesOrderItemState.IsReadyForPosting)
{
this.SalesOrderItemState = salesOrderItemStates.AwaitingAcceptance;
}
if (salesOrder.SalesOrderState.IsInProcess &&
this.SalesOrderItemState.IsAwaitingAcceptance || this.SalesOrderItemState.IsOnHold)
{
this.SalesOrderItemState = salesOrderItemStates.InProcess;
}
if (salesOrder.SalesOrderState.IsOnHold && this.SalesOrderItemState.IsInProcess)
{
this.SalesOrderItemState = salesOrderItemStates.OnHold;
}
if (salesOrder.SalesOrderState.IsFinished)
{
this.SalesOrderItemState = salesOrderItemStates.Finished;
}
if (salesOrder.SalesOrderState.IsCancelled)
{
this.SalesOrderItemState = salesOrderItemStates.Cancelled;
}
if (salesOrder.SalesOrderState.IsRejected)
{
this.SalesOrderItemState = salesOrderItemStates.Rejected;
}
}
if (this.IsValid)
{
// ShipmentState
if (!this.ExistOrderShipmentsWhereOrderItem)
{
this.SalesOrderItemShipmentState = salesOrderItemShipmentStates.NotShipped;
}
else if (this.QuantityShipped == 0 && this.QuantityPendingShipment > 0)
{
this.SalesOrderItemShipmentState = salesOrderItemShipmentStates.InProgress;
}
else
{
this.SalesOrderItemShipmentState = this.QuantityShipped < this.QuantityOrdered ?
salesOrderItemShipmentStates.PartiallyShipped :
salesOrderItemShipmentStates.Shipped;
}
// PaymentState
var orderBilling = this.OrderItemBillingsWhereOrderItem.Select(v => v.InvoiceItem).OfType <SalesInvoiceItem>().ToArray();
if (orderBilling.Any())
{
if (orderBilling.All(v => v.SalesInvoiceWhereSalesInvoiceItem.SalesInvoiceState.IsPaid))
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.Paid;
}
else if (orderBilling.All(v => !v.SalesInvoiceWhereSalesInvoiceItem.SalesInvoiceState.IsPaid))
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.NotPaid;
}
else
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.PartiallyPaid;
}
}
else
{
var shipmentBilling = this.OrderShipmentsWhereOrderItem.SelectMany(v => v.ShipmentItem.ShipmentItemBillingsWhereShipmentItem).Select(v => v.InvoiceItem).OfType <SalesInvoiceItem>().ToArray();
if (shipmentBilling.Any())
{
if (shipmentBilling.All(v => v.SalesInvoiceWhereSalesInvoiceItem.SalesInvoiceState.IsPaid))
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.Paid;
}
else if (shipmentBilling.All(v => !v.SalesInvoiceWhereSalesInvoiceItem.SalesInvoiceState.IsPaid))
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.NotPaid;
}
else
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.PartiallyPaid;
}
}
else
{
this.SalesOrderItemPaymentState = salesOrderItemPaymentStates.NotPaid;
}
}
// InvoiceState
var amountAlreadyInvoiced = this.OrderItemBillingsWhereOrderItem?.Sum(v => v.Amount);
if (amountAlreadyInvoiced == 0)
{
amountAlreadyInvoiced = this.OrderShipmentsWhereOrderItem
.SelectMany(orderShipment => orderShipment.ShipmentItem.ShipmentItemBillingsWhereShipmentItem)
.Aggregate(amountAlreadyInvoiced, (current, shipmentItemBilling) => current + shipmentItemBilling.Amount);
}
var leftToInvoice = this.TotalExVat - amountAlreadyInvoiced;
if (amountAlreadyInvoiced == 0)
{
this.SalesOrderItemInvoiceState = salesOrderItemInvoiceStates.NotInvoiced;
}
else if (amountAlreadyInvoiced > 0 && leftToInvoice > 0)
{
this.SalesOrderItemInvoiceState = salesOrderItemInvoiceStates.PartiallyInvoiced;
}
else
{
this.SalesOrderItemInvoiceState = salesOrderItemInvoiceStates.Invoiced;
}
// SalesOrderItem States
if (this.SalesOrderItemShipmentState.Shipped && this.SalesOrderItemInvoiceState.Invoiced)
{
this.SalesOrderItemState = salesOrderItemStates.Completed;
}
if (this.SalesOrderItemState.IsCompleted && this.SalesOrderItemPaymentState.Paid)
{
this.SalesOrderItemState = salesOrderItemStates.Finished;
}
}
this.CalculatePrice(derivation, salesOrder);
if (!this.IsValid && this.WasValid)
{
if (this.ExistReservedFromNonSerialisedInventoryItem && this.ExistQuantityCommittedOut)
{
var inventoryAssignment = this.SalesOrderItemInventoryAssignments.FirstOrDefault();
if (inventoryAssignment != null)
{
inventoryAssignment.Quantity = 0 - this.QuantityCommittedOut;
}
}
}
// TODO: Move to Custom
if (derivation.ChangeSet.IsCreated(this) && !this.ExistDescription)
{
if (this.ExistSerialisedItem)
{
var builder = new StringBuilder();
var part = this.SerialisedItem.PartWhereSerialisedItem;
if (part != null && part.ExistManufacturedBy)
{
builder.Append($", Manufacturer: {part.ManufacturedBy.PartyName}");
}
if (part != null && part.ExistBrand)
{
builder.Append($", Brand: {part.Brand.Name}");
}
if (part != null && part.ExistModel)
{
builder.Append($", Model: {part.Model.Name}");
}
builder.Append($", SN: {this.SerialisedItem.SerialNumber}");
if (this.SerialisedItem.ExistManufacturingYear)
{
builder.Append($", YOM: {this.SerialisedItem.ManufacturingYear}");
}
foreach (SerialisedItemCharacteristic characteristic in this.SerialisedItem.SerialisedItemCharacteristics)
{
if (characteristic.ExistValue)
{
var characteristicType = characteristic.SerialisedItemCharacteristicType;
if (characteristicType.ExistUnitOfMeasure)
{
var uom = characteristicType.UnitOfMeasure.ExistAbbreviation
? characteristicType.UnitOfMeasure.Abbreviation
: characteristicType.UnitOfMeasure.Name;
builder.Append(
$", {characteristicType.Name}: {characteristic.Value} {uom}");
}
else
{
builder.Append($", {characteristicType.Name}: {characteristic.Value}");
}
}
}
var details = builder.ToString();
if (details.StartsWith(","))
{
details = details.Substring(2);
}
this.Description = details;
}
else if (this.ExistProduct && this.Product is UnifiedGood unifiedGood)
{
var builder = new StringBuilder();
if (unifiedGood != null && unifiedGood.ExistManufacturedBy)
{
builder.Append($", Manufacturer: {unifiedGood.ManufacturedBy.PartyName}");
}
if (unifiedGood != null && unifiedGood.ExistBrand)
{
builder.Append($", Brand: {unifiedGood.Brand.Name}");
}
if (unifiedGood != null && unifiedGood.ExistModel)
{
builder.Append($", Model: {unifiedGood.Model.Name}");
}
foreach (SerialisedItemCharacteristic characteristic in unifiedGood.SerialisedItemCharacteristics)
{
if (characteristic.ExistValue)
{
var characteristicType = characteristic.SerialisedItemCharacteristicType;
if (characteristicType.ExistUnitOfMeasure)
{
var uom = characteristicType.UnitOfMeasure.ExistAbbreviation
? characteristicType.UnitOfMeasure.Abbreviation
: characteristicType.UnitOfMeasure.Name;
builder.Append($", {characteristicType.Name}: {characteristic.Value} {uom}");
}
else
{
builder.Append($", {characteristicType.Name}: {characteristic.Value}");
}
}
}
var details = builder.ToString();
if (details.StartsWith(","))
{
details = details.Substring(2);
}
this.Description = details;
}
}
this.Sync();
}
public void BaseOnDerive(ObjectOnDerive method)
{
var derivation = method.Derivation;
var session = this.Session();
// SalesOrder Derivations and Validations
this.BillToCustomer ??= this.ShipToCustomer;
this.ShipToCustomer ??= this.BillToCustomer;
this.Customers = new[] { this.BillToCustomer, this.ShipToCustomer, this.PlacingCustomer };
this.Locale ??= this.BillToCustomer?.Locale ?? this.Strategy.Session.GetSingleton().DefaultLocale;
this.VatRegime ??= this.BillToCustomer?.VatRegime;
this.Currency ??= this.BillToCustomer?.PreferredCurrency ?? this.BillToCustomer?.Locale?.Country?.Currency ?? this.TakenBy?.PreferredCurrency;
this.TakenByContactMechanism ??= this.TakenBy?.OrderAddress ?? this.TakenBy?.BillingAddress ?? this.TakenBy?.GeneralCorrespondence;
this.BillToContactMechanism ??= this.BillToCustomer?.BillingAddress ?? this.BillToCustomer?.ShippingAddress ?? this.BillToCustomer?.GeneralCorrespondence;
this.BillToEndCustomerContactMechanism ??= this.BillToEndCustomer?.BillingAddress ?? this.BillToEndCustomer?.ShippingAddress ?? this.BillToCustomer?.GeneralCorrespondence;
this.ShipToEndCustomerAddress ??= this.ShipToEndCustomer?.ShippingAddress ?? this.ShipToCustomer?.GeneralCorrespondence as PostalAddress;
this.ShipFromAddress ??= this.TakenBy?.ShippingAddress;
this.ShipToAddress ??= this.ShipToCustomer?.ShippingAddress;
this.ShipmentMethod ??= this.ShipToCustomer?.DefaultShipmentMethod ?? this.Store.DefaultShipmentMethod;
this.PaymentMethod ??= this.ShipToCustomer?.PartyFinancialRelationshipsWhereParty?.FirstOrDefault(v => object.Equals(v.InternalOrganisation, this.TakenBy))?.DefaultPaymentMethod ?? this.Store.DefaultCollectionMethod;
if (this.BillToCustomer?.BaseIsActiveCustomer(this.TakenBy, this.OrderDate) == false)
{
derivation.Validation.AddError(this, M.SalesOrder.BillToCustomer, ErrorMessages.PartyIsNotACustomer);
}
if (this.ShipToCustomer?.BaseIsActiveCustomer(this.TakenBy, this.OrderDate) == false)
{
derivation.Validation.AddError(this, M.SalesOrder.ShipToCustomer, ErrorMessages.PartyIsNotACustomer);
}
if (this.SalesOrderState.IsInProcess)
{
derivation.Validation.AssertExists(this, this.Meta.ShipToAddress);
derivation.Validation.AssertExists(this, this.Meta.BillToContactMechanism);
}
// SalesOrderItem Derivations and Validations
foreach (SalesOrderItem salesOrderItem in this.SalesOrderItems)
{
var salesOrderItemDerivedRoles = (SalesOrderItemDerivedRoles)salesOrderItem;
salesOrderItem.ShipFromAddress ??= this.ShipFromAddress;
salesOrderItemDerivedRoles.ShipToAddress = salesOrderItem.AssignedShipToAddress ?? salesOrderItem.AssignedShipToParty?.ShippingAddress ?? this.ShipToAddress;
salesOrderItemDerivedRoles.ShipToParty = salesOrderItem.AssignedShipToParty ?? this.ShipToCustomer;
salesOrderItemDerivedRoles.DeliveryDate = salesOrderItem.AssignedDeliveryDate ?? this.DeliveryDate;
salesOrderItemDerivedRoles.VatRegime = salesOrderItem.AssignedVatRegime ?? this.VatRegime;
salesOrderItemDerivedRoles.VatRate = salesOrderItem.VatRegime?.VatRate ?? salesOrderItem.Product?.VatRate ?? salesOrderItem.ProductFeature?.VatRate;
// TODO: Use versioning
if (salesOrderItem.ExistPreviousProduct && !salesOrderItem.PreviousProduct.Equals(salesOrderItem.Product))
{
derivation.Validation.AddError(salesOrderItem, M.SalesOrderItem.Product, ErrorMessages.SalesOrderItemProductChangeNotAllowed);
}
else
{
salesOrderItemDerivedRoles.PreviousProduct = salesOrderItem.Product;
}
if (salesOrderItem.ExistSalesOrderItemWhereOrderedWithFeature)
{
derivation.Validation.AssertExists(salesOrderItem, M.SalesOrderItem.ProductFeature);
derivation.Validation.AssertNotExists(salesOrderItem, M.SalesOrderItem.Product);
}
else
{
derivation.Validation.AssertNotExists(salesOrderItem, M.SalesOrderItem.ProductFeature);
}
if (salesOrderItem.ExistProduct && salesOrderItem.ExistQuantityOrdered && salesOrderItem.QuantityOrdered < salesOrderItem.QuantityShipped)
{
derivation.Validation.AddError(salesOrderItem, M.SalesOrderItem.QuantityOrdered, ErrorMessages.SalesOrderItemLessThanAlreadeyShipped);
}
var isSubTotalItem = salesOrderItem.ExistInvoiceItemType && (salesOrderItem.InvoiceItemType.IsProductItem || salesOrderItem.InvoiceItemType.IsPartItem);
if (isSubTotalItem)
{
if (salesOrderItem.QuantityOrdered == 0)
{
derivation.Validation.AddError(salesOrderItem, M.SalesOrderItem.QuantityOrdered, "QuantityOrdered is Required");
}
}
else
{
if (salesOrderItem.AssignedUnitPrice == 0)
{
derivation.Validation.AddError(salesOrderItem, M.SalesOrderItem.AssignedUnitPrice, "Price is Required");
}
}
derivation.Validation.AssertExistsAtMostOne(salesOrderItem, M.SalesOrderItem.Product, M.SalesOrderItem.ProductFeature);
derivation.Validation.AssertExistsAtMostOne(salesOrderItem, M.SalesOrderItem.SerialisedItem, M.SalesOrderItem.ProductFeature);
derivation.Validation.AssertExistsAtMostOne(salesOrderItem, M.SalesOrderItem.ReservedFromSerialisedInventoryItem, M.SalesOrderItem.ReservedFromNonSerialisedInventoryItem);
derivation.Validation.AssertExistsAtMostOne(salesOrderItem, M.SalesOrderItem.AssignedUnitPrice, M.SalesOrderItem.DiscountAdjustment, M.SalesOrderItem.SurchargeAdjustment);
}
var validOrderItems = this.SalesOrderItems.Where(v => v.IsValid).ToArray();
this.ValidOrderItems = validOrderItems;
if (this.ExistVatRegime && this.VatRegime.ExistVatClause)
{
this.DerivedVatClause = this.VatRegime.VatClause;
}
else
{
string TakenbyCountry = null;
if (this.TakenBy.PartyContactMechanisms?.FirstOrDefault(v => v.ContactPurposes.Any(p => Equals(p, new ContactMechanismPurposes(session).RegisteredOffice)))?.ContactMechanism is PostalAddress registeredOffice)
{
TakenbyCountry = registeredOffice.Country.IsoCode;
}
var OutsideEUCustomer = this.BillToCustomer?.VatRegime?.Equals(new VatRegimes(session).Export);
var shipFromBelgium = this.ValidOrderItems?.Cast <SalesOrderItem>().All(v => Equals("BE", v.ShipFromAddress?.Country?.IsoCode));
var shipToEU = this.ValidOrderItems?.Cast <SalesOrderItem>().Any(v => Equals(true, v.ShipToAddress?.Country?.EuMemberState));
var sellerResponsibleForTransport = this.SalesTerms.Any(v => Equals(v.TermType, new IncoTermTypes(session).Cif) || Equals(v.TermType, new IncoTermTypes(session).Cfr));
var buyerResponsibleForTransport = this.SalesTerms.Any(v => Equals(v.TermType, new IncoTermTypes(session).Exw));
if (Equals(this.VatRegime, new VatRegimes(session).ServiceB2B))
{
this.DerivedVatClause = new VatClauses(session).ServiceB2B;
}
else if (Equals(this.VatRegime, new VatRegimes(session).IntraCommunautair))
{
this.DerivedVatClause = new VatClauses(session).Intracommunautair;
}
else if (TakenbyCountry == "BE" &&
OutsideEUCustomer.HasValue && OutsideEUCustomer.Value &&
shipFromBelgium.HasValue && shipFromBelgium.Value &&
shipToEU.HasValue && shipToEU.Value == false)
{
if (sellerResponsibleForTransport)
{
// You sell goods to a customer out of the EU and the goods are being sold and transported from Belgium to another country out of the EU and you transport the goods and importer is the customer
this.DerivedVatClause = new VatClauses(session).BeArt39Par1Item1;
}
else if (buyerResponsibleForTransport)
{
// You sell goods to a customer out of the EU and the goods are being sold and transported from Belgium to another country out of the EU and the customer does the transport of the goods and importer is the customer
this.DerivedVatClause = new VatClauses(session).BeArt39Par1Item2;
}
}
}
this.DerivedVatClause = this.ExistAssignedVatClause ? this.AssignedVatClause : this.DerivedVatClause;
var salesOrderShipmentStates = new SalesOrderShipmentStates(this.Strategy.Session);
var salesOrderPaymentStates = new SalesOrderPaymentStates(this.Strategy.Session);
var salesOrderInvoiceStates = new SalesOrderInvoiceStates(this.Strategy.Session);
var salesOrderItemShipmentStates = new SalesOrderItemShipmentStates(derivation.Session);
var salesOrderItemPaymentStates = new SalesOrderItemPaymentStates(derivation.Session);
var salesOrderItemInvoiceStates = new SalesOrderItemInvoiceStates(derivation.Session);
// SalesOrder Shipment State
if (validOrderItems.Any())
{
if (validOrderItems.All(v => v.SalesOrderItemShipmentState.Shipped))
{
this.SalesOrderShipmentState = salesOrderShipmentStates.Shipped;
}
else if (validOrderItems.All(v => v.SalesOrderItemShipmentState.NotShipped))
{
this.SalesOrderShipmentState = salesOrderShipmentStates.NotShipped;
}
else if (validOrderItems.Any(v => v.SalesOrderItemShipmentState.InProgress))
{
this.SalesOrderShipmentState = salesOrderShipmentStates.InProgress;
}
else
{
this.SalesOrderShipmentState = salesOrderShipmentStates.PartiallyShipped;
}
// SalesOrder Payment State
if (validOrderItems.All(v => v.SalesOrderItemPaymentState.Paid))
{
this.SalesOrderPaymentState = salesOrderPaymentStates.Paid;
}
else if (validOrderItems.All(v => v.SalesOrderItemPaymentState.NotPaid))
{
this.SalesOrderPaymentState = salesOrderPaymentStates.NotPaid;
}
else
{
this.SalesOrderPaymentState = salesOrderPaymentStates.PartiallyPaid;
}
// SalesOrder Invoice State
if (validOrderItems.All(v => v.SalesOrderItemInvoiceState.Invoiced))
{
this.SalesOrderInvoiceState = salesOrderInvoiceStates.Invoiced;
}
else if (validOrderItems.All(v => v.SalesOrderItemInvoiceState.NotInvoiced))
{
this.SalesOrderInvoiceState = salesOrderInvoiceStates.NotInvoiced;
}
else
{
this.SalesOrderInvoiceState = salesOrderInvoiceStates.PartiallyInvoiced;
}
// SalesOrder OrderState
if (this.SalesOrderShipmentState.Shipped && this.SalesOrderInvoiceState.Invoiced)
{
this.SalesOrderState = new SalesOrderStates(this.Strategy.Session).Completed;
}
if (this.SalesOrderState.IsCompleted && this.SalesOrderPaymentState.Paid)
{
this.SalesOrderState = new SalesOrderStates(this.Strategy.Session).Finished;
}
}
// TODO: Move to versioning
this.PreviousBillToCustomer = this.BillToCustomer;
this.PreviousShipToCustomer = this.ShipToCustomer;
var singleton = session.GetSingleton();
this.AddSecurityToken(new SecurityTokens(session).DefaultSecurityToken);
this.ResetPrintDocument();
// CanShip
if (this.SalesOrderState.Equals(new SalesOrderStates(this.Strategy.Session).InProcess))
{
var somethingToShip = false;
var allItemsAvailable = true;
foreach (var salesOrderItem1 in validOrderItems)
{
if (!this.PartiallyShip && salesOrderItem1.QuantityRequestsShipping != salesOrderItem1.QuantityOrdered)
{
allItemsAvailable = false;
break;
}
if (this.PartiallyShip && salesOrderItem1.QuantityRequestsShipping > 0)
{
somethingToShip = true;
}
}
this.CanShip = (!this.PartiallyShip && allItemsAvailable) || somethingToShip;
}
else
{
this.CanShip = false;
}
// CanInvoice
if (this.SalesOrderState.IsInProcess && object.Equals(this.Store.BillingProcess, new BillingProcesses(this.Strategy.Session).BillingForOrderItems))
{
this.CanInvoice = false;
foreach (var orderItem2 in validOrderItems)
{
var amountAlreadyInvoiced1 = orderItem2.OrderItemBillingsWhereOrderItem.Sum(v => v.Amount);
var leftToInvoice1 = (orderItem2.QuantityOrdered * orderItem2.UnitPrice) - amountAlreadyInvoiced1;
if (leftToInvoice1 > 0)
{
this.CanInvoice = true;
}
}
}
else
{
this.CanInvoice = false;
}
if (this.SalesOrderState.Equals(new SalesOrderStates(this.Strategy.Session).InProcess) &&
Equals(this.Store.BillingProcess, new BillingProcesses(this.Strategy.Session).BillingForShipmentItems))
{
this.RemoveDeniedPermission(new Permissions(this.Strategy.Session).Get(this.Meta.Class, this.Meta.Invoice, Operations.Execute));
}
if (this.CanShip && this.Store.AutoGenerateCustomerShipment)
{
this.Ship();
}
if (this.SalesOrderState.IsInProcess &&
(!this.ExistLastSalesOrderState || !this.LastSalesOrderState.IsInProcess) &&
this.TakenBy.SerialisedItemSoldOn == new SerialisedItemSoldOns(this.Session()).SalesOrderAccept)
{
foreach (SalesOrderItem item in this.ValidOrderItems.Where(v => ((SalesOrderItem)v).ExistSerialisedItem))
{
if (item.ExistNextSerialisedItemAvailability)
{
item.SerialisedItem.SerialisedItemAvailability = item.NextSerialisedItemAvailability;
if (item.NextSerialisedItemAvailability.Equals(new SerialisedItemAvailabilities(this.Session()).Sold))
{
item.SerialisedItem.OwnedBy = this.ShipToCustomer;
item.SerialisedItem.Ownership = new Ownerships(this.Session()).ThirdParty;
}
}
item.SerialisedItem.AvailableForSale = false;
}
}
this.Sync(derivation, validOrderItems);
}