686 lines
24 KiB
C#
686 lines
24 KiB
C#
// (c) Copyright Ascensio System SIA 2010-2022
|
|
//
|
|
// This program is a free software product.
|
|
// You can redistribute it and/or modify it under the terms
|
|
// of the GNU Affero General Public License (AGPL) version 3 as published by the Free Software
|
|
// Foundation. In accordance with Section 7(a) of the GNU AGPL its Section 15 shall be amended
|
|
// to the effect that Ascensio System SIA expressly excludes the warranty of non-infringement of
|
|
// any third-party rights.
|
|
//
|
|
// This program is distributed WITHOUT ANY WARRANTY, without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For details, see
|
|
// the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
//
|
|
// You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia, EU, LV-1021.
|
|
//
|
|
// The interactive user interfaces in modified source and object code versions of the Program must
|
|
// display Appropriate Legal Notices, as required under Section 5 of the GNU AGPL version 3.
|
|
//
|
|
// Pursuant to Section 7(b) of the License you must retain the original Product logo when
|
|
// distributing the program. Pursuant to Section 7(e) we decline to grant you any rights under
|
|
// trademark law for use of our trademarks.
|
|
//
|
|
// All the Product's GUI elements, including illustrations and icon sets, as well as technical writing
|
|
// content are licensed under the terms of the Creative Commons Attribution-ShareAlike 4.0
|
|
// International. See the License terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
|
|
namespace ASC.Notify.Engine;
|
|
|
|
public interface INotifyEngineAction
|
|
{
|
|
void BeforeTransferRequest(NotifyRequest request);
|
|
void AfterTransferRequest(NotifyRequest request);
|
|
}
|
|
|
|
[Singletone]
|
|
public class NotifyEngine : INotifyEngine, IDisposable
|
|
{
|
|
private readonly ILog _logger;
|
|
private readonly Context _context;
|
|
private readonly List<SendMethodWrapper> _sendMethods = new List<SendMethodWrapper>();
|
|
private readonly Queue<NotifyRequest> _requests = new Queue<NotifyRequest>(1000);
|
|
private readonly Thread _notifyScheduler;
|
|
private readonly Thread _notifySender;
|
|
private readonly AutoResetEvent _requestsEvent = new AutoResetEvent(false);
|
|
private readonly AutoResetEvent _methodsEvent = new AutoResetEvent(false);
|
|
private readonly Dictionary<string, IPatternStyler> _stylers = new Dictionary<string, IPatternStyler>();
|
|
private readonly IPatternFormatter _sysTagFormatter = new ReplacePatternFormatter(@"_#(?<tagName>[A-Z0-9_\-.]+)#_", true);
|
|
private readonly TimeSpan _defaultSleep = TimeSpan.FromSeconds(10);
|
|
private readonly IServiceScopeFactory _serviceScopeFactory;
|
|
internal readonly ICollection<Type> Actions;
|
|
|
|
|
|
public NotifyEngine(Context context, IOptionsMonitor<ILog> options, IServiceScopeFactory serviceScopeFactory)
|
|
{
|
|
Actions = new List<Type>();
|
|
_context = context ?? throw new ArgumentNullException(nameof(context));
|
|
_logger = options.Get("ASC.Notify");
|
|
_serviceScopeFactory = serviceScopeFactory;
|
|
_notifyScheduler = new Thread(NotifyScheduler) { IsBackground = true, Name = "NotifyScheduler" };
|
|
_notifySender = new Thread(NotifySender) { IsBackground = true, Name = "NotifySender" };
|
|
}
|
|
|
|
public void AddAction<T>() where T : INotifyEngineAction
|
|
{
|
|
Actions.Add(typeof(T));
|
|
}
|
|
|
|
public void QueueRequest(NotifyRequest request)
|
|
{
|
|
lock (_requests)
|
|
{
|
|
if (!_notifySender.IsAlive)
|
|
{
|
|
_notifySender.Start();
|
|
}
|
|
|
|
_requests.Enqueue(request);
|
|
}
|
|
|
|
_requestsEvent.Set();
|
|
}
|
|
|
|
|
|
internal void RegisterSendMethod(Action<DateTime> method, string cron)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(method);
|
|
ArgumentNullOrEmptyException.ThrowIfNullOrEmpty(cron);
|
|
|
|
var w = new SendMethodWrapper(method, cron, _logger);
|
|
lock (_sendMethods)
|
|
{
|
|
if (!_notifyScheduler.IsAlive)
|
|
{
|
|
_notifyScheduler.Start();
|
|
}
|
|
|
|
_sendMethods.Remove(w);
|
|
_sendMethods.Add(w);
|
|
}
|
|
_methodsEvent.Set();
|
|
}
|
|
|
|
internal void UnregisterSendMethod(Action<DateTime> method)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(method);
|
|
|
|
lock (_sendMethods)
|
|
{
|
|
_sendMethods.Remove(new SendMethodWrapper(method, null, _logger));
|
|
}
|
|
}
|
|
|
|
private void NotifyScheduler(object state)
|
|
{
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
var min = DateTime.MaxValue;
|
|
var now = DateTime.UtcNow;
|
|
List<SendMethodWrapper> copy;
|
|
lock (_sendMethods)
|
|
{
|
|
copy = _sendMethods.ToList();
|
|
}
|
|
|
|
foreach (var w in copy)
|
|
{
|
|
if (!w.ScheduleDate.HasValue)
|
|
{
|
|
lock (_sendMethods)
|
|
{
|
|
_sendMethods.Remove(w);
|
|
}
|
|
}
|
|
|
|
if (w.ScheduleDate.Value <= now)
|
|
{
|
|
try
|
|
{
|
|
w.InvokeSendMethod(now);
|
|
}
|
|
catch (Exception error)
|
|
{
|
|
_logger.Error(error);
|
|
}
|
|
w.UpdateScheduleDate(now);
|
|
}
|
|
|
|
if (w.ScheduleDate.Value > now && w.ScheduleDate.Value < min)
|
|
{
|
|
min = w.ScheduleDate.Value;
|
|
}
|
|
}
|
|
|
|
var wait = min != DateTime.MaxValue ? min - DateTime.UtcNow : _defaultSleep;
|
|
|
|
if (wait < _defaultSleep)
|
|
{
|
|
wait = _defaultSleep;
|
|
}
|
|
else if (wait.Ticks > int.MaxValue)
|
|
{
|
|
wait = TimeSpan.FromTicks(int.MaxValue);
|
|
}
|
|
_methodsEvent.WaitOne(wait, false);
|
|
}
|
|
}
|
|
catch (ThreadAbortException)
|
|
{
|
|
return;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_logger.Error(e);
|
|
}
|
|
}
|
|
|
|
|
|
private void NotifySender(object state)
|
|
{
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
NotifyRequest request = null;
|
|
lock (_requests)
|
|
{
|
|
if (_requests.Count > 0)
|
|
{
|
|
request = _requests.Dequeue();
|
|
}
|
|
}
|
|
if (request != null)
|
|
{
|
|
using var scope = _serviceScopeFactory.CreateScope();
|
|
foreach (var action in Actions)
|
|
{
|
|
((INotifyEngineAction)scope.ServiceProvider.GetRequiredService(action)).AfterTransferRequest(request);
|
|
}
|
|
|
|
try
|
|
{
|
|
SendNotify(request, scope);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_logger.Error(e);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_requestsEvent.WaitOne();
|
|
}
|
|
}
|
|
}
|
|
catch (ThreadAbortException)
|
|
{
|
|
return;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_logger.Error(e);
|
|
}
|
|
}
|
|
|
|
|
|
private NotifyResult SendNotify(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
var sendResponces = new List<SendResponse>();
|
|
|
|
var response = CheckPreventInterceptors(request, InterceptorPlace.Prepare, serviceScope, null);
|
|
if (response != null)
|
|
{
|
|
sendResponces.Add(response);
|
|
}
|
|
else
|
|
{
|
|
sendResponces.AddRange(SendGroupNotify(request, serviceScope));
|
|
}
|
|
|
|
NotifyResult result;
|
|
if (sendResponces.Count == 0)
|
|
{
|
|
result = new NotifyResult(SendResult.OK, sendResponces);
|
|
}
|
|
else
|
|
{
|
|
result = new NotifyResult(sendResponces.Aggregate((SendResult)0, (s, r) => r.Result), sendResponces);
|
|
}
|
|
_logger.Debug(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
private SendResponse CheckPreventInterceptors(NotifyRequest request, InterceptorPlace place, IServiceScope serviceScope, string sender)
|
|
{
|
|
return request.Intercept(place, serviceScope) ? new SendResponse(request.NotifyAction, sender, request.Recipient, SendResult.Prevented) : null;
|
|
}
|
|
|
|
private List<SendResponse> SendGroupNotify(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
var responces = new List<SendResponse>();
|
|
SendGroupNotify(request, responces, serviceScope);
|
|
|
|
return responces;
|
|
}
|
|
|
|
private void SendGroupNotify(NotifyRequest request, List<SendResponse> responces, IServiceScope serviceScope)
|
|
{
|
|
if (request.Recipient is IDirectRecipient)
|
|
{
|
|
var subscriptionSource = request.GetSubscriptionProvider(serviceScope);
|
|
if (!request._isNeedCheckSubscriptions || !subscriptionSource.IsUnsubscribe(request.Recipient as IDirectRecipient, request.NotifyAction, request.ObjectID))
|
|
{
|
|
var directresponses = new List<SendResponse>(1);
|
|
try
|
|
{
|
|
directresponses = SendDirectNotify(request, serviceScope);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
directresponses.Add(new SendResponse(request.NotifyAction, request.Recipient, exc));
|
|
}
|
|
|
|
responces.AddRange(directresponses);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (request.Recipient is IRecipientsGroup)
|
|
{
|
|
var checkresp = CheckPreventInterceptors(request, InterceptorPlace.GroupSend, serviceScope, null);
|
|
if (checkresp != null)
|
|
{
|
|
responces.Add(checkresp);
|
|
}
|
|
else
|
|
{
|
|
var recipientProvider = request.GetRecipientsProvider(serviceScope);
|
|
|
|
try
|
|
{
|
|
var recipients = recipientProvider.GetGroupEntries(request.Recipient as IRecipientsGroup) ?? new IRecipient[0];
|
|
foreach (var recipient in recipients)
|
|
{
|
|
try
|
|
{
|
|
var newRequest = request.Split(recipient);
|
|
SendGroupNotify(newRequest, responces, serviceScope);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
responces.Add(new SendResponse(request.NotifyAction, request.Recipient, exc));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
responces.Add(new SendResponse(request.NotifyAction, request.Recipient, exc) { Result = SendResult.IncorrectRecipient });
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
responces.Add(new SendResponse(request.NotifyAction, request.Recipient, null)
|
|
{
|
|
Result = SendResult.IncorrectRecipient,
|
|
Exception = new NotifyException("recipient may be IRecipientsGroup or IDirectRecipient")
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<SendResponse> SendDirectNotify(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
if (request.Recipient is not IDirectRecipient)
|
|
{
|
|
throw new ArgumentException("request.Recipient not IDirectRecipient", nameof(request));
|
|
}
|
|
|
|
var responses = new List<SendResponse>();
|
|
var response = CheckPreventInterceptors(request, InterceptorPlace.DirectSend, serviceScope, null);
|
|
if (response != null)
|
|
{
|
|
responses.Add(response);
|
|
|
|
return responses;
|
|
}
|
|
|
|
try
|
|
{
|
|
PrepareRequestFillSenders(request, serviceScope);
|
|
PrepareRequestFillPatterns(request, serviceScope);
|
|
PrepareRequestFillTags(request, serviceScope);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
responses.Add(new SendResponse(request.NotifyAction, null, request.Recipient, SendResult.Impossible));
|
|
_logger.Error("Prepare", ex);
|
|
}
|
|
|
|
if (request._senderNames != null && request._senderNames.Length > 0)
|
|
{
|
|
foreach (var sendertag in request._senderNames)
|
|
{
|
|
var channel = _context.GetSender(sendertag);
|
|
if (channel != null)
|
|
{
|
|
try
|
|
{
|
|
response = SendDirectNotify(request, channel, serviceScope);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
response = new SendResponse(request.NotifyAction, channel.SenderName, request.Recipient, exc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response = new SendResponse(request.NotifyAction, sendertag, request.Recipient, new NotifyException($"Not registered sender \"{sendertag}\"."));
|
|
}
|
|
|
|
responses.Add(response);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response = new SendResponse(request.NotifyAction, request.Recipient, new NotifyException("Notice hasn't any senders."));
|
|
responses.Add(response);
|
|
}
|
|
|
|
return responses;
|
|
}
|
|
|
|
private SendResponse SendDirectNotify(NotifyRequest request, ISenderChannel channel, IServiceScope serviceScope)
|
|
{
|
|
if (request.Recipient is not IDirectRecipient)
|
|
{
|
|
throw new ArgumentException("request.Recipient not IDirectRecipient", nameof(request));
|
|
}
|
|
|
|
request.CurrentSender = channel.SenderName;
|
|
|
|
var oops = CreateNoticeMessageFromNotifyRequest(request, channel.SenderName, serviceScope, out var noticeMessage);
|
|
if (oops != null)
|
|
{
|
|
return oops;
|
|
}
|
|
|
|
request.CurrentMessage = noticeMessage;
|
|
var preventresponse = CheckPreventInterceptors(request, InterceptorPlace.MessageSend, serviceScope, channel.SenderName);
|
|
if (preventresponse != null)
|
|
{
|
|
return preventresponse;
|
|
}
|
|
|
|
channel.SendAsync(noticeMessage);
|
|
|
|
return new SendResponse(noticeMessage, channel.SenderName, SendResult.Inprogress);
|
|
}
|
|
|
|
private SendResponse CreateNoticeMessageFromNotifyRequest(NotifyRequest request, string sender, IServiceScope serviceScope, out NoticeMessage noticeMessage)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(request);
|
|
|
|
var recipientProvider = request.GetRecipientsProvider(serviceScope);
|
|
var recipient = request.Recipient as IDirectRecipient;
|
|
|
|
var addresses = recipient.Addresses;
|
|
if (addresses == null || addresses.Length == 0)
|
|
{
|
|
addresses = recipientProvider.GetRecipientAddresses(request.Recipient as IDirectRecipient, sender);
|
|
recipient = new DirectRecipient(request.Recipient.ID, request.Recipient.Name, addresses);
|
|
}
|
|
|
|
recipient = recipientProvider.FilterRecipientAddresses(recipient);
|
|
noticeMessage = request.CreateMessage(recipient);
|
|
|
|
addresses = recipient.Addresses;
|
|
if (addresses == null || !addresses.Any(a => !string.IsNullOrEmpty(a)))
|
|
{
|
|
//checking addresses
|
|
return new SendResponse(request.NotifyAction, sender, recipient, new NotifyException(string.Format("For recipient {0} by sender {1} no one addresses getted.", recipient, sender)));
|
|
}
|
|
|
|
var pattern = request.GetSenderPattern(sender);
|
|
if (pattern == null)
|
|
{
|
|
return new SendResponse(request.NotifyAction, sender, recipient, new NotifyException(string.Format("For action \"{0}\" by sender \"{1}\" no one patterns getted.", request.NotifyAction, sender)));
|
|
}
|
|
|
|
noticeMessage.Pattern = pattern;
|
|
noticeMessage.ContentType = pattern.ContentType;
|
|
noticeMessage.AddArgument(request.Arguments.ToArray());
|
|
var patternProvider = request.GetPatternProvider(serviceScope);
|
|
|
|
var formatter = patternProvider.GetFormatter(pattern);
|
|
try
|
|
{
|
|
if (formatter != null)
|
|
{
|
|
formatter.FormatMessage(noticeMessage, noticeMessage.Arguments);
|
|
}
|
|
_sysTagFormatter.FormatMessage(
|
|
noticeMessage, new[]
|
|
{
|
|
new TagValue(Context.SysRecipientId, request.Recipient.ID),
|
|
new TagValue(Context.SysRecipientName, request.Recipient.Name),
|
|
new TagValue(Context.SysRecipientAddress, addresses != null && addresses.Length > 0 ? addresses[0] : null)
|
|
}
|
|
);
|
|
//Do styling here
|
|
if (!string.IsNullOrEmpty(pattern.Styler))
|
|
{
|
|
//We need to run through styler before templating
|
|
StyleMessage(serviceScope, noticeMessage);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
return new SendResponse(request.NotifyAction, sender, recipient, exc);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void StyleMessage(IServiceScope scope, NoticeMessage message)
|
|
{
|
|
try
|
|
{
|
|
if (!_stylers.ContainsKey(message.Pattern.Styler))
|
|
{
|
|
if (scope.ServiceProvider.GetService(Type.GetType(message.Pattern.Styler, true)) is IPatternStyler styler)
|
|
{
|
|
_stylers.Add(message.Pattern.Styler, styler);
|
|
}
|
|
}
|
|
_stylers[message.Pattern.Styler].ApplyFormating(message);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
_logger.Warn("error styling message", exc);
|
|
}
|
|
}
|
|
|
|
private void PrepareRequestFillSenders(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
if (request._senderNames == null)
|
|
{
|
|
var subscriptionProvider = request.GetSubscriptionProvider(serviceScope);
|
|
|
|
var senderNames = new List<string>();
|
|
senderNames.AddRange(subscriptionProvider.GetSubscriptionMethod(request.NotifyAction, request.Recipient) ?? Array.Empty<string>());
|
|
senderNames.AddRange(request.Arguments.OfType<AdditionalSenderTag>().Select(tag => (string)tag.Value));
|
|
|
|
request._senderNames = senderNames.ToArray();
|
|
}
|
|
}
|
|
|
|
private void PrepareRequestFillPatterns(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
if (request._patterns == null)
|
|
{
|
|
request._patterns = new IPattern[request._senderNames.Length];
|
|
if (request._patterns.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var apProvider = request.GetPatternProvider(serviceScope);
|
|
for (var i = 0; i < request._senderNames.Length; i++)
|
|
{
|
|
var senderName = request._senderNames[i];
|
|
IPattern pattern = null;
|
|
if (apProvider.GetPatternMethod != null)
|
|
{
|
|
pattern = apProvider.GetPatternMethod(request.NotifyAction, senderName, request);
|
|
}
|
|
if (pattern == null)
|
|
{
|
|
pattern = apProvider.GetPattern(request.NotifyAction, senderName);
|
|
}
|
|
|
|
request._patterns[i] = pattern ?? throw new NotifyException($"For action \"{request.NotifyAction.ID}\" by sender \"{senderName}\" no one patterns getted.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PrepareRequestFillTags(NotifyRequest request, IServiceScope serviceScope)
|
|
{
|
|
var patternProvider = request.GetPatternProvider(serviceScope);
|
|
foreach (var pattern in request._patterns)
|
|
{
|
|
IPatternFormatter formatter;
|
|
try
|
|
{
|
|
formatter = patternProvider.GetFormatter(pattern);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
throw new NotifyException(string.Format("For pattern \"{0}\" formatter not instanced.", pattern), exc);
|
|
}
|
|
var tags = Array.Empty<string>();
|
|
try
|
|
{
|
|
if (formatter != null)
|
|
{
|
|
tags = formatter.GetTags(pattern) ?? Array.Empty<string>();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
throw new NotifyException(string.Format("Get tags from formatter of pattern \"{0}\" failed.", pattern), exc);
|
|
}
|
|
|
|
foreach (var tag in tags.Where(tag => !request.Arguments.Exists(tagValue => Equals(tagValue.Tag, tag)) && !request._requaredTags.Exists(rtag => Equals(rtag, tag))))
|
|
{
|
|
request._requaredTags.Add(tag);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private sealed class SendMethodWrapper
|
|
{
|
|
private readonly object _locker = new object();
|
|
private readonly CronExpression _cronExpression;
|
|
private readonly Action<DateTime> _method;
|
|
|
|
public DateTime? ScheduleDate { get; private set; }
|
|
public ILog Logger { get; }
|
|
|
|
public SendMethodWrapper(Action<DateTime> method, string cron, ILog log)
|
|
{
|
|
_method = method;
|
|
Logger = log;
|
|
if (!string.IsNullOrEmpty(cron))
|
|
{
|
|
_cronExpression = new CronExpression(cron);
|
|
}
|
|
|
|
UpdateScheduleDate(DateTime.UtcNow);
|
|
}
|
|
|
|
public void UpdateScheduleDate(DateTime d)
|
|
{
|
|
try
|
|
{
|
|
if (_cronExpression != null)
|
|
{
|
|
ScheduleDate = _cronExpression.GetTimeAfter(d);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error(e);
|
|
}
|
|
}
|
|
|
|
public void InvokeSendMethod(DateTime d)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
Task.Run(() =>
|
|
{
|
|
try
|
|
{
|
|
_method(d);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error(e);
|
|
}
|
|
}).Wait();
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
return obj is SendMethodWrapper w && _method.Equals(w._method);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return _method.GetHashCode();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_methodsEvent != null)
|
|
{
|
|
_methodsEvent.Dispose();
|
|
}
|
|
|
|
if (_requestsEvent != null)
|
|
{
|
|
_requestsEvent.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Scope]
|
|
public class NotifyEngineQueue
|
|
{
|
|
private readonly NotifyEngine _notifyEngine;
|
|
private readonly IServiceProvider _serviceProvider;
|
|
|
|
public NotifyEngineQueue(NotifyEngine notifyEngine, IServiceProvider serviceProvider)
|
|
{
|
|
_notifyEngine = notifyEngine;
|
|
_serviceProvider = serviceProvider;
|
|
}
|
|
|
|
public void QueueRequest(NotifyRequest request)
|
|
{
|
|
foreach (var action in _notifyEngine.Actions)
|
|
{
|
|
((INotifyEngineAction)_serviceProvider.GetRequiredService(action)).BeforeTransferRequest(request);
|
|
}
|
|
|
|
_notifyEngine.QueueRequest(request);
|
|
}
|
|
}
|