ГИС ЖКХ: асинхронная модель взаимодействия

/// <summary>
/// Базовый сервис для первого этапа взаимодействия - создания сообщений
/// </summary>
/// <typeparam name="TMessageDomain">Тип доменного сообщения</typeparam>
/// <typeparam name="TSourceDomain">Тип объекта, который возвращается из информационной системы</typeparam>
public class CreateMessageCoreService<TMessageDomain, TSourceDomain>
	where TMessageDomain : MessageDomain
{
	private readonly ISourceService<TSourceDomain> _sourceService;
	private readonly IMessageDomainConverter<TMessageDomain, TSourceDomain> _messageDomainConverter;
	private readonly IMessageDomainService<TMessageDomain> _messageDomainService;
	private readonly IOrgPPAGUIDService _orgPPAGUIDService;
	private readonly IGisLogger _logger;
	
	public CreateMessageCoreService(ISourceService<TSourceDomain> sourceService,
		IMessageDomainConverter<TMessageDomain, TSourceDomain> messageDomainConverter,
		IMessageDomainService<TMessageDomain> messageDomainService,
		IOrgPPAGUIDService orgPPAGUIDService, IGisLogger logger)
	{
		_sourceService = sourceService;
		_messageDomainConverter = messageDomainConverter;
		_messageDomainService = messageDomainService;
		_orgPPAGUIDService = orgPPAGUIDService;
		_logger = logger;
	}

	public void CreateMessages(CoreInitData coreInitData)
	{
		var stopWatch = new Stopwatch();
		stopWatch.Start();
		try
		{
			//получаем данные из информационной системы, по которым нужно осуществить взаимодействие
			var sourceDomains = _sourceService.GetSourceDomains(coreInitData);
			//получаем senderId по УК
			var orgPPAGUID = _orgPPAGUIDService.GetOrgPPAGUID(coreInitData.UkId);
			//по исходным данным создаем доменные сообщения 
			var messages = _messageDomainConverter.ToMessageDomain(sourceDomains, coreInitData, orgPPAGUID);
			//сохраняем сообщения в базу данных
			_messageDomainService.InsertMessageDomains(messages);

			stopWatch.Stop();
			_logger.Info(this.GetType(), $"Создано {messages.Count} доменных сообщений по УК {coreInitData.UkId} за {stopWatch.Elapsed}");
		}
		catch (Exception ex)
		{
			_logger.Error(this.GetType(), $"Произошло исключение при обработке {coreInitData}", ex);
		}
	}
}

/// <summary>
/// Базовый сервис для второго этапа взаимодействия - отправки сообщений
/// </summary>
/// <typeparam name="TMessageDomain">Тип доменного сообщения</typeparam>
/// <typeparam name="TMessageProxy">Тип прокси объекта сообщения</typeparam>
/// <typeparam name="TAckProxy">Тип прокси объекта ответа</typeparam>
public class SendMessageCoreService<TMessageDomain, TMessageProxy, TAckProxy>
	where TMessageDomain : MessageDomain
	where TAckProxy : IAckRequestAck
{
	private readonly IMessageDomainService<TMessageDomain> _messageDomainService;
	private readonly IMessageProxyConverter<TMessageDomain, TMessageProxy> _messageProxyConverter;
	private readonly ISendMessageProxyProvider<TMessageProxy, TAckProxy> _sendMessageProxyProvider;
	private readonly ISendMessageHandler<TMessageDomain, TAckProxy> _sendMessageHandler;
	private readonly IGisLogger _logger;
	
	public SendMessageCoreService(IMessageDomainService<TMessageDomain> messageDomainService,
		IMessageProxyConverter<TMessageDomain, TMessageProxy> messageProxyConverter,
		ISendMessageProxyProvider<TMessageProxy, TAckProxy> sendMessageProxyProvider,
		ISendMessageHandler<TMessageDomain, TAckProxy> sendMessageHandler, IGisLogger logger)
	{
		_messageDomainService = messageDomainService;
		_messageProxyConverter = messageProxyConverter;
		_sendMessageProxyProvider = sendMessageProxyProvider;
		_sendMessageHandler = sendMessageHandler;
		_logger = logger;
	}

	public void SendMessages(CoreInitData coreInitData)
	{
		var stopWatch = new Stopwatch();
		stopWatch.Start();
		try
		{
			//получаем доменные сообщения для отправки
			//не обязательно могут быть только новые
			//также поднимаются не отправленные с первого раза
			var messages = _messageDomainService.GetMessageDomainsForSend(coreInitData);
			foreach (var messageDomain in messages)
			{
				try
				{
					//по каждому из доменных сообщений создаем прокси сообщение
					var proxyMessageRequests = _messageProxyConverter.ToMessageProxy(messageDomain);
					//отправляем прокси сообщение
					var proxyAck = _sendMessageProxyProvider.SendMessage(proxyMessageRequests);
					//обрабатываем успешный результат
					_sendMessageHandler.SendSuccess(messageDomain, proxyAck);
				}
				catch (Exception exception)
				{
					//обрабатываем исключения
					_sendMessageHandler.SendFail(messageDomain, exception);
				}
			}

			stopWatch.Stop();
			_logger.Info(this.GetType(), $"По {messages.Count} доменным сообщениям УК {coreInitData.UkId} отправлено " +
						  $"{messages.Count(x => x.Status == MessageStatus.Sent)} сообщений, " +
						  $"{messages.Count(x => x.Status == MessageStatus.SendError)} упали с ошибкой, " +
						  $"{messages.Count(x => x.Status == MessageStatus.SendErrorTryAgain)} будут отправлены повторно, за {stopWatch.Elapsed}");
		}
		catch (Exception ex)
		{
			_logger.Error(this.GetType(), $"Произошло исключение при обработке {coreInitData}", ex);
		}
	}
}

	/// <summary>
	/// Базовый сервис для третьего этапа взаимодействия - получения результата обработки
	/// </summary>
	/// <typeparam name="TMessageDomain">Тип доменного сообщения</typeparam>
	/// <typeparam name="TGetStateResultProxy">Тип прокси объекта запроса результата обработки</typeparam>
	/// <typeparam name="TResultProxy">Тип прокси объекта результата обработки сообщения</typeparam>
	/// <typeparam name="TResult">Тип объекта результата обработки сообщения</typeparam>
	public class GetResultsCoreService<TMessageDomain, TGetStateResultProxy, TResultProxy, TResult>
		where TMessageDomain : MessageDomain
		where TResultProxy : IGetStateResult
	{
		private readonly IMessageDomainService<TMessageDomain> _messageDomainService;
		private readonly IGetResultProxyProvider<TGetStateResultProxy, TResultProxy> _getResultProxyProvider;
		private readonly IGetStateProxyConverter<TGetStateResultProxy, TMessageDomain> _getStateProxyConverter;
		private readonly IResultConverter<TResultProxy, TResult> _resultConverter;
		private readonly ISaveResultService<TResult, TMessageDomain> _saveResultService;
		private readonly IGetResultMessageHandler<TMessageDomain, TResult> _getResultMessageHandler;
		private readonly IGisLogger _logger;
		
		/// <summary>
		/// Количество дней, через которые считается, что запрос не выполнится никогда
		/// </summary>
		private const int GET_RESULT_TIMEOUT_IN_DAYS = 3;

		public GetResultsCoreService(IMessageDomainService<TMessageDomain> messageDomainService,
			IGetResultProxyProvider<TGetStateResultProxy, TResultProxy> getResultProxyProvider,
			IGetStateProxyConverter<TGetStateResultProxy, TMessageDomain> getStateProxyConverter,
			IResultConverter<TResultProxy, TResult> resultConverter,
			ISaveResultService<TResult, TMessageDomain> saveResultService,
			IGetResultMessageHandler<TMessageDomain, TResult> getResultMessageHandler, IGisLogger logger)
		{
			_messageDomainService = messageDomainService;
			_getResultProxyProvider = getResultProxyProvider;
			_getStateProxyConverter = getStateProxyConverter;
			_resultConverter = resultConverter;
			_saveResultService = saveResultService;
			_getResultMessageHandler = getResultMessageHandler;
			_logger = logger;
		}

		public void GetResults(CoreInitData coreInitData)
		{
			var stopWatch = new Stopwatch();
			stopWatch.Start();
			try
			{
				//получаем доменнные сообщения для проверки результата обработки
				var messages = _messageDomainService.GetMessageDomainsForGetResults(coreInitData);
				foreach (var messageDomain in messages)
				{
					try
					{
						//по доменному сообщению получаем getState для проверки результатов обработки сообщения
						var getStateProxy = _getStateProxyConverter.ToGetStateResultProxy(messageDomain);
						TResultProxy resultProxy;
						//проверяем результат обработки. 
						//если возвращается false, значит сообщение ещё не обработано
						//если true, значит можно получать результат обработки
						if (_getResultProxyProvider.TryGetResult(getStateProxy, out resultProxy))
						{
							//полученный ответ преобразовываем из прокси сущности в нашу бизнес-сущность результата обработки
							var result = _resultConverter.ToResult(resultProxy);
							//сохраняем результат обработки сообщения
							_saveResultService.SaveResult(result, messageDomain);
							//проставляем статусы обработки сообщения в доменном сообщении
							_getResultMessageHandler.Success(messageDomain, result);
						}
						else
						{
							if (messageDomain.SendedDate.HasValue 
								&& DateTime.Now.Subtract(messageDomain.SendedDate.Value).Days > GET_RESULT_TIMEOUT_IN_DAYS)
							{
								//в течение таймаута не можем получить результат обработки сообщения, помечаем
								_getResultMessageHandler.NoResultByTimeout(messageDomain);
							}
							else
							{
								//помечаем, что сообщение ещё не обработалось
								_getResultMessageHandler.NotReady(messageDomain);
							}
						}
					}
					catch (Exception exception)
					{
						//обрабатываем исключения во время работы
						_getResultMessageHandler.Fail(messageDomain, exception);
					}
				}
				stopWatch.Stop();
				_logger.Info(this.GetType(), $"По {messages.Count} доменным сообщениям УК {coreInitData.UkId} получено " +
							  $"{messages.Count(x => x.Status == MessageStatus.Done)} успешных ответов, " +
							  $"{messages.Count(x => x.Status == MessageStatus.InProcess)} в обработке, " +
							  $"{messages.Count(x => x.Status == MessageStatus.ResponseTakingError)} упали с ошибкой, " +
							  $"{messages.Count(x => x.Status == MessageStatus.ResponseTakingErrorTryAgain)} будут отправлены повторно, за {stopWatch.Elapsed}");
			}
			catch (Exception ex)
			{
				_logger.Error(this.GetType(),$"Произошло исключение при обработке {coreInitData}", ex);
			}
		}
	}