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"); } }