using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using Sungero.AsposeExtensions;
using Sungero.Commons;
using Sungero.Core;
using Sungero.CoreEntities;
using Sungero.Domain.SessionExtensions;
using Sungero.Domain.Shared;
using Sungero.Metadata;
using Ionic.Zip;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Pdf = Aspose.Pdf;
using PdfS = PdfSharp.Pdf;

namespace DirRX.Container.Server
{
  public class ModuleFunctions
  {
    #region Отбор и обработка документов

    /// <summary>
    /// Отправить в обработку документ, включенный в опись электронных дел.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <param name="iventoryId">ИД описи.</param>
    /// <returns>Пустая строка, либо сообщение об ошибке.</returns>
    [Public]
    public virtual string EnqueueDocumentForInventory(Sungero.Docflow.IOfficialDocument document, int iventoryId)
    {
      // Проверить не был ли документ обработан ранее.
      var eventLog = Container.TransferEventLogs.GetAll(x => x.Document != null && x.Document.Equals(document)).FirstOrDefault();
      
      try
      {
        if (eventLog == null)
        {
          // Создать новую запись протокола обработки.
          eventLog = Container.TransferEventLogs.Create();
          eventLog.Document = document;
        }
        else
        {
          // Автоматически сбросить статус ошибки при повторной отправке.
          if (eventLog.CurrentState == Container.TransferEventLog.CurrentState.Error)
            PublicFunctions.TransferEventLog.Remote.ResetErrorStatus(eventLog);
          else if (eventLog.CurrentState.HasValue)
          {
            var error = Resources.ErrorContainerAlreadyExistsFormat(eventLog.Id, eventLog.Id);
            Logger.DebugFormat("EnqueueDocumentForInventory. " + error);
            return error;
          }
        }
        
        eventLog.InventoryId = iventoryId;
        eventLog.CurrentState = Container.TransferEventLog.CurrentState.InQueue;

        // Найти правила обработки, подходящие для конкретного документа.
        var rules = SelectionRules.GetAll();
        
        if (rules.Any())
        {
          if (document.DocumentKind != null)
            rules = rules.Where(r => !r.DocumentKinds.Any() || r.DocumentKinds.Any(k => k.DocumentKind.Equals(document.DocumentKind)));
          
          if (document.Department != null)
            rules = rules.Where(r => !r.Departments.Any() || r.Departments.Any(d => d.Department.Equals(document.Department)));
          
          if (document.CaseFile != null)
            rules = rules.Where(r => !r.CaseFiles.Any() || r.CaseFiles.Any(c => c.CaseFile.Equals(document.CaseFile)));

          // Применить пользовательскую функцию фильтрации.
          var documentList = new List<Sungero.Docflow.IOfficialDocument>() { Sungero.Docflow.OfficialDocuments.As(document) };
          
          foreach (var rule in rules.OrderBy(r => r.Priority.GetValueOrDefault()).ThenBy(r => r.Id))
          {
            if (!string.IsNullOrEmpty(rule.FilteringModule) && !string.IsNullOrEmpty(rule.FilteringFunction))
            {
              var query = (IQueryable<Sungero.Docflow.IOfficialDocument>)Functions.Module.ExecuteServerFunction(rule.FilteringModule,
                                                                                                                rule.FilteringFunction,
                                                                                                                new object[] { documentList.AsQueryable() });
              if (!query.Any())
                continue;
            }
            
            // Использовать первое правило, которое удовлетворяет критериям.
            eventLog.SelectionRule = rule;
            break;
          }
        }
        
        eventLog.Save();
        
        // Отправить в обработку.
        var processHandler = AsyncHandlers.ProcessNextStageForInventory.Create();
        processHandler.eventLogId = eventLog.Id;
        processHandler.ExecuteAsync();
      }
      catch (Exception e)
      {
        var error = Resources.ErrorProcessingFunctionFormat(e.InnerException != null ? e.InnerException.Message : e.Message);
        Logger.DebugFormat("EnqueueDocumentForInventory. " + error);
        return error;
      }
      
      return string.Empty;
    }
    
    /// <summary>
    /// Создать временную папку для обработки контейнера.
    /// </summary>
    /// <param name="subFolder">Имя дочерней папки.</param>
    /// <returns>Путь к папке.</returns>
    public virtual string GetContainerFolder(string subFolder)
    {
      var resultPath = string.Empty;
      
      if (DirRX.Storage.PublicFunctions.Module.IsLinux())
      {
        resultPath = DirRX.Storage.PublicFunctions.Module.GetContainerFolder(subFolder);
      }
      else
      {
        // Получить корневую папку экспорта из настроек.
        var settings = PublicFunctions.ArchiveSetting.GetSettings();
        
        // Если папка не указана, использовать временную папку на сервере.
        if (string.IsNullOrEmpty(settings.ContainerFolder))
        {
          resultPath = DirRX.Storage.PublicFunctions.Module.GetContainerFolder(subFolder);
        }
        else
        {
          resultPath = settings.ContainerFolder;
          
          if (!string.IsNullOrWhiteSpace(subFolder))
          {
            resultPath = Path.Combine(settings.ContainerFolder, subFolder);
            if (!Directory.Exists(resultPath))
              Directory.CreateDirectory(resultPath);
          }
        }
      }
      
      return resultPath;
    }

    /// <summary>
    /// Создать контейнер и отправить его в ДА.
    /// </summary>
    /// <param name="eventLog">Запись журнала передачи документа.</param>
    /// <returns>Запись журнала передачи документа.</returns>
    [Public]
    public virtual DirRX.Container.ITransferEventLog ProcessArchiveDocument(DirRX.Container.ITransferEventLog eventLog)
    {
      // Получить основные настройки.
      var settings = PublicFunctions.ArchiveSetting.GetSettings();

      // Хранить контейнеры в системе-источнике.
      // True - решение ДА установлено в системе-источники, обмен данными посредством прямых вызовов функций.
      // False - решение ДА установлено отдельно, обмен данными с помощью WebApi,
      var currentSystemIsArchive = settings.ArchiveStorage == Container.ArchiveSetting.ArchiveStorage.SourceSystem;
      
      // Контейнеры хранятся в ДА. Контейнер передается в теле запроса (true), либо ссылки на файл в сетевой папке (false).
      var sendContainerInRequestBody = settings.SendingMethod == Container.ArchiveSetting.SendingMethod.Content;

      var hash = string.Empty;
      
      var isCaseInventory = eventLog.InventoryId.HasValue && eventLog.InventoryId.Value > 0;
      
      // -------------------------------------
      // Создать контейнер.
      // -------------------------------------
      if (eventLog.CurrentState == Container.TransferEventLog.CurrentState.InQueue && string.IsNullOrEmpty(eventLog.FilePath))
      {
        // Изменить статус на время формирования контейнера. Завершение создания определяется заполненностью uid.
        eventLog.CurrentState = Container.TransferEventLog.CurrentState.Creating;
        eventLog.Save();
        
        // Сформировать путь к файлу для хранения контейнера.
        var containerFolder = this.GetContainerFolder("outltacontainers");
        var containerFile = Path.Combine(containerFolder, string.Format(@"out_container_{0}.zip", eventLog.Document.Id));
        var containerType = eventLog.SelectionRule != null ? eventLog.SelectionRule.ArchiveDocumentType : "ArchiveDocument";
        
        // Сформировать контейнер и выгрузить в zip-файл.

        var stopWatch = new System.Diagnostics.Stopwatch();
        
        stopWatch.Start();
        var container = Functions.Module.CreateContainer(settings.SourceUid, eventLog.Document, containerType, containerFile);
        stopWatch.Stop();
        
        if (File.Exists(containerFile))
          eventLog.FilePath = containerFile;
        
        if (string.IsNullOrEmpty(container.Error))
        {
          var ts = stopWatch.Elapsed;
          string elapsedTime = String.Format("{0:00}:{1:00}.{2}", ts.Minutes, ts.Seconds, ts.Milliseconds);
          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionCreateContainer, Resources.InfoContainerСreated + " Время: " + elapsedTime);
          hash = this.GetFileHash(containerFile);
          Functions.TransferEventLog.AddProcessingLog(eventLog,  Resources.ActionCreateContainer, Resources.ContainerHashFormat(hash));
          eventLog.ContainerUid = container.Uid;
        }
        else
        {
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.Error;
          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionCreateContainer, container.Error);
        }
        
        eventLog.Save();
        
        // Если контейнер создается по описи, завершить итерацию.
        if (isCaseInventory)
          return eventLog;
      }

      // -------------------------------------
      // Отправить контейнер в архивную систему.
      // -------------------------------------
      if (eventLog.CurrentState == Container.TransferEventLog.CurrentState.Creating && !string.IsNullOrEmpty(eventLog.ContainerUid))
      {
        // Изменить статус на время отправки.
        eventLog.CurrentState = Container.TransferEventLog.CurrentState.Sending;
        eventLog.Save();

        var response = DirRX.Storage.Structures.Module.ResultAnswer.Create();
        
        // Занести контейнер в версию текущего документа или отправить контейнер в ДА через WebApi.
        if (currentSystemIsArchive)
        {
          if (sendContainerInRequestBody)
            response = DirRX.Storage.PublicFunctions.Module.EnqueueContainerOneInstance(eventLog.FilePath);
          else
            response = DirRX.Storage.PublicFunctions.Module.ProcessContainerByLink(eventLog.FilePath, hash);
        }
        else
        {
          Logger.DebugFormat("LTA. Отправка контейнера {0} в теле запроса через интегр. сервис", eventLog.FilePath);
          var responseText = Functions.Module.SendContainer(eventLog.FilePath, hash);
          Logger.DebugFormat("LTA. Ответ интегр. сервиса: {0}", responseText);
          var json = JObject.Parse(responseText);
          if (json != null)
          {
            response.Status = json.Value<string>("Status");
            response.Message = json.Value<string>("Message");
            response.Guid = json.Value<string>("Guid");
          }
        }
        
        if (response.Status != "Error")
        {
          eventLog.TempGuid =  response.Guid;
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.InProcess;
          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionSendContainer, Resources.InfoContainerSent);
        }
        else
        {
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.Error;
          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionSendContainer, Resources.ErrorProcessingFunctionFormat(response.Message));
        }
        eventLog.Save();
        
        // Если контейнер создается по описи, завершить итерацию.
        if (isCaseInventory)
          return eventLog;
      }
      
      // -------------------------------------
      // Запросить статус обработки контейнера в архивной системе.
      // -------------------------------------
      if (eventLog.CurrentState == Container.TransferEventLog.CurrentState.InProcess && string.IsNullOrEmpty(eventLog.LTADocumentUrl))
      {
        // Получить статус в архивной системе.
        var response = DirRX.Storage.Structures.Module.ResultAnswer.Create();
        
        if (currentSystemIsArchive)
        {
          response = DirRX.Storage.PublicFunctions.Module.GetStatusInfo(eventLog.TempGuid);
        }
        else
        {
          response.Status = Functions.Module.GetContainerStatus(eventLog.TempGuid);
        }
        
        Logger.DebugFormat("LTA. Статус обработки контейнера {0}", response.Status);
        
        if (response.Status == "Complete")
        {
          // Сформировать ссылку на архивный документ и поставить статус "Контейнер принят" в исходной системе.
          if (!currentSystemIsArchive)
            eventLog.LTADocumentUrl = this.GetArchiveDocumentUrl(eventLog.Document.Id);

          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionSendContainer, Resources.InfoContainerAccepted);
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.Accepted;
          eventLog.Save();
        }
        else if (response.Status == "Error")
        {
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.Error;
          Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionSendContainer, Resources.ErrorProcessingFunctionFormat(response.Message));
          eventLog.Save();
        }
        
        // Если контейнер создается по описи, завершить итерацию.
        if (isCaseInventory)
          return eventLog;
      }
      
      // -------------------------------------
      // Обработать исходный документ после получения подтверждения из архивной системы.
      // -------------------------------------
      if (eventLog.CurrentState == Container.TransferEventLog.CurrentState.Accepted)
      {
        var document = eventLog.Document;
        
        // Создать версию со ссылкой на архивный документ.
        if (!currentSystemIsArchive && !string.IsNullOrWhiteSpace(eventLog.LTADocumentUrl))
        {
          try
          {
            using (var memory = new MemoryStream())
            {
              using (var writer = new StreamWriter(memory))
              {
                writer.WriteLine("[InternetShortcut]");
                writer.WriteLine("URL=" + eventLog.LTADocumentUrl);
                
                // Ключевые слова прописываются в ярлык документа в ДА для полнотекстового поиска. При необходимости изменить.
                writer.WriteLine(string.Format("keywords={0}, {1} №{2} от {3}, {4}", document.Name, document.DocumentKind.Name, document.RegistrationNumber, document.RegistrationDate, document.Note));
                writer.Flush();

                var newVersion = document.Versions.AddNew();
                newVersion.Body.Write(memory);
                newVersion.Note = Resources.LTAVersionNote;
                newVersion.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("url");
                document.Save();
              }
            }
            
            eventLog.CurrentState = Container.TransferEventLog.CurrentState.Complete;
            Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionPostprocessDocument, Resources.InfoArchiveVersionCreated);
          }
          catch (Exception e)
          {
            eventLog.CurrentState = Container.TransferEventLog.CurrentState.Error;
            Functions.TransferEventLog.AddProcessingLog(eventLog,
                                                        Resources.ActionPostprocessDocument,
                                                        Resources.ErrorProcessingFunctionFormat(e.InnerException != null ? e.InnerException.Message : e.Message));
          }
        }
        else if (currentSystemIsArchive)
        {
          // Если ссылка не заполнена, записать в историю, что версия уже создана в исходном документе.
          var version = eventLog.Document.LastVersion;
          if (version.AssociatedApplication.Extension == "zip" && version.Note == Resources.LTAVersionNote)
            Functions.TransferEventLog.AddProcessingLog(eventLog, Resources.ActionPostprocessDocument, Resources.InfoSourceVersionCreated);
        }

        // Удалить все версии документа, кроме последней после успешого экспорта в ДА.
        if (document.HasVersions && !document.VersionsLocked)
        {
          while (true)
          {
            var ver = document.Versions.Where(v => v.Number != document.LastVersion.Number).FirstOrDefault();
            if (ver != null)
              document.DeleteVersion(ver);
            else
              break;
          }
        }
        else
          Logger.DebugFormat(Resources.ErrorVersionLockedFormat(document.Name, document.Id));
        
        // Удалить временный файл контейнера на диске.
        if (!string.IsNullOrEmpty(eventLog.FilePath) && File.Exists(eventLog.FilePath))
          File.Delete(eventLog.FilePath);
        
        if (eventLog.CurrentState != Container.TransferEventLog.CurrentState.Error)
          eventLog.CurrentState = Container.TransferEventLog.CurrentState.Complete;

        eventLog.Save();
        
        // Отнять права на исходный документ.
        this.ChangeAccessRightsToRead(document);
      }
      return eventLog;
    }

    // Изменить права всех пользователей документа на "Чтение".
    private void ChangeAccessRightsToRead(Sungero.Docflow.IOfficialDocument document)
    {
      var documentAccessRights = document.AccessRights;
      foreach (var accessRight in documentAccessRights.Current)
      {
        if (accessRight.AccessRightsType != DefaultAccessRightsTypes.Read)
        {
          documentAccessRights.Revoke(accessRight.Recipient, accessRight.AccessRightsType);
          documentAccessRights.Grant(accessRight.Recipient, DefaultAccessRightsTypes.Read);
        }
      }
      documentAccessRights.Save();
    }
    
    /// <summary>
    /// Сформировать Url документа в долговременном архиве.
    /// </summary>
    /// <param name="documentId">ИД документа в системе-источнике.</param>
    /// <returns>Url документа.</returns>
    [Public, Remote]
    public virtual string GetArchiveDocumentUrl(int documentId)
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      return string.Format("{0}/GetDocumentUrl(source='{1}',uid='{2}')", settings.WebApiUrl, settings.SourceUid, documentId);
    }
    
    /// <summary>
    /// Подготовить документы для передачи в архив.
    /// </summary>
    [Public]
    public virtual void PrepareAndProcessArchiveDocuments()
    {
      // Для каждого правила обработки с автоматическим запуском.
      foreach (var rule in Container.SelectionRules.GetAll(x => x.Status == Container.SelectionRule.Status.Active).OrderBy(x => x.Priority.GetValueOrDefault()).ThenBy(x => x.Id))
      {
        // Получить список документов.
        var documents = Functions.SelectionRule.GetDocumentsByRule(rule).ToList();
        
        // Отправить в обработку.
        foreach (var document in documents)
          Functions.SelectionRule.EnqueueDocumentByRule(rule, document);
      }
    }

    /// <summary>
    /// Получить ответственного за администрирование ДА.
    /// </summary>
    /// <returns>Роль.</returns>
    [Public]
    public virtual IRecipient GetAdmin()
    {
      return Roles.GetAll(g => g.Name == "Администраторы").FirstOrDefault();
    }
    
    /// <summary>
    /// Отправить уведомление администратору об ошибках обработки документов.
    /// </summary>
    /// <param name="inventoryId">ИД сдаточной описи.</param>
    [Public]
    public virtual void SendErrorNotificationForArchiveDocuments(int? inventoryId)
    {
      // Список документов с ошибками.
      var errorContainers = Container.TransferEventLogs.GetAll(x => x.Status == Container.TransferEventLog.Status.Active &&
                                                               x.CurrentState == Container.TransferEventLog.CurrentState.Error);
      
      if (inventoryId.HasValue && inventoryId.Value > 0)
        errorContainers = errorContainers.Where(x => x.InventoryId == inventoryId.Value);
      
      if (errorContainers.Any())
      {
        var simpleTask = Sungero.Workflow.SimpleTasks.Create();
        simpleTask.Subject = Resources.ErrorNoticeSubject;
        
        if (inventoryId.HasValue)
          simpleTask.Subject += Resources.ErrorInventoryLabelFormat(inventoryId);
        
        var step = simpleTask.RouteSteps.AddNew();
        step.AssignmentType = Sungero.Workflow.SimpleTask.AssignmentType.Notice;
        step.Performer = this.GetAdmin();
        
        simpleTask.Save();
        simpleTask.Start();
      }
    }
    
    #endregion
    
    #region Создание контейнера
    
    /// <summary>
    /// Сформировать zip-контейнер для передачи документа в долговременный архив.
    /// </summary>
    /// <param name="systemCode">Код системы.</param>
    /// <param name="document">Документ.</param>
    /// <param name="type">Тип архивного документа.</param>
    /// <param name="containerFile">Путь к файлу контейнера.</param>
    /// <returns>Структура, содержащая данные о контейнере.</returns>
    [Public]
    public virtual Structures.Module.IContainer CreateContainer(string systemCode, Sungero.Docflow.IOfficialDocument document, string type, string containerFile)
    {
      // Сформировать данные для описателя контейнера.
      var containerInfo = Structures.Module.Container.Create();
      
      // Создать временную папку для хранения локальных файлов контейнера.
      var containerPath = Path.GetTempPath() + (!string.IsNullOrWhiteSpace(containerFile) ?
                                                Path.GetFileNameWithoutExtension(containerFile) :
                                                string.Format(@"out_container_{0}", document.Id));
      try
      {
        if (Directory.Exists(containerPath))
          Directory.Delete(containerPath, true);
        
        Directory.CreateDirectory(containerPath);
      }
      catch (Exception e)
      {
        containerInfo.Error = e.Message;
        return containerInfo;
      }
      
      // Код системы не может быть пустым.
      if (string.IsNullOrWhiteSpace(systemCode))
      {
        containerInfo.Error = Resources.ErrorNoSystemCodeSpecified;
        return containerInfo;
      }
      
      // Заполнить основные свойства контейнера.
      containerInfo.Uid = string.Format("{{{0}}}{{{1}}}", systemCode, document.Id);
      containerInfo.Type = type;
      containerInfo.Source = systemCode;
      containerInfo.Created = Sungero.Core.Calendar.Now.ToString(System.Globalization.CultureInfo.InvariantCulture);
      
      var error = string.Empty;
      try
      {
        // Экспортировать основной документ.
        containerInfo.Document = this.CreateDocumentInfo(document, containerPath, true);
        
        // Проверить заполненность вдадельца (обязательный реквизит).
        if (string.IsNullOrEmpty(containerInfo.Document.Owner))
          error = Resources.OwnerNotSpecified;
        else
        {
          
          // Экпортировать приложения.
          if (document.HasRelations)
          {
            containerInfo.Attachments = new List<Structures.Module.IDocument>();
            
            foreach (var relation in Sungero.Content.DocumentRelations.GetAll(x => Equals(x.Source.Id, document.Id) && Sungero.Docflow.OfficialDocuments.Is(x.Target)))
            {
              var relatedDocument = Sungero.Docflow.OfficialDocuments.As(relation.Target);
              var documentInfo = this.CreateDocumentInfo(relatedDocument, containerPath, false);
              containerInfo.Attachments.Add(documentInfo);
            }
          }
          
          // Сформировать PDF/A файл.
          var fileName = Constants.Module.PreviewFileName;
          var message = this.ConvertToPdfA(document, Path.Combine(containerPath, fileName));
          if (string.IsNullOrEmpty(message))
          {
            containerInfo.Preview = Structures.Module.Preview.Create(fileName);
            
            // Сохранить описатель в формате json.
            Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings()
            {
              Formatting = Newtonsoft.Json.Formatting.Indented,
              NullValueHandling = NullValueHandling.Ignore
            };

            var jsonText = JsonConvert.SerializeObject(containerInfo, settings);
            using (StreamWriter fs = File.CreateText(Path.Combine(containerPath, Constants.Module.ContainerInfoFileName)))
              fs.WriteLine(jsonText);
            
            // Запаковать контейнер в zip-архив.
            if (File.Exists(containerFile))
              File.Delete(containerFile);
            
            using (ZipFile zip = new ZipFile(containerFile, Encoding.UTF8))
            {
              zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed;
              zip.AddDirectory(containerPath);
              zip.Save();
            }
            
          }
          else
            error = Resources.ErrorProcessingFunctionFormat(message);
        }
      }
      catch (Exception e)
      {
        Logger.Error(e.ToString());
        error = Resources.ErrorProcessingFunctionFormat(e.InnerException != null ? e.InnerException.Message : e.Message);
      }
      
      // Удалить временную папку.
      Directory.Delete(containerPath, true);
      
      if (!string.IsNullOrEmpty(error))
        containerInfo.Error = error;
      
      return containerInfo;
    }

    /// <summary>
    /// Создать описание документа для долговременного архива.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <param name="folder">Имя папки для выгрузки (без завершающего слэша).</param>
    /// <param name="needMeta">Выгружать метаданные.</param>
    /// <returns>Структура с описанием документа.</returns>
    [Public]
    public virtual Structures.Module.IDocument CreateDocumentInfo(Sungero.Docflow.IOfficialDocument document, string folder, bool needMeta = true)
    {
      var result = Structures.Module.Document.Create();
      var docNamePrefix = string.Format("minorDocument.{0}", document.Id);
      
      // Информация о карточке документа.
      if (needMeta == true)
      {
        result.Uid = document.Id.ToString();
        result.Kind = document.DocumentKind.Id.ToString();
        result.Name = document.Name;
        
        var department = document.Department;
        if (department == null)
        {
          var employee = Sungero.Company.Employees.GetAll(u => Equals(u, document.Author)).FirstOrDefault();
          if (employee != null)
            department = employee.Department;
        }
        
        if (department != null)
          result.Owner = department.Id.ToString();
        
        result.Registration = Structures.Module.Registration.Create(document.RegistrationNumber,
                                                                    document.RegistrationDate.HasValue ? document.RegistrationDate.Value.ToString(CultureInfo.InvariantCulture) : null);
        
        if (document.CaseFile != null)
          result.CaseFile = document.CaseFile.Id.ToString();
        
        result.Requisites = this.GetDocumentRequisites(document);
        
        docNamePrefix = string.Format("mainDocument.{0}", document.Id);
      }

      // Ссылка на файл с телом и на файлы электронной подписи.
      if (document.HasVersions)
      {
        var fileName = string.Format("{0}.{1}", docNamePrefix, document.AssociatedApplication.Extension);
        var version = document.LastVersion;
        var exportPath = Path.Combine(folder, fileName);
        
        using (var file = new System.IO.FileStream(exportPath, FileMode.Create))
        {
          using (var sourceStream = version.Body.Read())
            sourceStream.CopyTo(file);
        }

        if (File.Exists(exportPath))
          result.LocalFile = fileName;
        
        result.Signatures = this.ExportSignatures(version, folder, docNamePrefix);
      }
      
      return result;
    }
    
    /// <summary>
    /// Дополнительные реквизиты документа, которые необходимо добавить в метаданные контейнера.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <returns>Список дополнительных реквизитов.</returns>
    [Public]
    public virtual List<Structures.Module.IRequisite> GetDocumentRequisites(Sungero.Docflow.IOfficialDocument document)
    {
      var requisiteList = new List<Structures.Module.IRequisite>();
      
      if (!string.IsNullOrEmpty(document.Note))
        requisiteList.Add(new Structures.Module.Requisite() { Name = "Note", Value = document.Note });
      
      if (document.OurSignatory != null && !string.IsNullOrEmpty(document.OurSignatory.Name))
        requisiteList.Add(new Structures.Module.Requisite() { Name = "OurSignatory", Value = document.OurSignatory.Name });
      
      return requisiteList;
    }
    
    /// <summary>
    /// Получить список типов контейнеров из ДА.
    /// </summary>
    /// <returns>Список типов контейнеров.</returns>
    [Public]
    public virtual List<string> GetArchiveDocsTypes()
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      
      if (settings.ArchiveStorage == Container.ArchiveSetting.ArchiveStorage.SourceSystem)
      {
        // Если архив используется в системе-источнике, получить список типов непосредственно.
        return Storage.PublicFunctions.Module.GetArchiveDocumentsList();
      }
      else
      {
        // Получить список типов, используя WebApi.
        var url = string.Format("{0}/GetArchiveDocumentTypes", settings.WebApiUrl);
        var result = this.ApiWebRequest(url, "GET", null, settings.WebApiAuthentication);
        var containerTypeList = JObject.Parse(result.Message)["Message"].ToString();
        return containerTypeList.Split(',').ToList();
      }
    }
    
    /// <summary>
    /// Экспортировать электронные подписи версии документа.
    /// </summary>
    /// <param name="version">Версия документа.</param>
    /// <param name="folder">Папка экспорта ЭП.</param>
    /// <param name="filenamePrefix">Префикс имени файла экспортируемой ЭП.</param>
    /// <returns>Список электронных подписей.</returns>
    public virtual List<Structures.Module.ISignature> ExportSignatures(Sungero.Content.IElectronicDocumentVersions version, string folder, string filenamePrefix = "sign")
    {
      // Выгрузить электронные подписи.
      var result = new List<Structures.Module.ISignature>();
      
      var signatures = Sungero.Core.Signatures.Get(version);
      if (signatures.Any())
      {
        foreach (var signature in signatures)
        {
          var signatureInfo = Structures.Module.Signature.Create();
          var signatureFormat = Signatures.GetSignatureInfo(signature).SignatureFormat;
          
          if (signatureFormat != SignatureFormat.Hash)
          {
            var signatureData = signature.GetDataSignature();
            
            // Проверить достоверность подписи.
            using (var memory = new System.IO.MemoryStream())
            {
              version.Body.Read().CopyTo(memory);
              if (ExternalSignatures.Verify(signatureData, memory).Result != Sungero.Core.SignatureVerificationResult.Success)
                throw new Exception(Resources.ErrorSignatureNotValidFormat(signature.SignatoryFullName, signature.SigningDate));
            }
            
            var fileName = string.Format("{0}.{1}.sig", filenamePrefix, signature.Id);
            File.WriteAllBytes(Path.Combine(folder, fileName), signatureData);
            signatureInfo.LocalFile = fileName;
          }
          else
          {
            // Для простых подписей сохранить информацию о подписанте.
            signatureInfo.FullName = signature.SignatoryFullName;
            signatureInfo.Date = signature.SigningDate.ToString(CultureInfo.InvariantCulture);
          }
          
          result.Add(signatureInfo);
        }
      }
      return result;
    }
    
    /// <summary>
    /// Получить хэш файла.
    /// </summary>
    /// <param name="filename">Имя файла.</param>
    /// <returns>Строка со значением хэш.</returns>
    public virtual string GetFileHash(string filename)
    {
      var stringBuilder = new StringBuilder();
      using (MD5 md5 = MD5.Create())
      {
        using (FileStream fs = File.OpenRead(filename))
        {
          byte[] hash = md5.ComputeHash(fs);
          for (int i = 0; i < hash.Length; i++)
            stringBuilder.Append(hash[i].ToString("X2"));
        }
      }
      return stringBuilder.ToString();
    }
    
    #endregion
    
    #region Обмен данными с архивной системой

    /// <summary>
    /// Создать запрос в архивную систему.
    /// </summary>
    /// <returns>Задача "Запрос в архив".</returns>
    [Remote, Public]
    public virtual IArchiveRequestTask CreateArchiveRequestTask()
    {
      return Container.ArchiveRequestTasks.Create();
    }
    
    /// <summary>
    /// Отправить zip-контейнер в долговременный архив.
    /// </summary>
    /// <param name="filename">Полный путь до контейнера.</param>
    /// <param name="hash">Контрольная сумма файла с контейнером.</param>
    /// <returns>Ответ сервиса в виде json-строки.</returns>
    [Public]
    public virtual string SendContainer(string filename, string hash = "")
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      
      // Отправить содержимое или ссылку в зависимости от настройки.
      if (settings.SendingMethod == Container.ArchiveSetting.SendingMethod.Link)
      {
        var url = string.Format("{0}/ImportContainerFromLink", settings.WebApiUrl);
        Logger.Debug(Resources.RequestSendingFormat(url));
        var data = DirRX.Container.Structures.Module.ApiWebJsonList.Create();
        data.Lines = new List<DirRX.Container.Structures.Module.IApiWebJsonLine>();
        data.Lines.Add(DirRX.Container.Structures.Module.ApiWebJsonLine.Create("content", filename));
        data.Lines.Add(DirRX.Container.Structures.Module.ApiWebJsonLine.Create("hash", hash));
        var result = this.ApiWebRequest(url, "POST", data, settings.WebApiAuthentication);
        return result.Message;
      }
      else if (settings.SendingMethod == Container.ArchiveSetting.SendingMethod.Content)
      {
        var url = string.Format("{0}/ImportContainer", settings.WebApiUrl);
        Logger.Debug(Resources.RequestSendingFormat(url));
        var data = DirRX.Container.Structures.Module.ApiWebJsonList.Create();
        data.Lines = new List<DirRX.Container.Structures.Module.IApiWebJsonLine>();
        data.Lines.Add(DirRX.Container.Structures.Module.ApiWebJsonLine.Create("content", filename));
        var result = this.ApiWebRequest(url, "POST", data, settings.WebApiAuthentication, true);
        return result.Message;
      }
      else
        return "{\"Status\":\"Error\",\"Message\":\"Некорректные настройки долговременного архива\"}";
    }
    
    /// <summary>
    /// Получить статус импорта контейнера в ДА.
    /// </summary>
    /// <param name="guid">Уникальный идентификатор контейнера.</param>
    /// <returns>Статус импорта в ДА.</returns>
    [Remote(IsPure = true), Public]
    public virtual string GetContainerStatus(string guid)
    {
      var result = string.Empty;
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      var url = string.Format("{0}/GetStatus(guid='{1}')", settings.WebApiUrl, guid);
      var answer = this.ApiWebRequest(url, "GET", null, settings.WebApiAuthentication);
      var json = JObject.Parse(answer.Message);
      if (json != null)
        result = json.Value<string>("Status");
      return result;
    }
    
    /// <summary>
    /// Получить число контейнеров для сдаточной описи.
    /// </summary>
    /// <param name="inventoryId">ИД описи.</param>
    /// <param name="status">Статус обработки конейнеров.</param>
    /// <returns>Число контейнеров.</returns>
    [Public]
    public virtual int GetNumberOfInventoryContainers(int inventoryId, string status)
    {
      var containers = TransferEventLogs.GetAll(x => x.InventoryId == inventoryId);
      
      if (status == "Error")
        containers = containers.Where(x => x.CurrentState == DirRX.Container.TransferEventLog.CurrentState.Error);
      else if (status == "InProcess")
      {
        var processedStates = new List<Sungero.Core.Enumeration>() {
          DirRX.Container.TransferEventLog.CurrentState.Error,
          DirRX.Container.TransferEventLog.CurrentState.Accepted,
          DirRX.Container.TransferEventLog.CurrentState.Complete };
        
        containers = containers.Where(x => x.CurrentState.HasValue && !processedStates.Contains(x.CurrentState.Value));
      }

      return containers.Count();
    }
    #endregion
    
    #region Синхронизация
    /// <summary>
    /// Получить данные для синхронизации справочников из ДА.
    /// </summary>
    /// <returns>Данные в виде json-строки.</returns>
    [Remote(IsPure = true), Public]
    public virtual string GetSyncSettings()
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      var url = string.Format("{0}/GetSyncSettings(source='{1}')", settings.WebApiUrl, settings.SourceUid);
      var result = this.ApiWebRequest(url, "GET", null, settings.WebApiAuthentication);
      var response = result.Message;
      
      if (result.Code == "OK" && !string.IsNullOrEmpty(response) && response != @"{}")
      {
        var json = JObject.Parse(response);
        if (json != null)
          return json.Value<string>("Data");
      }
      
      return string.Empty;
    }

    /// <summary>
    /// Отправить данные для синхронизации в ДА.
    /// </summary>
    /// <param name="jsonData">Данные.</param>
    /// <returns>Ответ сервиса в виде json-строки.</returns>
    [Public]
    public virtual string SendSyncData(string jsonData)
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      var url = string.Format("{0}/SendSyncData", settings.WebApiUrl);
      var data = DirRX.Container.Structures.Module.ApiWebJsonList.Create();
      data.Lines = new List<DirRX.Container.Structures.Module.IApiWebJsonLine>();
      data.Lines.Add(DirRX.Container.Structures.Module.ApiWebJsonLine.Create("content", jsonData));
      var result = this.ApiWebRequest(url, "POST", data, settings.WebApiAuthentication);
      return result.Message;
    }

    /// <summary>
    /// Отправить запрос в архив на получение информации или доступа.
    /// </summary>
    /// <param name="jsonData">Запрос в виде json-строки.</param>
    /// <returns>ИД задачи на обработку запроса.</returns>
    [Remote(IsPure = true), Public]
    public virtual int SendArchiveRequest(string jsonData)
    {
      var taskId = 0;
      var response = DirRX.Storage.Structures.Module.ResultAnswer.Create();
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      
      if (settings.ArchiveStorage == Container.ArchiveSetting.ArchiveStorage.SourceSystem)
      {
        response = Storage.PublicFunctions.Module.ProcessLTARequest(jsonData);
      }
      else
      {
        var url = string.Format("{0}/SendRequest", settings.WebApiUrl);
        var data = DirRX.Container.Structures.Module.ApiWebJsonList.Create();
        data.Lines = new List<DirRX.Container.Structures.Module.IApiWebJsonLine>();
        data.Lines.Add(DirRX.Container.Structures.Module.ApiWebJsonLine.Create("content", jsonData));
        var result = this.ApiWebRequest(url, "POST", data, settings.WebApiAuthentication);
        var json = JObject.Parse(result.Message);
        response.Guid = json.Value<string>("Guid");
      }
      
      if (!string.IsNullOrEmpty(response.Guid))
        taskId = Int32.Parse(response.Guid);
      
      return taskId;
    }

    /// <summary>
    /// Получить результаты запроса в архив.
    /// </summary>
    /// <param name="taskId">ИД задачи на обработку запроса в ДА.</param>
    /// <returns>Результат обработки запроса в виде json-строки.</returns>
    [Public]
    public virtual string GetArchiveRequestResult(int taskId)
    {
      var responseText = string.Empty;
      var response = DirRX.Storage.Structures.Module.ResultAnswer.Create();
      
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      
      if (settings.ArchiveStorage == Container.ArchiveSetting.ArchiveStorage.SourceSystem)
      {
        response = Storage.PublicFunctions.Module.GetArchiveRequestStatus(taskId);
        responseText = response.Data;
      }
      else
      {
        var url = string.Format("{0}/GetRequestStatus(taskId={1})", settings.WebApiUrl, taskId);
        
        var result = this.ApiWebRequest(url, "GET", null, settings.WebApiAuthentication);
        
        if (result.Code == "OK")
          responseText = result.Message;
      }
      
      if (!string.IsNullOrEmpty(responseText) && responseText != @"{}")
      {
        var json = JObject.Parse(responseText);
        if (json != null)
          return json.Value<string>("Data");
        else
          Logger.Debug("Не смог распарсить");
      }

      return string.Empty;
    }
    
    /// <summary>
    /// Получить схему проверки контейнера из ДА.
    /// </summary>
    /// <param name="archiveDocumentType">Тип архивного документа.</param>
    /// <returns>Данные в виде json-строки.</returns>
    [Remote(IsPure = true), Public]
    public virtual string GetValidationScheme(string archiveDocumentType)
    {
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      var url = string.Format("{0}/GetValidationScheme(documentType='{1}')", settings.WebApiUrl, archiveDocumentType);
      var result = this.ApiWebRequest(url, "GET", null, settings.WebApiAuthentication);
      var response = result.Message;
      if (result.Code == "OK" && !string.IsNullOrEmpty(response) && response != @"{}")
      {
        var json = JObject.Parse(response);
        if (json != null)
          return json.Value<string>("Data");
      }
      return string.Empty;
    }
    
    #endregion
    
    #region Настройки
    /// <summary>
    /// Установить значение параметра.
    /// </summary>
    /// <param name="paramKey">Имя параметра.</param>
    /// <param name="paramValue">Значения параметра.</param>
    /// <remarks>Обертка для вызова с клиента функции InsertOrUpdateDocflowParam.</remarks>
    [Remote, Public]
    public virtual void SetDocflowParam(string paramKey, string paramValue)
    {
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(paramKey, paramValue);
    }
    
    /// <summary>
    /// Получить записи справочника, измененные с последней синхронизации.
    /// </summary>
    /// <param name="entityName">Имя справочника.</param>
    /// <param name="syncDate">Дата последней синхронизации.</param>
    /// <returns>Список записей.</returns>
    public IQueryable<Sungero.Domain.Shared.IEntity> GetChangedEntities(string entityName, DateTime? syncDate)
    {
      // Если дата не указана, получить все записи.
      var lastSyncDate = syncDate.HasValue ? syncDate.Value : Sungero.Core.Calendar.SqlMinValue;
      
      var assembly = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("Sungero.Domain.Interfaces")).FirstOrDefault();
      
      var entityType = assembly.GetTypes().Where(type => type.IsEntity() && !type.IsChildEntity() &&
                                                 type.GetEntityMetadata().GetOriginal().Name.ToLower() == entityName.ToLower())
        .FirstOrDefault();
      
      var entityTypeMetadata = entityType.GetEntityMetadata();
      
      var entityGuid = entityTypeMetadata.GetOriginal().NameGuid;
      
      var originalTypeGuid = entityGuid.GetOriginalTypeGuid();
      var historyType = entityTypeMetadata.HistoryTypeGuid.GetTypeByGuid();
      
      using (var session = new Sungero.Domain.Session())
      {
        var entities = session.GetAll(entityType).Where(s => Sungero.Domain.Session.GetAllFromCurrentSession(historyType).Cast<IHistory>()
                                                        .Any(h => h.EntityType == originalTypeGuid && h.EntityId == s.Id && h.HistoryDate.Value >= lastSyncDate))
          .OrderBy(s => s.Id);
        
        return entities;
      }
      
    }
    
    /// <summary>
    /// Синхронизировать данные системы-источника.
    /// </summary>
    /// <param name="setting">Запись справочника с настройками системы-источника.</param>
    /// <remarks>Обертка для вызова с клиента функции SenSyncData.</remarks>
    [Public]
    public virtual void SynchronizeChangedData(Container.IArchiveSetting setting)
    {
      // Получить список измененных сущностей для каждого из синхронизируемых типов.
      foreach (var item in setting.SyncEntities)
      {
        var entities = Container.Functions.Module.GetChangedEntities(item.Type, item.SyncDate);
        
        Logger.Debug(" === Число измененных сущностей: " + entities.Count());
        
        if (entities.Any())
        {
          
          foreach (var entity in entities)
          {
            var syncData = Container.Functions.ArchiveSetting.GetSyncData(setting, entity);
            
            if (syncData != string.Empty)
            {
              var message = Container.PublicFunctions.Module.SendSyncData(syncData);
            }
            else
              Logger.DebugFormat("Не удалось синхронизировать запись справочника {0} ИД {1}", entity.Info.Name, entity.Id);
          }
          item.SyncDate = Sungero.Core.Calendar.Now;
        }
      }
      setting.Save();
    }
    #endregion
    
    #region Преобразование в PDF/A
    /// <summary>
    /// Проверить поддерживает ли основной документ входное расширение файла.
    /// </summary>
    /// <param name="ext">Расширение документа.</param>
    /// <returns>True/false.</returns>
    public virtual bool IsSupportConvertPdfExtension(string ext)
    {
      var extensions = new List<string>() { "pdf", "docx", "doc", "rtf", "xls", "xlsx", "xlsm", "odt", "odp", "ods", "ppt", "pptx", "jpg", "jpeg", "png", "bmp", "tif", "tiff" };
      return extensions.Any(v => v.Contains(ext.ToLower()));
    }
    
    /// <summary>
    /// Проверить версию документа на PDF формат.
    /// </summary>
    /// <param name="version">Версия документа.</param>
    /// <returns>True - если версия документа в формате PDF.</returns>
    public bool IsPdfVersion(Sungero.Content.IElectronicDocumentVersions version)
    {
      return version.AssociatedApplication.Extension.ToLower() == "pdf";
    }
    
    /// <summary>
    /// Получить путь для экспорта временного файла.
    /// </summary>
    /// <param name="extension">Расширение временного файла.</param>
    /// <returns>Полный путь до временного файла.</returns>
    public string GetTempFilePath(string extension)
    {
      return Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + "." + extension);
    }
    
    /// <summary>
    /// Получить путь до тела выгржуенного документа в формате PDF.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <returns>Путь до тела документа.</returns>
    public string GetPdfDocumentPath(Sungero.Docflow.IOfficialDocument document)
    {
      if (this.IsPdfVersion(document.LastVersion))
      {
        var path = GetTempFilePath(document.LastVersion.AssociatedApplication.Extension);
        document.LastVersion.Export(path);
        return path;
      }
      return this.DocumentToPdf(document, true);
    }
    
    /// <summary>
    /// Конвертировать документ в pdf/a.
    /// </summary>
    /// <param name="inputStream">Исходный документ в виде потока байт.</param>
    /// <param name="extension">Расширение документа.</param>
    /// <returns>Конвертированный документ в виде потока байт</returns>
    [Public]
    public virtual System.IO.MemoryStream ConvertStreamToPdfA(System.IO.MemoryStream inputStream, string extension)
    {
      var pdfaDocumentStream = new System.IO.MemoryStream();
      try
      {
        // Заполнить параметры конвертации: расширение исходного файла и формат pdf/a.
        var paramsConvert = new PdfConverter.Models.ConvertParameters();
        paramsConvert.FileExtension = extension;
        paramsConvert.TargetFormat = PdfConverter.Models.PdfFormat.PDF_A_1B;
        var archiveSetting = PublicFunctions.ArchiveSetting.GetSettings();
        if (archiveSetting.PDFAVersion == Container.ArchiveSetting.PDFAVersion.v1A)
          paramsConvert.TargetFormat = PdfConverter.Models.PdfFormat.PDF_A_1A;
        
        var logger = new PdfConvertLogger.Wrapper(Sungero.Core.Logger.Error, Sungero.Core.Logger.Debug);
        var converter = new PdfConverter.Converter();
        inputStream.Seek((Int64)0, SeekOrigin.Begin);
        converter.ConvertToPdfA(inputStream, pdfaDocumentStream, paramsConvert, logger);
      }
      catch (Exception e)
      {
        Logger.DebugFormat("ConvertStreamToPdfA. {0}", e.InnerException != null ? e.InnerException.Message : e.Message);
        Logger.Debug(e.ToString());
      }
      
      return pdfaDocumentStream;
    }
    
    /// <summary>
    /// Преобразовать документ в PDF-файл.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <param name="setSignatureMark">Признак простановки штампа ЭП на документ.</param>
    /// <returns>Полный путь до преобразованного pdf-файла.</returns>
    [Public]
    public virtual string DocumentToPdf(Sungero.Docflow.IOfficialDocument document, bool setSignatureMark = false)
    {
      var result = string.Empty;
      
      if (document.HasVersions)
      {
        var version = document.LastVersion;
        var extension = version.BodyAssociatedApplication.Extension;
        
        if (this.IsSupportConvertPdfExtension(extension))
        {
          System.IO.MemoryStream pdfDocumentStream = null;
          using (var inputStream = new System.IO.MemoryStream())
          {
            version.Body.Read().CopyTo(inputStream);
            inputStream.Seek((Int64)0, SeekOrigin.Begin);
            try
            {
              // Конвертировать в PDF. Заполнить PDF-метаданные из карточки документа.
              pdfDocumentStream = this.ConvertStreamToPdfA(inputStream, extension);
              var pdfDocument = new Pdf.Document(pdfDocumentStream);
              pdfDocument.RemovePdfaCompliance();
              pdfDocument.Info.Author = document.Author.DisplayValue;
              pdfDocument.Info.CreationDate = document.Created.HasValue ? document.Created.Value : Sungero.Core.Calendar.Now;
              pdfDocument.Info.ModDate = document.Modified.HasValue ? document.Modified.Value : pdfDocument.Info.CreationDate;
              pdfDocument.Save(pdfDocumentStream, Pdf.SaveFormat.Pdf);

              if (setSignatureMark)
              {
                // Ставить штамп если есть утверждающие подписи.
                var versionSignatures = Signatures.Get(version)
                  .Where(s => s.IsExternal != true && s.SignatureType == SignatureType.Approval)
                  .ToList();
                
                if (versionSignatures.Any())
                {
                  var pdfConverter = new Sungero.AsposeExtensions.Converter();
                  var signatureMark = Sungero.Docflow.PublicFunctions.Module.GetSignatureMarkAsHtml(document, version.Id);
                  pdfDocumentStream = (System.IO.MemoryStream)pdfConverter.AddSignatureMark(pdfDocumentStream, extension, signatureMark, "%signature_mark_place%", 10);
                }
              }
              
              var pdfFilename = this.GetTempFilePath("pdf");
              System.IO.File.WriteAllBytes(pdfFilename, pdfDocumentStream.ToArray());
              result = pdfFilename;
            }
            catch (Exception e)
            {
              Logger.Error(e.InnerException != null ? e.InnerException.Message : e.Message);
              Logger.Debug(e.ToString());
            }
          }
          
          if (pdfDocumentStream != null)
            pdfDocumentStream.Close();
        }
        else
        {
          Logger.DebugFormat("Расширение {0} документа {1} для преобразования в pdf не поддерживается.", extension, document.Name);
        }
      }
      else
        Logger.DebugFormat("У документа ИД {0} отсутствуют версии.", document.Id);
      
      return result;
    }
    
    /// <summary>
    /// Склеить несколько файлов PDF в один.
    /// </summary>
    /// <param name="inFiles">Список полных путей до pdf-файлов для склеивания.</param>
    /// <param name="outFile">Полный путь выходного pdf-файла.</param>
    /// <returns>Текст ошибки или пустую строку, если преобразование удалось.</returns>
    [Public]
    public virtual string MergePdf(List<string> inFiles, string outFile)
    {
      string result = string.Empty;
      if (inFiles.Count > 1)
      {
        bool mainDoc = true;
        try
        {
          PdfS.PdfDocument outputDocument = new PdfS.PdfDocument();
          
          var updateInfo = false;
          foreach (string file in inFiles)
          {
            PdfS.PdfDocument inputDocument = PdfS.IO.PdfReader.Open(file, PdfS.IO.PdfDocumentOpenMode.Import);
            
            // Заполнить метаданные из основного документа (предполагается, что он первый в списке).
            if (!updateInfo)
            {
              outputDocument.Info.Author = inputDocument.Info.Author;
              outputDocument.Info.CreationDate = inputDocument.Info.CreationDate;
              outputDocument.Info.ModificationDate = inputDocument.Info.ModificationDate;
              updateInfo = true;
            }
            
            int count = inputDocument.PageCount;
            for (int i = 0; i < count; i++)
            {
              PdfS.PdfPage page = inputDocument.Pages[i];
              outputDocument.AddPage(page);
            }
            mainDoc = false;
          }
          outputDocument.Save(outFile);
        }
        catch (Exception e)
        {
          result = GetInnerExceptionsMessages(e);
          if (mainDoc)
            result = Resources.PreviewNotCreated + ". " + result;
          Logger.ErrorFormat("Merging pdf error: {0}", result);
        }
      }
      else
      {
        File.Copy(inFiles[0], outFile, true);
      }
      
      return result;
    }

    /// <summary>
    /// Преобразовать файл(ы) PDF в формат PDF/A и склеить их в один файл.
    /// </summary>
    /// <param name="inFiles">Полные пути до pdf-файлов.</param>
    /// <param name="outFile">Полный путь до склееного pdf-файла.</param>
    /// <param name="version">Версия формата pdf/a.</param>
    /// <returns>Текст ошибки или пустая строку, если преобразование удалось.</returns>
    [Public]
    public virtual string ConvertFilesToPdfA(List<string> inFiles, string outFile, string version)
    {
      var result = this.MergePdf(inFiles, outFile);
      
      if (!result.Contains(Resources.PreviewNotCreated))
      {
        if (string.IsNullOrEmpty(result))
        {
          try
          {
            using (var inputStream = new MemoryStream())
            {
              var pdfDocument = new Pdf.Document(outFile);
              pdfDocument.Save(inputStream);
              inputStream.Seek((Int64)0, SeekOrigin.Begin);
              
              var outputStream = this.ConvertStreamToPdfA(inputStream, "pdf");
              if (outputStream != null)
              {
                File.WriteAllBytes(outFile, outputStream.ToArray());
                outputStream.Close();
              }
              else
                result = string.Format("Unable to convert file {0} to format PDF-A.", outFile);
            }
          }
          catch (Exception e)
          {
            result = e.InnerException != null ? e.InnerException.Message : e.Message;
            Logger.Debug(e.ToString());
          }
        }
      }
      else
      {
        result = Resources.PreviewNotCreated;
      }
      return result;
    }
    
    /// <summary>
    /// Преобразовать основной документ и его приложения в формат PDF/A.
    /// </summary>
    /// <param name="document">Документ для преобразования.</param>
    /// <param name="outFile">Полный путь до преобразуемого файла.</param>
    /// <returns>Текст ошибки или пустая строку, если преобразование удалось.</returns>
    [Public]
    public virtual string ConvertToPdfA(Sungero.Docflow.IOfficialDocument document, string outFile)
    {
      var result = string.Empty;
      Logger.Debug("=== Start PDF/A converting ===");

      List<string> inPdfFiles = new List<string>() { };
      var pdfaVersion = "1b";
      var settings = PublicFunctions.ArchiveSetting.GetSettings();
      pdfaVersion = settings.PDFAVersion.Value.Value;
      
      // Преобразовать в pdf основной документ.
      var documentPdfFile = this.GetPdfDocumentPath(document);
      if (!string.IsNullOrEmpty(documentPdfFile))
        inPdfFiles.Add(documentPdfFile);
      else
      {
        result = Container.Resources.ErrorConvertedToPdf;
        Logger.ErrorFormat(result);
        return result;
      }
      
      // Преобразовать в pdf связанные документы.
      foreach (var relation in Sungero.Content.DocumentRelations.GetAll(x => Equals(x.Source.Id, document.Id) && Sungero.Docflow.OfficialDocuments.Is(x.Target)))
      {
        var relatedDocument = Sungero.Docflow.OfficialDocuments.As(relation.Target);
        var relatedPdfFile = this.GetPdfDocumentPath(relatedDocument);
        if (!string.IsNullOrEmpty(relatedPdfFile))
          inPdfFiles.Add(relatedPdfFile);
      }
      
      // Склеить документы и преобразовать в PDF/A результат.
      result = this.ConvertFilesToPdfA(inPdfFiles, outFile, pdfaVersion);
      
      // Удалить временные pdf файлы.
      foreach (var file in inPdfFiles)
      {
        File.Delete(file);
      }
      
      return result;
    }
    #endregion
    
    #region Общие функции для работы с WebApi

    /// <summary>
    /// Отправить запрос на сервис интеграции.
    /// </summary>
    /// <param name="url">Полный url для вызова метода сервиса интеграции.</param>
    /// <param name="method">Метод отправки запроса - get/post.</param>
    /// <param name="data">Отправляемые данные в виде структуры.</param>
    /// <param name="authentication">Строка базовой аутентификации.</param>
    /// <param name="isSendFile">Отправить в запросе тело файла.</param>
    /// <returns>Структура с ответом сервиса интеграции.</returns>
    public virtual Structures.Module.IWSAnswer ApiWebRequest(string url, string method, DirRX.Container.Structures.Module.IApiWebJsonList data, string authentication, bool isSendFile = false)
    {
      var result = Structures.Module.WSAnswer.Create();
      var request = WebRequest.Create(url);
      request.Method = method;
      request.Headers.Add("Authorization", "Basic " + authentication);
      
      if (method.ToUpper() == "POST" && data != null)
      {
        request.ContentType = "application/json";
        byte[] postBytes;
        var jsonData = new JObject();
         
        if (isSendFile)
        {
          // имя файла для передачи в значении content 
          postBytes = File.ReadAllBytes(data.Lines[0].Value);
          jsonData.Add(data.Lines[0].Key, postBytes);
        }
        else
        {
          foreach (var pair in data.Lines)
          {
            jsonData.Add(pair.Key, pair.Value);
          }
        }
        postBytes = Encoding.UTF8.GetBytes(jsonData.ToString());
        request.ContentLength = postBytes.Length;
        Stream dataStream = request.GetRequestStream();
        dataStream.Write(postBytes, 0, postBytes.Length);
        dataStream.Close();
      }

      var response = (HttpWebResponse)request.GetResponse();
      result.Code = response.StatusCode.ToString();
      StreamReader reader = new StreamReader(response.GetResponseStream());
      result.Message = reader.ReadToEnd();
      response.Close();
      Logger.DebugFormat("web api request: {0}, answer: {1}, {2}", url, result.Code, result.Message);
      return result;
    }
    #endregion
    
    #region Служебные функции
    /// <summary>
    /// Собрать цепочку InnerExceptions в одну строку.
    /// </summary>
    /// <param name="e">Исключение.</param>
    /// <returns>Строка InnerExceptions исключений.</returns>
    private static string GetInnerExceptionsMessages(Exception e)
    {
      var result = e.InnerException != null ?
        string.Concat(e.InnerException.Message.TrimEnd('.'), ". ",  GetInnerExceptionsMessages(e.InnerException)) :
        string.Empty;
      return string.IsNullOrEmpty(result) ? e.Message : result;
    }
    
    /// <summary>
    /// Выполнить серверную функцию.
    /// </summary>
    /// <param name="moduleName">Имя решения и модуля.</param>
    /// <param name="functionName">Имя функции.</param>
    /// <param name="parameters">Массив параметров.</param>
    /// <returns>Результат выполнения функции.</returns>
    [Public]
    public virtual object ExecuteServerFunction(string moduleName, string functionName, object[] parameters)
    {
      if (string.IsNullOrEmpty(moduleName) || string.IsNullOrEmpty(functionName))
        throw new Exception("LTAContainer. ExecuteServerFunction. Function or module name not specified.");
      
      var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.Contains(string.Format("{0}.Server,", moduleName)));
      if (!assemblies.Any())
        throw new Exception(string.Format("LTAContainer. ExecuteServerFunction. Module \"{0}\" does not exist.", moduleName));
      
      var assembly = assemblies.First();
      var functionTypeName = string.Format("{0}.Functions.Module", moduleName);
      var function = assembly.GetTypes().FirstOrDefault(a => a.FullName == functionTypeName);
      if (function == null)
        throw new Exception(string.Format("LTAContainer. ExecuteServerFunction. Function \"{0}\" of module \"{1}\" does not exist.", functionName, moduleName));
      
      var method = function.GetMethod(functionName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
      if (method == null)
        throw new Exception(string.Format("LTAContainer. ExecuteServerFunction. Function \"{0}\" of module \"{1}\" does not exist.", functionName, moduleName));

      return method.Invoke(null, parameters);
    }
    
    /// <summary>
    /// Удалить контейнеры.
    /// </summary>
    /// <param name="transferEventIds">Список ИД записей справочника "Журнал передачи в архив".</param>
    [Remote]
    public virtual void DeleteContainers(List<int> transferEventIds)
    {
      var errorIds = new List<int>();
      foreach (var id in transferEventIds)
      {
        try
        {
          var item = Container.TransferEventLogs.Get(id);
          Container.TransferEventLogs.Delete(item);
        }
        catch
        {
          errorIds.Add(id);
        }
      }
      
      if (errorIds.Any())
        Logger.DebugFormat("Container. TransferEventLogs. Не удалось удалить записи ИД:", string.Join(",", errorIds));
    }
    
    /// <summary>
    /// Получить служебного пользователя.
    /// </summary>
    /// <returns>Пользователь с именем Integration Service, либо, при его отсутствии, Service User.</returns>
    public virtual Sungero.CoreEntities.IUser GetServiceUser()
    {
      return Users.GetAll(x => x.IsSystem == true && (x.Name == "Integration Service" || x.Name == "Service User")).OrderBy(x => x.Name).FirstOrDefault();
    }
    #endregion
  }
}