using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Linq;
using System.Security.Cryptography;
using Sungero.Core;
using Sungero.CoreEntities;
using Sungero.Domain.Shared;
using Sungero.Metadata;
using CommonLibrary;
using Newtonsoft.Json.Linq;
using Ionic.Zip;
using Compression = System.IO.Compression;

namespace DirRX.Storage.Server
{
  public class ModuleFunctions
  {
    
    #region Фонды
    
    /// <summary>
    /// Функция для получения последней даты для листа фонда.
    /// </summary>
    /// <param name="inventoryId">ИД сводной описи.</param>
    /// <param name="destroyed">Признак выбывшего дела.</param>
    /// <returns>Крайняя дата окончания дел в сводной описи.</returns>
    [Public]
    public static string GetInventoryEndDate(int inventoryId, bool destroyed)
    {
      var result = string.Empty;
      var caseFiles = DirRX.Storage.PublicFunctions.Module.GetCaseFilesForSheetReport(inventoryId, destroyed);
      
      var endDates = caseFiles.OrderByDescending(x => x.EndDate);
      
      var maxEndDate = endDates.FirstOrDefault();
      
      if (maxEndDate != null)
      {
        if (maxEndDate.EndDate != null)
        {
          result += maxEndDate.EndDate.Value.ToShortDateString();
        }
      }
      
      return result;
    }
    
    /// <summary>
    /// Функция для получения первой даты для листа фонда.
    /// </summary>
    /// <param name="inventoryId">ИД сводной описи.</param>
    /// <param name="destroyed">Признак выбывшего дела.</param>
    /// <returns>Крайняя дата включения дел в сводную опись.</returns>
    [Public]
    public static string GetInventoryBeginDate(int inventoryId, bool destroyed)
    {
      var result = string.Empty;
      var caseFiles = DirRX.Storage.PublicFunctions.Module.GetCaseFilesForSheetReport(inventoryId, destroyed);
      
      var beginDates = caseFiles.OrderBy(x => x.StartDate);
      var minDate = beginDates.FirstOrDefault();
      
      if (minDate != null)
      {
        if (minDate.StartDate != null)
        {
          result += minDate.StartDate.Value.ToShortDateString();
        }
      }
      
      return result;
    }
    
    /// <summary>
    /// Функция для получения основания для выбытия для листа фонда.
    /// </summary>
    /// <param name="inventoryId">ИД сводной описи.</param>
    /// <param name="destroyed">Признак выбывшего дела.</param>
    /// <returns>Основания выбытия дел.</returns>
    [Public]
    public static string GetDisposalReason(int inventoryId, bool destroyed)
    {
      var result = string.Empty;
      var inventory = DirRX.Storage.ConsolidatedInventories.GetAll(x => x.Id == inventoryId);
      
      // Получим все выбывшие дела из сводной описи.
      var caseFiles = DirRX.Storage.PublicFunctions.Module.GetCaseFilesForSheetReport(inventoryId, destroyed);
      
      foreach (var caseFile in caseFiles)
      {
        if (caseFile.LTADestructionActDirRX != null)
        {
          result += " " + caseFile.LTADestructionActDirRX.Name;
        }
      }
      
      return result;
    }
    
    /// <summary>
    /// Дела для листа фонда.
    /// </summary>
    /// <param name="consInventoryId">ИД сводной описи.</param>
    /// <param name="destroyed">Признак выбывшего документа.</param>
    /// <returns>Список дел.</returns>
    [Public]
    public IQueryable<DirRX.LongTermArchive.ICaseFile> GetCaseFilesForSheetReport(int consInventoryId, bool destroyed)
    {
      var inventory = DirRX.Storage.ConsolidatedInventories.GetAll(x => x.Id == consInventoryId);
      
      // Получим все выбывшие дела из сводной описи.
      return destroyed ? DirRX.LongTermArchive.CaseFiles.GetAll(x => x.LTAConsInventoryDirRX == inventory
                                                                && x.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.DestroyedDirRX)
        : DirRX.LongTermArchive.CaseFiles.GetAll(x => x.LTAConsInventoryDirRX == inventory
                                                 && x.LTAStageDirRX != DirRX.LongTermArchive.CaseFile.LTAStageDirRX.DestroyedDirRX);
    }
    
    [Public, Remote]
    public DirRX.Storage.IFundsSheet CreateFundsSheet(DirRX.Storage.IFund fund)
    {
      var document = DirRX.Storage.FundsSheets.GetAll(x => x.Fund == fund).FirstOrDefault();
      if (document == null)
      {
        using (new Sungero.Domain.Session(true, false))
        {
          document = Storage.FundsSheets.Create();
          document.Fund = fund;
          document.Subject = fund.Name;
          document.Save();
        }
      }
      // Сформировать тело документа из отчета.
      DirRX.Storage.PublicFunctions.FundsSheet.GenerateLastVersionFromReport(document);
      return document;
    }
    
    /// <summary>
    /// Поулчить спосок фондов на указанный период.
    /// </summary>
    /// <param name="year">Год периода.</param>
    /// <returns>Список документов "Список фондов".</returns>
    [Public]
    public IQueryable<Storage.IFundsList> GetFundsList(int year)
    {
      return Storage.FundsLists.GetAll(x => x.FundsDate.Value.Year == year);
    }
    
    /// <summary>
    /// Поулчить лист фонда.
    /// </summary>
    /// <param name="fund">Фонд.</param>
    /// <returns>документ "Лист фонда".</returns>
    [Public,Remote(IsPure=true)]
    public DirRX.Storage.IFundsSheet GetFundsSheet(DirRX.Storage.IFund fund)
    {
      return DirRX.Storage.FundsSheets.GetAll(x => x.Fund == fund).FirstOrDefault();
    }
    
    /// <summary>
    /// Получить фонды на указанный период.
    /// </summary>
    /// <param name="year">Год периода.</param>
    /// <returns>Список записей справочника "Фонды".</returns>
    [Public]
    public IQueryable<Storage.IFund> GetFundsToList(int year)
    {
      return Storage.Funds.GetAll(x => x.IncomeDate.Value.Year <= year);
    }
    
    /// <summary>
    /// Создание документа по отчету.
    /// </summary>
    /// <param name="year">Год.</param>
    /// <returns>Список фондов.</returns>
    [Public, Remote]
    public virtual Storage.IFundsList CreateFundsList(int year)
    {
      var document = Storage.FundsLists.Null;
      using (new Sungero.Domain.Session(true, false))
      {
        document = Storage.FundsLists.Create();
        document.FundsDate = Calendar.GetDate(year, 1, 1);
        document.State.Properties.Subject.IsRequired = false;
        document.Versions.AddNew();
        var version = document.LastVersion;
        version.Author = Users.Current;
        version.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("docx");
        document.Save();
      }
      Storage.PublicFunctions.FundsList.GenerateLastVersionFromReport(document);
      return document;
    }
    
    /// <summary>
    /// Получить организацию архива и его руководителя.
    /// </summary>
    /// <returns>Словарь организация архива/руководитель архива.</returns>
    [Public]
    public virtual Storage.Structures.Module.ArchiveCompanyInfo GetArchiveCompanyInfo()
    {
      var result = new Storage.Structures.Module.ArchiveCompanyInfo();
      
      var archiveManager = Storage.PublicFunctions.Module.Remote.GetArchiveManager();
      if (archiveManager != null)
      {
        result.ArchiveManager = archiveManager;
        var company = Sungero.Company.BusinessUnits.GetAll(b => b.CEO.Id == archiveManager.Id).FirstOrDefault();
        var businessUnit = archiveManager.Department.BusinessUnit;
        
        if (company != null)
          result.BusinessUnit = company;
        else if (businessUnit != null)
          result.BusinessUnit = businessUnit;
        else
        {
          var error = string.Format("Не найдена Наша организация для руководителя {0}", archiveManager.Name);
          Logger.ErrorFormat(error);
          throw new Exception(error);
        }
      }
      else
      {
        var error = "Не заполнена настройка Руководитель архива";
        Logger.Error(error);
        throw new Exception(error);
      }
      return result;
    }
    #endregion
    
    #region Проверка архивных документов
    
    /// <summary>
    /// Получить сотрудника, ответственного за проверку архивных документов, из параметра Docflow.
    /// </summary>
    /// <returns>Запись справочника "Сотрудники".</returns>
    [Remote(IsPure = true), Public]
    public virtual Sungero.Company.IEmployee GetVerificationResponsible()
    {
      var paramKey = Constants.Module.DocflowParams.VerificationResponsibleKey;
      var responsibleId = (int)Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsNumbericValue(paramKey);
      return Sungero.Company.Employees.GetAll(x => x.Id == responsibleId).SingleOrDefault();
    }
    
    /// <summary>
    /// Сохранить ИД сотрудника, ответственного за проверку архивных документов, в параметре Docflow.
    /// </summary>
    /// <param name="responsible">Сотрудник.</param>
    [Public, Remote]
    public virtual void SetVerificationResponsible(Sungero.Company.IEmployee responsible)
    {
      var paramKey = Constants.Module.DocflowParams.VerificationResponsibleKey;
      var paramValue = responsible != null ? responsible.Id.ToString() : string.Empty;
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(paramKey, paramValue);
    }
    
    /// <summary>
    /// Получить руководителя архива.
    /// </summary>
    /// <returns>Запись справочника "Сотрудники".</returns>
    [Public, Remote]
    public virtual Sungero.Company.IEmployee GetArchiveManager()
    {
      var role = Roles.GetAll().Where(x => x.Sid == Constants.Module.Initialize.ArchiveManagerRoleGuid).FirstOrDefault();
      if (role != null && role.RecipientLinks.FirstOrDefault() != null)
        return Sungero.Company.Employees.As(role.RecipientLinks.FirstOrDefault().Member);
      else
        return Sungero.Company.Employees.Current;
    }
    
    /// <summary>
    /// Сохранить ИД руководителя архива.
    /// </summary>
    /// <param name="archiveManager">Руководитель архива.</param>
    [Public, Remote]
    public virtual void SetArchiveManager(Sungero.Company.IEmployee archiveManager)
    {
      var role = Roles.GetAll().Where(x => x.Sid == Constants.Module.Initialize.ArchiveManagerRoleGuid).FirstOrDefault();
      if (role != null && archiveManager != null && !archiveManager.IncludedIn(role))
      {
        AccessRights.AllowRead(
          () =>
          {
            role.RecipientLinks.FirstOrDefault().Member = archiveManager;
            role.Save();
          });
      }
    }
    
    /// <summary>
    /// Установить дату очередной проверки документов.
    /// </summary>
    [Public, Remote]
    public virtual void SetVerificationTermForAllDocuments()
    {
      // Документов может быть миллион, изменения могут быть стартованы с клиента, поэтому используем асинхронный обработчик, чтобы не задерживать работу.
      var asyncHandler = AsyncHandlers.SetVerificationTermForAllDocuments.Create();
      asyncHandler.ExecuteAsync();
    }

    /// <summary>
    /// Сформировать отчет о результатах проверки.
    /// </summary>
    /// <param name="sessionDate">Дата и время начала проверки.</param>
    /// <param name="reason">Основание проверки.</param>
    /// <param name="responsible">Ответственный.</param>
    /// <returns>Текст сообщения с результатами проверки контейнеров.</returns>
    [Public, Remote]
    public virtual string GetVerificationResults(DateTime sessionDate, string reason, Sungero.Company.IEmployee responsible)
    {
      // Подсчитать число проверенных контейнеров.
      var results = Storage.ArchiveEventLogs.GetAll(x => x.JobStartDate.HasValue &&
                                                    x.JobStartDate.Value == sessionDate &&
                                                    x.VerificationReason == reason &&
                                                    x.VerificationResponsible == responsible)
        .ToList();
      
      if (results.Count > 0)
        return Resources.VerificationResultsTemplateFormat(
          results.First().VerificationReason,
          results.First().VerificationDate != null ? results.First().VerificationDate.Value.ToShortDateString() : string.Empty,
          sessionDate,
          results.Max(x => x.JobEndDate),
          results.Count(),
          results.Count(x => x.VerificationResult == Storage.ArchiveEventLog.VerificationResult.Succeeded),
          results.Count(x => x.VerificationResult != Storage.ArchiveEventLog.VerificationResult.Succeeded),
          results.Count(x => x.VerificationResult == Storage.ArchiveEventLog.VerificationResult.PresenceError),
          results.Count(x => x.VerificationResult == Storage.ArchiveEventLog.VerificationResult.IntegrityError),
          results.Count(x => x.VerificationResult == Storage.ArchiveEventLog.VerificationResult.HashError));
      
      return string.Empty;
    }

    /// <summary>
    /// Получить документы для инцидентной проверки.
    /// </summary>
    /// <param name="documentKinds">Виды (ИД) проверяемых документов.</param>
    /// <param name="departments">Подразделения (ИД) проверяемых документов.</param>
    /// <param name="createDateBegin">Дата создания проверяемых документов, начало интервала.</param>
    /// <param name="createDateEnd">Дата создания проверяемых документов, конец интервала.</param>
    /// <returns>Список ИД записей справочника "Журнал поступления и выбытия документов".</returns>
    [Public, Remote(IsPure = true)]
    public virtual List<int> GetArchiveDocumentsForVerification(List<int> documentKinds,
                                                                List<int> departments,
                                                                DateTime? createDateBegin,
                                                                DateTime? createDateEnd)
    {
      var result = new List<int>();
      
      // Отобрать записи в Журнале поступления и выбытия для указанных критериев проверки.
      AccessRights.AllowRead(
        () =>
        {
          var query = Storage.ArchiveEventLogs.GetAll(x => x.DocumentId.HasValue && x.CurrentState != DirRX.Storage.ArchiveEventLog.CurrentState.Destroyed);

          if (documentKinds != null && documentKinds.Count > 0)
            query = query.Where(x => x.Details.Any(d => d.EntityType == Constants.Module.EntityType.DocumentKind && d.EntityId.HasValue && documentKinds.Contains(d.EntityId.Value)) && x.CurrentState != Storage.ArchiveEventLog.CurrentState.Destroyed);
          
          if (departments != null && departments.Count > 0)
            query = query.Where(x => x.Details.Any(d => d.EntityType == Constants.Module.EntityType.Department && !string.IsNullOrEmpty(d.DocumentValue) && documentKinds.Contains(int.Parse(d.DocumentValue))));
          
          if (createDateBegin.HasValue)
            query = query.Where(x => x.Created.Value >= createDateBegin.Value.BeginningOfDay());

          if (createDateEnd.HasValue)
            query = query.Where(x => x.Created.Value <= createDateEnd.Value.EndOfDay());

          result = query.Select(x => x.Id).ToList();
        });
      
      return result;
    }
    
    /// <summary>
    /// Запустить инцидентную проверку архивных документов.
    /// </summary>
    /// <param name="archiveEventIds">Список ИД записей "Журнал поступления и выбытия документов".</param>
    /// <param name="verificationReason">Основание для проверки.</param>
    /// <param name="verificationResponsible">Ответственный за проверку.</param>
    [Public, Remote]
    public virtual void EnqueueArchiveDocumentsVerification(List<int> archiveEventIds,
                                                            string verificationReason,
                                                            Sungero.Company.IEmployee verificationResponsible)
    {
      // Время начала проверки, общее для всех документов пакета.
      var jobStartDate = Calendar.Now;

      // Комментарий для истории в журнале.
      var note = Storage.ArchiveEventLogs.Resources.VerificationInitiatedByUserFormat(
        Users.Current != null && Users.Current.IsSystem != true ? Users.Current.DisplayValue : Storage.ArchiveEventLogs.Resources.VerificationSystemUser,
        verificationReason);
      
      // Запланировать проверку для каждого архивного документа отдельно.
      foreach (var id in archiveEventIds)
      {
        try
        {
          AccessRights.AllowRead(
            () =>
            {
              var archiveEvent = Storage.ArchiveEventLogs.Get(id);
              archiveEvent.VerificationReason = verificationReason;
              archiveEvent.VerificationResponsible = verificationResponsible;
              archiveEvent.JobStartDate = jobStartDate;
              archiveEvent.JobEndDate = null;
              archiveEvent.VerificationResult = null;
              
              Storage.PublicFunctions.ArchiveEventLog.AddEventHistory(archiveEvent, Storage.ArchiveEventLogs.Resources.Operation_Verification,
                                                                      DirRX.Storage.ArchiveEventLog.CurrentState.InQueue, note);
            });
        }
        catch (Exception e)
        {
          archiveEventIds.Remove(id);
          Logger.DebugFormat("EnqueueArchiveDocumentsVerification. Не удалось сохранить журнал ИД {0}", id);
          Logger.Debug(e.ToString());
        }
      }
      
      if (archiveEventIds.Any())
      {
        foreach (var archiveEventId in archiveEventIds)
        {
          var asyncHandler = Storage.AsyncHandlers.VerifyContainer.Create();
          asyncHandler.eventId = archiveEventId;
          asyncHandler.ExecuteAsync();
        }
        
        // После проверки всех документов отправить уведомление ответственному.
        var checkAsyncHandler = Storage.AsyncHandlers.SendNotificationAfterVerification.Create();
        checkAsyncHandler.eventId = archiveEventIds.First();
        checkAsyncHandler.ExecuteAsync();
      }
    }
    
    #endregion
    
    #region Сводные описи
    
    /// <summary>
    /// Найти все сводные описи фонда.
    /// </summary>
    /// <param name="fund">Фонд.</param>
    /// <returns>Список сводных описей.</returns>
    [Public, Remote]
    public List<DirRX.Storage.IConsolidatedInventory> GetConsolidatedInventories(DirRX.Storage.IFund fund)
    {
      return DirRX.Storage.ConsolidatedInventories.GetAll(x => x.Fund == fund).ToList();
    }
    
    /// <summary>
    /// Получить количество листов в сводной описи.
    /// </summary>
    /// <param name="consolidatedInventory">Сводная опись.</param>
    /// <returns>Количество листов сводной описи.</returns>
    [Public, Remote]
    public static int GetNumberOfSheets(DirRX.Storage.IConsolidatedInventory consolidatedInventory)
    {
      var result = 0;
      
      var consInv = DirRX.Storage.ConsolidatedInventories.GetAll(x => x.Id == consolidatedInventory.Id
                                                                 && (x.Type == DirRX.Storage.ConsolidatedInventory.Type.Permanent
                                                                     || x.Type == DirRX.Storage.ConsolidatedInventory.Type.Temporary
                                                                     || x.Type == DirRX.Storage.ConsolidatedInventory.Type.Personnel))
        .FirstOrDefault();
      
      var caseFiles = DirRX.LongTermArchive.CaseFiles.GetAll(x => x.LTAConsInventoryDirRX.Fund == consInv.Fund);
      
      if (caseFiles.Any())
      {
        foreach (var caseFile in caseFiles)
        {
          result += caseFile.LTASheetsCountDirRX.HasValue ? caseFile.LTASheetsCountDirRX.Value : 0;
        }
      }
      return result;
    }
    
    /// <summary>
    /// Проверить наличие утвержденного годового роаздела.
    /// </summary>
    /// <param name="inventory">Сводная опись.</param>
    /// <param name="year">Год.</param>
    /// <returns>Признак наличия утвержденного годового раздела (true/false).</returns>
    [Public, Remote]
    public virtual bool ApprovedAnnualSectionExists(Storage.IConsolidatedInventory inventory, int year)
    {
      var document = this.GetAnnualSection(inventory, year);
      if (document == null)
        return false;
      
      return Signatures.Get(document).Where(x => x.SignatureType == SignatureType.Approval).Any();
    }

    /// <summary>
    /// Получить годовой раздел.
    /// </summary>
    /// <param name="inventory">Сводная опись.</param>
    /// <param name="year">Год.</param>
    /// <returns>Годовой раздел.</returns>
    [Public, Remote]
    public virtual IAnnualSection GetAnnualSection(Storage.IConsolidatedInventory inventory, int? year)
    {
      if (inventory == null)
        return Storage.AnnualSections.Null;
      
      if (year.HasValue)
        return Storage.AnnualSections.GetAll(x => x.ConsolidatedInventory == inventory && x.Year == year.Value).FirstOrDefault();
      else
        return Storage.AnnualSections.GetAll(x => x.ConsolidatedInventory == inventory).OrderByDescending(x => x.Year).FirstOrDefault();
    }
    
    /// <summary>
    /// Проверить наличие утвержденного годового раздела за более поздний год.
    /// </summary>
    /// <param name="inventory">Сводная опись.</param>
    /// <param name="year">Год.</param>
    /// <returns>Сообщение об ошибке, либо пустая строка.</returns>
    [Public, Remote]
    public virtual string LaterApprovedAnnualSectionsExists(Storage.IConsolidatedInventory inventory, int year)
    {
      var result = string.Empty;
      foreach (var document in Storage.AnnualSections.GetAll(x => x.ConsolidatedInventory == inventory && x.Year >= year).OrderByDescending(x => x.Year))
      {
        if (Signatures.Get(document).Where(x => x.SignatureType == SignatureType.Approval).Any())
        {
          result = Storage.ConsolidatedInventories.Resources.ApprovedAnnualSectionExistFormat(inventory.Number, document.Year);
          break;
        }
        
      }
      return result;
    }
    
    /// <summary>
    /// Получить сводную опись по ИД.
    /// </summary>
    /// <param name="id">ИД описи.</param>
    /// <returns>Сводная опись.</returns>
    [Public, Remote(IsPure = true)]
    public virtual IConsolidatedInventory GetConsolidatedInventory(int id)
    {
      var result = ConsolidatedInventories.Null;
      AccessRights.AllowRead(() => { result = ConsolidatedInventories.GetAll(x => x.Id == id).SingleOrDefault(); });
      return result;
    }
    
    /// <summary>
    /// Получить список дел на архивном хранении, не включенных в сводные описи.
    /// </summary>
    /// <returns>Список записей справочника "Номенклатура дел".</returns>
    [Remote(IsPure = true), Public]
    public virtual System.Linq.IQueryable<DirRX.LongTermArchive.ICaseFile> GetCaseFilesToInventory()
    {
      return LongTermArchive.CaseFiles.GetAll().Where(x => x.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.ArchivedDirRX && x.LTAConsInventoryDirRX == null);
    }
    
    /// <summary>
    /// Создать/переформировать годовой раздел сводной описи.
    /// </summary>
    /// <param name="inventory">Сводная опись.</param>
    /// <param name="year">Год.</param>
    /// <param name="countCaseOfFiles">Число дел в описи.</param>
    /// <returns>Годовой раздел сводной описи.</returns>
    [Public, Remote]
    public virtual Storage.IAnnualSection CreateAnnualSection(Storage.IConsolidatedInventory inventory, int year, int countCaseOfFiles)
    {
      var archivist = Sungero.Company.Employees.Current;
      if (archivist == null)
        archivist = CaseArchiving.PublicFunctions.Module.Remote.GetEmployeesForArchivistRole().FirstOrDefault();
      
      var document = Storage.AnnualSections.GetAll(x => x.ConsolidatedInventory == inventory && x.Year == year).FirstOrDefault();
      if (document == null)
      {
        // Создать годовой раздел.
        using (new Sungero.Domain.Session(true, false))
        {
          document = Storage.AnnualSections.Create();
          document.ConsolidatedInventory = inventory;
          Guid guidDocKind;
          if (inventory.Type == Storage.ConsolidatedInventory.Type.Permanent)
            guidDocKind = Constants.Module.Initialize.AnnualSectionPermanentDocumentKind;
          else if (inventory.Type == Storage.ConsolidatedInventory.Type.ElectronicPerm)
            guidDocKind = Constants.Module.Initialize.AnnualSectionElectronicPermanentDocumentKind;
          else if (inventory.Type == Storage.ConsolidatedInventory.Type.Temporary)
            guidDocKind = Constants.Module.Initialize.AnnualSectionTempDocumentKind;
          else if (inventory.Type == Storage.ConsolidatedInventory.Type.ElectronicTemp)
            guidDocKind = Constants.Module.Initialize.AnnualSectionElectronicTempDocumentKind;
          else  // if (inventory.Type == Storage.ConsolidatedInventory.Type.Personnel)
            guidDocKind = Constants.Module.Initialize.AnnualSectionPersonalDocumentKind;
          var externalLink = Sungero.Docflow.PublicFunctions.Module.GetExternalLink(Constants.Module.Initialize.DocumentKindTypeGuid, guidDocKind);
          document.DocumentKind = Sungero.Docflow.DocumentKinds.GetAll().Where(x => x.Id == externalLink.EntityId).FirstOrDefault();
          document.ConsInventNum = inventory.Number;
          document.Fund = inventory.Fund;
          document.BusinessUnit = inventory.BusinessUnit;
          document.OurSignatory = inventory.BusinessUnit.CEO;
          document.Year = year;
          document.Archivist = archivist;
          document.CountOfCaseFiles = countCaseOfFiles;
          
          if (archivist != null)
            document.AccessRights.Grant(archivist, DefaultAccessRightsTypes.FullAccess);
        }
        document.Save();
      }
      
      return document;
    }
    
    /// <summary>
    /// Создать/переформировать реестр описей.
    /// </summary>
    /// <returns>Реестр описей.</returns>
    [Public, Remote]
    public virtual Storage.IConsolidatedInventoryList CreateConsolidatedInventoryList()
    {
      var document = Storage.ConsolidatedInventoryLists.GetAll().FirstOrDefault();
      if (document == null)
      {
        using (new Sungero.Domain.Session(true, false))
        {
          document = Storage.ConsolidatedInventoryLists.Create();
          document.Name = Resources.InventoryList;
          document.Save();
        }
      }
      Storage.Functions.ConsolidatedInventoryList.GenerateLastVersionFromReport(document);
      return document;
    }
    
    /// <summary>
    /// Получить виды документов для типа "Годовые разделы".
    /// </summary>
    /// <returns>Виды документов.</returns>
    [Remote(IsPure = true), Public]
    public virtual IQueryable<Sungero.Docflow.IDocumentKind> GetAnnualSectionDocumentKinds()
    {
      // Отсортировать список, чтобы первым был вид документа по умолчанию.
      return Sungero.Docflow.DocumentKinds.GetAll().Where(x => x.DocumentType.DocumentTypeGuid == AnnualSection.ClassTypeGuid.ToString()).OrderBy(x => x.IsDefault == true ? 0 : x.Id);
    }
    
    /// <summary>
    /// Получить список утвержденных годовых разделов.
    /// </summary>
    /// <returns>Список годовых разделов, у которых утверждена последняя версия.</returns>
    [Remote(IsPure = true)]
    public virtual IQueryable<Storage.IAnnualSection> GetApprovedAnnualSections()
    {
      return Storage.AnnualSections.GetAll(x => x.HasVersions && x.LastVersionApproved == true);
    }
    
    #endregion
    
    #region Уничтожение документов

    /// <summary>
    /// Получить акт по ИД.
    /// </summary>
    /// <param name="id">ИД документа.</param>
    /// <returns>Акт о выделении дел к уничтожению.</returns>
    [Public, Remote(IsPure = true)]
    public virtual IDestructionAct GetDestructionAct(int id)
    {
      var result = DestructionActs.Null;
      AccessRights.AllowRead(() => { result = DestructionActs.GetAll(x => x.Id == id).SingleOrDefault(); });
      return result;
    }
    
    /// <summary>
    /// Отправить акт на верификацию.
    /// </summary>
    /// <param name="document">Акт о выделении дел к уничтожению.</param>
    [Public]
    public virtual void SendDestructionActForVerification(Storage.IDestructionAct document)
    {
      var task = Storage.VerificationActTasks.Create();
      task.DocumentGroup.DestructionActs.Add(document);
      task.Start();
    }

    /// <summary>
    /// Получить виды документов для типа карточки "Акты о выделении дел к уничтожению".
    /// </summary>
    /// <returns>Виды документов.</returns>
    [Remote(IsPure = true), Public]
    public virtual IQueryable<Sungero.Docflow.IDocumentKind> GetDestructionActDocumentKinds()
    {
      // Отсортировать список, чтобы первым был вид документа по умолчанию.
      var externalLink = Sungero.Docflow.PublicFunctions.Module.GetExternalLink(Constants.Module.Initialize.DocumentKindTypeGuid, Constants.Module.Initialize.DestructionActDocumentKind);
      
      return Sungero.Docflow.DocumentKinds.GetAll().Where(x => x.Id == externalLink.EntityId).OrderBy(x => x.IsDefault == true ? 0 : x.Id);
    }

    /// <summary>
    /// Отправить акт на согласование по регламенту.
    /// </summary>
    /// <param name="document">Акт.</param>
    /// <param name="author">Инициатор.</param>
    [Public]
    public virtual void SendDestructionActForApproving(Storage.IDestructionAct document, IUser author)
    {
      // Проверить не создана ли уже задача на согласование (например, вручную).
      var createdTasks = Sungero.Docflow.PublicFunctions.Module.Remote.GetApprovalTasks(document);
      
      if (!createdTasks.Any())
      {
        // Создать задачу на согласование по регламенту.
        var approvalTask = Sungero.Docflow.PublicFunctions.Module.Remote.CreateApprovalTask(document);
        
        approvalTask.Author = author;
        approvalTask.StartedBy = author;
        approvalTask.Signatory = document.Signatory;
        approvalTask.Save();
        
        approvalTask.AddApprovers.Clear();
        var role = Roles.GetAll(x => x.Sid == Storage.PublicConstants.Module.Initialize.ExpertCommissionRoleGuid).FirstOrDefault();
        if (role != null && role.RecipientLinks.Any())
        {
          var recipientLinks = role.RecipientLinks;
          foreach (var recipient in recipientLinks)
            approvalTask.AddApprovers.AddNew().Approver = recipient.Member;
        }
        approvalTask.Save();
        approvalTask.Start();
      }
    }

    /// <summary>
    /// Создать акты о выделении дел к уничтожению по списку дел.
    /// </summary>
    /// <param name="caseFiles">Список дел.</param>
    /// <param name="archivist">Архивист (приемщик дел).</param>
    /// <param name="department">Подразделение.</param>
    /// <returns>Список созданных актов.</returns>
    [Public, Remote]
    public virtual IDestructionAct CreateDestructionAct(List<DirRX.LongTermArchive.ICaseFile> caseFiles, Sungero.Company.IEmployee archivist, Sungero.Company.IDepartment department)
    {
      // Если архивист не указан, взять из роли.
      if (archivist == null)
        archivist = DirRX.CaseArchiving.PublicFunctions.Module.Remote.GetEmployeesForArchivistRole().FirstOrDefault();
      
      // Заполнить карточку акта.
      var firstCaseFile = caseFiles.FirstOrDefault();
      var document = Storage.DestructionActs.Null;
      
      using (new Sungero.Domain.Session(true, false))
      {
        document = Storage.DestructionActs.Create();
        // Статус у всех дел должен быть одинаковый (проверить в вызывающем коде).
        document.CaseFileStage = firstCaseFile != null ? firstCaseFile.LTAStageDirRX : Storage.DestructionAct.CaseFileStage.CompletedDirRX;
        document.Department = department != null ? department : archivist.Department;
        document.BusinessUnit = document.Department != null ? document.Department.BusinessUnit : null;
        document.Archivist = archivist;
        if (document.BusinessUnit != null && document.BusinessUnit.CEO != null)
          document.Signatory = document.BusinessUnit.CEO;
        if (archivist != null)
          document.AccessRights.Grant(archivist, DefaultAccessRightsTypes.FullAccess);
        document.Save();
      }
      
      // Связать дела с актом.
      foreach (var caseFile in caseFiles)
        DirRX.LongTermArchive.PublicFunctions.CaseFile.UpdateDestructionAct(caseFile, document, null);     
      
      return document;
    }

    /// <summary>
    /// Получить список дел к уничтожению.
    /// </summary>
    /// <returns>Список записей справочника "Дело".</returns>
    [Remote(IsPure = true), Public]
    public virtual System.Linq.IQueryable<DirRX.LongTermArchive.ICaseFile> GetCaseFilesToDestroy()
    {
      return LongTermArchive.CaseFiles.GetAll().Where(x => (x.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.CompletedDirRX || x.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.ArchivedDirRX) &&
                                                      x.LTADestructionActDirRX == null &&
                                                      x.LTADestructionDateDirRX != null &&
                                                      x.LTADestructionDateDirRX <= Calendar.Now);
    }
    
    /// <summary>
    /// Получить ИД всех документов из дела.
    /// </summary>
    /// <param name="caseFile">Дело.</param>
    /// <returns>ИД документов по делу.</returns>
    [Public]
    public virtual List<int> GetDocumentsToDestroy(DirRX.LongTermArchive.ICaseFile caseFile)
    {
      return Sungero.Docflow.OfficialDocuments.GetAll(d => Equals(d.CaseFile, caseFile)).Select(x => x.Id).ToList();
    }
    
    /// <summary>
    /// Заполнить свойства об уничтожении архивного документа.
    /// </summary>
    /// <param name="archiveDocument">Архивный документ.</param>
    /// <param name="dateTime">Дата и время уничтожения.</param>
    /// <param name="act">Акт об уничтожении.</param>
    [Public]
    public virtual void FillArchiveDocumentDeletedParams(DirRX.Storage.IArchiveDocumentBase archiveDocument, DateTime dateTime, DirRX.Storage.IDestructionAct act)
    {
      archiveDocument.Deleted = dateTime;
      archiveDocument.DestructionAct = act;
      archiveDocument.Save();
    }
    
    #endregion

    #region Описи

    /// <summary>
    /// Получить архивные документы для указанного дела.
    /// </summary>
    /// <param name="caseFileId">ИД дела.</param>
    /// <returns>Список ИД документов.</returns>
    [Public]
    public virtual List<int> GetArchiveDocumentIds(int caseFileId)
    {
      return ArchiveDocuments.GetAll(x => x.CaseFile != null && x.CaseFile.Id == caseFileId).Select(x => x.Id).ToList();
    }

    /// <summary>
    /// Связать архивный документ со сдаточной описью.
    /// </summary>
    /// <param name="archiveDocumentId">ИД документа.</param>
    /// <param name="inventoryId">ИД описи.</param>
    /// <returns>Сообщение об ошибке, либо пустая строка.</returns>
    [Public]
    public virtual string LinkArchiveDocumentToInventory(int archiveDocumentId, int inventoryId)
    {
      var error = string.Empty;
      var eventLog = PublicFunctions.Module.Remote.GetArchiveEventLogEntry(archiveDocumentId);
      
      if (eventLog != null)
      {
        try
        {
          eventLog.InventoryId = inventoryId;
          var comment = string.Format("Документ передан на архивное хранение. Опись ИД {0}", inventoryId);
          Functions.ArchiveEventLog.AddEventHistory(eventLog, ArchiveEventLogs.Resources.Operation_Change, eventLog.CurrentState.Value, comment);
          
          // Изъять права.
          this.ChangeAccessRightsToRead(Sungero.Content.ElectronicDocuments.Get(archiveDocumentId));
        }
        catch (Exception e)
        {
          error = e.InnerException != null ? e.InnerException.Message : e.Message;
        }
      }
      else
      {
        error = string.Format("Не найдена запись журнала для архивного документа ИД {0}", archiveDocumentId);
      }
      
      return error;
    }
    
    #endregion
    
    #region Интеграция
    
    /// <summary>
    /// Получить режим сопоставления записей.
    /// </summary>
    /// <param name="externalEntityId">ИД записи "Справочники системы-источника".</param>
    /// <returns>Режим сопоставления.</returns>
    [Remote(IsPure = true), Public]
    public virtual Sungero.Core.Enumeration? GetMappingMode(int externalEntityId)
    {
      return Storage.ExternalEntities.Get(externalEntityId).MappingMode;
    }
    
    /// <summary>
    /// Удалить синхронизируемые данные.
    /// </summary>
    /// <param name="syncDataIds">Список ИД записей справочника "Синхроинзируемые данные".</param>
    [Remote]
    public virtual void DeleteSyncData(List<int> syncDataIds)
    {
      var errorIds = new List<int>();
      foreach (var id in syncDataIds)
      {
        try
        {
          var item = Storage.SyncDatas.Get(id);
          Storage.SyncDatas.Delete(item);
        }
        catch
        {
          errorIds.Add(id);
        }
      }
      
      if (errorIds.Any())
        Logger.DebugFormat("Storage. DeleteSyncData. Не удалось удалить записи ИД:", string.Join(",", errorIds));
    }
    
    /// <summary>
    /// Удалить запись справочника "Ссылки внешней системы".
    /// </summary>
    /// <param name="entity">Запись справочника "Ссылки внешней системы".</param>
    [Public]
    public virtual void DeleteExternalEntityLink(LongTermArchive.IExternalEntityLink entity)
    {
      try
      {
        LongTermArchive.ExternalEntityLinks.Delete(entity);
      }
      catch (Exception e)
      {
        Logger.Debug(e.ToString());
      }
    }
    
    /// <summary>
    /// Получить список неподтвержденных данных для синхронизации в очереди на обработку.
    /// </summary>
    /// <returns>Список записей справочника "Синхронизируемые данные".</returns>
    [Public, Remote(IsPure = true)]
    public virtual IQueryable<Storage.ISyncData> GetNotConfirmedSyncData()
    {
      return Storage.SyncDatas.GetAll(x => x.CurrentState == Storage.SyncData.CurrentState.InQueue && !x.Accepted.HasValue);
    }
    
    /// <summary>
    /// Получить схему проверки контейнера.
    /// </summary>
    /// <param name="archiveDocumentType">Тип архивного документа.</param>
    /// <returns>Схема проверки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetArchiveValidationScheme(string archiveDocumentType)
    {
      var result = Structures.Module.ResultAnswer.Create();
      result.Status = Constants.Module.Status.Ok;

      // В зависимости от типа документа возвращать свою схему проверки
      switch (archiveDocumentType)
      {
        case "ArchiveDocument":
          result.Data = Constants.Module.ContainerJsonSchema.ArchiveDocument;
          break;
        default:
          result.Data = Constants.Module.ContainerJsonSchema.ArchiveDocument;
          break;
      }
      return result;
    }

    /// <summary>
    /// Отправить уведомление о необходимости подтвердить синхронизацию.
    /// </summary>
    [Public]
    public virtual void SendNotificationToConfirmSync()
    {
      var notConfirmed = this.GetNotConfirmedSyncData();
      
      if (notConfirmed.Any())
      {
        var role = Roles.GetAll(g => g.Sid == Constants.Module.Initialize.SyncAdminRoleGuid).FirstOrDefault();
        
        if (role != null)
        {
          var roleUsers = Sungero.CoreEntities.Roles.GetAllUsersInGroup(role);
          
          if (roleUsers.Any())
          {
            this.SendNotice(Resources.SyncDataConfirmationNoticeSubject, Resources.SyncDataConfirmationNoticeDescription, roleUsers);
          }
        }
      }
    }
    
    /// <summary>
    /// Получить настройки синхронизации справочников системы-источника.
    /// </summary>
    /// <param name="sourceSystemCode">Код системы-источника.</param>
    /// <returns>Описание настроек в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetArchiveSyncSettings(string sourceSystemCode)
    {
      var result = Structures.Module.ResultAnswer.Create();
      
      var externalSystem = Storage.ExternalSystems.GetAllCached(x => x.SourceUid == sourceSystemCode).FirstOrDefault();
      if (externalSystem != null)
      {
        result.Status = Constants.Module.Status.Ok;
        result.Guid = externalSystem.Id.ToString();
        result.Data = Functions.ExternalSystem.GetSyncSettings(externalSystem);
      }
      else
      {
        result.Status = Constants.Module.Status.Error;
        result.Message = "Не найдена система-источник с кодом " + sourceSystemCode;
      }
      
      return result;
    }
    
    /// <summary>
    /// Найти запись "Справочник системы-источника".
    /// </summary>
    /// <param name="externalSystemCode">Код системы-источника.</param>
    /// <param name="externalUid">UID справочника системы-источника.</param>
    /// <param name="entityType">Тип сущности DirectumRX.</param>
    /// <returns>Сущность "Справочник системы-источника".</returns>
    [Public]
    public virtual Storage.IExternalEntity GetExternalEntity(string externalSystemCode, string externalUid, string entityType)
    {
      Storage.IExternalEntity result = null;
      
      // Тип справочника (внешний или внутренний) обязателен.
      if (!string.IsNullOrWhiteSpace(externalUid) || !string.IsNullOrWhiteSpace(entityType))
      {
        var query = ExternalEntities.GetAll(x => x.Status == Storage.ExternalEntity.Status.Active);
        
        if (!string.IsNullOrWhiteSpace(externalSystemCode))
          query = query.Where(x => x.ExternalSystem != null && x.ExternalSystem.SourceUid == externalSystemCode);
        
        if (!string.IsNullOrWhiteSpace(externalUid))
          query = query.Where(x => x.Uid == externalUid);
        
        if (!string.IsNullOrWhiteSpace(entityType))
          query = query.Where(x => x.EntityType == entityType);
        
        result = query.FirstOrDefault();
      }
      
      return result;
    }

    /// <summary>
    /// Синхронизировать данные системы-источника, полученные в виде массива байт.
    /// </summary>
    /// <param name="json">Описание синхронизируемых данных.</param>
    /// <returns>Информация о состоянии обработки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer SaveSyncData(string json)
    {
      // Создать запись в журнале регистрации поступивших пакетов.
      var info = SyncDatas.Create();
      var result = Structures.Module.ResultAnswer.Create();
      
      info.Data = json;
      info.CurrentState = Storage.SyncData.CurrentState.InQueue;
      info.Created = Calendar.Now;
      
      try
      {
        var jsonData = JObject.Parse(json);

        if (jsonData != null)
        {
          var systemUid = jsonData.Value<string>("SystemUid");
          if (!string.IsNullOrEmpty(systemUid))
          {
            var externalSystem = Storage.ExternalSystems.GetAllCached(x => x.SourceUid.ToLower() == systemUid.ToLower()).FirstOrDefault();
            
            if (externalSystem != null)
            {
              info.ExternalSystem = externalSystem;
              
              var sourceUid = jsonData.Value<string>("SourceType");
              var archiveType = jsonData.Value<string>("ArchiveType");
              var externalEntity = Storage.ExternalEntities.Null;
              
              if (archiveType != string.Empty)
                externalEntity = Storage.ExternalEntities.GetAll(x => x.ExternalSystem.Equals(externalSystem) && x.EntityType == archiveType).FirstOrDefault();
              
              if (externalEntity == null && sourceUid != string.Empty)
                externalEntity = Storage.ExternalEntities.GetAll(x => x.ExternalSystem.Equals(externalSystem) && x.Uid == sourceUid).FirstOrDefault();
              
              if (externalEntity != null)
              {
                info.ExternalEntity = externalEntity;
                
                // Запустить синхронизацию, если включена соответствующая настройка.
                if (externalEntity.AcceptWithoutConfirmation == true)
                {
                  var assyncHandler = AsyncHandlers.SynchronizeExternalEntities.Create();
                  assyncHandler.eventLogId = info.Id;
                  assyncHandler.ExecuteAsync();
                }
              }
            }
          }
        }

        info.Save();
        result.Status = Constants.Module.Status.Ok;
        return result;
      }
      catch (Exception e)
      {
        var error = e.InnerException != null ? e.InnerException.Message : e.Message;
        result.Status = Constants.Module.Status.Error;
        result.Message = error;
        return result;
      }
    }
    
    /// <summary>
    /// Получить список записей системы-источника, синхронизированных в ДА.
    /// </summary>
    /// <param name="externalSystemCode">Код системы-источника.</param>
    /// <param name="externalUid">UID справочника системы-источника.</param>
    /// <returns>Список записей в формате json.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetArchiveEntityRecords(string externalSystemCode, string externalUid)
    {
      var result = Structures.Module.ResultAnswer.Create();
      
      var externalEntity = Storage.ExternalEntities.GetAll(x => x.ExternalSystem.SourceUid == externalSystemCode && x.Uid == externalUid).FirstOrDefault();
      if (externalEntity != null)
      {
        result.Status = Constants.Module.Status.Ok;
        result.Guid = externalEntity.Id.ToString();
        result.Data = Functions.ExternalEntity.GetRecordsData(externalEntity);
      }
      else
      {
        result.Status = Constants.Module.Status.Error;
        result.Message = Storage.Resources.ErrorExternalEntityNotFoundFormat(externalUid).ToString();
      }
      
      return result;
    }
    #endregion
    
    #region Интеграционный сервис
    
    /// <summary>
    /// Передать полученный по HTTP контейнер в архивную систему.
    /// </summary>
    /// <returns>Json-строка, содержащая guid контейнера в архивной системе.</returns>
    /// <remarks>Тело запроса содержит zip-контейнер в виде массива байт.</remarks>
    [Public(WebApiRequestType = RequestType.Post)]
    public virtual Structures.Module.IResultAnswer ImportContainer(byte[] content)
    {
      return DirRX.Storage.PublicFunctions.Module.ProcessContainerByContent(content);
    }
    
    /// <summary>
    /// Передать путь к контейнеру в архивную систему.
    /// </summary>
    /// <returns>Json-строка, содержащая guid контейнера в архивной системе.</returns>
    /// <remarks>Тело запроса содержит путь к файлу.</remarks>
    [Public(WebApiRequestType = RequestType.Post)]
    public virtual Structures.Module.IResultAnswer ImportContainerFromLink(string content, string hash)
    {
      return DirRX.Storage.PublicFunctions.Module.ProcessContainerByLink(content, hash);
    }
    
    /// <summary>
    /// Передать данные синхронизируемого справочника в архивную систему.
    /// </summary>
    /// <remarks>Тело запроса содержит данные для синхронизации в виде массива байт.</remarks>
    [Public(WebApiRequestType = RequestType.Post)]
    public virtual Structures.Module.IResultAnswer SendSyncData(string content)
    {
      return DirRX.Storage.PublicFunctions.Module.SaveSyncData(content);
    }
    
    /// <summary>
    /// Передать запрос а в архивную систему.
    /// </summary>
    /// <remarks>Тело запроса содержит данные для синхронизации в виде массива байт.</remarks>
    [Public(WebApiRequestType = RequestType.Post)]
    public virtual Structures.Module.IResultAnswer SendRequest(string content)
    {
      return DirRX.Storage.PublicFunctions.Module.ProcessLTARequest(content);
    }
    
    /// <summary>
    /// Вернуть состояние обработки контейнера.
    /// </summary>
    /// <param name="guid">Временный ГУИД контейнера в архивной системе.</param>
    /// <returns>Json-строка, содержащая состояние обработки контейнера и ссылку на документ в архивной системе.</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetStatus(string guid)
    {
      return DirRX.Storage.PublicFunctions.Module.GetStatusInfo(guid);
    }
    
    /// <summary>
    /// Вернуть Url и статус хранения архивного документа.
    /// </summary>
    /// <param name="source">Код исходной системы.</param>
    /// <param name="uid">ИД документа в исходной системе.</param>
    /// <returns>Json-строка, содержащая статус хранения и ссылку на документ в архивной системе.</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetDocumentStatus(string source, string uid)
    {
      return DirRX.Storage.PublicFunctions.Module.GetArchiveDocumentStatus(source, uid);
    }
    
    /// <summary>
    /// Получить гиперссылку архивного документа.
    /// </summary>
    /// <param name="source">Система-источник.</param>
    /// <param name="uid">ИД документа.</param>
    /// <returns>Гиперссылка на документ в архивной системе.</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetDocumentUrl(string source, string uid)
    {
      var result = Structures.Module.ResultAnswer.Create();
      result.Status = Constants.Module.Status.Ok;
      result.Document = DirRX.Storage.PublicFunctions.Module.GetDocumentHyperlink(source, uid);
      
      if (string.IsNullOrEmpty(result.Document))
      {
        result.Status = Constants.Module.Status.Error;
        result.Message = DirRX.Storage.Resources.DocumentNotFound;
      }
      
      return result;
    }
    
    /// <summary>
    /// Вернуть список типов контейнеров в архивной системе.
    /// </summary>
    /// <returns>Cписок типов контейнеров в архивной системе.</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetArchiveDocumentTypes()
    {
      var result = Structures.Module.ResultAnswer.Create();
      result.Message = string.Join(",", DirRX.Storage.PublicFunctions.Module.GetArchiveDocumentsList());
      return result;
    }
    
    /// <summary>
    /// Получить настройки синхронизации справочников исходной и архивной систем
    /// </summary>
    /// <param name="source">Код исходной системы.</param>
    /// <returns>Настройки синхронизации в виде json-строки</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetSyncSettings(string source)
    {
      return DirRX.Storage.PublicFunctions.Module.GetArchiveSyncSettings(source);
    }
    
    /// <summary>
    /// Вернуть json-схему для проверки контейнера.
    /// </summary>
    /// <param name="documentType">Тип архивного документа.</param>
    /// <returns>json-схема для проверки контейнера</returns>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetValidationScheme(string documentType)
    {
      return DirRX.Storage.PublicFunctions.Module.GetArchiveValidationScheme(documentType);
    }
    
    /// <summary>
    /// Получить список записей синхронизируемого справочника из архивной системы.
    /// </summary>
    /// <param name="source">Код исходной системы.</param>
    /// <param name="uid">UID справочника исходной системы.</param>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetEntityRecords(string source, string uid)
    {
      return DirRX.Storage.PublicFunctions.Module.GetArchiveEntityRecords(source, uid);
    }
    
    /// <summary>
    /// Получить результат обработки запроса в Архив.
    /// </summary>
    /// <param name="taskId">ИД задачи на обработку запроса.</param>
    [Public(WebApiRequestType = RequestType.Get)]
    public virtual Structures.Module.IResultAnswer GetRequestStatus(int taskId)
    {
      return DirRX.Storage.PublicFunctions.Module.GetArchiveRequestStatus(taskId);
    }
    
    #endregion
    
    #region Прием контейнеров
    
    /// <summary>
    /// Получить запись журнала поступления и выбытия.
    /// </summary>
    /// <param name="id">ИД архивного документа.</param>
    /// <returns>Запись справочника "Журнал поступления и выбытия документов".</returns>
    [Remote, Public]
    public virtual DirRX.Storage.IArchiveEventLog GetArchiveEventLogEntry(int id)
    {
      return DirRX.Storage.ArchiveEventLogs.GetAll(x => Equals(x.DocumentId, id)).FirstOrDefault();
    }
    
    /// <summary>
    /// Добавить запись в журнал поступления и выбытия.
    /// </summary>
    /// <param name="guid">ГУИД контейнера.</param>
    /// <param name="operation">Операция.</param>
    /// <param name="state">Статус.</param>
    /// <param name="comment">Комментарий.</param>
    public virtual void AddArchiveEventLog(string guid, string operation, Sungero.Core.Enumeration state, string comment = "")
    {
      var archiveEvent = Storage.ArchiveEventLogs.GetAll(e => e.TempGuid == guid.ToLower()).FirstOrDefault();
      
      // Проверка наличия контейнера не предусмотрена, функцию предполагается вызывать в try-catch.
      var lockInfo = Locks.GetLockInfo(archiveEvent);
      if (lockInfo != null && lockInfo.IsLocked)
        Locks.Unlock(archiveEvent);

      Functions.ArchiveEventLog.AddEventHistory(archiveEvent, operation, state, comment);
    }
    
    /// <summary>
    /// Получить путь к папке для обработки ДА-контейнера.
    /// </summary>
    /// <param name="subFolder">Подпапка.</param>
    /// <returns>Путь к папке.</returns>
    [Public]
    public virtual string GetContainerFolder(string subFolder)
    {
      var rootFolder = string.Empty;
      if (this.IsLinux())
        rootFolder = Storage.Constants.Module.Paths.LinuxDockerContainerVolume;
      else
        rootFolder = Path.GetTempPath();
      
      var folder = Path.Combine(rootFolder, Storage.Constants.Module.Paths.LTAContainersFolder);
      if (!string.IsNullOrWhiteSpace(subFolder))
        folder = Path.Combine(folder, subFolder);
      
      if (!Directory.Exists(folder))
      {
        Directory.CreateDirectory(folder);
      }
      
      return folder;
    }
    
    [Public]
    public virtual bool IsLinux()
    {
      var linuxPlatform = System.Runtime.InteropServices.OSPlatform.Linux;
      return System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(linuxPlatform);
    }

    /// <summary>
    /// Сформировать URL документа по идентификатору.
    /// </summary>
    /// <param name="source">ИД системы-источника.</param>
    /// <param name="uid">ИД документа.</param>
    /// <returns>Гиперссылка на документ в ДА.</returns>
    [Public]
    public virtual string GetDocumentHyperlink(string source, string uid)
    {
      var archiveEvent = ArchiveEventLogs.GetAll().Where(x => x.SourceDocumentUid == uid && x.SourceSystemUid == source && x.DocumentId != null).FirstOrDefault();
      if (archiveEvent != null)
      {
        var doc = Sungero.Content.ElectronicDocuments.Get(archiveEvent.DocumentId.Value);
        var url = Hyperlinks.Get(doc);
        return url;
      }
      else
        return string.Empty;
    }
    
    /// <summary>
    /// Изменить права всех пользователей документа на "Чтение".
    /// </summary>
    /// <param name="document">Документ.</param>
    private void ChangeAccessRightsToRead(Sungero.Content.IElectronicDocument 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>
    /// Обработать ДА-контейнер, полученный в виде массива байт.
    /// </summary>
    /// <param name="zipContent">Содержимое контейнера, zip-архив.</param>
    /// <returns>Информация о состоянии обработки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer ProcessContainerByContent(byte[] zipContent)
    {
      // Сформировать ГУИД контейнера.
      var guid = Guid.NewGuid().ToString();
      
      // Сохранить содержимое контейнера во временный файл.
      var processingFolder = this.GetContainerFolder(DirRX.Storage.Constants.Module.Paths.LTAQueueContainersFolder);
      var processingFile = Path.Combine(processingFolder, string.Format(@"container_{0}.zip", guid));
      
      File.WriteAllBytes(processingFile, zipContent);
      
      // Создать запись в Журнале событий. Инициировать асинхронный импорт контейнера.
      var info = this.EnqueueContainerForImport(processingFile, guid, string.Empty);
      
      // Сформировать ответ для WebApi. Вернуть guid для отслеживания статуса обработки.
      return Functions.ArchiveEventLog.GetStatus(info);
    }
    
    /// <summary>
    /// Обработать ДА-контейнер, полученный в виде ссылки на файл.
    /// </summary>
    /// <param name="sourceFile">Путь к zip-файлу с контейнером.</param>
    /// <param name="hash">Контрольная сумма zip-файла с контейнером.</param>
    /// <returns>Информация о состоянии обработки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer ProcessContainerByLink(string sourceFile, string hash)
    {
      // Сформировать ГУИД контейнера.
      var guid = Guid.NewGuid().ToString();
      
      // Скопировать исходный файл в папку обработки.
      var processingFolder = this.GetContainerFolder(DirRX.Storage.Constants.Module.Paths.LTAQueueContainersFolder);
      var processingFile = Path.Combine(processingFolder, string.Format(@"container_{0}.zip", guid));
      
      if (File.Exists(sourceFile))
      {
        Logger.DebugFormat("Copying container {0} to {1}", sourceFile, processingFile);
        File.Copy(sourceFile, processingFile, true);
      }
      else
        Logger.ErrorFormat("Container {0} not found", sourceFile);
      
      // Создать запись в Журнале событий. Инициировать асинхронный импорт контейнера.
      var info = this.EnqueueContainerForImport(processingFile, guid, hash);
      
      // Вернуть guid для отслеживания статуса обработки.
      return Functions.ArchiveEventLog.GetStatus(info);
    }

    /// <summary>
    /// Обработать ДА-контейнер, если источник и ДА - это одна система.
    /// </summary>
    /// <param name="sourceFile">Путь к zip-файлу с контейнером.</param>
    /// <returns>Информация о состоянии обработки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer EnqueueContainerOneInstance(string sourceFile)
    {
      // Сформировать ГУИД контейнера.
      var guid = Guid.NewGuid().ToString().ToLower();
      
      // Скопировать исходный файл в папку обработки.
      var processingFolder = this.GetContainerFolder(DirRX.Storage.Constants.Module.Paths.LTAQueueContainersFolder);
      var processingFile = Path.Combine(processingFolder, string.Format(@"container_{0}.zip", guid));
      
      if (File.Exists(sourceFile))
        File.Copy(sourceFile, processingFile);
      
      // Создать запись в Журнале событий.
      var archiveEvent = Storage.ArchiveEventLogs.Create();
      archiveEvent.FilePath = sourceFile;
      archiveEvent.TempGuid = guid;
      archiveEvent.ArchiveIsModule = true;

      Functions.ArchiveEventLog.AddEventHistory(archiveEvent, ArchiveEventLogs.Resources.Operation_Import, Storage.ArchiveEventLog.CurrentState.InQueue, "Постановка в очередь для импорта контейнера в версию в исходной системе");
      
      // Вызвать асинхронный обработчик.
      var asyncHandler = DirRX.Storage.AsyncHandlers.ImportContainer.Create();
      asyncHandler.eventId = archiveEvent.Id;
      asyncHandler.ExecuteAsync();
      
      // Вернуть guid для отслеживания статуса обработки.
      return Functions.ArchiveEventLog.GetStatus(archiveEvent);
    }
    
    /// <summary>
    /// Постановка в очередь асинх. обработчика для импорта контейнера.
    /// </summary>
    /// <param name="containerFile">Путь к zip-файлу с контейнером.</param>
    /// <param name="tempGuid">Уникальный идентификатор контейнера.</param>
    /// <param name="hash">Хэш контейнера.</param>
    /// <returns>Запись справочника Журнал событий.</returns>
    [Public]
    public virtual Storage.IArchiveEventLog EnqueueContainerForImport(string containerFile, string tempGuid, string hash)
    {
      // Создать запись в Журнале событий.
      var archiveEvent = Storage.ArchiveEventLogs.Create();
      archiveEvent.Name = tempGuid.ToLower();
      archiveEvent.FilePath = containerFile;
      archiveEvent.TempGuid = tempGuid.ToLower();
      archiveEvent.Save();
      
      Functions.ArchiveEventLog.AddEventHistory(archiveEvent, ArchiveEventLogs.Resources.Operation_Import, Storage.ArchiveEventLog.CurrentState.InQueue, "EnqueueContainerForImport. Постановка в очередь");
      
      // Вызвать асинхронный обработчик.
      var asyncHandler = DirRX.Storage.AsyncHandlers.ImportContainer.Create();
      asyncHandler.eventId = archiveEvent.Id;
      asyncHandler.hash = hash;
      asyncHandler.ExecuteAsync();
      
      return archiveEvent;
    }

    /// <summary>
    /// Загрузить контейнер из файла в структуру для последующей обработки.
    /// </summary>
    /// <param name="filename">Путь к файлу.</param>
    /// <returns>Информация о контейнере.</returns>
    [Public]
    public virtual Storage.Structures.Module.IContainer LoadContainer(string filename)
    {
      var result = Storage.Structures.Module.Container.Create();
      var error = string.Empty;
      
      try
      {
        // Проверить целостность zip-архива.
        TextWriter stringWriter = new StringWriter();
        
        if (ZipFile.CheckZip(filename, false, stringWriter))
        {
          result.ZipContent = File.ReadAllBytes(filename);
          
          // Извлечь метаданные (container.json) из архива.
          using (ZipFile zip = ZipFile.Read(filename))
          {
            var metadataText = string.Empty;
            var metadataEntry = zip.FirstOrDefault(e => e.FileName == Constants.Module.ContainerInfoFileName);
            
            if (metadataEntry != null)
            {
              using (var metadataMS = new MemoryStream())
              {
                metadataEntry.Extract(metadataMS);
                metadataMS.Position = 0;
                using (var sr = new StreamReader(metadataMS))
                {
                  metadataText = sr.ReadToEnd();
                }
              }
            }

            if (!string.IsNullOrWhiteSpace(metadataText))
            {
              result.Metadata = metadataText;
              
              try
              {
                var containerJson = JObject.Parse(metadataText);
                result.SourceUid = containerJson.Value<string>("Source").ToLower();
                result.DocumentName = containerJson.SelectToken("Document").Value<string>("Name");
                result.DocumentUid = containerJson.SelectToken("Document").Value<string>("Uid").ToLower();
                result.Type = containerJson.Value<string>("Type");
              }
              catch
              {
                error = Resources.ErrorParsingMetadata;
              }
            }
            else
              error = Resources.ErrorMissingMetadataFormat(Constants.Module.ContainerInfoFileName);
            
            if (error == string.Empty)
            {
              if (string.IsNullOrEmpty(result.Type))
                error = Resources.ErrorMissingType;
              else if (!this.GetArchiveDocumentsList().Any(t => t.Contains(result.Type)))
                error = Resources.ErrorContainerTypeFormat(result.Type);
            }
            
            result.Hash = this.GetFileHash(filename);
          }
        }
        else
        {
          error = Resources.ErrorReadingZipFileFormat(filename);
          error += Environment.NewLine;
          error += string.Join(Environment.NewLine, stringWriter.ToString());
        }
      }
      catch (Exception e)
      {
        error = Resources.ErrorReadingZipFileFormat(filename);
        error += Environment.NewLine;
        error += e.InnerException != null ? e.InnerException.Message : e.Message;
        
        Logger.Debug(e.ToString());
      }
      
      result.Message = error;
      result.Valid = error == string.Empty;
      
      return result;
    }
    
    /// <summary>
    /// Проверить контейнер.
    /// </summary>
    /// <param name="container">Информация о контейнере.</param>
    /// <returns>Сообщение об ошибке или пустая строка.</returns>
    [Public]
    public virtual string CheckContainer(Storage.Structures.Module.IContainer container)
    {
      // Проверить корректность json-описания контейнера.
      var error = this.CheckMetadata(container.Metadata, container.Type);

      if (error == string.Empty)
      {
        var json = JObject.Parse(container.Metadata);
        
        if (json != null && json.HasValues)
        {
          Stream stream = new MemoryStream(container.ZipContent);
          using (ZipFile zip = ZipFile.Read(stream))
          {
            // Проверить наличие и ЭП основного документа.
            if (error == string.Empty)
            {
              var mainDocumentJson = json.SelectToken("Document");
              error = this.CheckDocumentInContainer(zip, mainDocumentJson, container.EventId);
            }
            
            // Проверить наличие приложений и их электронные подписи.
            if (error == string.Empty)
            {
              var attachmentsJson = (JArray)json.SelectToken("Attachments");
              if (attachmentsJson != null && attachmentsJson.Any())
              {
                foreach (JToken documentJson in attachmentsJson)
                {
                  error = this.CheckDocumentInContainer(zip, documentJson, container.EventId);
                  if (error != string.Empty)
                    break;
                }
              }
            }

            // Проверить наличие файла preview.pdf.
            if (error == string.Empty && !zip.Any(e => e.FileName == Constants.Module.PreviewFileName))
              error = Resources.ErrorMissingPreviewFormat(Constants.Module.PreviewFileName);
          }
        }
        else
          error = Resources.ErrorParsingMetadata;
      }
      
      if (error != string.Empty)
      {
        container.Valid = false;
        container.Message = error;
      }
      
      return error;
    }
    
    /// <summary>
    /// Проверить документ контейнера.
    /// </summary>
    /// <param name="containerZip">Содержимое контейнера, объект DotNetZip.</param>
    /// <param name="documentJson">Описание документа, объект Json.</param>
    /// <param name="eventLogId">ИД записи журнала поступления и выбытия.</param>
    /// <returns>Сообщение об ошибке или пустая строка.</returns>
    public virtual string CheckDocumentInContainer(Ionic.Zip.ZipFile containerZip, Newtonsoft.Json.Linq.JToken documentJson, int eventLogId)
    {
      if (documentJson != null && documentJson.HasValues)
      {
        // Проверить наличие файла в архиве.
        var documentFileName = documentJson.Value<string>("LocalFile");
        if (!string.IsNullOrWhiteSpace(documentFileName))
        {
          var documentEntry = containerZip.FirstOrDefault(e => e.FileName == documentFileName);
          
          if (documentEntry != null)
          {
            // Проверить квалифицированные электронные подписи.
            var signaturesJson = (JArray)documentJson.SelectToken("Signatures");
            if (signaturesJson != null)
            {
              var signaturesFileName = signaturesJson.Values<string>("LocalFile");
              if (signaturesFileName.Any())
              {
                using (var documentMS = new MemoryStream())
                {
                  documentEntry.Extract(documentMS);
                  foreach (var signatureFileName in signaturesFileName)
                  {
                    var signatureEntry = containerZip.FirstOrDefault(e => e.FileName == signatureFileName);
                    if (signatureEntry != null)
                    {
                      documentMS.Position = 0;
                      using (var signatureMS = new MemoryStream())
                      {
                        signatureEntry.Extract(signatureMS);
                        
                        var decoded = Storage.Functions.Module.DecodeFromBase64(signatureMS.ToArray());
                        var verifyInfo = ExternalSignatures.Verify(decoded, documentMS);
                        // Проверить ЭП
                        if (verifyInfo.Result != Sungero.Core.SignatureVerificationResult.Success)
                          return Resources.ErrorSignatureNotValidFormat(signatureFileName);
                      }
                    }
                    else
                      return Resources.ErrorMissingSignatureFormat(signatureFileName);
                  }
                }
              }
            }
          }
          else
            return Resources.ErrorContainerFileNotFoundFormat(documentFileName);
        }
      }
      return string.Empty;
    }
    
    /// <summary>
    /// Получить хэш файла.
    /// </summary>
    /// <param name="filename">Имя файла.</param>
    /// <returns>Строка со значением хэш.</returns>
    public virtual string GetFileHash(string filename)
    {
      var stringBuilder = new StringBuilder();
      using (var md5 = MD5.Create())
      {
        using (var fileStream = File.OpenRead(filename))
        {
          byte[] hash = md5.ComputeHash(fileStream);
          for (int i = 0; i < hash.Length; i++)
            stringBuilder.Append(hash[i].ToString("X2"));
        }
      }
      return stringBuilder.ToString();
    }
    
    /// <summary>
    /// Получить хэш потока.
    /// </summary>
    /// <param name="stream">Поток файла.</param>
    /// <returns>Строка со значением хэш.</returns>
    public virtual string GetStreamHash(System.IO.Stream stream)
    {
      var stringBuilder = new StringBuilder();
      using (var md5 = MD5.Create())
      {
        byte[] hash = md5.ComputeHash(stream);
        for (int i = 0; i < hash.Length; i++)
          stringBuilder.Append(hash[i].ToString("X2"));
      }
      return stringBuilder.ToString();
    }

    /// <summary>
    /// Синхронизировать реквизиты контейнера.
    /// </summary>
    /// <param name="container">Информация о контейнере.</param>
    /// <returns>Список синхронизированных реквизитов.</returns>
    [Public]
    public virtual List<DirRX.Storage.Structures.Module.ISyncInfo> SynchronizeRequisites(Storage.Structures.Module.IContainer container)
    {
      var requisites = new List<DirRX.Storage.Structures.Module.ISyncInfo>();
      
      // Извлечь данные о синхронизируемых реквизитах.
      var containerJson = JObject.Parse(container.Metadata);
      var documentJson = containerJson.SelectToken("Document");
      
      // Внешняя система.
      var externalSystemId = containerJson.Value<string>("Source");
      
      if (!string.IsNullOrEmpty(externalSystemId))
      {
        var entityId = ExternalSystems.GetAllCached(x => x.Status == Storage.ExternalSystem.Status.Active && x.SourceUid == externalSystemId).Select(x => x.Id).FirstOrDefault();
        requisites.Add(Storage.Structures.Module.SyncInfo.Create("ExternalSystem", string.Empty, externalSystemId, Constants.Module.EntityType.ExternalEntity, entityId, true));
      }
      
      // Вид документа.
      var externalDocumentKind = documentJson.Value<string>("Kind");
      if (!string.IsNullOrEmpty(externalDocumentKind))
      {
        var externalEntity = PublicFunctions.Module.GetExternalEntity(externalSystemId, string.Empty, Constants.Module.EntityType.DocumentKind);
        var entityId = externalEntity != null ? PublicFunctions.ExternalEntity.GetEntityId(externalEntity, externalDocumentKind) : null;
        requisites.Add(Storage.Structures.Module.SyncInfo.Create("DocumentKind", string.Empty, externalDocumentKind, Constants.Module.EntityType.DocumentKind, entityId, true));
      }
      
      // Подразделение.
      var externalDepartment = documentJson.Value<string>("Owner");
      if (!string.IsNullOrEmpty(externalDepartment))
      {
        var externalEntity = PublicFunctions.Module.GetExternalEntity(externalSystemId, string.Empty, Constants.Module.EntityType.Department);
        var entityId = externalEntity != null ? PublicFunctions.ExternalEntity.GetEntityId(externalEntity, externalDepartment) : null;
        requisites.Add(Storage.Structures.Module.SyncInfo.Create("Department", string.Empty, externalDepartment, Constants.Module.EntityType.Department, entityId, true));
      }

      // Дело.
      var externalCaseFile = documentJson.Value<string>("CaseFile");
      if (!string.IsNullOrEmpty(externalCaseFile))
      {
        var externalEntity = PublicFunctions.Module.GetExternalEntity(externalSystemId, string.Empty, Constants.Module.EntityType.CaseFile);
        var entityId = externalEntity != null ? PublicFunctions.ExternalEntity.GetEntityId(externalEntity, externalCaseFile) : null;
        var required = externalEntity == null || externalEntity.AllowNotMapped != true;
        requisites.Add(Storage.Structures.Module.SyncInfo.Create("CaseFile", string.Empty, externalCaseFile, Constants.Module.EntityType.CaseFile, entityId, required));
      }
      
      // Дополнительные реквизиты.
      var requisitesJson = documentJson.SelectToken("Requisites");
      if (requisitesJson != null && requisitesJson.HasValues)
      {
        foreach (var item in (JArray)requisitesJson)
        {
          var requisiteName = item.Value<string>("Name");
          var requisiteType = item.Value<string>("Type");
          var requisiteValue = item.Value<string>("Value");
          var externalEntity = PublicFunctions.Module.GetExternalEntity(externalSystemId, requisiteType, string.Empty);
          var entityId = externalEntity != null ? PublicFunctions.ExternalEntity.GetEntityId(externalEntity, requisiteValue) : null;
          var externalUid = externalEntity != null ? externalEntity.Uid : string.Empty;
          var required = externalEntity != null && externalEntity.AllowNotMapped != true;
          requisites.Add(Storage.Structures.Module.SyncInfo.Create(requisiteName, requisiteType, requisiteValue, externalUid, entityId, required));
        }
      }
      
      // Проверить наличие синхронизированных значений у обязательных реквизитов.
      var errorSync = requisites.Where(x => x.Required && !x.EntityId.HasValue).Select(x => x.ExternalName).ToArray();
      if (errorSync.Any())
      {
        container.Message = Resources.ErrorRequisitesNotSynchronizedFormat(string.Join(",", errorSync));
        container.Valid = false;
      }
      
      return requisites;
    }

    /// <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("Storage. 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("Storage. 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("Storage. 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("Storage. ExecuteServerFunction. Function \"{0}\" of module \"{1}\" does not exist.", functionName, moduleName));

      return method.Invoke(null, parameters);
    }
    
    /// <summary>
    /// Создать архивный документ.
    /// </summary>
    /// <param name="container">Содержимое zip-контейнера в виде структуры.</param>
    /// <returns>ИД созданного документа, текст ошибки.</returns>
    [Public]
    public virtual Structures.Module.IDocumentCreatingResult CreateLTADocument(Storage.Structures.Module.IContainer container)
    {
      var result = Structures.Module.DocumentCreatingResult.Create();
      try
      {
        var document = (IArchiveDocumentBase)Functions.Module.ExecuteServerFunction("DirRX.Storage", string.Format("Create{0}", container.Type), new object[] { container });
        this.FillLTADocument(container, document);
        result.Id = document.Id;
      }
      catch (Exception e)
      {
        var error = Storage.Resources.ErrorCreationLTADocumentFormat(container.Type, e.InnerException != null ? e.InnerException.Message : e.Message);

        Logger.Debug(error);
        result.ErrorMessage = error;
      }
      return result;
    }
    
    /// <summary>
    /// Заполнить основные реквизиты архивного документа, создать PDF/A версию и контейнер, выдать права.
    /// </summary>
    /// <param name="container">Содержимое zip-контейнера в виде структуры.</param>
    /// <param name="document">Документ.</param>
    [Public]
    public virtual void FillLTADocument(Storage.Structures.Module.IContainer container, DirRX.Storage.IArchiveDocumentBase document)
    {
      if (container.Valid)
      {
        // Заполнить дело.
        var requisite = container.Requisites.Where(x => x.EntityType == Constants.Module.EntityType.CaseFile && x.EntityId.HasValue).FirstOrDefault();
        if (requisite != null)
          document.CaseFile = Sungero.Docflow.CaseFiles.Get(requisite.EntityId.Value);
        else
        {
          // Назначить дело, используя правила.
          var query = Storage.CaseFileRules.GetAll(x => x.Status == Storage.CaseFileRule.Status.Active);
          if (document.DocumentKind != null)
            query = query.Where(x => !x.DocumentKinds.Any() || x.DocumentKinds.Any(item => item.DocumentKind.Id == document.DocumentKind.Id));
          if (document.Department != null)
            query = query.Where(x => !x.Departments.Any() || x.Departments.Any(item => item.Department.Id == document.Department.Id));
          if (document.RegistrationDate != null)
            query = query.Where(x => x.CaseFile.StartDate <= document.RegistrationDate && (!x.CaseFile.EndDate.HasValue || x.CaseFile.EndDate >= document.RegistrationDate));
          if (document.DocumentDate != null)
            query = query.Where(x => (x.FromDate.HasValue && x.ToDate.HasValue) ? (x.FromDate <= document.DocumentDate && x.ToDate >= document.DocumentDate)
                                : (x.FromDate.HasValue ? x.FromDate <= document.DocumentDate : (x.ToDate.HasValue ? x.ToDate >= document.DocumentDate : true)));
          
          if (query.Any())
            document.CaseFile = query.OrderByDescending(x => x.Id).First().CaseFile;
        }
        
        using (var containerData = new MemoryStream(container.ZipContent))
        {
          // Сохранить zip-архив в версию документа.
          var version = document.Versions.AddNew();
          version.Body.Write(containerData);
          version.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("zip");
          document.Save();

          // Сохранить PDF/A-файл в отображаемое представление для версии.
          containerData.Position = 0;
          using (ZipFile zip = ZipFile.Read(containerData))
          {
            var previewEntry = zip.FirstOrDefault(e => e.FileName == Constants.Module.PreviewFileName);
            if (previewEntry != null)
            {
              using (var previewMS = new MemoryStream())
              {
                previewEntry.Extract(previewMS);
                version.PublicBody.Write(previewMS);
                version.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("pdf");
                document.Save();
              }
            }
          }
        }

        this.SetArchiveDocumentAccessRights(document);
      }
    }
    
    /// <summary>
    /// Задать права доступа на архивный документ.
    /// </summary>
    /// <param name="document">Архивный документ.</param>
    /// <returns>Пустая строка, либо текст ошибки.</returns>
    [Public]
    public virtual string SetArchiveDocumentAccessRights(DirRX.Storage.IArchiveDocumentBase document)
    {
      var result = string.Empty;
      
      // Выдать права на документ, используя правила назначения прав.
      var allRules = Sungero.Docflow.AccessRightsRules.GetAll(x => x.Status == Sungero.Docflow.AccessRightsRule.Status.Active);
      if (document.DocumentKind != null)
        allRules = allRules.Where(x => !x.DocumentKinds.Any() || x.DocumentKinds.Any(item => item.DocumentKind.Id == document.DocumentKind.Id));
      
      foreach (var rule in allRules)
      {
        if (!this.TryGrantRightsToDocument(document, rule))
        {
          if (result != string.Empty)
            result += Environment.NewLine;
          
          result += Storage.Resources.ErrorGrantRightsByRuleFormat(rule.Name);
        }
      }
      
      DirRX.LongTermArchive.ICaseFile caseFile = null;
      
      // Проверить статус дела.
      if (document.CaseFile != null)
        caseFile = DirRX.LongTermArchive.CaseFiles.GetAll(x => x.Id == document.CaseFile.Id).SingleOrDefault();
      
      var isNotArchived = caseFile == null || (
        caseFile.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.InWork ||
        caseFile.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.CompletedDirRX ||
        caseFile.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.InventoriedDirRX);
      
      // Выдать права на полный доступ роли Архивист.
      var archivistRole = Sungero.CoreEntities.Roles
        .GetAll(x => Equals(x.Sid.Value, DirRX.CaseArchiving.PublicConstants.Module.Initialize.ArchivistRoleGuid))
        .SingleOrDefault();
      
      if (archivistRole != null && !this.TryGrantRightsToDocument(document, archivistRole, isNotArchived ? DefaultAccessRightsTypes.FullAccess : DefaultAccessRightsTypes.Read))
      {
        if (result != string.Empty)
          result += Environment.NewLine;
        
        result += Storage.Resources.ErrorGrantRightsToRoleFormat(archivistRole.DisplayValue);
      }
      
      // Выдать права на изменение роли Делопроизводители.
      var clerksRole = Sungero.CoreEntities.Roles
        .GetAll(x => Equals(x.Sid.Value, DirRX.CaseArchiving.PublicConstants.Module.Initialize.ClerksRole))
        .SingleOrDefault();

      if (clerksRole != null && !this.TryGrantRightsToDocument(document, clerksRole, isNotArchived ? DefaultAccessRightsTypes.Change : DefaultAccessRightsTypes.Read))
      {
        if (result != string.Empty)
          result += Environment.NewLine;
        
        result += Storage.Resources.ErrorGrantRightsToRoleFormat(clerksRole.DisplayValue);
      }
      
      return result;
    }
    
    /// <summary>
    /// Записать контейнер в версию документа.
    /// </summary>
    /// <param name="container">Содержимое zip-контейнера в виде структуры.</param>
    /// <returns>Текст ошибки.</returns>
    [Public]
    public virtual string CreateLTADocumentVersion(Storage.Structures.Module.IContainer container)
    {
      var error = string.Empty;
      
      if (container.Valid)
      {
        try
        {
          var containerJson = JObject.Parse(container.Metadata);
          var documentJson = containerJson.SelectToken("Document");
          var docId = documentJson.Value<int>("Uid");
          
          using (var containerData = new MemoryStream(container.ZipContent))
          {
            // Сохранить zip-архив в версию документа.
            var document = Sungero.Docflow.OfficialDocuments.Get(docId);
            Logger.DebugFormat("document {0} versions lock = {1}", document.Id, document.VersionsLocked);
            var version = document.Versions.AddNew();
            version.Note = Resources.ContainerVersionDescription;
            version.Body.Write(containerData);
            version.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("zip");

            // Сохранить PDF/A-файл в отображаемое представление для версии.
            containerData.Position = 0;
            using (var zip = ZipFile.Read(containerData))
            {
              var previewEntry = zip.FirstOrDefault(e => e.FileName == Constants.Module.PreviewFileName);
              if (previewEntry != null)
              {
                using (var previewMS = new MemoryStream())
                {
                  previewEntry.Extract(previewMS);
                  version.PublicBody.Write(previewMS);
                  version.AssociatedApplication = Sungero.Content.AssociatedApplications.GetByExtension("pdf");
                  document.Save();
                }
              }
            }
          }
        }
        catch (Exception e)
        {
          error = string.Format("{0}\n {1}", e.Message, e.StackTrace);
          Logger.DebugFormat("Ошибка при формировании версии документа из контейнера. {0}", error);
          return error;
        }
      }
      else
      {
        error = Storage.Resources.ErrorInvalidContainerFile;
      }
      
      return error;
    }
    
    /// <summary>
    /// Проверить метаданные контейнера.
    /// </summary>
    /// <param name="metadata">Метаданные контейнера в виде json-строки.</param>
    /// <param name="containerType">Тип контейнера.</param>
    /// <returns>Сообщение об ошибке, либо пустая строка.</returns>
    public virtual string CheckMetadata(string metadata, string containerType)
    {
      var result = string.Empty;
      if (!string.IsNullOrWhiteSpace(metadata))
      {
        try
        {
          if (!string.IsNullOrEmpty(metadata))
          {
            var schemaContent = string.Empty;
            // Проверить схему в зависимости от типа контейнера
            switch (containerType)
            {
              case "ArchiveDocument":
                schemaContent = Constants.Module.ContainerJsonSchema.ArchiveDocument;
                break;
              default:
                schemaContent = Constants.Module.ContainerJsonSchema.ArchiveDocument;
                break;
            }
            
            var schema = NJsonSchema.JsonSchema.FromJsonAsync(schemaContent).Result;
            var validator = new NJsonSchema.Validation.JsonSchemaValidator();
            var validateResult = validator.Validate(metadata, schema);

            if (validateResult.Count > 0)
            {
              result = Resources.ErrorMetadataNotValidFormat(string.Join(Environment.NewLine, validateResult));
              Logger.DebugFormat("Метаданные контейнера не соответствуют требуемому формату.\n{0}", result);
            }
          }
          else
          {
            result = Resources.ErrorParsingMetadata;
            Logger.DebugFormat("Не удалось распарсить строку метаданных.\n{0}", metadata);
          }
        }
        catch (Exception e)
        {
          result = e.InnerException != null ? e.InnerException.Message : e.Message;
          Logger.DebugFormat("Ошибка чтения метаданных.\n {0}", result);
        }
      }
      else
      {
        result = Resources.ErrorMissingMetadataFormat(Constants.Module.ContainerInfoFileName);
        Logger.Debug(result);
      }
      
      return result;
    }

    /// <summary>
    /// Получить информацию о состоянии обработки контейнера.
    /// </summary>
    /// <param name="guid">ГУИД контейнера в архивной системе.</param>
    /// <returns>Информация о состоянии обработки в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetStatusInfo(string guid)
    {
      var result = Structures.Module.ResultAnswer.Create();
      
      if (!string.IsNullOrWhiteSpace(guid))
      {
        var info = Storage.ArchiveEventLogs.GetAll(x => x.TempGuid == guid.ToLower()).FirstOrDefault();
        
        if (info != null)
        {
          return Functions.ArchiveEventLog.GetStatus(info);
        }
        else
        {
          result.Guid = guid;
          result.Status = Storage.ArchiveEventLog.CurrentState.Error.ToString();
          result.Message = Resources.ErrorMetadataNotFoundFormat(guid).ToString();
        }
      }
      else
      {
        result.Status = Storage.ArchiveEventLog.CurrentState.Error.ToString();
        result.Message = Resources.ErrorContainerNotSpecified.ToString();
      }
      
      return result;
    }

    /// <summary>
    /// Получить статус хранения архивного документа.
    /// </summary>
    /// <param name="sourceUid">Код исходной системы.</param>
    /// <param name="documentUid">Идентификатор документа в исходной системе.</param>
    /// <returns>Информация о статусе документа в виде json-строки.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetArchiveDocumentStatus(string sourceUid, string documentUid)
    {
      var storedStatus = "Stored";
      var errorStatus = Storage.ArchiveEventLog.CurrentState.Error.ToString();
      var destroyedStatus = Storage.ArchiveEventLog.CurrentState.Destroyed;
      
      var result = Structures.Module.ResultAnswer.Create();
      
      if (!string.IsNullOrWhiteSpace(sourceUid) && !string.IsNullOrWhiteSpace(documentUid))
      {
        var info = Storage.ArchiveEventLogs.GetAll(x => x.SourceDocumentUid == documentUid.ToLower() && x.SourceSystemUid == sourceUid.ToLower()).FirstOrDefault();
        if (info != null)
        {
          result.Guid = info.TempGuid;
          
          if (info.DocumentId.HasValue)
          {
            // Проверить существует ли документ.
            var document = Sungero.Content.ElectronicDocuments.Get(info.DocumentId.Value);
            if (document != null)
            {
              if (info.CurrentState != destroyedStatus)
                result.Status = storedStatus;
              else
                result.Status = destroyedStatus.ToString();
            }
            else
            {
              result.Status = errorStatus;
              result.Message = Resources.ErrorLTADocumentNotFoundFormat(info.DocumentId, info.TempGuid).ToString();
            }
          }
          else
          {
            // Если документ еще не создан, вернуть текущий статус обработки.
            result.Status = info.CurrentState.ToString();
            if (!string.IsNullOrWhiteSpace(info.Message))
              result.Message = info.Message;
          }
        }
        else
        {
          result.Status = Storage.ArchiveEventLog.CurrentState.Error.ToString();
          result.Message = Resources.ErrorMetadataNotFoundFormat().ToString();
        }
      }
      else
      {
        result.Status = Constants.Module.Status.Error;
        result.Message = Storage.Resources.ErrorNoParametersSpecified.ToString();
      }
      return result;
    }
    
    /// <summary>
    /// Выдать права на документ по правилу.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <param name="rule">Правило.</param>
    /// <returns>Возвращает true, если права удалось выдать, false - если надо повторить позже.</returns>
    public virtual bool TryGrantRightsToDocument(Storage.IArchiveDocumentBase document, Sungero.Docflow.IAccessRightsRule rule)
    {
      Logger.DebugFormat("TryGrantRightsToDocument: document {0}, rule {1}", document.Id, rule.Id);
      
      var isChanged = false;
      foreach (var member in rule.Members.Where(m => m.Recipient.IsSystem != true))
      {
        if (!document.AccessRights.IsGrantedDirectly(Sungero.Docflow.PublicFunctions.Module.GetRightTypeGuid(member.RightType), member.Recipient))
        {
          if (Locks.GetLockInfo(document).IsLockedByOther)
          {
            Logger.DebugFormat("TryGrantRightsToDocument: cannot grant rights, document {0} is locked.", document.Id);
            return false;
          }

          document.AccessRights.Grant(member.Recipient, Sungero.Docflow.PublicFunctions.Module.GetRightTypeGuid(member.RightType));
          isChanged = true;
        }
      }
      if (isChanged)
      {
        try
        {
          ((Sungero.Domain.Shared.IExtendedEntity)document).Params[Sungero.Docflow.PublicConstants.OfficialDocument.DontUpdateModified] = true;
          document.Save();
        }
        catch (Exception ex)
        {
          Logger.Error("TryGrantRightsToDocument: cannot grant rights to document", ex);
          return false;
        }
      }
      else
      {
        Logger.DebugFormat("TryGrantRightsToDocument: rights already granted for document {0}, rule {1}", document.Id, rule.Id);
      }
      
      return true;
    }
    
    /// <summary>
    /// Выдать права на документ роли.
    /// </summary>
    /// <param name="document">Документ.</param>
    /// <param name="role">Рол.</param>
    /// <param name="rightType">Тип прав.</param>
    /// <returns>Возвращает true, если права удалось выдать, false - если надо повторить позже.</returns>
    public virtual bool TryGrantRightsToDocument(Storage.IArchiveDocumentBase document, Sungero.CoreEntities.IRole role, System.Guid rightType)
    {
      Logger.DebugFormat("TryGrantRightsToDocument: document {0}, role {1}", document.Id, role);
      
      var isChanged = false;
      
      if (!document.AccessRights.IsGranted(DefaultAccessRightsTypes.FullAccess, role))
      {
        if (Locks.GetLockInfo(document).IsLockedByOther)
        {
          Logger.DebugFormat("TryGrantRightsToDocument: cannot grant rights, document {0} is locked.", document.Id);
          return false;
        }
        
        document.AccessRights.Grant(role, rightType);
        isChanged = true;
      }
      if (isChanged)
      {
        try
        {
          ((Sungero.Domain.Shared.IExtendedEntity)document).Params[Sungero.Docflow.PublicConstants.OfficialDocument.DontUpdateModified] = true;
          document.Save();
        }
        catch (Exception ex)
        {
          Logger.Error("TryGrantRightsToDocument: cannot grant rights to document", ex);
          return false;
        }
      }
      else
      {
        Logger.DebugFormat("TryGrantRightsToDocument: rights already granted for document {0}, role {1}", document.Id, role.Name);
      }
      
      return true;
    }
    
    /// <summary>
    /// Сформировать список типов архивных документов.
    /// </summary>
    /// <returns>Список типов архивных документов.</returns>
    [Public]
    public virtual List<string> GetArchiveDocumentsList()
    {
      var docList = this.GetDocumentTypes(typeof(IArchiveDocumentBase));
      return docList;
    }
    
    /// <summary>
    /// Получить наследуемые типы документов от текущего.
    /// </summary>
    /// <param name="documentType">Тип документа, передавать как typeof(IArchiveDocumentBase).</param>
    /// <returns>Список имен типов документов.</returns>
    public virtual List<string> GetDocumentTypes(System.Type documentType)
    {
      var metadata = documentType.GetEntityMetadata();
      var entities = metadata.DescendantEntities.ToList();
      entities.Add(metadata);
      var docList = entities.Select(m => m.GetOriginal()).Distinct()
        .Where(de => !de.IsAbstract)
        .Select(de => de.Name)
        .ToList();
      return docList;
    }
    
    /// <summary>
    /// Создать основной архивный документ.
    /// </summary>
    /// <param name="container">Содержимое zip-контейнера в виде структуры.</param>
    /// <returns>Документ.</returns>
    [Public]
    public virtual Storage.IArchiveDocument CreateArchiveDocument(Storage.Structures.Module.IContainer container)
    {
      // Получить метаданные в виде объекта.
      var containerJson = JObject.Parse(container.Metadata);
      var documentJson = containerJson.SelectToken("Document");
      
      // Создать документ, заполнить карточку.
      var document = Storage.ArchiveDocuments.Create();
      document.Name = documentJson.Value<string>("Name");
      document.Subject = document.Name;
      
      // Заполнить вид документа синхронизированным значением.
      var req = container.Requisites.Where(x => x.EntityType == Constants.Module.EntityType.DocumentKind && x.EntityId.HasValue).FirstOrDefault();
      if (req != null)
        document.DocumentKind = Sungero.Docflow.DocumentKinds.Get(req.EntityId.Value);
      
      // Заполнить подразделение.
      req = container.Requisites.Where(x => x.EntityType == Constants.Module.EntityType.Department && x.EntityId.HasValue).FirstOrDefault();
      if (req != null)
        document.Department = Sungero.Company.Departments.Get(req.EntityId.Value);
      
      document.BusinessUnit = document.Department.BusinessUnit;
      document.LifeCycleState = Sungero.Docflow.OfficialDocument.LifeCycleState.Active;
      document.ContainerUid = containerJson.Value<string>("Uid");
      
      var registrationJson = documentJson.SelectToken("Registration");
      if (registrationJson != null && registrationJson.HasValues)
      {
        document.RegistrationNumber = registrationJson.Value<string>("Number");
        document.RegistrationDate = registrationJson.Value<DateTime>("Date");
      }
      
      // Пример обработки дополнительных реквизитов в метаданных
      /*
      var requisitesDocument = documentJson.SelectToken("Requisites");
      if (requisitesDocument != null && requisitesDocument.HasValues)
      {
        foreach (var requisite in requisitesDocument)
        {
          if (requisite.Value<string>("Name") == "OurSignatory")
            document.Note += "Подписал: " + requisite.Value<string>("Value");
          
          if (requisite.Value<string>("Name") == "Note")
            document.Note += "Примечание: " + requisite.Value<string>("Value");
        }
      }
       */
      
      document.Save();
      return document;
    }
    
    #endregion
    
    #region Усовершенствование ЭП
    /// <summary>
    /// Определить дату улучшения ЭП, информацию добавить в коллецию записи журнала поступления и выбытия.
    /// </summary>
    /// <param name="eventLog">Запись Журнала поступления и выбытия.</param>
    /// <returns>Результат добавления информации.</returns>
    [Public]
    public virtual string SetNextImproveDate(Storage.IArchiveEventLog eventLog)
    {
      var error = string.Empty;
      var metadata = eventLog.Metadata;
      if (!string.IsNullOrEmpty(metadata))
      {
        try
        {
          var signatures = new Dictionary<string, string>();
          var containerJson = JObject.Parse(metadata);
          string document = (string)containerJson["Document"]["LocalFile"];
          var signatureToken = (JArray)containerJson["Document"]["Signatures"];
          
          if (signatureToken != null)
          {
            foreach (var jsonSignature in signatureToken)
            {
              var signature = (string)jsonSignature["LocalFile"];
              if (!string.IsNullOrEmpty(signature))
                signatures.Add(signature, document);
            }
          }
          
          var attachmentsToken = (JArray)containerJson["Attachments"];
          if (attachmentsToken != null)
          {
            foreach (var jsonAttachment in attachmentsToken)
            {
              var attachment = (string)jsonAttachment["LocalFile"];
              signatureToken = (JArray)jsonAttachment["Signatures"];
              if (signatureToken != null)
              {
                foreach (var jsonSignature in signatureToken)
                {
                  var signature = (string)jsonSignature["LocalFile"];
                  if (!string.IsNullOrEmpty(signature))
                    signatures.Add(signature, attachment);
                }
              }
            }
          }
          
          if (signatures.Any())
          {
            var minValidityPeriod = this.GetMinValidityPeriod(eventLog, signatures);

            var diff = minValidityPeriod.Subtract(Calendar.Now);
            var minDays = Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsNumbericValue(Constants.Module.DocflowParams.DaysBeforeImproveKey);
            if (diff.Days > minDays)
              eventLog.NextImproveDate = minValidityPeriod.AddDays(-1 * minDays);
            else if (diff.Days > 0 && diff.Days <= minDays)
              eventLog.NextImproveDate = minValidityPeriod.AddDays(1);
            else if (diff.Days == 0)
              eventLog.NextImproveDate = Calendar.Now.AddMinutes(3);
            if (eventLog.NextImproveDate > minValidityPeriod)
              eventLog.NextImproveDate = Calendar.Now;
          }
        }
        catch (Exception e)
        {
          error = Storage.Resources.ErrorSettingImprovementDateFormat(e.Message);
          Logger.ErrorFormat("{0} {1}", error, e.InnerException.Message);
        }
      }
      else
        error = Storage.Resources.ErrorMetadataNotFound;
      return error;
    }
    
    /// <summary>
    /// Определить минимальную дату срока действия списка сертификатов.
    /// </summary>
    /// <param name="eventLog">Запись Журнала поступления и выбытия.</param>
    /// <param name="signatures">Список сертификатов.</param>
    /// <returns>Минимальная дата окончания действия сертификата из списка.</returns>
    public virtual DateTime GetMinValidityPeriod(Storage.IArchiveEventLog eventLog, System.Collections.Generic.IDictionary<string, string> signatures)
    {
      var minValidityPeriod = Calendar.GetDate(5000, 06, 01);
      var improveAfterImport = Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsStringValue(Constants.Module.DocflowParams.ImproveAfterImportKey) == "true";
      if (improveAfterImport && signatures.Count > 0)
      {
        minValidityPeriod = Calendar.Now.AddMinutes(5);
      }

      foreach (var signature in signatures)
      {
        var signatureRow = eventLog.ContainerSignatures.AddNew();
        signatureRow.Filename = signature.Value;
        signatureRow.SignFilename = signature.Key;
        var validityPeriod = minValidityPeriod;
        
        byte[] signatureContent = null;
        using (ZipFile zip = ZipFile.Read(eventLog.FilePath))
        {
          var metadataEntry = zip.FirstOrDefault(e => e.FileName == signature.Key);
          if (metadataEntry != null)
          {
            using (var metadataMS = new MemoryStream())
            {
              metadataEntry.Extract(metadataMS);
              signatureContent = metadataMS.ToArray();
            }
          }
        }
        var signInfo = ExternalSignatures.GetSignatureInfo(signatureContent);
        
        switch (signInfo.SignatureFormat)
        {
          case SignatureFormat.CadesBes:
            {
              var cadesBesInfo = signInfo.AsCadesBesSignatureInfo();
              validityPeriod = cadesBesInfo.Certificate.NotAfter;
              break;
            }
          case SignatureFormat.CadesT:
            {
              var cadesTInfo = signInfo.AsCadesTSignatureInfo();
              validityPeriod = cadesTInfo.Certificate.NotAfter;
              break;
            }
          case SignatureFormat.CadesXL:
            {
              var cadesXLInfo = signInfo.AsCadesXLSignatureInfo();
              validityPeriod = cadesXLInfo.EvidenceTimestamp.Certificate.NotAfter;
              break;
            }
          case SignatureFormat.CadesA:
            {
              var cadesAInfo = signInfo.AsCadesASignatureInfo();
              validityPeriod = cadesAInfo.ArchiveTimestamps.Last().Certificate.NotAfter;
              break;
            }
          default:
            validityPeriod = minValidityPeriod;
            break;
        }
        
        if (minValidityPeriod > validityPeriod)
          minValidityPeriod = validityPeriod;
      }
      return minValidityPeriod;
    }
    
    /// <summary>
    /// Улучшить ЭП контейнера.
    /// </summary>
    /// <param name="eventLog">Запись справочника "Журнал поступления и выбытия документов".</param>
    public virtual void ImproveArchiveDocumentSignatures(IArchiveEventLog eventLog)
    {
      var doc = Sungero.Content.ElectronicDocuments.Null;
      
      try
      {
        doc = Sungero.Content.ElectronicDocuments.Get(eventLog.DocumentId.Value);
      }
      catch (Exception e)
      {
        Storage.Functions.Module.AddArchiveEventLog(eventLog.TempGuid, Storage.ArchiveEventLogs.Resources.Operation_Improve, Storage.ArchiveEventLog.CurrentState.Error, "Ошибка при получении документа. " + e.Message);
        Logger.DebugFormat("{0} {1}", e.Message, e.InnerException.Message);
        return;
      }
      
      // Временная папка для ЭП и док-в из контейнера
      var containerFolder = this.GetContainerFolder(DirRX.Storage.Constants.Module.Paths.LTAImproveContainersFolder);
      var containerFilename = Path.Combine(containerFolder, string.Format(@"{0}.zip", eventLog.TempGuid));
      var folder = this.GetContainerFolder(Path.Combine(DirRX.Storage.Constants.Module.Paths.LTAImproveContainersFolder, eventLog.TempGuid));
      eventLog.FilePath = folder;
      eventLog.Save();
      
      // Распаковать zip-контейнер во временную папку
      using (var file = new System.IO.FileStream(containerFilename, FileMode.Create))
      {
        using (var sourceStream = doc.LastVersion.Body.Read())
          sourceStream.CopyTo(file);
      }
      
      this.ClearDirectory(folder);
      Compression.ZipFile.ExtractToDirectory(containerFilename, folder);
      File.Delete(containerFilename);
      var improveResult = Structures.Module.ImproveResult.Create();
      eventLog.ImproveStartDate = Calendar.Now;
      improveResult = PublicFunctions.Module.ImproveArchiveDocument(eventLog);
      
      Logger.DebugFormat("ImproveArchiveDocumentSignatures(). Eventlog id = {0}. Improve result: ErrorMessage={1}, CadesLevel={2}, NextImproveDate={3}", eventLog.Id, improveResult.ErrorMessage, improveResult.CadesLevel, improveResult.NextImproveDate.ToString());
      
      if (improveResult.NextImproveDate != null && string.IsNullOrEmpty(improveResult.ErrorMessage))
      {
        Storage.Functions.Module.AddArchiveEventLog(eventLog.TempGuid, Storage.ArchiveEventLogs.Resources.Operation_Improve, Storage.ArchiveEventLog.CurrentState.InProcess, Resources.NewImproveTimeAssignedFormat(improveResult.NextImproveDate.ToString()));
        eventLog.NextImproveDate = improveResult.NextImproveDate;
      }
      
      if (!string.IsNullOrEmpty(improveResult.ErrorMessage))
      {
        Storage.Functions.Module.AddArchiveEventLog(eventLog.TempGuid, Storage.ArchiveEventLogs.Resources.Operation_Improve, Storage.ArchiveEventLog.CurrentState.Error, improveResult.ErrorMessage);
        eventLog.ImproveResult = Storage.ArchiveEventLog.CurrentState.Error.Value;
      }
      else
      {
        Compression.ZipFile.CreateFromDirectory(folder, containerFilename);
        // Импортировать zip-контейнер из временной папки c улучшенными ЭП
        using (var zipFile = new FileStream(containerFilename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
        {
          doc.LastVersion.Body.Write(zipFile);
          doc.Save();
          var newHash = Storage.Functions.Module.GetStreamHash(zipFile);
          eventLog.Hash = newHash;
          eventLog.CadesLevel = improveResult.CadesLevel;
          Storage.Functions.Module.AddArchiveEventLog(eventLog.TempGuid, Storage.ArchiveEventLogs.Resources.Operation_Import, Storage.ArchiveEventLog.CurrentState.InProcess, Resources.ContainerUpdatedFormat(newHash));
          Storage.Functions.Module.AddArchiveEventLog(eventLog.TempGuid, Storage.ArchiveEventLogs.Resources.Operation_Improve, Storage.ArchiveEventLog.CurrentState.Complete, Resources.ImproveCompleteToLevelFormat(improveResult.CadesLevel));
          eventLog.ImproveResult = Storage.ArchiveEventLog.CurrentState.Complete.Value;
        }
      }
      eventLog.ImproveEndDate = Calendar.Now;
      
      // Удалить временную папку
      Directory.Delete(folder, true);
      File.Delete(containerFilename);
      eventLog.FilePath = string.Empty;
      eventLog.Save();
    }
    
    /// <summary>
    /// Усовершенствовать ЭП архивного документа.
    /// </summary>
    /// <param name="eventLog">Запись справочника "Журнал поступления и выбытия документов".</param>
    /// <returns>Результат усовершенствования в виде структуры.</returns>
    [Public]
    public virtual Structures.Module.IImproveResult ImproveArchiveDocument(IArchiveEventLog eventLog)
    {
      var improveResult = new Structures.Module.ImproveResult();
      
      if (eventLog.ContainerSignatures.Count > 0)
      {
        var dataFileNames = eventLog.ContainerSignatures.Select(f => f.Filename).Distinct();
        Logger.DebugFormat("ImproveArchiveDocument() start. Event log id = {0}, signatures in container = {1}", eventLog.Id, dataFileNames.Count());
        
        foreach (var dataFileName in dataFileNames)
        {
          var signatureFileNames = eventLog.ContainerSignatures.Where(f => f.Filename == dataFileName).Select(s => s.SignFilename).ToList();
          Logger.Debug(string.Format(@"doc filename {0}\\{1}", eventLog.FilePath, dataFileName));
          
          using (var dataFileStream = File.OpenRead(Path.Combine(eventLog.FilePath, dataFileName)))
          {
            var signatures = new Dictionary<string, byte[]>();
            foreach (var signatureFileName in signatureFileNames)
            {
              var signFileName = Path.Combine(eventLog.FilePath, signatureFileName);
              var decoded = Storage.Functions.Module.DecodeFromBase64(File.ReadAllBytes(signFileName));
              signatures.Add(signFileName, decoded);
              Logger.Debug(string.Format(@"signature filename {0}", signFileName));
            }
            
            var signatureInfos = ExternalSignatures.Verify(signatures, dataFileStream);
            if (signatureInfos.Any(i => i.Value.Result != Sungero.Core.SignatureVerificationResult.Success))
            {
              improveResult.ErrorMessage = Resources.ErrorInvalidSignature;
              break;
            }
            
            var signaturesToImprove = this.GetSignaturesToImprove(signatureInfos);
            var improvedSignatureContainers = new Dictionary<string, IImprovedSignatureContainer>();
            var errorMessage = string.Empty;
            
            foreach (var signature in signaturesToImprove)
            {
              improvedSignatureContainers.Add(signature.Key, this.ImproveSignature(signature.Key, signature.Value, dataFileStream, ref errorMessage));
              if (!string.IsNullOrEmpty(errorMessage))
                break;
            }
            
            if (!string.IsNullOrEmpty(errorMessage))
            {
              improveResult.ErrorMessage = errorMessage;
              break;
            }
            
            foreach(var improveSign in improvedSignatureContainers)
            {
              Logger.DebugFormat("ImproveArchiveDocument(). Improve result of doc with eventlog id {0} is {1}, next try date is {2}", eventLog.Id, improveSign.Value.ImproveResult.ToString(), improveSign.Value.NextTryDate.ToString());
            }
            
            if (improvedSignatureContainers.Any(c => c.Value.ImproveResult == ImproveSignatureResult.TryLater))
            {
              var maxNextTryDate = improvedSignatureContainers.Values
                .Where(c => c.ImproveResult == ImproveSignatureResult.TryLater)
                .OrderByDescending(c => c.NextTryDate).First();
              improveResult.NextImproveDate = maxNextTryDate.NextTryDate.AddHours(1);
              break;
            }
            
            if (improvedSignatureContainers.Any(c => c.Value.ImproveResult == ImproveSignatureResult.OutdatedSignatureCertificates))
            {
              improveResult.ErrorMessage = Resources.ErrorDeprecatedSignature;
              break;
            }
            
            foreach (var improvedSignatureContainer in improvedSignatureContainers)
            {
              File.WriteAllBytes(improvedSignatureContainer.Key, improvedSignatureContainer.Value.ImprovedSignature);
            }
            
            var improvedSignatureInfo = ExternalSignatures.GetSignatureInfo(
              improvedSignatureContainers[improvedSignatureContainers.Keys.First()].ImprovedSignature);
            
            switch (improvedSignatureInfo.SignatureFormat)
            {
              case SignatureFormat.CadesT:
                {
                  improveResult.CadesLevel = "CAdES-T";
                  improveResult.NextImproveDate = Calendar.Now.AddMinutes(5);
                  break;
                }
              case SignatureFormat.CadesXL:
                {
                  improveResult.CadesLevel = "CAdES-XL";
                  improveResult.NextImproveDate = Calendar.Now.AddMinutes(5);
                  break;
                }
              case SignatureFormat.CadesA:
                {
                  var cadesAInfo = improvedSignatureInfo.AsCadesASignatureInfo();
                  var certificateExpirationDate = cadesAInfo.ArchiveTimestamps.Last().Certificate.NotAfter;
                  improveResult.CadesLevel = "CAdES-A";
                  improveResult.NextImproveDate = certificateExpirationDate.AddMonths(-3);
                  break;
                }
              default:
                break;
            }
          }
        }
      }
      return improveResult;
    }
    
    /// <summary>
    /// Определить ЭП, которые необходимо усовершенствовать.
    /// </summary>
    /// <param name="allSignatures">Список ЭП.</param>
    /// <returns>Список ЭП для усовершенствования.</returns>
    private IReadOnlyDictionary<string, ISignatureInfo> GetSignaturesToImprove(IReadOnlyDictionary<string, ISignatureInfo> allSignatures)
    {
      var signaturesToImprove = new Dictionary<string, ISignatureInfo>();
      
      // В процессе архивирования подписей нужно сначала выровнять их формат от наименьшего к наибольшему.
      if (allSignatures.Values.Any(s => s.SignatureFormat == SignatureFormat.CadesBes) && allSignatures.Values.Any(s => s.SignatureFormat != SignatureFormat.CadesBes))
      {
        foreach (var key in allSignatures.Keys)
        {
          if (allSignatures[key].SignatureFormat == SignatureFormat.CadesBes)
            signaturesToImprove.Add(key, allSignatures[key]);
        }
      }
      else if (allSignatures.Values.Any(s => s.SignatureFormat == SignatureFormat.CadesT) && allSignatures.Values.Any(s => s.SignatureFormat != SignatureFormat.CadesT))
      {
        foreach (var key in allSignatures.Keys)
        {
          if (allSignatures[key].SignatureFormat == SignatureFormat.CadesT)
            signaturesToImprove.Add(key, allSignatures[key]);
        }
      }
      else
      {
        foreach (var key in allSignatures.Keys)
          signaturesToImprove.Add(key, allSignatures[key]);
      }
      return signaturesToImprove;
    }
    
    /// <summary>
    /// Усовершенствовать подпись.
    /// </summary>
    /// <param name="signatureFileName">Имя файла с подписью.</param>
    /// <param name="signatureInfo">Информация о подписи.</param>
    /// <param name="dataFileStream">Поток с данными, на которые была поставлена подпись.</param>
    /// <param name="errorMessage">Сообщение об ошибке.</param>
    /// <returns>Контейнер усовершенствованной подписи.</returns>
    private IImprovedSignatureContainer ImproveSignature(string signatureFileName, ISignatureInfo signatureInfo, System.IO.Stream dataFileStream, ref string errorMessage)
    {
      try
      {
        var signature = File.ReadAllBytes(signatureFileName);
        switch (signatureInfo.SignatureFormat)
        {
          case SignatureFormat.CadesBes:
            {
              return ExternalSignatures.ImproveToCadesT(signature, dataFileStream);
            }
          case SignatureFormat.CadesT:
            {
              return ExternalSignatures.ImproveToCadesXL(signature, dataFileStream);
            }
          case SignatureFormat.CadesXL:
          case SignatureFormat.CadesA:
            {
              return ExternalSignatures.ImproveToCadesA(signature, dataFileStream);
            }
          default:
            {
              errorMessage = Resources.ErrorSignatureFormatFormat(Path.GetFileName(signatureFileName));
              Logger.Debug(errorMessage);
              return null;
            }
        }
      }
      catch (Exception ex)
      {
        errorMessage = ex.Message;
        Logger.Error(errorMessage, ex);
        return null;
      }
    }
    
    /// <summary>
    /// Отправка уведомления.
    /// </summary>
    /// <param name="subject">Тема.</param>
    /// <param name="text">Текст уведомления.</param>
    /// <param name="users">Список адресатов.</param>
    [Public]
    public virtual void SendNotice(string subject, string text, System.Collections.Generic.IEnumerable<IRecipient> users)
    {
      var task = Sungero.Workflow.SimpleTasks.Create();
      task.Subject = subject;
      task.ActiveText = text;
      
      foreach (var user in users)
      {
        var step = task.RouteSteps.AddNew();
        step.AssignmentType = Sungero.Workflow.SimpleTask.AssignmentType.Notice;
        step.Performer = user;
      }
      
      task.Save();
      task.Start();
    }
    
    [Public]
    public virtual void SendNotice(string subject, string text, System.Collections.Generic.IEnumerable<IRecipient> users, IEntity attachment)
    {
      var task = Sungero.Workflow.SimpleTasks.Create();
      task.Subject = subject;
      task.ActiveText = text;
      task.Attachments.Add(attachment);
      
      foreach (var user in users)
      {
        var step = task.RouteSteps.AddNew();
        step.AssignmentType = Sungero.Workflow.SimpleTask.AssignmentType.Notice;
        step.Performer = user;
      }
      
      task.Save();
      task.Start();
    }
    #endregion
    
    #region Обработка запросов в архив
    
    /// <summary>
    /// Получить сотрудника, ответственного за обработку запросов.
    /// </summary>
    /// <returns>Запись справочника "Сотрудники".</returns>
    [Remote(IsPure = true), Public]
    public virtual Sungero.Company.IEmployee GetRequestResponsible()
    {
      var paramKey = Constants.Module.DocflowParams.RequestResponsibleKey;
      var responsibleId = (int)Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsNumbericValue(paramKey);
      return Sungero.Company.Employees.GetAll(x => x.Id == responsibleId).SingleOrDefault();
    }
    
    /// <summary>
    /// Сохранить ИД сотрудника, ответственного за обработку запросов.
    /// </summary>
    /// <param name="responsible">Сотрудник.</param>
    [Public, Remote]
    public virtual void SetRequestResponsible(Sungero.Company.IEmployee responsible)
    {
      var paramKey = Constants.Module.DocflowParams.RequestResponsibleKey;
      var paramValue = responsible != null ? responsible.Id.ToString() : string.Empty;
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(paramKey, paramValue);
    }
    
    /// <summary>
    /// Получить список пользователей архива.
    /// </summary>
    /// <returns>Список пользователей из роли "Пользователи архива".</returns>
    [Remote(IsPure = true), Public]
    public virtual List<Sungero.CoreEntities.IUser> GetArchiveUsers()
    {
      var roleArchiveUsers = Sungero.CoreEntities.Roles.GetAll(r => r.Sid == Constants.Module.Initialize.ArchiveUsersRoleGuid).SingleOrDefault();
      return roleArchiveUsers.RecipientLinks.Where(x => x.Member != null && Users.Is(x.Member)).Select(x => Users.As(x.Member)).ToList();
    }
    
    /// <summary>
    /// Создать запрос в архив.
    /// </summary>
    /// <returns>Задача "Запрос в архив".</returns>
    [Remote, Public]
    public virtual IRequestProcessingTask CreateRequestProcessingTask()
    {
      return Storage.RequestProcessingTasks.Create();
    }
    
    /// <summary>
    /// Отфильтровать не архивные документы.
    /// </summary>
    /// <param name="documentsIds">Список ИД документов.</param>
    /// <returns>Список ИД документов, отсутствующих в Журнале поступления и выбытия, либо уже уничтоженных.</returns>
    [Remote, Public]
    public virtual List<int> FilterNonArchiveDocuments(List<int> documentsIds)
    {
      var archiveDocumentIds = new HashSet<int>(Storage.ArchiveEventLogs.GetAll(x => x.DocumentId.HasValue && x.DocumentId.Value > 0 && x.DestructionAct == null).Select(x => x.DocumentId.Value));
      return documentsIds.Where(x => !archiveDocumentIds.Contains(x)).ToList();
    }

    /// <summary>
    /// Создать архивную выписку.
    /// </summary>
    /// <returns>Простой документ с видом "Архивная выписка".</returns>
    [Remote, Public]
    public virtual Sungero.Docflow.ISimpleDocument CreateArchiveExtract()
    {
      var document = Sungero.Docflow.SimpleDocuments.Null;
      var externalLink = Sungero.Docflow.PublicFunctions.Module.GetExternalLink(Storage.PublicConstants.Module.Initialize.DocumentKindTypeGuid,
                                                                                Storage.PublicConstants.Module.Initialize.ArchiveExtractDocumentKind);
      var template = Sungero.Content.ElectronicDocumentTemplates.GetAll(x => x.Name == Resources.InitArchiveExtractDocumentKindName).FirstOrDefault();
      if (externalLink != null)
      {
        if (template != null)
        {
          document = Sungero.Docflow.SimpleDocuments.CreateFrom(template);
          document.DocumentKind = Sungero.Docflow.DocumentKinds.GetAll(x => x.Id == externalLink.EntityId).SingleOrDefault();
          document.Save();
        }
        else
        {
          throw AppliedCodeException.Create("Не найден шаблон для вида документа \"Архивная выписка\"");
        }
      }
      else
      {
        throw AppliedCodeException.Create("Не найден вид документа \"Архивная выписка\"");
      }
      
      return document;
    }

    /// <summary>
    /// Создать архивную справку.
    /// </summary>
    /// <returns>Простой документ с видом "Архивная справка".</returns>
    [Remote, Public]
    public virtual Sungero.Docflow.ISimpleDocument CreateArchivalReference()
    {
      var document = Sungero.Docflow.SimpleDocuments.Null;
      var externalLink = Sungero.Docflow.PublicFunctions.Module.GetExternalLink(Storage.PublicConstants.Module.Initialize.DocumentKindTypeGuid,
                                                                                Storage.PublicConstants.Module.Initialize.ArchivalReferenceDocumentKind);
      var template = Sungero.Content.ElectronicDocumentTemplates.GetAll(x => x.Name == Resources.InitArchivalReferenceDocumentKindName).FirstOrDefault();
      if (externalLink != null)
      {
        if (template != null)
        {
          document = Sungero.Docflow.SimpleDocuments.CreateFrom(template);
          document.DocumentKind = Sungero.Docflow.DocumentKinds.GetAll(x => x.Id == externalLink.EntityId).SingleOrDefault();
          document.Save();
        }
        else
        {
          throw AppliedCodeException.Create("Не найден шаблон для вида документа \"Архивная справка\"");
        }
      }
      else
      {
        throw AppliedCodeException.Create("Не найден вид документа \"Архивная справка\"");
      }
      
      return document;
    }
    
    /// <summary>
    /// Сохранить результаты запроса в истории документа.
    /// </summary>
    /// <param name="document">Архивный документ.</param>
    /// <param name="note">Комментарий для сохранения в истории.</param>
    [Public]
    public virtual void WriteRequestAccessHistory(Storage.IArchiveDocumentBase document, string note)
    {
      // HACK для локализации необходимо добавить Enum_Operation_Request в ресурсы ArchiveDocumentBase.
      document.History.Write(new Sungero.Core.Enumeration("Request"), null, note);
    }
    
    /// <summary>
    /// Создать задачу на обработку запроса.
    /// </summary>
    /// <param name="content">Содержимое запроса к архиву в виде json-строки.</param>
    /// <returns>ИД задачи на обработку.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer ProcessLTARequest(string content)
    {
      var json = new JObject();
      var result = Structures.Module.ResultAnswer.Create();
      
      // Создать задачу для обработки запроса.
      try
      {
        var task = RequestProcessingTasks.Create();

        task.RequestData = content;
        task.Author = Functions.Module.GetServiceUser();
        task.Save();
        task.Start();
        
        result.Status = Constants.Module.Status.Ok;
        result.Guid = task.Id.ToString();
      }
      catch (Exception e)
      {
        var error = e.InnerException != null ? e.InnerException.Message : e.Message;
        result.Status = Constants.Module.Status.Error;
        result.Message = error;
        Logger.Error(error);
      }
      return result;
    }

    /// <summary>
    /// Получить статус запроса.
    /// </summary>
    /// <param name="taskId">ИД задачи в ДА.</param>
    /// <returns>Информация о запросе, строка в формате json.</returns>
    [Public]
    public virtual Structures.Module.IResultAnswer GetArchiveRequestStatus(int taskId)
    {
      // Если задание на обработку запроса выполнено, вернуть результаты. Иначе сформировать сообщение о том, что запрос еще обрабатывается.
      var result = Structures.Module.ResultAnswer.Create();
      result.Guid = taskId.ToString();
      
      try
      {
        var task = Storage.RequestProcessingTasks.Get(taskId);
        result.Status = Constants.Module.Status.Ok;

        if (!string.IsNullOrEmpty(task.RequestResults))
        {
          result.Data = task.RequestResults;
        }
        else
        {
          var data = new JObject();
          data.Add("Status", "InProcess");
          data.Add("Message", "Обработка запроса не завершена");
          result.Data = data.ToString();
        }
      }
      catch (Exception e)
      {
        Logger.Debug(e.ToString());
        result.Status = Constants.Module.Status.Error;
        result.Message = e.Message;
      }
      return result;
    }
    
    /// <summary>
    /// Конвертировать ФИО в родительный падеж.
    /// </summary>
    /// <param name="userName">Фамилия, имя, отчество.</param>
    /// <returns>Фамилия в родительном падеже с инициалами.</returns>
    public static string GetUserNameInGenitive(string userName)
    {
      PersonFullName personalData;
      var result = userName;
      if (PersonFullName.TryParse(userName, out personalData) && !string.IsNullOrEmpty(personalData.MiddleName))
      {
        personalData.DisplayFormat = PersonFullNameDisplayFormat.LastNameAndInitials;
        result = CaseConverter.ConvertPersonFullNameToTargetDeclension(personalData, Sungero.Core.DeclensionCase.Genitive);
      }
      return result;
    }

    #endregion
    
    #region Настройки
    /// <summary>
    /// Сохранить основные настройки модуля.
    /// </summary>
    /// <param name="verificationInterval">Период плановой проверки, дней.</param>
    /// <param name="minDaysBeforeImprove">Число дней до передподписания.</param>
    /// <param name="improveAfterImport">Улучшать подписи после импорта (true/false).</param>
    [Remote(IsPure = true), Public]
    public virtual void SetMainSettings(int verificationInterval, int minDaysBeforeImprove, bool improveAfterImport)
    {
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(Constants.Module.DocflowParams.ImproveAfterImportKey, improveAfterImport.ToString().ToLower());
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(Constants.Module.DocflowParams.DaysBeforeImproveKey, minDaysBeforeImprove.ToString());
      Sungero.Docflow.PublicFunctions.Module.InsertOrUpdateDocflowParam(Constants.Module.DocflowParams.VerificationIntervalKey, verificationInterval.ToString());
    }
    
    /// <summary>
    /// Получить сотрудника для текущего пользователя.
    /// </summary>
    /// <returns>Запись справочника "Сотрудники", соответствующая текущему пользователю.</returns>
    [Remote(IsPure = true), Public]
    public virtual Sungero.Company.IEmployee GetEmployeeForCurentUser()
    {
      var result = Sungero.Company.Employees.Null;
      if (Users.Current != null)
        result = Sungero.Company.Employees.GetAll(e => Equals(Users.Current, e)).SingleOrDefault();
      return result;
    }

    /// <summary>
    /// Получить сотрудника для пользователя.
    /// </summary>
    /// <param name="user">Пользователь.</param>
    /// <returns>Запись справочника "Сотрудники", соответствующая пользователю.</returns>
    [Remote(IsPure = true), Public]
    public virtual Sungero.Company.IEmployee GetEmployeeForUser(Sungero.CoreEntities.IUser user)
    {
      var result = Sungero.Company.Employees.Null;
      if (user != null)
        result = Sungero.Company.Employees.GetAll(e => Equals(user, e)).SingleOrDefault();
      return result;
    }
    
    /// <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
    
    #region Служебные
    
    /// <summary>
    /// Очистить папку.
    /// </summary>
    [Public]
    public virtual void ClearDirectory(string folder)
    {
      if (!string.IsNullOrEmpty(folder))
      {
        var fileslist = Directory.GetFiles(folder, "*");
        if (fileslist.Length > 0)
        {
          Directory.Delete(folder);
          Directory.CreateDirectory(folder);
        }
      }
    }
    #endregion
  }
}