ModuleAsyncHandlers.cs 25.6 KB

Raw Blame History Permalink

using System;
using System.IO;
using System.IO.Compression;
using System.Collections.Generic;
using System.Linq;
using Sungero.Core;
using Sungero.CoreEntities;

namespace DirRX.Storage.Server
{
  public class ModuleAsyncHandlers
  {
    // Отменить временный доступ к документу.
    public virtual void RevokeTemporaryAccessRights(DirRX.Storage.Server.AsyncHandlerInvokeArgs.RevokeTemporaryAccessRightsInvokeArgs args)
    {
      var eventLog = Storage.ArchiveEventLogs.Get(args.eventLogId);
      var document = Sungero.Content.ElectronicDocuments.Get(eventLog.DocumentId.Value);
      var access = document.AccessRights;

      foreach (var item in eventLog.TemporaryAccess.Where(x => x.Status == Storage.ArchiveEventLogTemporaryAccess.Status.Granted && x.TermTo < Calendar.Now.BeginningOfDay()))
      {
        access.Revoke(item.User, DefaultAccessRightsTypes.Read);
        item.Status = Storage.ArchiveEventLogTemporaryAccess.Status.Revoked;
      }

      if (eventLog.State.IsChanged)
      {
        access.Save();
        eventLog.Save();
      }
    }

    // Предоставить временный доступ на чтение документа.
    public virtual void GrantTemporaryAccessRightsToRead(DirRX.Storage.Server.AsyncHandlerInvokeArgs.GrantTemporaryAccessRightsToReadInvokeArgs args)
    {
      var eventLog = PublicFunctions.Module.Remote.GetArchiveEventLogEntry(args.documentId);
      if (eventLog != null)
      {
        var document = Sungero.Content.ElectronicDocuments.Get(args.documentId);
        var accessRights = document.AccessRights;
        var user = Users.GetAll(x => x.Id == args.userId).SingleOrDefault();
        if (user != null && user.IsSystem != true && !accessRights.IsGrantedDirectly(DefaultAccessRightsTypes.Read, user))
        {
          accessRights.Grant(user, DefaultAccessRightsTypes.Read);
          accessRights.Save();

          var tempAccessItem = eventLog.TemporaryAccess.AddNew();
          tempAccessItem.Request = args.request;
          tempAccessItem.TermFrom = args.termFrom;
          tempAccessItem.TermTo = args.termTo;
          tempAccessItem.User = user;
          tempAccessItem.Status = Storage.ArchiveEventLogTemporaryAccess.Status.Granted;

          var note = Storage.ArchiveEventLogs.Resources.InfoRequestAccessNoteFormat(user.DisplayValue, args.termFrom.ToString(), args.termTo.ToString());

          var operation = ArchiveDocumentBases.Resources.Enum_Operation_Request;
          Storage.PublicFunctions.ArchiveEventLog.AddEventHistory(eventLog, operation, eventLog.CurrentState.Value, note);

          if (Storage.ArchiveDocumentBases.Is(document))
            Storage.PublicFunctions.Module.WriteRequestAccessHistory(Storage.ArchiveDocumentBases.As(document), note);
          else
            document.History.Write(new Sungero.Core.Enumeration("Request"), null, note);
        }
      }
      else
        Logger.DebugFormat("Не найдена запись журнала Поступление и выбытие документов для документа ИД {0}", args.documentId);
    }

    // Синхронизировать свойства архивного документа в Журнале поступления и выбытия.
    public virtual void SynchronizeArchiveDocumentProperties(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SynchronizeArchiveDocumentPropertiesInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика SynchronizeArchiveDocumentProperties. ИД документа {0}", args.documentId);

      if (args.documentId == 0)
      {
        Logger.Debug("SynchronizeArchiveDocumentProperties. Передан пустой ИД документа.");
        return;
      }

      var eventLog = PublicFunctions.Module.Remote.GetArchiveEventLogEntry(args.documentId);

      if (eventLog == null)
      {
        Logger.Debug("SynchronizeArchiveDocumentProperties. Не найден журнал поступления и выбытия.");
        return;
      }

      Storage.PublicFunctions.ArchiveEventLog.SynchronizeArchiveDocumentProperties(eventLog);
    }

    // Отправить уведомление ответственному, если все документы проверены.
    public virtual void SendNotificationAfterVerification(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SendNotificationAfterVerificationInvokeArgs args)
    {
      args.Retry = false;

      // Минимальное время перезапупска, сек.
      var minRetryInterval = 10;

      Logger.Debug("Старт асинхронного обработчика SendNotificationAfterVerification");

      if (args.eventId == 0)
      {
        Logger.Debug("SendNotificationAfterVerification. Передан пустой ИД журнала.");
        return;
      }

      var eventLog = Storage.ArchiveEventLogs.GetAll(x => Equals(x.Id, args.eventId)).Single();

      // Если это был последний проверенный контейнер в сессии, отправить уведомление с результатами обработки.
      var sessionHasResults = Storage.ArchiveEventLogs.GetAll(x => x.JobStartDate.HasValue && x.JobStartDate.Value == eventLog.JobStartDate.Value &&
                                                              x.VerificationReason == eventLog.VerificationReason &&
                                                              x.VerificationResponsible == eventLog.VerificationResponsible);

      if (sessionHasResults.Any() && !sessionHasResults.Any(x => !x.JobEndDate.HasValue))
      {
        // Сформировать отчет о результатах сессии (пока текстовый).
        var message = PublicFunctions.Module.Remote.GetVerificationResults(eventLog.JobStartDate.Value,
                                                                           eventLog.VerificationReason,
                                                                           eventLog.VerificationResponsible);
        var responsible = eventLog.VerificationResponsible;
        if (responsible == null)
          responsible = PublicFunctions.Module.Remote.GetVerificationResponsible();

        if (responsible.Login != null)
        {
          var responsibleUser = Sungero.CoreEntities.Users.GetAll().Where(u => u.Login == responsible.Login);

          // Отправить умедомление ответственному.
          if (responsibleUser != null)
            DirRX.Storage.PublicFunctions.Module.SendNotice(DirRX.Storage.Resources.VerificationResultSubject, message, responsibleUser);
          else
            Logger.Debug("Не удалось определить ответственного за проверку для отправки уведомления.");
        }
      }
      else
      {
        // Количество непроверенных документов.
        var nonVerified = sessionHasResults.Count(x => !x.JobEndDate.HasValue);

        if (nonVerified > 0)
        {
          // Предполагаемое время на проверку одного документа в секундах.a
          var time = (Calendar.Now - eventLog.JobStartDate.Value).Seconds;
          var verified = sessionHasResults.Count() - nonVerified;
          double processingTimeForOneDocument = time > 0 && verified > 0 ? (1.1 * time / verified) : 0.1f;
          var totalTime = Math.Round(processingTimeForOneDocument * nonVerified, 0);
          if (totalTime < minRetryInterval)
            totalTime = minRetryInterval;

          args.NextRetryTime = Calendar.Now.AddSeconds(totalTime);
          args.Retry = true;

          Logger.Debug("Итерация " + args.RetryIteration.ToString() + ". Проверено: " + verified.ToString() + ". Среднее время " + processingTimeForOneDocument.ToString() + ". След. отслеживание " + args.NextRetryTime.ToString());
        }

      }
    }

    // Синхронизировать данные.
    public virtual void SynchronizeExternalEntities(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SynchronizeExternalEntitiesInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика SynchronizeData. ИД записи Синхронизируемые данные {0}.", args.eventLogId);

      // Измененить статус.
      var eventLog = Storage.SyncDatas.GetAll(x => x.Id == args.eventLogId).FirstOrDefault();
      eventLog.CurrentState = Storage.SyncData.CurrentState.InProcess;
      eventLog.Save();

      // Обработать полученные данные.
      if (eventLog != null)
      {
        eventLog.Message = PublicFunctions.SyncData.AddOrUpdateEntity(eventLog);
        eventLog.CurrentState = string.IsNullOrEmpty(eventLog.Message) ? Storage.SyncData.CurrentState.Complete : Storage.SyncData.CurrentState.Error;
        eventLog.Save();
      }
      else
      {
        // Запись успели удалить.
        Logger.DebugFormat("Storage. SynchronizeData. Запись ИД {0} не найдена.", args.eventLogId);
      }

      args.Retry = false;
    }

    public virtual void DeleteExternalEntityLinks(DirRX.Storage.Server.AsyncHandlerInvokeArgs.DeleteExternalEntityLinksInvokeArgs args)
    {
      args.Retry = false;
      Logger.DebugFormat("Старт асинхронного обработчика DeleteExternalEntityLinks. Параметры: код системы источника = {0}. Тип справочника = {1}.", args.ExtSystemId, args.EntityType);
      var cnt = 0;
      foreach (var item in DirRX.LongTermArchive.ExternalEntityLinks.GetAll(x => x.ExtSystemId.ToUpper() == args.ExtSystemId.ToUpper() &&
                                                                            x.EntityType.ToUpper() == args.EntityType.ToUpper()))
      {
        try
        {
          DirRX.LongTermArchive.ExternalEntityLinks.Delete(item);
          cnt += 1;
        }
        catch (Exception e)
        {
          Logger.DebugFormat("Storage. DeleteExternalEntityLinks. Не удалось удалить внешнюю ссылку ИД {0}. \n{1}", item.Id, e.ToString());
        }
      }

      Logger.DebugFormat("Storage. DeleteExternalEntityLinks. Удалено внешних ссылок: {0}", cnt);
    }

    public virtual void ImproveProcessChecker(DirRX.Storage.Server.AsyncHandlerInvokeArgs.ImproveProcessCheckerInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика ImproveProcessChecker. Параметры: iteration = {0}", args.RetryIteration);
      var idsString = args.Ids;
      List<int> ids = new List<int>(Array.ConvertAll(idsString.Split(','), int.Parse));
      Logger.DebugFormat("Проверяется улучшение ЭП в документах с ИД журналов {0}", idsString);
      var successDocs = Storage.ArchiveEventLogs.GetAll().Where(i => ids.Contains(i.Id) && i.CurrentState == Storage.ArchiveEventLog.CurrentState.Complete);
      var errorDocs = Storage.ArchiveEventLogs.GetAll().Where(i => ids.Contains(i.Id) && i.CurrentState == Storage.ArchiveEventLog.CurrentState.Error);
      var totalDocs = successDocs.Count() + errorDocs.Count();
      if (ids.Count == totalDocs)
      {
        args.Retry = false;
        var message = DirRX.Storage.Resources.NotificationImproveProcessCheckerSuccessFormat(ids.Count, successDocs.Count(), errorDocs.Count());
        Logger.Debug(message);

        var responsible = Sungero.CoreEntities.Roles.GetAll(x => Equals(x.Sid.Value, DirRX.Storage.PublicConstants.Module.Initialize.ResponsiblePeriodicProceduresRoleGuid));
        DirRX.Storage.PublicFunctions.Module.SendNotice(DirRX.Storage.Resources.NotificationImproveProcessCheckerSubject, message, responsible);
      }
      else
      {
        // Запланировать след. проверку.
        args.Retry = true;
        args.NextRetryTime = Calendar.Now.AddMinutes(15);
      }

      if (args.RetryIteration > 1000)
      {
        args.Retry = false;
        var message = Resources.NotificationImproveProcessCheckerFailFormat(args.RetryIteration, ids.Count, successDocs.Count(), errorDocs.Count());
        Logger.Debug(message);

        var responsible = Sungero.CoreEntities.Roles.GetAll(x => Equals(x.Sid.Value, DirRX.Storage.PublicConstants.Module.Initialize.ResponsiblePeriodicProceduresRoleGuid));
        DirRX.Storage.PublicFunctions.Module.SendNotice(DirRX.Storage.Resources.NotificationImproveProcessCheckerSubject, message, responsible);
      }
    }

    public virtual void ImproveArchiveDocumentSignature(DirRX.Storage.Server.AsyncHandlerInvokeArgs.ImproveArchiveDocumentSignatureInvokeArgs args)
    {
      args.Retry = false;
      var eventLog = ArchiveEventLogs.Get(args.eventId);
      Logger.DebugFormat("Старт асинхронного обработчика ImpoveArchiveDocumentSignature. Параметры: archiveEvent.ID = {0}, guid = {1}", eventLog.Id, eventLog.TempGuid);
      Functions.Module.ImproveArchiveDocumentSignatures(eventLog);
    }

    // Выполнить обработку ДА-контейнера.
    public virtual void ImportContainer(DirRX.Storage.Server.AsyncHandlerInvokeArgs.ImportContainerInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика ImportContainer. Параметры: archiveEvent.ID = {0}", args.eventId);
      try
      {
        var archiveEvent = ArchiveEventLogs.Get(args.eventId);
        Functions.ArchiveEventLog.ImportContainer(archiveEvent, args.hash);
      }
      catch (Exception e)
      {
        Logger.DebugFormat("ImportContainer. Ошибка обработки контейнера ИД {0}\n{1}", args.eventId, e.ToString());
      }
      finally
      {
        args.Retry = false;
      }
    }

    // Выполнить проверки наличия, целостности, неизменности контейнера.
    public virtual void VerifyContainer(DirRX.Storage.Server.AsyncHandlerInvokeArgs.VerifyContainerInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика VerifyContainer. Параметры: eventId = {0}", args.eventId);
      try
      {
        // Проверить контейнер.
        var archiveEvent = ArchiveEventLogs.Get(args.eventId);

        var success = Storage.PublicFunctions.ArchiveEventLog.Remote.VerifyContainer(archiveEvent);

        // Если проверка была плановой, установить следующую дату проверки.
        var defaultReason = Storage.ArchiveEventLogs.Resources.DefaultVerificationReason.ToString();
        if (success && archiveEvent.VerificationReason == defaultReason)
        {
          var term = (int)Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsNumbericValue(Constants.Module.DocflowParams.VerificationIntervalKey);
          var verificationDate = archiveEvent.JobEndDate.Value.AddDays(term);

          Functions.ArchiveEventLog.SetVerificationDate(archiveEvent, verificationDate);

          archiveEvent.Save();
        }
      }
      catch (Exception e)
      {
        Logger.DebugFormat("VerifyContainer. Ошибка проверки контейнера ИД {0}\n{1}", args.eventId, e.ToString());
      }
      finally
      {
        args.Retry = false;
      }
    }

    // Установить срок проверки для всех документов.
    public virtual void SetVerificationTermForAllDocuments(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SetVerificationTermForAllDocumentsInvokeArgs args)
    {
      var term = (int)Sungero.Docflow.PublicFunctions.Module.Remote.GetDocflowParamsNumbericValue(Constants.Module.DocflowParams.VerificationIntervalKey);
      Logger.DebugFormat("Старт асинхронного обработчика SetVerificationTermForAllDocuments. Параметры: term = {0}, iteration = {1}", term, args.RetryIteration);

      // Установить новую дату проверки для каждого документа с пустым или успешным результом проверки.
      var locked = 0;
      var responsible = Sungero.Company.Employees.Null;

      foreach (var archiveEvent in Storage.ArchiveEventLogs.GetAll(x => x.DocumentId.HasValue && x.CurrentState != Storage.ArchiveEventLog.CurrentState.InProcess &&
                                                                   (!x.VerificationResult.HasValue || x.VerificationResult.Value == Storage.ArchiveEventLog.VerificationResult.Succeeded)))
      {
        var lockInfo = Locks.GetLockInfo(archiveEvent);
        if (lockInfo.IsLockedByMe || (!lockInfo.IsLocked && Locks.TryLock(archiveEvent)))
        {
          // Рассчитать следующую дату проверки.
          var verificationDate = (archiveEvent.JobEndDate.HasValue ? archiveEvent.JobEndDate.Value : archiveEvent.Created.Value).AddDays(term);

          Functions.ArchiveEventLog.SetVerificationDate(archiveEvent, verificationDate);

          Locks.Unlock(archiveEvent);
        }
        else
        {
          Logger.DebugFormat("SetVerificationTermForAllDocuments. Не удалось заблокировать журнал ИД {0}.", archiveEvent.Id);
          locked += 1;
        }
      }

      args.Retry = locked > 0 && args.RetryIteration < 30;
    }

    // Установить дату проверки контейнера.
    public virtual void SetVerificationDate(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SetVerificationDateInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика SetNextVerificationDate. Параметры: eventId = {0}, date = {1}", args.eventId, args.verificationDate.ToShortDateString());

      try
      {
        var archiveEvent = ArchiveEventLogs.Get(args.eventId);

        Functions.ArchiveEventLog.SetVerificationDate(archiveEvent, args.verificationDate);
      }
      catch (Exception e)
      {
        Logger.DebugFormat("SetNextVerificationDate. Ошибка обработки контейнера ИД {0}\n{1}", args.eventId, e.ToString());
      }
      finally
      {
        args.Retry = false;
      }
    }

    // Удалить тела документов.
    public virtual void DestroyDocumentsBodies(DirRX.Storage.Server.AsyncHandlerInvokeArgs.DestroyDocumentsBodiesInvokeArgs args)
    {
      var documentId = args.documentId;
      var act = DestructionActs.GetAll(x => Equals(x.Id, args.actId)).SingleOrDefault();
      var document = Sungero.Content.ElectronicDocuments.GetAll(x => Equals(x.Id, documentId)).SingleOrDefault();

      if (document.HasVersions)
      {
        while (true)
        {
          var version = document.Versions.FirstOrDefault();
          if (version != null)
          {
            document.DeleteVersion(version);
          }
          else break;
        }
        if (Storage.ArchiveDocumentBases.Is(document))
        {
          DirRX.Storage.PublicFunctions.Module.FillArchiveDocumentDeletedParams((Storage.IArchiveDocumentBase)document, Calendar.Now, act);
        }

        if (document.State.IsChanged)
          document.Save();
      }
      var archiveEventLogEntry = PublicFunctions.Module.Remote.GetArchiveEventLogEntry(args.documentId);
      if (archiveEventLogEntry != null)
      {
        PublicFunctions.ArchiveEventLog.AddEventHistory(archiveEventLogEntry, Storage.ArchiveEventLogs.Resources.Operation_Destroy,
                                                        Storage.ArchiveEventLog.CurrentState.Complete,
                                                        string.Format("Тело документа уничтожено согласно акта \"{0}\"", archiveEventLogEntry.DestructionAct.Name));
        archiveEventLogEntry.CurrentState = Storage.ArchiveEventLog.CurrentState.Destroyed;
        archiveEventLogEntry.Save();
      }
    }

    // Проверить удаление тел документов.
    public virtual void CheckDestroyDocumentsBodies(DirRX.Storage.Server.AsyncHandlerInvokeArgs.CheckDestroyDocumentsBodiesInvokeArgs args)
    {
      Logger.DebugFormat("Старт асинхронного обработчика CheckDestroyDocumentsBodies. Параметры: iteration = {0}", args.RetryIteration);
      var destructionAct = DirRX.Storage.DestructionActs.GetAll(x => x.Id == args.Id).FirstOrDefault();
      Logger.DebugFormat("Проверяется уничтожение тел документов по акту с ИД {0}", args.Id);
      var successDocs = Storage.ArchiveEventLogs.GetAll(x => x.DestructionAct == destructionAct && x.CurrentState == Storage.ArchiveEventLog.CurrentState.Destroyed);
      var errorDocs = Storage.ArchiveEventLogs.GetAll(x => x.DestructionAct == destructionAct && x.CurrentState == Storage.ArchiveEventLog.CurrentState.Error);
      var totalDocs = Storage.ArchiveEventLogs.GetAll(x => x.DestructionAct == destructionAct).Count();

      if (totalDocs == (successDocs.Count() + errorDocs.Count()))
      {
        args.Retry = false;
        var message = DirRX.Storage.Resources.NotificationCheckDestroyDocumentsBodiesSuccessFormat(totalDocs, successDocs.Count(), errorDocs.Count());
        Logger.Debug(message);

        // Установить статус дела "Уничтожено"
        var caseFiles = DirRX.LongTermArchive.CaseFiles.GetAll(x => x.LTADestructionActDirRX == destructionAct);
        var destructionDate = Calendar.Now;

        foreach (var caseFile in caseFiles)
        {
          caseFile.LTAStageDirRX = DirRX.LongTermArchive.CaseFile.LTAStageDirRX.DestroyedDirRX;
          caseFile.LTALastDocumentDestroyedDirRX = destructionDate;
          caseFile.Save();
        }

        // Отправить уведомление.
        var responsible = Sungero.CoreEntities.Roles.GetAll(x => Equals(x.Sid.Value, DirRX.Storage.PublicConstants.Module.Initialize.ResponsiblePeriodicProceduresRoleGuid));
        if (responsible.Any())
        {
          message = Resources.NotificationCheckDestroyDocumentsBodiesSuccessFormat(destructionAct.Name, totalDocs, successDocs.Count(), errorDocs.Count());
          DirRX.Storage.PublicFunctions.Module.SendNotice(DirRX.Storage.Resources.NotificationCheckDestroyDocumentsBodiesSubject, message, responsible, destructionAct);
        }
        else
        {
          message = DirRX.Storage.Resources.NotificationCheckDestroyDocumentsBodiesResponsibleNotFound;
          Logger.Debug(message);
        }
      }
      else
      {
        // Планирование след. проверки.
        args.Retry = true;
        args.NextRetryTime = Calendar.Now.AddMinutes(5);
      }

      if (args.RetryIteration > 100)
      {
        args.Retry = false;
        var message = Resources.NotificationCheckDestroyDocumentsBodiesFailFormat(args.RetryIteration, totalDocs, successDocs.Count(), errorDocs.Count());
        Logger.Debug(message);

        // Отправить уведомление.
        var responsible = Sungero.CoreEntities.Roles.GetAll(x => Equals(x.Sid.Value, DirRX.Storage.PublicConstants.Module.Initialize.ResponsiblePeriodicProceduresRoleGuid));
        DirRX.Storage.PublicFunctions.Module.SendNotice(DirRX.Storage.Resources.NotificationCheckDestroyDocumentsBodiesSubject, message, responsible);
      }
    }

    // Подготовить документы к удалению.
    public virtual void SetDocsToDestroy(DirRX.Storage.Server.AsyncHandlerInvokeArgs.SetDocsToDestroyInvokeArgs args)
    {
      var actId = args.actInventoryId;

      Logger.DebugFormat("Storage. Старт асинхронного обработчика SetDocsToDestroy для акта ИД {0}.", actId);

      var act = Storage.DestructionActs.GetAll(x => x.Id == actId).SingleOrDefault();
      if (act == null)
      {
        Logger.DebugFormat("SetDocsToDestroy. Не удалось получить акт уничтожения ИД {0}", actId);
        return;
      }

      var caseFiles = DirRX.LongTermArchive.CaseFiles.GetAll(x => Equals(x.LTADestructionActDirRX, act));

      foreach (var caseFile in caseFiles)
      {
        var documentIds = PublicFunctions.Module.GetDocumentsToDestroy(caseFile);

        foreach (var documentId in documentIds)
        {

          var archiveEventLogEntry = PublicFunctions.Module.Remote.GetArchiveEventLogEntry(documentId);
          if (archiveEventLogEntry != null)
          {
            archiveEventLogEntry.DestructionAct = caseFile.LTADestructionActDirRX;
            archiveEventLogEntry.DestructionDate = caseFile.LTADestructionDateDirRX;
            PublicFunctions.ArchiveEventLog.AddEventHistory(archiveEventLogEntry,
                                                            Storage.ArchiveEventLogs.Resources.Operation_Destroy,
                                                            Storage.ArchiveEventLog.CurrentState.InQueue,
                                                            string.Format("Документ подготовлен к уничтожению согласно акта \"{0}\"", archiveEventLogEntry.DestructionAct.Name));
          }
          else
          {
            Logger.ErrorFormat("Не удалось найти запись в журнале для документа с ИД = {0}, ИД акта уничтожения = {1}", documentId, act.Id);
            args.Retry = false;
          }
        }
      }
    }

  }
}