using System;
using System.Collections.Generic;
using System.Linq;
using Sungero.Core;
using Sungero.CoreEntities;
using Directum.Dci.Sdk;
using Directum.Dci.Common;

namespace DirRX.DciCore.Server
{
  public class ModuleFunctions
  {
    /// <summary>
    /// Запустить асинхронный обработчик для обработки входящего сообщения DCI.
    /// </summary>
    /// <param name="processMessageGlobalId">GUID сообщения DCI.</param>
    /// <returns>Текст ошибки или строка "Success".</returns>
    [Public(WebApiRequestType = RequestType.Post)]
    public string EnqueueDciMessage(string processMessageGlobalId)
    {
      var logPrefix = string.Format("EnqueueDciMessageHandler. Received DCI message GUID = {0}", processMessageGlobalId);
      
      try
      {
        Logger.DebugFormat("{0}. Start RX async handler.", logPrefix);

        var handler = DirRX.DciCore.AsyncHandlers.ReceiveProcessMessage.Create();
        handler.MessageGUID = processMessageGlobalId;
        handler.ExecuteAsync();

        Logger.DebugFormat("{0}. The end of the function.", logPrefix);
        
        // DCI не принимает string.Empty в качестве результата.
        return "Success";
      }
      catch (Exception ex)
      {
        var errorMessage = string.Format("{0}. The ended with error.", logPrefix);
        Logger.Error(errorMessage, ex);
        return errorMessage;
      }
    }
    
    #region Подбор обработчиков по switch-case
    
    /// <summary>
    /// Обработать входящее сообщение из DCI.
    /// </summary>
    /// <param name="messageGUID">GUID сообщения DCI.</param>
    /// <returns>Текст ошибки при обработке сообщения из DCI.</returns>
    public virtual string ProcessDCIMessage(Directum.Dci.Sdk.IProcessMessage message)
    {
      var processName = message.ProcessKindName;
      var messageName = message.Name;
      
      #region DCICheckLink.
      if (processName == Constants.DciProcessKind.DCICheckLinkProcess.Name)
      {
        switch (messageName)
        {
          case Constants.DciProcessKind.DCICheckLinkProcess.PingMessage.Name:
            return ProcessPingDciMessage(message);
          case Constants.DciProcessKind.DCICheckLinkProcess.PongMessage.Name:
            return ProcessPongDciMessage(message);
          default:
            break;
        }
      }
      #endregion
      
      return DirRX.DciCore.Resources.NotFoundReceiveHandlerByProcessFormat(messageName, processName);
    }
    
    /// <summary>
    /// Подобрать имя исходящего сообщения для сущности.
    /// </summary>
    /// <param name="entity">Сущность.</param>
    /// <returns>Имя сообщения.</returns>
    [Public]
    public virtual string GetDCIMessageNameByEntity(Sungero.CoreEntities.IDatabookEntry entity)
    {
      // Реализован самый простой способ вычислить имя сообщения - изменена/удалена. Данный фрагмент используется по умолчанию для всех типов сущности.
      var messageName = string.Empty;
      
      if (entity == null)
        messageName = Constants.DciProcessKind.DefaultDciMessageName.RecordDeletion;
      else
        messageName = Constants.DciProcessKind.DefaultDciMessageName.RecordChanges;
      
      return messageName;
      
      #region Шаблон кода для реализации функции в перекрытии.
      //// var messageName = string.Empty;
      //// if (<Репозиторий типа сущности>.Is(entity))
      //// {
      ///     // Поиск нужной операции в истории типа сущности и подбор имени сообщения.
      ///     return messageName
      //// }
      //// return base.GetDCIMessageNameByEntity(entity);
      #endregion
    }
    
    /// <summary>
    /// Подготовить вложение для исходящего сообщения DCI.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <param name="entity">Сущность.</param>
    /// <param name="globalEntityId">Глобальный ИД сущности.</param>
    /// <returns>Обновленное сообщение DCI.</returns>
    public virtual Directum.Dci.Sdk.IProcessMessage PrepareDCIMessageAttach(Directum.Dci.Sdk.IProcessMessage message, Sungero.CoreEntities.IDatabookEntry entity, string globalEntityId)
    {
      var processName = message.ProcessKindName;
      var messageName = message.Name;
      
      #region Шаблон кода для реализации функции в перекрытии.
      //// var processName = message.ProcessKindName;
      //// var messageName = message.Name;
      //// 
      //// switch (processName)
      //// {
      ////     #region <Имя типа справочника>.
      ////   case <Имя процесса синхронизации, обычно заканчивается на ReferenceSynchronization>:
      ////     switch (messageName)
      ////     {
      ////       case Constants.DciProcessKind.DefaultDciMessageName.RecordChanges:
      ////         return Fill<Имя типа сущности>DCIMessageAttach(message, entity, globalEntityId);
      ////
      ////       case Constants.DciProcessKind.DefaultDciMessageName.RecordDeletion:
      ////         return CreateDeletionDCIMessageAttach(message, globalEntityId);
      ////
      ////       default:
      ////         break;
      ////     }
      ////     break;
      ////     #endregion
      //// }
      //// 
      //// return base.PrepareDCIMessageAttach(message, entity, globalEntityId);
      #endregion
      
      throw new AppliedCodeException(DirRX.DciCore.Resources.NotFoundPrepareHandlerByProcessFormat(messageName, processName));
    }
    
    #endregion
    
    #region API DCI.
    
    /// <summary>
    /// Получить фабрику работы с процессами DCI.
    /// </summary>
    /// <returns>Фабрика.</returns>
    public Directum.Dci.Sdk.ProcessFactory GetProcessFactory()
    {
      var setting = Functions.DciSetting.GetDciSettings();
      return GetProcessFactory(setting);
    }
    
    /// <summary>
    /// Получить фабрику работы с процессами DCI.
    /// </summary>
    /// <param name="setting">Запись справочника "Настройки DCI".</param>
    /// <returns>Фабрика.</returns>
    public Directum.Dci.Sdk.ProcessFactory GetProcessFactory(IDciSetting setting)
    {
      return ProcessFactory.GetFactory(setting.ExchangeFolder, setting.AdapterServiceUrl);
    }
    
    /// <summary>
    /// Получить процесс по сообщению DCI.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <returns>Процесс DCI.</returns>
    public Directum.Dci.Sdk.IProcess GetProcessByMessage(Directum.Dci.Sdk.IProcessMessage message)
    {
      var factory = GetProcessFactory();
      return factory.GetProcessByMessage(message);
    }

    /// <summary>
    /// Получить глобальный ИД предыдущего отправленного сообщения по процессу.
    /// </summary>
    /// <param name="entityGlobalId">Глобальный ИД объекта.</param>
    /// <param name="processName"></param>
    /// <param name="externalSystemID">Идентификатор внешней системы.</param>
    /// <returns>Глобальный ИД ведущего сообщения</returns>
    public string GetLastSentMessageGloblalId(string entityGlobalId, string processName, string externalSystemID)
    {
      var processFactory = GetProcessFactory();

      var lastSentMessageGlobalId = string.Empty;
      if (string.IsNullOrEmpty(entityGlobalId))
        return lastSentMessageGlobalId;

      // Найти последнее отправленное сообщение по процессу, для указания его ведущим.
      var processParams = new ObjectDictionary();
      processParams.SetVar("RecordGUID", entityGlobalId);
      var foundProcesses = processFactory.GetProcessesByParameters(processParams);
      if (foundProcesses.Count == 0)
        return lastSentMessageGlobalId;

      while (!foundProcesses.EOF)
      {
        var process = (Directum.Dci.Sdk.IProcess)foundProcesses.Value;
        if (process.ProcessKindName == processName)
        {
          var lastSentMessage = process.GetLastSentDependentMessage(externalSystemID);
          if (lastSentMessage != null)
          {
            // Делам связь с предыдущим сообщением не зависимо от его состояния (Ошибка/Отправлено), так как неизвестно состояние сообщения на принимающей стороне.
            lastSentMessageGlobalId = lastSentMessage.GlobalId;
            //break;
          }
          else
          {
            // HACK в случае когда метод GetLastSentDependentMessage ничего не вернул, выполняем поиск единственного отправленного сообщения.
            // HACK как альтернатива поиску - помечать все сообщения как имеющее зависимость (isDepended), но при этом не заполнять ведущее сообщение (LeaderMessageGlobalId) - тогда GetLastSentDependentMessage вернет последнее отправленное сообщение.
            var allMessages = process.GetAllMessages();
            if (allMessages.Count == 1)
            {
              var firstMessage = (Directum.Dci.Sdk.IProcessMessage)allMessages.Value;
              if (firstMessage != null)
                lastSentMessageGlobalId = firstMessage.GlobalId;
              //break;
            }
          }
        }
        foundProcesses.Next();
      }
      return lastSentMessageGlobalId;
    }

    /// <summary>
    /// Создать сообщение.
    /// </summary>
    /// <param name="processName">Имя процесса.</param>
    /// <param name="messageName">Имя сообщения.</param>
    /// <param name="processGlobalId">GUID процесса.</param>
    /// <param name="entityId">ИД синхронизируемого объекта.</param>
    /// <param name="objectTypeGlobalId">GUID типа синхронизируемого объекта.</param>
    /// <param name="processFactory">Фабрика DCI.</param>
    /// <param name="setting">Запись справочника "Настройки DCI".</param>
    /// <param name="stopWhenConfirmed">Признак автоматического закрытия процесса при подтверждении всех отправленных сообщений.</param>
    /// <returns>Сообщение.</returns>
    public Directum.Dci.Sdk.IProcessMessage CreateMessage(string processName, string messageName,
                                                          string processGlobalId, int entityId,
                                                          string objectTypeGlobalId, Directum.Dci.Sdk.ProcessFactory processFactory,
                                                          IDciSetting setting, bool stopWhenConfirmed)
    {
      // Определить процесс по синхронизируемому объекту
      var entityGlobalId = string.Empty;
      var lastSentMessageGlobalId = string.Empty;
      var isDepended = false;
      if (entityId > int.MinValue)
      {
        //        // TODO доп. действия для документов. Реализовать при проработке отправки сообщений.
        //        //        // Для документов переопределить гуид типа сущности.
        //        //        if (processName == "DocumentSynchronization")
        //        //        {
        //        //          if (string.IsNullOrEmpty(objectTypeGlobalId))
        //        //          {
        //        //            var document = Content.ElectronicDocuments.Get(entityId);
        //        //            var meta = document.GetEntityMetadata();
        //        //            objectTypeGlobalId = meta.NameGuid.ToString();
        //        //          }
        //        //        }
        // TODO вынести из функции
        var entityLink = GetExternalEntityLink(entityId, objectTypeGlobalId, setting.ExternalSystemID);
        entityGlobalId = entityLink.ExtEntityId.ToString();
        
        lastSentMessageGlobalId = GetLastSentMessageGloblalId(entityGlobalId, processName, setting.ExternalSystemID);
        if (!string.IsNullOrEmpty(lastSentMessageGlobalId))
        {
          isDepended = true;
          // По ведущему сообщению получить GUID процесса.
          var leadMessage = processFactory.GetProcessMessageByGlobalId(lastSentMessageGlobalId);
          processGlobalId = leadMessage.ProcessGlobalId;
        }
      }
      
      // Создать новый процесс или использовать существующий.
      var process = string.IsNullOrEmpty(processGlobalId) ? processFactory.CreateProcess(processName) : processFactory.GetProcessByGlobalId(processGlobalId);
      // Указать GUID синхронизируемого объекта в параметрах процесса.
      // TODO вынести RecordGUID в константы. Реализовать при проработке отправки сообщений.
      if (!string.IsNullOrEmpty(entityGlobalId) && process.Params.FindItem("RecordGUID") == null)
        process.Params.SetVar("RecordGUID", entityGlobalId);
      process.StopWhenConfirmed = stopWhenConfirmed;
      process.Save();
      
      var message = process.CreateProcessMessage(messageName, setting.SystemID, setting.ExternalSystemID, string.Empty, isDepended);
      if (isDepended)
        message.LeaderMessageGlobalId = lastSentMessageGlobalId;
      message.Save();
      
      return message;
    }
    
    /// <summary>
    /// Остановить межсистемный процесс по синхронизации.
    /// </summary>
    /// <param name="process">Процесс DCI.</param>
    public void StopSynchronizationProcess(Directum.Dci.Sdk.IProcess process)
    {
      var processKind = Functions.DciProcessKind.GetProcessKindByName(process.ProcessKindName);
      // Если тип процесса - синхронизация (справочников/документов), то завершить процесс.
      if (processKind.ProcessType == DciCore.DciProcessKind.ProcessType.DataSync || processKind.ProcessType == DciCore.DciProcessKind.ProcessType.DocSync)
      {
        Logger.Debug(string.Format("Процесс {0}. Завершение процесса синхронизации.", process.GlobalId));
        try
        {
          var endDate = process.EndDate;
          if (endDate != null && !string.IsNullOrWhiteSpace(endDate.ToString()))
          {
            Logger.Debug(string.Format("Процесс {0}. Процесс уже завершен. Дата завершения: {1}", process.GlobalId, endDate));
          }
          else
          {
            process.Stop();
            Logger.Debug(string.Format("Процесс {0}. Процесс завершен.", process.GlobalId));
          }
        }
        catch (Exception ex)
        {
          Logger.Error(string.Format("Процесс {0}. Ошибка завершения процесса.\n{1}\n{2}", process.GlobalId, ex.Message, ex.StackTrace));
        }
      }
    }
    
    #endregion
    
    #region API для ExternalEntityLinks.
    
    /// <summary>
    /// Получить запись справочника "Ссылки внешней системы" для экземпляра сущности.
    /// </summary>
    /// <param name="entityId">ИД сущности.</param>
    /// <param name="entityTypeGuid">GUID типа сущности.</param>
    /// <param name="externalSystemID">Идентификатор внешней системы.</param>
    /// <returns>Запись справочника "Ссылки внешней системы" для экземпляра сущности.</returns>
    [Public, Remote]
    public Sungero.Commons.IExternalEntityLink GetExternalEntityLink(int entityId, string entityTypeGuid, string externalSystemID)
    {
      // TODO Использовать ли поле ExtSystemId в ExternalEntityLinks для нескольких внешних систем. Проработать когда будет несколько систем.
      var externalLink = Sungero.Commons.ExternalEntityLinks.GetAll()
        .Where(l => l.EntityId == entityId && l.EntityType == entityTypeGuid)
        .FirstOrDefault();
      if (externalLink == null)
      {
        var newGuid = Guid.NewGuid().ToString();
        externalLink = SetExternalEntityLinkGuid(entityId, entityTypeGuid, externalSystemID, newGuid);
      }
      return externalLink;
    }
    
    /// <summary>
    /// Установить GUID внешней ссылки для экземпляра сущности.
    /// </summary>
    /// <param name="entityId">Ид сущности.</param>
    /// <param name="entityTypeGuid">GUID типа сущности.</param>
    /// <param name="externalSystemID">Идентификатор внешней системы.</param>
    /// <param name="externalEntityGuid">Внешний GUID сущности.</param>
    [Public, Remote]
    public Sungero.Commons.IExternalEntityLink SetExternalEntityLinkGuid(int entityId, string entityTypeGuid, string externalSystemID, string externalEntityGuid)
    {
      var externalLink = Sungero.Commons.ExternalEntityLinks.Create();
      externalLink.EntityId = entityId;
      externalLink.EntityType = entityTypeGuid;
      externalLink.ExtSystemId = externalSystemID;
      externalLink.ExtEntityId = Guid.Parse(externalEntityGuid).ToString();
      externalLink.Save();
      
      return externalLink;
    }
    
    /// <summary>
    /// Получить все записи справочника по глобальному идентификатору сущности.
    /// </summary>
    /// <param name="guid">Глобальный идентификатор.</param>
    /// <returns>Коллекция сущностей или null.</returns>
    [Public, Remote(IsPure = true)]
    public IQueryable<Sungero.Commons.IExternalEntityLink> GetAllEntityLinksByGuid(string guid)
    {
      var globalId = Guid.Parse(guid).ToString();
      // TODO Использовать ли поле ExtSystemId в ExternalEntityLinks для нескольких внешних систем.Проработать когда будет несколько систем.
      var externalLinks = Sungero.Commons.ExternalEntityLinks.GetAll()
        .Where(x => x.ExtEntityId == globalId);
      return externalLinks;
    }
    
    /// <summary>
    /// Получить запись справочника по глобальному идентификатору сущности.
    /// </summary>
    /// <param name="guid">Глобальный идентификатор.</param>
    /// <returns>Сущность или null.</returns>
    [Public, Remote(IsPure = true)]
    public Sungero.Commons.IExternalEntityLink GetEntityLinkByGuid(string guid)
    {
      if (string.IsNullOrWhiteSpace(guid))
        return null;
      
      return GetAllEntityLinksByGuid(guid).FirstOrDefault();
    }
    
    /// <summary>
    /// Получить ИД сущности по глобальному идентификатору сущности.
    /// </summary>
    /// <param name="guid">Глобальный идентификатор.</param>
    /// <returns>ИД сущности или 0.</returns>
    [Public, Remote(IsPure = true)]
    public int GetEntityIdByGuid(string guid)
    {
      var externalLink = GetEntityLinkByGuid(guid);
      return externalLink != null ? externalLink.EntityId.Value : 0;
    }
    #endregion
    
    #region Функции по преобразованию даты.
    
    /// <summary>
    /// Преобразовать строку в дату.
    /// </summary>
    /// <param name="value">Строка формата ДД.ММ.ГГГГ (наличие ведущего нуля не принципиально).</param>
    /// <returns>Дата-время или null.</returns>
    /// <remarks>Генерирует исключение в случае ошибки преобразования.</remarks>
    [Public]
    public virtual DateTime? StringToDate(string value)
    {
      if (string.IsNullOrWhiteSpace(value))
        return null;
      
      var util = new Directum.Dci.Sdk.Utils();
      return util.StringToDate(value);
    }
    
    /// <summary>
    /// Преобразовать строку в дату со временем.
    /// </summary>
    /// <param name="value">Строка формата ДД.ММ.ГГГГ ЧЧ:ММ:СС.мс (наличие ведущего нуля не принципиально).</param>
    /// <returns>Дата-время или null.</returns>
    /// <remarks>Генерирует исключение в случае ошибки преобразования.</remarks>
    [Public]
    public virtual DateTime? StringToDateTime(string value)
    {
      if (string.IsNullOrWhiteSpace(value))
        return null;
      
      var util = new Directum.Dci.Sdk.Utils();
      return util.StringToDateTime(value);
    }
    
    /// <summary>
    /// Преобразовать дату в строку.
    /// </summary>
    /// <param name="value">Дата-время.</param>
    /// <returns>Строка формата ДД.ММ.ГГГГ.</returns>
    [Public]
    public virtual string DateToDciString(DateTime value)
    {
      var util = new Directum.Dci.Sdk.Utils();
      return util.DateToString(value);
    }
    
    /// <summary>
    /// Преобразовать дату со временем в строку.
    /// </summary>
    /// <param name="value">Дата-время.</param>
    /// <returns>Строка формата ДД.ММ.ГГГГ ЧЧ:ММ:СС.мс.</returns>
    [Public]
    public virtual string DateTimeToDciString(DateTime value)
    {
      var util = new Directum.Dci.Sdk.Utils();
      return util.DateTimeToString(value);
    }
    
    #endregion
    
    #region Прочие функции.
    
    /// <summary>
    /// Отправить уведомление об ошибках.
    /// </summary>
    /// <param name="errors">Список ошибок.</param>
    /// <param name="processName">Имя процесса DCI.</param>
    /// <param name="processGUID">GUID процесса DCI.</param>
    /// <param name="messageName">Имя сообщения DCI.</param>
    /// <param name="messageGUID">GUID сообщения DCI.</param>
    [Public]
    public virtual void SendNotificatiobAboutReceiveErrors(System.Collections.Generic.IList<string> errors, string processName, string processGUID, string messageName, string messageGUID)
    {
      var task = Sungero.Workflow.SimpleTasks.Create();
      var step = task.RouteSteps.AddNew();
      step.AssignmentType = Sungero.Workflow.SimpleTaskRouteSteps.AssignmentType.Notice;
      step.Performer = Roles.Administrators; // TODO отправлять на спец роль. например Roles.GetAll(r => r.Sid == PublicConstants.Module.RoleGuid.DCIResponsible).First();
      task.Subject = DirRX.DciCore.Resources.ReceiveErrorTaskSubjectFormat(messageName, processName);
      task.ActiveText = DirRX.DciCore.Resources.ReceiveErrorTaskTextFormat(string.Join(Environment.NewLine, errors));
      task.NeedsReview = false;
      task.Start();
    }
    
    /// <summary>
    /// Найти запись справочника системы по ИД.
    /// </summary>
    /// <param name="entityId">ИД сущности.</param>
    /// <param name="entityTypeGuid">GUID типа сущности.</param>
    /// <returns>Сущность или null.</returns>
    [Public, Remote(IsPure = true)]
    public virtual Sungero.CoreEntities.IDatabookEntry GetDatabookEntityById(int entityId, string entityTypeGuid)
    {
      // HACK универсальный код по поиску записи справочника.
      var targetEntity = Sungero.CoreEntities.Databooks.Null;
      var entityList = Sungero.CoreEntities.Databooks.GetAll(e => e.Id == entityId);
      // В linq-запросе не работает вызов GetType(), поэтому дальнейший перебор в цикле.
      foreach (var entity in entityList)
      {
        var entityType = entity.GetType();
        if (entityType != null)
        {
          var guid = Sungero.Domain.Shared.TypeExtension.GetTypeGuid(entityType);
          if (guid.ToString().ToLower() == entityTypeGuid.ToLower())
          {
            if (targetEntity == null)
              targetEntity = entity;
            else
              // Это исключение никогда не должно сработать, но если оно случится - нужно пересмотреть подход к поиску сущностей.
              throw AppliedCodeException.Create(DirRX.DciCore.Resources.MultipleEntitiesFoundToDeleteFormat(entityId, entityTypeGuid));
          }
        }
      }
      
      return targetEntity;
    }
    
    /// <summary>
    /// Получить список измененных записей справочника за период.
    /// </summary>
    /// <param name="baseGuid">Базовый GUID типа сущности.</param>
    /// <param name="dateBegin">Дата начала изменений.</param>
    /// <param name="dateEnd">Дата конца изменений.</param>
    /// <returns>Список ИД измененных записей справочника.</returns>
    [Public]
    public virtual IQueryable<int> GetChangedDatabookRecords(string baseGuid, DateTime dateBegin, DateTime dateEnd)
    {
      // HACK универсальный код по поиску в истории записей справочника.
      
      var actions = new List<Enumeration?> {
        Sungero.CoreEntities.History.Action.Create,
        Sungero.CoreEntities.History.Action.Update,
        Sungero.CoreEntities.History.Action.Delete};
      
      return Sungero.CoreEntities.DatabookHistories.GetAll()
        .Where(h => h.EntityType.ToString() == baseGuid
               && h.HistoryDate >= dateBegin
               && h.HistoryDate <= dateEnd
               && actions.Contains(h.Action))
        .Select(h => h.EntityId.Value)
        .Distinct();
    }
    
    #endregion
    
    #region Шаблоны кода.
    
    #region Шаблон кода для обработчика приема.
    
    //// /// <summary>
    //// /// Обработать сообщение по изменению "Имя типа сущности".
    //// /// </summary>
    //// /// <param name="message">Сообщение DCI.</param>
    //// /// <returns>Пустая строка или текст ошибки.</returns>
    //// public string Process<Имя типа сущности>DCIMessage(Directum.Dci.Sdk.IProcessMessage message)
    //// {
    ////   /// -------------------------------------------------
    ////   /// Подготовка к обработке сообщения.
    ////   /// -------------------------------------------------
    ////
    ////   // Получить данные из сообщения DCI.
    ////   var data = message.LoadData("MainRecord");
    ////   var globalId = Guid.Parse(data.ValueByName("GUID").ToString()).ToString();
    ////   var entityLink = GetEntityLinkByGuid(globalId);
    ////
    ////   var entity = entityLink != null ? <Репозиторий типа сущности>.Get(entityLink.EntityId.Value) : <Репозиторий типа сущности>.Create();
    ////
    ////   // Если запись заблокирована, отправить сообщение повторно в очередь.
    ////   if (Locks.GetLockInfo(entity).IsLocked)
    ////     return Constants.Module.ErrorType.EntityIsLocked;
    ////
    ////   /// -------------------------------------------------
    ////   /// Обновление записи справочника.
    ////   /// -------------------------------------------------
    ////   /// Для преобразования строковых значений в типы .net использовать функции:
    ////   /// StringToDouble - Преобразовать строку в double.
    ////   /// StringToInt - Преобразовать строку в целое число.
    ////   /// StringToDate - Преобразовать строку в дату.
    ////   /// StringToDateTime - Преобразовать строку в дату со временем.
    ////   /// Base64ToString - Раскодировать строку из base64.
    ////   /// и другие функции модуля DciCore.
    ////
    ////   // Указать GUID базового типа сущности.
    ////   var entityTypeGuid = <GUID типа сущности>;
    ////   var name = data.ValueByName("Наименование").ToString();
    ////   entity.Name = name;
    ////   entity.Save();
    ////
    ////   /// -------------------------------------------------
    ////   /// Завершение приема сообщения.
    ////   /// -------------------------------------------------
    ////
    ////   if (entityLink == null)
    ////     SetExternalEntityLinkGuid(entity.Id, entityTypeGuid, message.Sender, globalId);
    ////
    ////   return string.Empty;
    //// }
    
    #endregion
    
    #region Шаблон кода для обработчика отправки.
    
    //// /// <summary>
    //// /// Заполнить сообщение DCI информацией для обновления "Имя типа сущности".
    //// /// </summary>
    //// /// <param name="message">Сообщение DCI.</param>
    //// /// <param name="entity">Сущность.</param>
    //// /// <param name="globalEntityId">Глобальный ИД сущности.</param>
    //// /// <returns>Обновленное сообщение DCI.</returns>
    //// public virtual Directum.Dci.Sdk.IProcessMessage Fill<Имя типа сущности>DCIMessageAttach(Directum.Dci.Sdk.IProcessMessage message, Sungero.CoreEntities.IDatabookEntry entity, string globalEntityId)
    //// {
    ////   /// -------------------------------------------------
    ////   /// Подготовка к формированию сообщения.
    ////   /// -------------------------------------------------
    ////   var attach = new ObjectDictionary();
    ////   attach.Add("GUID", globalEntityId);
    ////
    ////   var record = <Репозиторий типа сущности>.As(entity);
    ////
    ////   /// -------------------------------------------------
    ////   /// Заполнение сообщения свойствами записи справочника.
    ////   /// -------------------------------------------------
    ////   /// Для преобразования в строку можно использовать функции:
    ////   /// ConvertRXStatusToD5Status - Преобразовать статус записи RX в состояние записи D5.
    ////   /// StringToBase64 - Закодировать строку из base64.
    ////   /// и другие функции модуля DciCore.
    ////   attach.Add("Наименование", record.Name);
    ////   attach.Add("Состояние", DciCore.PublicFunctions.Module.ConvertD5StatusToRXStatus(record.Status));
    ////
    ////   /// -------------------------------------------------
    ////   /// Завершение формирования сообщения.
    ////   /// -------------------------------------------------
    ////   message.AttachData(attach, "MainRecord");
    ////   message.Save();
    ////   return message;
    //// }
    
    #endregion
    
    #endregion
    
    #region Функции-обработчики по приёму.
    
    #region Обработчик по удалению.
    
    /// <summary>
    /// Обработать сообщение по удалению сущности.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <returns>Текст ошибки или пустая строка.</returns>
    public virtual string ProcessDeletionDCIMessage(Directum.Dci.Sdk.IProcessMessage message)
    {
      var data = message.LoadData("DeletedRecordData");
      var guid = data.ValueByName("GUID");
      
      var globalId = Guid.Parse(guid.ToString()).ToString();
      var entityLink = GetEntityLinkByGuid(globalId);
      if (entityLink == null)
        return DirRX.DciCore.Resources.NotFoundExternalEntityLinkFormat(globalId);
      
      // Сперва заполнить свойство IsDelete у ExternalEntityLinks и сохранить. Данное свойство используется в стандартной в событиях до удаления и если оно не означено, то запрещается удаление.
      if (entityLink.IsDeleted != true)
      {
        entityLink.IsDeleted = true;
        entityLink.Save();
      }
      
      // Удалить сущность из системы.
      var deleteResult = string.Empty;
      try
      {
        var entityId = entityLink.EntityId.Value;
        var entityTypeGuid = entityLink.EntityType;
        deleteResult = DeleteEntityByProcessName(entityId, entityTypeGuid, message.ProcessKindName);
      }
      catch (Exception ex)
      {
        deleteResult = DirRX.DciCore.Resources.DeleteEntityErrorFormat(ex.Message, ex.StackTrace);
        Logger.Error(string.Format("Процесс {0}. {1}", message.ProcessGlobalId, deleteResult));
      }
      
      // Удалить связанные записи из справочника "Ссылки внешней системы".
      if (string.IsNullOrWhiteSpace(deleteResult))
      {
        /// HACK получаем все сущности, так как:
        /// 1. В стандартной разработке есть код по удалению записи из справочника ссылки "Ссылки внешней системы", соответственно наша ссылка устаревает (ссылаться на отсутствующую запись справочника).
        /// 2. Есть шанс что в справочнике могли создаться дубли.
        var entityLinks = GetAllEntityLinksByGuid(globalId);
        foreach (var link in entityLinks)
          Sungero.Commons.ExternalEntityLinks.Delete(link);
      }
      
      return deleteResult;
    }
    
    /// <summary>
    /// Удалить сущности из системы по ИД.
    /// </summary>
    /// <param name="entityId">ИД сущности.</param>
    /// <param name="entityTypeGuid">GUID типа сущности.</param>
    /// <param name="processName">Имя процесса DCI.</param>
    /// <returns>Текст ошибки или пустая строка.</returns>
    [Public, Remote]
    public virtual string DeleteEntityByProcessName(int entityId, string entityTypeGuid, string processName)
    {
      // HACK универсальный код по удалению записи справочника.
      // TODO нужна доработка для удаления документов
      
      var targetEntity = GetDatabookEntityById(entityId, entityTypeGuid);
      
      if (targetEntity == null)
        return DirRX.DciCore.Resources.NoEntitiesFoundToDeleteFormat(entityId, entityTypeGuid);
      
      var lockInfo = Locks.GetLockInfo(targetEntity);
      if (lockInfo.IsLocked)
        return DirRX.DciCore.PublicConstants.Module.ErrorType.EntityIsLocked;
      
      Sungero.CoreEntities.Databooks.Delete(targetEntity);

      return string.Empty;
      
      #region Шаблон кода для реализации функции в перекрытии.
      //// switch (processName)
      //// {
      ////   case <Имя процесса синхронизации, обычно заканчивается на ReferenceSynchronization>:
      ////     var entity = <Репозиторий типа сущности>.Get(entityId);
      ////     // Если запись заблокирована, отправить сообщение повторно в очередь.
      ////     var lockInfo = Locks.GetLockInfo(entity);
      ////     if (lockInfo.IsLocked)
      ////       return Constants.Module.ErrorType.EntityIsLocked;
      ////     <Репозиторий типа сущности>.Delete(entity);
      ////     break;
      ////   default:
      ////     return base.DeleteEntityByProcessName(entityId, processName);
      //// }
      //// return string.Empty;
      #endregion
      
      //return DirRX.DciCore.Resources.NotFoundDeleteHandlerByProcessFormat(processName);
    }
    
    #endregion
    
    #region DCICheckLink
    
    /// <summary>
    /// Обработать сообщение Ping.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <returns>Пустая строка или текст ошибки.</returns>
    public string ProcessPingDciMessage(Directum.Dci.Sdk.IProcessMessage message)
    {
      // Получить словарь с данными из сообщения.
      var data = message.LoadData("TestData");
      var dataGuid = data.ValueByName("GUID");
      var dataDate = data.ValueByName("Date");
      var dataNum1 = data.ValueByName("Num");
      var dataNum2 = data.ValueByName("Num2");
      
      if (dataGuid == null || dataDate == null || dataNum1 == null || dataNum2 == null)
        return DirRX.DciCore.Resources.InsufficientDataError;
      
      var guid = dataGuid.ToString();
      var date = dataDate.ToString();
      var num1 = dataNum1.ToString();
      var num2 = dataNum2.ToString();
      
      var stringBuilder = new System.Text.StringBuilder();
      
      stringBuilder.AppendLine(string.Format("Процесс: {0} ({1}). Сообщение: {2} ({3}). Получено сообщение. Значения данных:",
                                             message.ProcessGlobalId, message.ProcessKindName, message.GlobalId, message.Name));
      stringBuilder.AppendLine(string.Format("GUID = {0}", guid));
      stringBuilder.AppendLine(string.Format("Date = {0}", date));
      stringBuilder.AppendLine(string.Format("Num = {0}", num1));
      stringBuilder.AppendLine(string.Format("Num2 = {0}", num2));
      Logger.Debug(stringBuilder.ToString());
      stringBuilder.Clear();
      
      Logger.Debug(string.Format("Процесс: {0} ({1}). Сообщение: {2} ({3}). Проверка данных...",
                                 message.ProcessGlobalId, message.ProcessKindName, message.GlobalId, message.Name));
      DateTime tempDate;
      var isDate = Calendar.TryParseDate(date, out tempDate);
      var tempNum1 = Functions.Module.StringToDouble(num1);
      var tempNum2 = Functions.Module.StringToDouble(num2);
      var isNumber1 = (tempNum1 != null);
      var isNumber2 = (tempNum2 != null);
      tempNum1 += 1.5;
      tempNum2 += 1.0 / 3.0;
      
      stringBuilder.AppendLine(string.Format("Процесс: {0} ({1}). Сообщение: {2} ({3}). Результаты проверки данных:",
                                             message.ProcessGlobalId, message.ProcessKindName, message.GlobalId, message.Name));
      stringBuilder.AppendLine(string.Format("Date = {0}, is date = {1}", date, isDate));
      stringBuilder.AppendLine(string.Format("Num = {0}, is double = {1}", num1, isNumber1));
      stringBuilder.AppendLine(string.Format("Num2 = {0}, is double = {1}", num2, isNumber2));
      stringBuilder.AppendLine(string.Format("Num + 1.5 = {0}", tempNum1));
      stringBuilder.AppendLine(string.Format("Num2 + 1/3 = {0}", tempNum2));
      Logger.Debug(stringBuilder.ToString());
      stringBuilder.Clear();
      
      Logger.Debug(string.Format("Процесс: {0} ({1}). Сообщение: {2} ({3}). Остановка процесса.",
                                 message.ProcessGlobalId, message.ProcessKindName, message.GlobalId, message.Name));
      var process = GetProcessByMessage(message);
      process.Stop();
      
      return string.Empty;
    }
    
    /// <summary>
    /// Обработать сообщение Pong.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <returns>Пустая строка или текст ошибки.</returns>
    public string ProcessPongDciMessage(Directum.Dci.Sdk.IProcessMessage message)
    {
      // Получить параметры сообщения.
      var messageParams = message.Params;
      var paramDirection = messageParams.ValueByName("Direction").ToString();
      var paramServiceType = messageParams.ValueByName("ServiceType").ToString();
      var paramEventTime = messageParams.ValueByName("EventTime").ToString();
      var paramEndpointType = messageParams.ValueByName("EndpointType").ToString();
      
      var paramIndex = 0;
      var paramServiceName = string.Empty;
      paramIndex = messageParams.IndexOfName("ServiceName");
      if (paramIndex >= 0)
        paramServiceName = messageParams.GetValues(paramIndex).ToString();
      
      var paramEndpointName = string.Empty;
      paramIndex = messageParams.IndexOfName("EndpointName");
      if (paramIndex >= 0)
        paramEndpointName = messageParams.GetValues(paramIndex).ToString();
      
      // var stringBuilder = new System.Text.StringBuilder();
      // stringBuilder.AppendLine(string.Format("Процесс: {0} ({1}). Сообщение: {2} ({3}). Получено сообщение. Значения параметров:",
      //                                        message.ProcessGlobalId, message.ProcessKindName, message.GlobalId, message.Name));
      // stringBuilder.AppendLine(string.Format("paramDirection = {0}", paramDirection));
      // stringBuilder.AppendLine(string.Format("paramServiceType = {0}", paramServiceType));
      // stringBuilder.AppendLine(string.Format("paramEventTime = {0}", paramEventTime));
      // stringBuilder.AppendLine(string.Format("paramEndpointType = {0}", paramEndpointType));
      // stringBuilder.AppendLine(string.Format("paramServiceName = {0}", paramServiceName));
      // stringBuilder.AppendLine(string.Format("paramEndpointName = {0}", paramEndpointName));
      // Logger.Debug(stringBuilder.ToString());
      // stringBuilder.Clear();
      
      var eventStr = new System.Text.StringBuilder();
      var serviceType = string.Empty;
      var endpointType = string.Empty;
      eventStr.AppendFormat("Получатель {0}.", message.Sender);
      if (paramServiceType == "SystemAdapter")
        serviceType = "Адаптер к системе";
      else if (paramServiceType == "TransportAdapter")
        serviceType = "Адаптер к транспорту";
      else if (paramServiceType == "Transport")
        serviceType = "Транспорт";
      eventStr.AppendFormat(" {0}", serviceType);
      
      if (!string.IsNullOrWhiteSpace(paramServiceName))
        eventStr.AppendFormat(" {0}", paramServiceName);
      
      if (paramDirection == "From")
      {
        eventStr.Append(": Сообщение получено");
        
        if (paramEndpointType == "System")
          endpointType = "из системы";
        else if (paramEndpointType == "RoutingService")
          endpointType = "из сервиса маршрутизации";
        else if (paramEndpointType == "TransportAdapter")
          endpointType = "из адаптера к транспорту";
        else if (paramEndpointType == "Transport")
          endpointType = "из транспорта";
        
        eventStr.AppendFormat(" {0}", endpointType);
      }
      else
      {
        eventStr.Append(": Сообщение отправлено");
        
        if (paramEndpointType == "System")
          endpointType = "в систему";
        else if (paramEndpointType == "RoutingService")
          endpointType = "в сервис маршрутизации";
        else if (paramEndpointType == "TransportAdapter")
          endpointType = "в адаптер к транспорту";
        else if (paramEndpointType == "Transport")
          endpointType = "в транспорт";
        
        eventStr.AppendFormat(" {0}", endpointType);
      }
      
      if (!string.IsNullOrWhiteSpace(paramEndpointName))
        eventStr.AppendFormat(" {0}", paramEndpointName);
      
      Logger.Debug(eventStr.ToString());
      
      return string.Empty;
    }
    #endregion
    
    #endregion
    
    #region Функции-обработчики по отправке.
    
    #region DCICheckLink
    
    /// <summary>
    /// Отправить тестовое сообщение для проверки связи между системами.
    /// </summary>
    /// <returns>GUID процесса DCI.</returns>
    [Public, Remote(IsPure = true)]
    public string SendDciPing()
    {
      var setting = Functions.DciSetting.GetDciSettings();
      var processFactory = GetProcessFactory(setting);

      var message = CreateMessage(Constants.DciProcessKind.DCICheckLinkProcess.Name, Constants.DciProcessKind.DCICheckLinkProcess.PingMessage.Name, string.Empty, int.MinValue, string.Empty, processFactory, setting, true);
      
      // Сформировать тестовое сообщение.
      var attach = new ObjectDictionary();
      attach.Add("GUID", Guid.NewGuid().ToDelphiGuid());  // TODO сделать более явный вызов ToDelphiGuid из Directum.Dci.Common. Реализовать при проработке отправки сообщений.
      attach.Add("Date", Calendar.Today);
      attach.Add("Num", 1.0 / 3.0);
      attach.Add("Num2", 1.25);
      attach.Add("TestStatus", Sungero.CoreEntities.DatabookEntry.Status.Active);
      
      message.AttachData(attach, "TestData");
      message.Save();
      message.Send();

      var process = GetProcessByMessage(message);
      return process.GlobalId;
    }
    
    #endregion
    
    /// <summary>
    /// Заполнить сообщение DCI информацией для удаления сущности.
    /// </summary>
    /// <param name="message">Сообщение DCI.</param>
    /// <param name="globalEntityId">Глобальный ИД сущности.</param>
    /// <returns>Обновленное сообщение DCI.</returns>
    public virtual Directum.Dci.Sdk.IProcessMessage CreateDeletionDCIMessageAttach(Directum.Dci.Sdk.IProcessMessage message, string globalEntityId)
    {
      var attach = new ObjectDictionary();
      attach.Add("GUID", globalEntityId);
      message.AttachData(attach, "DeletedRecordData");
      message.Save();
      return message;
      // TODO помечать запись удаленной в extlinks
      
      #region Шаблон кода для реализации функции в перекрытии.
      //// switch (message.ProcessKindName)
      //// {
      ////   case <Имя процесса синхронизации, обычно заканчивается на ReferenceSynchronization>:
      ////     var attach = new ObjectDictionary();
      ////     attach.Add("GUID", globalEntityId);
      ////     message.AttachData(attach, "DeletedRecordData");
      ////
      ////     var entityId = GetEntityIdByGuid(globalEntityId);
      ////     var entity = <Репозиторий типа сущности>.Get(entityId);
      ////     var customAttach = new ObjectDictionary();
      ////     //customAttach.Add("", entity.);
      ////     message.AttachData(customAttach, "CustomData");
      ////
      ////     message.Save();
      ////     break;
      ////
      ////   default:
      ////     return base.CreateDeletionDCIMessageAttach(message, globalEntityId);
      //// }
      //// return message;
      #endregion
    }
    
    #endregion
    
  }
}