public virtual OperationLog FromChangedEntry <T>(GenericChangedEntry <T> changedEntry) where T : IEntity
{
if (changedEntry == null)
{
throw new ArgumentNullException(nameof(changedEntry));
}
return(FromChangedEntry(changedEntry, changedEntry.OldEntry.GetType().Name));
}
public static OrderRequestReviewJobArgument FromChangedEntry(GenericChangedEntry <CustomerOrder> changedEntry)
{
var result = new OrderRequestReviewJobArgument
{
CustomerOrderId = changedEntry.NewEntry?.Id ?? changedEntry.OldEntry?.Id,
StoreId = changedEntry.NewEntry.StoreId,
CustomerId = changedEntry.NewEntry.CustomerId
};
return(result);
}
protected virtual IEnumerable <OperationLog> GetChangedEntryOperationLogs(GenericChangedEntry <IOperation> changedEntry)
{
var result = new List <string>();
//TDB: Rework to make more extensible
if (changedEntry.EntryState == EntryState.Modified)
{
var diff = Comparer.Compare(changedEntry.OldEntry, changedEntry.NewEntry);
if (changedEntry.OldEntry is Shipment shipment)
{
result.AddRange(GetShipmentChanges(shipment, changedEntry.NewEntry as Shipment));
diff.AddRange(Comparer.Compare(shipment, changedEntry.NewEntry as Shipment));
}
else if (changedEntry.OldEntry is PaymentIn payment)
{
result.AddRange(GetPaymentChanges(payment, changedEntry.NewEntry as PaymentIn));
diff.AddRange(Comparer.Compare(payment, changedEntry.NewEntry as PaymentIn));
}
else if (changedEntry.OldEntry is CustomerOrder order)
{
result.AddRange(GetCustomerOrderChanges(order, changedEntry.NewEntry as CustomerOrder));
diff.AddRange(Comparer.Compare(order, changedEntry.NewEntry as CustomerOrder));
}
List <string> auditableProperties;
var type = changedEntry.OldEntry.GetType();
if (!_auditablePropertiesListByTypeDict.TryGetValue(type.Name, out auditableProperties))
{
auditableProperties = type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(AuditableAttribute)))
.Select(x => x.Name)
.ToList();
_auditablePropertiesListByTypeDict[type.Name] = auditableProperties;
}
if (auditableProperties.Any())
{
var observedDifferences = diff.Join(auditableProperties, x => x.Name.ToLowerInvariant(), x => x.ToLowerInvariant(), (x, y) => x).ToArray();
foreach (var difference in observedDifferences.Distinct(new DifferenceComparer()))
{
result.Add($"The {changedEntry.OldEntry.OperationType} {changedEntry.NewEntry.Number} property '{difference.Name}' changed from '{difference.OldValue}' to '{difference.NewValue}'");
}
}
}
else if (changedEntry.EntryState == EntryState.Deleted)
{
result.Add($"The {changedEntry.NewEntry.OperationType} {changedEntry.NewEntry.Number} deleted");
}
else if (changedEntry.EntryState == EntryState.Added)
{
result.Add($"The new {changedEntry.NewEntry.OperationType} {changedEntry.NewEntry.Number} added");
}
return(result.Select(x => GetLogRecord(changedEntry.NewEntry, x)));
}
public async Task GetFullfilmentCenterForLineItemAsync_GetAdditionalFfc_FfcFound()
{
// Arrange
var mainFulfillmentCenterId = "MainFulfillmentCenterId";
var additionalFulfillmentCenterId = "additionalFulfillmentCenterId";
var changedOrder = new CustomerOrder
{
StoreId = TestStoreId,
Items = new List <LineItem> {
new LineItem {
Id = "{01234567-89ab-cdef-0123-456789abcdef}", ProductId = "shoes", Quantity = 1
}
}
};
var changedEntry = new GenericChangedEntry <CustomerOrder>(changedOrder, changedOrder, EntryState.Added);
var inventoryServiceMock = new Mock <IInventoryService>();
var settingsManagerMock = new Mock <ISettingsManager>();
var itemServiceMock = new Mock <IItemService>();
var storeServiceMock = new Mock <IStoreService>();
storeServiceMock.Setup(x => x.GetByIdAsync(TestStoreId, It.IsAny <string>()))
.ReturnsAsync(new Store {
MainFulfillmentCenterId = mainFulfillmentCenterId, AdditionalFulfillmentCenterIds = new List <string>()
{
additionalFulfillmentCenterId
}
});
inventoryServiceMock.Setup(x => x.GetProductsInventoryInfosAsync(It.IsAny <IEnumerable <string> >(), null))
.ReturnsAsync(new List <InventoryInfo>()
{
new InventoryInfo()
{
InStockQuantity = 0, FulfillmentCenterId = mainFulfillmentCenterId
},
new InventoryInfo()
{
InStockQuantity = 10, FulfillmentCenterId = additionalFulfillmentCenterId
}
});
var targetHandler = new AdjustInventoryOrderChangedEventHandler(inventoryServiceMock.Object,
storeServiceMock.Object, settingsManagerMock.Object, itemServiceMock.Object);
// Act
var actualChanges = await targetHandler.GetProductInventoryChangesFor(changedEntry);
// Assert
actualChanges.Should().HaveCount(1);
actualChanges.First().FulfillmentCenterId.Should().Be(additionalFulfillmentCenterId);
}
public virtual OperationLog FromChangedEntry <T>(GenericChangedEntry <T> changedEntry) where T : IEntity
{
if (changedEntry == null)
{
throw new ArgumentNullException(nameof(changedEntry));
}
ObjectId = changedEntry.OldEntry.Id;
ObjectType = changedEntry.OldEntry.GetType().Name;
OperationType = changedEntry.EntryState;
return(this);
}
protected virtual void TryAdjustOrderInventory(GenericChangedEntry <CustomerOrder> changedEntry)
{
var customerOrder = changedEntry.OldEntry;
if (!customerOrder.IsPrototype)
{
var itemChanges = GetProductInventoryChangesFor(changedEntry);
if (itemChanges.Any())
{
TryAdjustOrderInventory(itemChanges);
}
}
}
protected virtual async Task TryToSendOrderNotificationsAsync(GenericChangedEntry <CustomerOrder> changedEntry)
{
// Collection of order notifications
var notifications = new List <OrderEmailNotificationBase>();
if (IsOrderCanceled(changedEntry))
{
var notification = _notificationManager.GetNewNotification <CancelOrderEmailNotification>(changedEntry.NewEntry.StoreId, "Store", changedEntry.NewEntry.LanguageCode);
notifications.Add(notification);
}
if (changedEntry.EntryState == EntryState.Added && !changedEntry.NewEntry.IsPrototype)
{
var notification = _notificationManager.GetNewNotification <OrderCreateEmailNotification>(changedEntry.NewEntry.StoreId, "Store", changedEntry.NewEntry.LanguageCode);
notifications.Add(notification);
}
if (HasNewStatus(changedEntry))
{
var notification = _notificationManager.GetNewNotification <NewOrderStatusEmailNotification>(changedEntry.NewEntry.StoreId, "Store", changedEntry.NewEntry.LanguageCode);
notification.NewStatus = changedEntry.NewEntry.Status;
notification.OldStatus = changedEntry.OldEntry.Status;
notifications.Add(notification);
}
if (IsOrderPaid(changedEntry))
{
var notification = _notificationManager.GetNewNotification <OrderPaidEmailNotification>(changedEntry.NewEntry.StoreId, "Store", changedEntry.NewEntry.LanguageCode);
notifications.Add(notification);
}
if (IsOrderSent(changedEntry))
{
var notification = _notificationManager.GetNewNotification <OrderSentEmailNotification>(changedEntry.NewEntry.StoreId, "Store", changedEntry.NewEntry.LanguageCode);
notifications.Add(notification);
}
var customer = await GetCustomerAsync(changedEntry.NewEntry.CustomerId);
foreach (var notification in notifications)
{
notification.CustomerOrder = changedEntry.NewEntry;
notification.Customer = customer;
await SetNotificationParametersAsync(notification, changedEntry);
_notificationManager.ScheduleSendNotification(notification);
}
}
protected virtual IEnumerable <OperationLog> GetChangedEntryOperationLogs(GenericChangedEntry <IOperation> changedEntry)
{
var result = new List <string>();
if (changedEntry.EntryState == EntryState.Modified)
{
var diff = Comparer.Compare(changedEntry.OldEntry, changedEntry.NewEntry);
var shipment = changedEntry.OldEntry as Shipment;
if (shipment != null)
{
result.AddRange(GetShipmentChanges(shipment, changedEntry.NewEntry as Shipment));
diff.AddRange(Comparer.Compare(shipment, changedEntry.NewEntry as Shipment));
}
var payment = changedEntry.OldEntry as PaymentIn;
if (payment != null)
{
result.AddRange(GetPaymentChanges(payment, changedEntry.NewEntry as PaymentIn));
diff.AddRange(Comparer.Compare(payment, changedEntry.NewEntry as PaymentIn));
}
var order = changedEntry.OldEntry as CustomerOrder;
if (order != null)
{
result.AddRange(GetCustomerOrderChanges(order, changedEntry.NewEntry as CustomerOrder));
diff.AddRange(Comparer.Compare(order, changedEntry.NewEntry as CustomerOrder));
}
var observedDifferences = diff.Join(_observedProperties, x => x.Name.ToLowerInvariant(), x => x.ToLowerInvariant(), (x, y) => x).ToArray();
foreach (var difference in observedDifferences.Distinct(new DifferenceComparer()))
{
result.Add(string.Format(OrderResources.OperationPropertyChanged, changedEntry.OldEntry.OperationType, changedEntry.NewEntry.Number, difference.Name, difference.OldValue, difference.NewValue));
}
}
else if (changedEntry.EntryState == EntryState.Deleted)
{
result.Add(string.Format(OrderResources.OperationDeleted, changedEntry.NewEntry.OperationType, changedEntry.NewEntry.Number));
}
else if (changedEntry.EntryState == EntryState.Added)
{
result.Add(string.Format(OrderResources.OperationAdded, changedEntry.NewEntry.OperationType, changedEntry.NewEntry.Number));
}
return(result.Select(x => GetLogRecord(changedEntry.NewEntry, x)));
}
protected virtual void TryDeleteDynamicPropertiesForRemovedLineItems(GenericChangedEntry <ShoppingCart> changedEntry)
{
var originalDynPropOwners = changedEntry.OldEntry.GetFlatObjectsListWithInterface <IHasDynamicProperties>()
.Distinct()
.ToList();
var modifiedDynPropOwners = changedEntry.NewEntry.GetFlatObjectsListWithInterface <IHasDynamicProperties>()
.Distinct()
.ToList();
var removingDynPropOwners = new List <IHasDynamicProperties>();
var hasDynPropComparer = AnonymousComparer.Create((IHasDynamicProperties x) => x.Id);
modifiedDynPropOwners.CompareTo(originalDynPropOwners, hasDynPropComparer, (state, changed, orig) =>
{
if (state == EntryState.Deleted)
{
_dynamicPropertyService.DeleteDynamicPropertyValues(orig);
}
});
}
protected virtual async Task TryAdjustOrderInventory(GenericChangedEntry <CustomerOrder> changedEntry)
{
var customerOrder = changedEntry.OldEntry;
//Skip prototypes
if (customerOrder.IsPrototype)
{
return;
}
var origLineItems = new LineItem[] { };
var changedLineItems = new LineItem[] { };
if (changedEntry.EntryState == EntryState.Added)
{
changedLineItems = changedEntry.NewEntry.Items.ToArray();
}
else if (changedEntry.EntryState == EntryState.Deleted)
{
origLineItems = changedEntry.OldEntry.Items.ToArray();
}
else
{
origLineItems = changedEntry.OldEntry.Items.ToArray();
changedLineItems = changedEntry.NewEntry.Items.ToArray();
}
var inventoryAdjustments = new HashSet <InventoryInfo>();
//Load all inventories records for all changes and old order items
var inventoryInfos = await _inventoryService.GetProductsInventoryInfosAsync(origLineItems.Select(x => x.ProductId).Concat(changedLineItems.Select(x => x.ProductId)).Distinct().ToArray());
changedLineItems.CompareTo(origLineItems, EqualityComparer <LineItem> .Default, async(state, changed, orig) =>
{
await AdjustInventory(inventoryInfos, inventoryAdjustments, customerOrder, state, changed, orig);
});
//Save inventories adjustments
if (inventoryAdjustments != null)
{
await _inventoryService.SaveChangesAsync(inventoryAdjustments);
}
}
protected virtual IEnumerable <OperationLog> GetChangedEntryOperationLogs(GenericChangedEntry <Member> changedEntry)
{
var result = new List <string>();
var oldContact = changedEntry.OldEntry as Contact;
var changedContact = changedEntry.NewEntry as Contact;
var diff = Comparer.Compare(oldContact, changedContact);
//First, we detect changes with simple properties of the contact object.
var observedDifferences = diff.Join(_observedProperties, x => x.Name.ToLowerInvariant(), x => x.ToLowerInvariant(), (x, y) => x).ToArray();
var anonymousDiffComparer = AnonymousComparer.Create((Difference x) => string.Join(":", x.Name, x.NewValue, x.OldValue));
foreach (var difference in observedDifferences.Distinct(anonymousDiffComparer))
{
result.Add(string.Format(MemberResources.MemberPropertyChanged, difference.Name, difference.OldValue, difference.NewValue));
}
//Second, detect changes for contact dependencies
result.AddRange(GetContactDependenciesChanges(oldContact, changedContact));
return(result.Select(x => GetLogRecord(changedContact, x)));
}
/// <summary>
/// Forms a list of product inventory changes for inventory adjustment. This method is intended for unit-testing only,
/// and there should be no need to call it from the production code.
/// </summary>
/// <param name="changedEntry">The entry that describes changes made to order.</param>
/// <returns>Array of required product inventory changes.</returns>
public virtual ProductInventoryChange[] GetProductInventoryChangesFor(GenericChangedEntry <CustomerOrder> changedEntry)
{
var customerOrder = changedEntry.NewEntry;
var customerOrderShipments = customerOrder.Shipments?.ToArray();
var oldLineItems = changedEntry.OldEntry.Items?.ToArray() ?? Array.Empty <LineItem>();
var newLineItems = changedEntry.NewEntry.Items?.ToArray() ?? Array.Empty <LineItem>();
var itemChanges = new List <ProductInventoryChange>();
newLineItems.CompareTo(oldLineItems, EqualityComparer <LineItem> .Default, (state, changedItem, originalItem) =>
{
var newQuantity = changedItem.Quantity;
var oldQuantity = originalItem.Quantity;
if (changedEntry.EntryState == EntryState.Added || state == EntryState.Added)
{
oldQuantity = 0;
}
else if (changedEntry.EntryState == EntryState.Deleted || state == EntryState.Deleted)
{
newQuantity = 0;
}
if (oldQuantity != newQuantity)
{
var itemChange = AbstractTypeFactory <ProductInventoryChange> .TryCreateInstance();
itemChange.ProductId = changedItem.ProductId;
itemChange.QuantityDelta = newQuantity - oldQuantity;
itemChange.FulfillmentCenterId = GetFullfilmentCenterForLineItem(changedItem, customerOrder.StoreId, customerOrderShipments);
itemChanges.Add(itemChange);
}
});
//Do not return unchanged records
return(itemChanges.Where(x => x.QuantityDelta != 0).ToArray());
}
protected virtual async Task TryToCancelOrder(GenericChangedEntry <CustomerOrder> changedEntry)
{
var store = await _storeService.GetByIdAsync(changedEntry.NewEntry.StoreId);
//Try to load payment methods for payments
var gatewayCodes = changedEntry.NewEntry.InPayments.Select(x => x.GatewayCode).ToArray();
var paymentMethods = await GetPaymentMethodsAsync(store.Id, gatewayCodes);
foreach (var payment in changedEntry.NewEntry.InPayments)
{
payment.PaymentMethod = paymentMethods.FirstOrDefault(x => x.Code == payment.GatewayCode);
}
var toCancelPayments = new List <PaymentIn>();
var isOrderCancelled = !changedEntry.OldEntry.IsCancelled && changedEntry.NewEntry.IsCancelled;
if (isOrderCancelled)
{
toCancelPayments = changedEntry.NewEntry.InPayments?.ToList();
}
else
{
foreach (var canceledPayment in changedEntry.NewEntry?.InPayments.Where(x => x.IsCancelled))
{
var oldSamePayment = changedEntry.OldEntry?.InPayments.FirstOrDefault(x => x == canceledPayment);
if (oldSamePayment != null && !oldSamePayment.IsCancelled)
{
toCancelPayments.Add(canceledPayment);
}
}
}
TryToCancelOrderPayments(toCancelPayments);
if (!toCancelPayments.IsNullOrEmpty())
{
await _orderService.SaveChangesAsync(new[] { changedEntry.NewEntry });
}
}
/// <summary>
/// Set base notification parameters (sender, recipient, isActive)
/// </summary>
/// <param name="notification"></param>
/// <param name="changedEntry"></param>
protected virtual async Task SetNotificationParametersAsync(Notification notification, GenericChangedEntry <CustomerOrder> changedEntry)
{
var order = changedEntry.NewEntry;
var store = _storeService.GetById(order.StoreId);
notification.IsActive = true;
notification.Sender = store.Email;
notification.Recipient = await GetOrderRecipientEmailAsync(order);
// Allow to filter notification log either by customer order or by subscription
if (string.IsNullOrEmpty(order.SubscriptionId))
{
notification.ObjectTypeId = "CustomerOrder";
notification.ObjectId = order.Id;
}
else
{
notification.ObjectTypeId = "Subscription";
notification.ObjectId = order.SubscriptionId;
}
}
/// <summary>
/// Is order canceled
/// </summary>
/// <param name="changedEntry"></param>
/// <returns></returns>
protected virtual bool IsOrderCanceled(GenericChangedEntry <CustomerOrder> changedEntry)
{
var result = !changedEntry.OldEntry.IsCancelled && changedEntry.NewEntry.IsCancelled;
return(result);
}
protected virtual async Task <IEnumerable <OperationLog> > GetChangedEntryOperationLogsAsync(GenericChangedEntry <IOperation> changedEntry)
{
var result = new List <string>();
if (changedEntry.EntryState == EntryState.Modified)
{
var diff = Comparer.Compare(changedEntry.OldEntry, changedEntry.NewEntry);
var shipment = changedEntry.OldEntry as Shipment;
if (shipment != null)
{
result.AddRange(GetShipmentChanges(shipment, changedEntry.NewEntry as Shipment));
diff.AddRange(Comparer.Compare(shipment, changedEntry.NewEntry as Shipment));
}
var payment = changedEntry.OldEntry as PaymentIn;
if (payment != null)
{
result.AddRange(GetPaymentChanges(payment, changedEntry.NewEntry as PaymentIn));
diff.AddRange(Comparer.Compare(payment, changedEntry.NewEntry as PaymentIn));
}
var order = changedEntry.OldEntry as CustomerOrder;
if (order != null)
{
result.AddRange(await GetCustomerOrderChangesAsync(order, changedEntry.NewEntry as CustomerOrder));
diff.AddRange(Comparer.Compare(order, changedEntry.NewEntry as CustomerOrder));
}
var observedDifferences = diff.Join(_observedProperties, x => x.Name.ToLowerInvariant(), x => x.ToLowerInvariant(), (x, y) => x).ToArray();
foreach (var difference in observedDifferences.Distinct(new DifferenceComparer()))
{
result.Add($"The {changedEntry.OldEntry.OperationType} {changedEntry.NewEntry.Number} property '{difference.Name}' changed from '{difference.OldValue}' to '{difference.NewValue}'");
}
}
else if (changedEntry.EntryState == EntryState.Deleted)
{
result.Add($"The {changedEntry.NewEntry.OperationType} {changedEntry.NewEntry.Number} deleted");
}
else if (changedEntry.EntryState == EntryState.Added)
{
result.Add($"The new {changedEntry.NewEntry.OperationType} {changedEntry.NewEntry.Number} added");
}
return(result.Select(x => GetLogRecord(changedEntry.NewEntry, x)));
}
protected virtual bool IsOrderInState(GenericChangedEntry <CustomerOrder> changedEntry, string state)
{
var result = changedEntry.OldEntry.Status != changedEntry.NewEntry.Status && changedEntry.NewEntry.Status.EqualsInvariant(state);
return(result);
}
protected virtual Task <IEnumerable <OperationLog> > GetChangedEntryOperationLogsAsync(GenericChangedEntry <Subscription> changedEntry)
{
var result = new List <OperationLog>();
var original = changedEntry.OldEntry;
var modified = changedEntry.NewEntry;
if (changedEntry.EntryState == EntryState.Modified)
{
if (original.SubscriptionStatus != modified.SubscriptionStatus)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.StatusChanged, original.SubscriptionStatus, modified.SubscriptionStatus));
}
if (original.Interval != modified.Interval)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.IntervalChanged, original.Interval, modified.Interval));
}
if (original.IntervalCount != modified.IntervalCount)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.IntervalCountChanged, original.IntervalCount, modified.IntervalCount));
}
if (original.TrialPeriodDays != modified.TrialPeriodDays)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.TrialPeriodChanged, original.TrialPeriodDays, modified.TrialPeriodDays));
}
if (original.CurrentPeriodEnd != modified.CurrentPeriodEnd)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.NextBillingDateChanged, original.CurrentPeriodEnd, modified.CurrentPeriodEnd));
}
if (original.Balance != modified.Balance)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.BalanceChanged, original.Balance, modified.Balance));
}
if (modified.IsCancelled && original.IsCancelled != modified.IsCancelled)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.SubscriptionCanceled, modified.CancelledDate, modified.CancelReason ?? ""));
}
if (original.OuterId != modified.OuterId)
{
result.Add(GetLogRecord(modified.Id, SubscriptionResources.OuterIdChanged, original.OuterId, modified.OuterId));
}
}
return(Task.FromResult <IEnumerable <OperationLog> >(result));
}
protected virtual Task <IEnumerable <OperationLog> > GetChangedEntryOperationLogsAsync(GenericChangedEntry <CustomerOrder> changedEntry)
{
var result = new List <OperationLog>();
//log for new recurring orders creation
//handle only recurring orders
if (changedEntry.EntryState == EntryState.Added && !string.IsNullOrEmpty(changedEntry.OldEntry.SubscriptionId))
{
var operationLog = GetLogRecord(changedEntry.NewEntry.SubscriptionId, SubscriptionResources.NewRecurringOrderCreated, changedEntry.NewEntry.Number);
result.Add(operationLog);
}
return(Task.FromResult <IEnumerable <OperationLog> >(result));
}
public void AdjustInventoryHandler_GetProductInventoryChanges_ForOrderChanges(GenericChangedEntry <CustomerOrder> orderChangedEntry,
IEnumerable <AdjustInventoryOrderChangedEventHandler.ProductInventoryChange> expectedChanges)
{
// Arrange
var inventoryServiceMock = new Mock <IInventoryService>();
var settingsManagerMock = new Mock <ISettingsManager>();
var storeServiceMock = new Mock <IStoreService>();
storeServiceMock.Setup(x => x.GetById(TestStoreId))
.Returns(new Store {
MainFulfillmentCenterId = TestFulfillmentCenterId
});
var targetHandler = new AdjustInventoryOrderChangedEventHandler(inventoryServiceMock.Object,
storeServiceMock.Object, settingsManagerMock.Object);
// Act
var actualChanges = targetHandler.GetProductInventoryChangesFor(orderChangedEntry);
// Assert
var equalityComparer = AnonymousComparer.Create((AdjustInventoryOrderChangedEventHandler.ProductInventoryChange x) => $"{x.FulfillmentCenterId} {x.ProductId} {x.QuantityDelta}");
Assert.Equal(expectedChanges, actualChanges, equalityComparer);
}
protected virtual async Task TryToSendOrderNotificationsAsync(GenericChangedEntry <CustomerOrder> changedEntry)
{
// Collection of order notifications
var notifications = new List <OrderEmailNotificationBase>();
if (IsOrderCanceled(changedEntry))
{
var notification = await _notificationSearchService.GetNotificationAsync <CancelOrderEmailNotification>(new TenantIdentity(changedEntry.NewEntry.StoreId, nameof(Store)));
if (notification != null)
{
notifications.Add(notification);
}
}
if (changedEntry.EntryState == EntryState.Added && !changedEntry.NewEntry.IsPrototype)
{
var notification = await _notificationSearchService.GetNotificationAsync <OrderCreateEmailNotification>(new TenantIdentity(changedEntry.NewEntry.StoreId, nameof(Store)));
if (notification != null)
{
notifications.Add(notification);
}
}
if (HasNewStatus(changedEntry))
{
var notification = await _notificationSearchService.GetNotificationAsync <NewOrderStatusEmailNotification>(new TenantIdentity(changedEntry.NewEntry.StoreId, nameof(Store)));
if (notification != null)
{
notification.NewStatus = changedEntry.NewEntry.Status;
notification.OldStatus = changedEntry.OldEntry.Status;
notifications.Add(notification);
}
}
if (IsOrderPaid(changedEntry))
{
var notification = await _notificationSearchService.GetNotificationAsync <OrderPaidEmailNotification>(new TenantIdentity(changedEntry.NewEntry.StoreId, nameof(Store)));
if (notification != null)
{
notifications.Add(notification);
}
}
if (IsOrderSent(changedEntry))
{
var notification = await _notificationSearchService.GetNotificationAsync <OrderSentEmailNotification>(new TenantIdentity(changedEntry.NewEntry.StoreId, nameof(Store)));
if (notification != null)
{
notifications.Add(notification);
}
}
var customer = await GetCustomerAsync(changedEntry.NewEntry.CustomerId);
foreach (var notification in notifications)
{
notification.CustomerOrder = changedEntry.NewEntry;
notification.Customer = customer;
notification.LanguageCode = changedEntry.NewEntry.LanguageCode;
await SetNotificationParametersAsync(notification, changedEntry);
_notificationSender.ScheduleSendNotification(notification);
}
}
protected virtual async Task TryToSendOrderNotificationsAsync(GenericChangedEntry <CustomerOrder> changedEntry)
{
// Collection of order notifications
var notifications = new List <OrderEmailNotificationBase>();
if (IsOrderCanceled(changedEntry))
{
var originalNotification = await _notificationService.GetByTypeAsync(nameof(CancelOrderEmailNotification));
if (originalNotification is CancelOrderEmailNotification notification)
{
notification.CustomerOrder = changedEntry.NewEntry;
notifications.Add(notification);
}
}
if (changedEntry.EntryState == EntryState.Added && !changedEntry.NewEntry.IsPrototype)
{
var originalNotification = await _notificationService.GetByTypeAsync(nameof(OrderCreateEmailNotification));
if (originalNotification is OrderCreateEmailNotification notification)
{
notification.CustomerOrder = changedEntry.NewEntry;
notifications.Add(notification);
}
}
if (HasNewStatus(changedEntry))
{
var originalNotification = await _notificationService.GetByTypeAsync(nameof(NewOrderStatusEmailNotification));
if (originalNotification is NewOrderStatusEmailNotification notification)
{
notification.CustomerOrder = changedEntry.NewEntry;
notification.NewStatus = changedEntry.NewEntry.Status;
notification.OldStatus = changedEntry.OldEntry.Status;
notifications.Add(notification);
}
}
if (IsOrderPaid(changedEntry))
{
var originalNotification = await _notificationService.GetByTypeAsync(nameof(OrderPaidEmailNotification));
if (originalNotification is OrderCreateEmailNotification notification)
{
notification.CustomerOrder = changedEntry.NewEntry;
notifications.Add(notification);
}
}
if (IsOrderSent(changedEntry))
{
var originalNotification = await _notificationService.GetByTypeAsync(nameof(OrderSentEmailNotification));
if (originalNotification is OrderCreateEmailNotification notification)
{
notification.CustomerOrder = changedEntry.NewEntry;
notifications.Add(notification);
}
}
foreach (var notification in notifications)
{
notification.CustomerOrder = changedEntry.NewEntry;
await SetNotificationParametersAsync(notification, changedEntry);
await _notificationSender.SendNotificationAsync(notification, changedEntry.NewEntry.LanguageCode);
}
}
protected virtual OrderRequestReviewJobArgument[] GetJobArgumentsForChangedEntry(GenericChangedEntry <CustomerOrder> changedEntry)
{
var result = new List <OrderRequestReviewJobArgument>();
var state = _settingsManager.GetValue(ModuleConstants.Settings.General.RequestReviewOrderInState.Name, (string)ModuleConstants.Settings.General.RequestReviewOrderInState.DefaultValue);
if (IsOrderInState(changedEntry, state))
{
result.Add(OrderRequestReviewJobArgument.FromChangedEntry(changedEntry));
}
return(result.ToArray());
}
/// <summary>
/// The order has a new status
/// </summary>
/// <param name="changedEntry"></param>
/// <returns></returns>
protected virtual bool HasNewStatus(GenericChangedEntry <CustomerOrder> changedEntry)
{
var retVal = changedEntry.OldEntry.Status != changedEntry.NewEntry.Status;
return(retVal);
}
protected virtual Task <IEnumerable <OperationLog> > GetChangedEntryOperationLogsAsync(GenericChangedEntry <QuoteRequest> changedEntry)
{
var result = new List <OperationLog>();
var original = changedEntry.OldEntry;
var modified = changedEntry.NewEntry;
if (changedEntry.EntryState == EntryState.Modified)
{
result.Add(GetLogRecord(modified.Id, QuoteResources.Updated));
if (original.Status != modified.Status)
{
result.Add(GetLogRecord(modified.Id, QuoteResources.StatusChanged, original.Status, modified.Status));
}
if (original.Comment != modified.Comment)
{
result.Add(GetLogRecord(modified.Id, QuoteResources.CommentChanged, original.Comment, modified.Comment));
}
if (original.IsLocked != modified.IsLocked)
{
result.Add(GetLogRecord(modified.Id, QuoteResources.IsLockedChanged, original.IsLocked, modified.IsLocked));
}
}
return(Task.FromResult <IEnumerable <OperationLog> >(result));
}
/// <summary>
/// Set base notification parameters (sender, recipient, isActive)
/// </summary>
/// <param name="notification"></param>
/// <param name="changedEntry"></param>
protected virtual async Task SetNotificationParametersAsync(Notification notification, GenericChangedEntry <CustomerOrder> changedEntry)
{
var order = changedEntry.NewEntry;
var store = await _storeService.GetByIdAsync(order.StoreId, StoreResponseGroup.StoreInfo.ToString());
if (notification is EmailNotification emailNotification)
{
emailNotification.From = store.Email;
emailNotification.To = await GetOrderRecipientEmailAsync(order);
}
// Allow to filter notification log either by customer order or by subscription
if (string.IsNullOrEmpty(order.SubscriptionId))
{
notification.TenantIdentity = new TenantIdentity(order.Id, nameof(CustomerOrder));
}
else
{
notification.TenantIdentity = new TenantIdentity(order.SubscriptionId, "Subscription");
}
}
