/// <summary>
/// Handles the event
/// </summary>
/// <param name="eventMessage">The event message</param>
public void HandleEvent(OrderPaidEvent eventMessage)
{
//ensure the plugin is installed and active
if (!IsPluginEnabled())
{
return;
}
var order = eventMessage.Order;
//settings per store
var store = _storeService.GetStoreById(order.StoreId) ?? _storeContext.CurrentStore;
var googleAnalyticsSettings = _settingService.LoadSetting <GoogleAnalyticsSettings>(store.Id);
//ecommerce is disabled
if (!googleAnalyticsSettings.EnableEcommerce)
{
return;
}
//we use HTTP requests to notify GA about new orders (only when they are paid)
bool sendRequest = !googleAnalyticsSettings.UseJsToSendEcommerceInfo;
if (sendRequest)
{
ProcessOrderEvent(order, true);
}
}
/// <summary>
/// Handle the order paid event
/// </summary>
/// <param name="eventMessage">The event message.</param>
public async Task HandleEventAsync(OrderPaidEvent eventMessage)
{
//handle event
await _sendinBlueMarketingAutomationManager.HandleOrderCompletedEventAsync(eventMessage.Order);
await _sendinBlueEmailManager.UpdateContactAfterCompletingOrderAsync(eventMessage.Order);
}
public void HandleEvent(OrderPaidEvent orderPaidEvent)
{
if (orderPaidEvent.Order.Customer == null)
{
return;
}
//reward points for the first purchase
if (_rewardPointsSettingsForFirstPurchase.IsEnabled)
{
//check whether this order is the first
var paidOrders = _orderService.SearchOrders(customerId: orderPaidEvent.Order.Customer.Id, psIds: new[] { (int)PaymentStatus.Paid }.ToList());
if (paidOrders.TotalCount > 1)
{
return;
}
//check whether delay is set
var activationDate = GetRewardPointsActivationDate(_rewardPointsSettingsForFirstPurchase);
//get message for the current customer
var message = _rewardPointsSettingsForFirstPurchase.GetLocalizedSetting(settings => settings.Message,
orderPaidEvent.Order.CustomerLanguageId, orderPaidEvent.Order.StoreId);
//add reward points for the first purchase
_rewardPointService.AddRewardPointsHistoryEntry(orderPaidEvent.Order.Customer, _rewardPointsSettingsForFirstPurchase.Points,
orderPaidEvent.Order.StoreId, message, activatingDate: activationDate);
}
//reward points for the fast purchase
if (_rewardPointsSettingsForFastPurchase.IsEnabled)
{
//get start time of purchase
var purchaseStartTime = _genericAttributeService.GetAttribute <DateTime?>(orderPaidEvent.Order.Customer, "PurchaseStartTime", orderPaidEvent.Order.StoreId);
if (!purchaseStartTime.HasValue)
{
return;
}
//clear start time
_genericAttributeService.SaveAttribute <DateTime?>(orderPaidEvent.Order.Customer, "PurchaseStartTime", null, orderPaidEvent.Order.StoreId);
//compare the time of purchase with the set time span
if (DateTime.UtcNow.Subtract(purchaseStartTime.Value) > TimeSpan.FromMinutes(_rewardPointsSettingsForFastPurchase.Minutes ?? 0))
{
return;
}
//check whether delay is set
var activationDate = GetRewardPointsActivationDate(_rewardPointsSettingsForFastPurchase);
//get message for the current customer
var message = _rewardPointsSettingsForFastPurchase.GetLocalizedSetting(settings => settings.Message,
orderPaidEvent.Order.CustomerLanguageId, orderPaidEvent.Order.StoreId);
//add reward points for the first purchase
_rewardPointService.AddRewardPointsHistoryEntry(orderPaidEvent.Order.Customer, _rewardPointsSettingsForFastPurchase.Points,
orderPaidEvent.Order.StoreId, message, activatingDate: activationDate);
}
}
public void HandleEvent(OrderPaidEvent eventMessage)
{
if (eventMessage?.Order == null)
{
return;
}
if (!eventMessage.Order.PaymentMethodSystemName.IsCaseInsensitiveEqual(AmazonPayPlugin.SystemName))
{
return;
}
if (!_pluginFinder.IsPluginReady(_services.Settings, AmazonPayPlugin.SystemName, eventMessage.Order.StoreId))
{
return;
}
try
{
var settings = _services.Settings.LoadSetting <AmazonPaySettings>(eventMessage.Order.StoreId);
_amazonPayService.Value.CloseOrderReference(settings, eventMessage.Order);
}
catch (Exception exception)
{
Logger.Error(exception);
}
}
public void Handle(OrderPaidEvent evt)
{
//付款通知
var user = repository.Find(evt.UserId);
MessageFactory.GetService(MessageType.Email).Send(user.Email, "付款通知", "买家已经为您付款了，请注意查收，订单号：" + evt.OrderId + "，时间：" + evt.EventTime);
}
/// <summary>
/// Order Paid Event
/// </summary>
/// <param name="eventMessage"></param>
public void HandleEvent(OrderPaidEvent eventMessage)
{
var storeScope = _storeContext.ActiveStoreScopeConfiguration;
var ShipRocketSettings = _settingService.LoadSetting <ShipRocketSetting>(storeScope);
if (ShipRocketSettings.Enable)
{
var order = eventMessage.Order;
if (order.PaymentMethodSystemName != "Payments.CashOnDelivery")
{
var oldorder = _ShipRocketService.GetShiprocketOrderByOrderId(order.Id);
if (oldorder == null)
{
NopShiprocketOrder SO = new NopShiprocketOrder()
{
OrderId = order.Id,
ShiprocketStatues = false
};
_ShipRocketService.InsertShiprocketOrder(SO);
}
}
}
}
/// <summary>
/// Handles the event
/// </summary>
/// <param name="eventMessage">The event message</param>
public async Task HandleEventAsync(OrderPaidEvent eventMessage)
{
//ensure the plugin is installed and active
if (!await IsPluginEnabledAsync())
{
return;
}
var order = eventMessage.Order;
//settings per store
var store = await _storeService.GetStoreByIdAsync(order.StoreId) ?? await _storeContext.GetCurrentStoreAsync();
var googleAnalyticsSettings = await _settingService.LoadSettingAsync <GoogleAnalyticsSettings>(store.Id);
//ecommerce is disabled
if (!googleAnalyticsSettings.EnableEcommerce)
{
return;
}
//we use HTTP requests to notify GA about new orders (only when they are paid)
var sendRequest = !googleAnalyticsSettings.UseJsToSendEcommerceInfo;
if (sendRequest)
{
await ProcessOrderEventAsync(order, true);
}
}
public async Task ProcessOrderPaidEvent(OrderPaidEvent eventDto)
{
eventDto.EventTarget = nameof(ProcessOrderPaidEvent);
var hasProcessed = await _tracker.HasProcessedAsync(eventDto);
if (!hasProcessed)
{
await Task.CompletedTask;
}
}
public async Task <bool> Handle(ChangeStatusOrderAlterationCommend request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new NullReferenceException("CangeOrderStatusCommand is null!");
}
var orderAlter = await _orderAlterationRepository.SingleOrDefaultAsync(x => x.Id == request.Id);
if (orderAlter == null)
{
return(false);
}
orderAlter.SetOrderStatus(request.OrderStatus);
try
{
_orderAlterationRepository.UpdateUoW(orderAlter);
////Save Local Integration Event with pending status (InsertOrderPaidEvent Or InsertAlterationFinishedEvent)
//var orderPaidEvent = await InsertOrderPaidEvent(orderAlter);
//var alterationFinishedEvent = await InsertAlterationFinishedEvent(orderAlter);
await _orderAlterationRepository.SaveChangesAsync();
try
{
// publish Integration event
if (orderAlter.OrderStatusId == Status.Paid.Id)
{
var orderPaidEvent = new OrderPaidEvent(orderAlter.Id);
await _endpoint.Publish(orderPaidEvent);
}
else if (orderAlter.OrderStatusId == Status.Done.Id)
{
var alterationFinishedEvent = new AlterationFinishedEvent(orderAlter.Id);
await _endpoint.Publish(alterationFinishedEvent);
}
}
catch (Exception ex)
{
//update Local Integration Event to ready status
//await _localIntegrationEventRepository.UpdateLocalIntegrationEvent(orderPaidEvent.Id);
}
}
catch (Exception ex)
{
throw;
}
return(true);
}
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Success</returns>
/// <exception cref="ApiException">A server side error occurred.</exception>
public async System.Threading.Tasks.Task WhenAsync(OrderPaidEvent @event, System.Threading.CancellationToken cancellationToken)
{
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/v1/Projections/order-paid");
var client_ = _httpClient;
try
{
using (var request_ = new System.Net.Http.HttpRequestMessage())
{
var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(@event, _settings.Value));
content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
request_.Content = content_;
request_.Method = new System.Net.Http.HttpMethod("PUT");
PrepareRequest(client_, request_, urlBuilder_);
var url_ = urlBuilder_.ToString();
request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
PrepareRequest(client_, request_, url_);
var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
try
{
var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
if (response_.Content != null && response_.Content.Headers != null)
{
foreach (var item_ in response_.Content.Headers)
{
headers_[item_.Key] = item_.Value;
}
}
ProcessResponse(client_, response_);
var status_ = ((int)response_.StatusCode).ToString();
if (status_ == "200")
{
return;
}
else
if (status_ != "200" && status_ != "204")
{
var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new ApiException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
}
}
finally
{
if (response_ != null)
{
response_.Dispose();
}
}
}
}
finally
{
}
}
/// <returns>Success</returns>
/// <exception cref="ApiException">A server side error occurred.</exception>
public System.Threading.Tasks.Task WhenAsync(OrderPaidEvent @event)
{
return(WhenAsync(@event, System.Threading.CancellationToken.None));
}
private void When(OrderPaidEvent @event) =>
With(this, state =>
{
state.OrderStatus = OrderStatus.Paid;
});
/// <summary>
/// Handles the event
/// </summary>
/// <param name="eventMessage">The event message</param>
public void HandleEvent(OrderPaidEvent eventMessage)
{
ProcessOrderEvent(eventMessage.Order, true);
}
public Task HandleEventAsync(OrderPaidEvent msg)
{
return(Task.FromResult(0));
}
public void HandleEvent(OrderPaidEvent eventMessage)
{
if (!_smsSettings.Enabled)
{
return;
}
if (!_smsSettings.EnableOrderPayed)
{
return;
}
if (_smsSettings.IgnnoreUserIDs.Split(',').Contains(eventMessage.Order.CustomerId.ToString()))
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "SMS alert not send. user:"******" in Ignore Lit",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
return;
}
string template = "";
if (eventMessage.Order.CustomerLanguageId == _smsSettings.SecondLanguageID)
{
// second language
template = _smsSettings.TemplateOrderPayed2;
}
else
{
if (eventMessage.Order.CustomerLanguageId == _smsSettings.ThirdLanguageID)
{
// Third language
template = _smsSettings.TemplateOrderPayed3;
}
else
{
// default
template = _smsSettings.TemplateOrderPayed;
}
}
if (string.IsNullOrEmpty(template))
{
template = _smsSettings.TemplateOrderPayed;
}
try
{
template = string.Format(template, eventMessage.Order.Id, eventMessage.Order.OrderTotal);
}
catch { }
var pluginDescriptor = _pluginFinder.GetPluginDescriptorBySystemName("SMS.Notifications");
if (pluginDescriptor == null)
{
return;
}
if (!_pluginFinder.AuthenticateStore(pluginDescriptor, _storeContext.CurrentStore.Id))
{
return;
}
var plugin = pluginDescriptor.Instance() as SMSNotificationsProvider;
if (plugin == null)
{
return;
}
string phonenum = string.IsNullOrEmpty(eventMessage.Order.Customer.BillingAddress.PhoneNumber) ?
eventMessage.Order.Customer.ShippingAddress.PhoneNumber :
eventMessage.Order.Customer.BillingAddress.PhoneNumber;
phonenum = ParcePhoneNumbe(phonenum);
string resText = "";
if (plugin.SendSms(phonenum, template, out resText))
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "\"Order payed\" SMS alert has been sent to phone:" + phonenum,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
}
else
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "\"Order payed\" SMS alert can't send to phone:" + phonenum + ". Error " + resText,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
}
}
public async Task When([FromBody] OrderPaidEvent @event) =>
ReadModelForOrderContext.locker.Lock(() =>
{
var existingOrder = ReadModelForOrderContext.Orders.SingleOrDefault(o => o.Id == @event.OrderId);
existingOrder.OrderStatus = "Paid";
});
/// <summary>
/// Handle the order paid event
/// </summary>
/// <param name="eventMessage">The event message.</param>
public void HandleEvent(OrderPaidEvent eventMessage)
{
//handle event
_sendinBlueMarketingAutomationManager.HandleOrderCompletedEvent(eventMessage.Order);
_sendinBlueEmailManager.UpdateContactAfterCompletingOrder(eventMessage.Order);
}
public async Task ProcessOrderPaidEvent(OrderPaidEvent eto)
{
_logger.LogInformation("start.....");
_logger.LogInformation("end.....");
await Task.CompletedTask;
}
