DownloadProgressManager
using kCura.WinEDDS;
using kCura.WinEDDS.Exporters;
using Relativity.DataExchange.Export.VolumeManagerV2.Metadata.Text;
using Relativity.DataExchange.Export.VolumeManagerV2.Repository;
using Relativity.DataExchange.Logger;
using Relativity.DataExchange.Process;
using Relativity.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Relativity.DataExchange.Export.VolumeManagerV2.Statistics
{
public class DownloadProgressManager : IDownloadProgress, IDownloadProgressManager
{
private readonly HashSet<int> _artifactsProcessed;
private readonly FileRequestRepository _nativeRepository;
private readonly ImageRepository _imageRepository;
private readonly LongTextRepository _longTextRepository;
private readonly FileRequestRepository _pdfRepository;
private readonly IStatus _status;
private readonly ILog _logger;
private readonly object _syncObject = new object();
private int exportedNativeCount;
private int exportedPdfCount;
private int exportedImageCount;
private int exportedLongTextCount;
public DownloadProgressManager(FileRequestRepository nativeRepository, ImageRepository imageRepository, LongTextRepository longTextRepository, FileRequestRepository pdfRepository, IStatus status, ILog logger)
{
_nativeRepository = nativeRepository;
_imageRepository = imageRepository;
_longTextRepository = longTextRepository;
_pdfRepository = pdfRepository;
_status = status;
_logger = logger;
_artifactsProcessed = new HashSet<int>();
}
public void FinalizeBatchProcessedCount()
{
lock (_syncObject) {
_logger.LogVerbose("Finalizing the batch processed artifact count...", Array.Empty<object>());
int num = 0;
foreach (FileRequest<ObjectExportInfo> fileRequest in _nativeRepository.GetFileRequests()) {
int artifactID = fileRequest.Artifact.ArtifactID;
if (UpdateProcessedCount(artifactID, true)) {
_logger.LogWarning("The processed document count was incremented for artifact {ArtifactId} during finalization.", new object[1] {
artifactID
});
num++;
}
}
_logger.LogVerbose("Finalized the batch processed artifact count and incremented by {FinalizedArtifactCount}.", new object[1] {
num
});
}
}
public void MarkArtifactAsError(int artifactId, string message)
{
lock (_syncObject) {
if (!_artifactsProcessed.Contains(artifactId)) {
_logger.LogVerbose("Marking artifact {ArtifactId} as error. Message: {ErrorMessage}", new object[2] {
artifactId,
message
});
_artifactsProcessed.Add(artifactId);
}
PublishProcessedCount();
}
}
public void MarkFileAsCompleted(string targetFile, int lineNumber, bool transferResult)
{
lock (_syncObject) {
_logger.LogVerbose("Marking {TargetFile} {LineNumber} file as completed.", new object[2] {
targetFile.Secure(),
lineNumber
});
IList<FileRequest<ObjectExportInfo>> fileRequestByDestinationLocation = _nativeRepository.GetFileRequestByDestinationLocation(targetFile);
IList<FileRequest<ObjectExportInfo>> fileRequestByDestinationLocation2 = _pdfRepository.GetFileRequestByDestinationLocation(targetFile);
if (fileRequestByDestinationLocation.Count > 0) {
MarkAsCompleted(fileRequestByDestinationLocation, transferResult);
if (transferResult)
_status.UpdateFilesExportedCount(++exportedNativeCount, exportedPdfCount, exportedImageCount, exportedLongTextCount);
} else if (fileRequestByDestinationLocation2.Count > 0) {
MarkAsCompleted(fileRequestByDestinationLocation2, transferResult);
if (transferResult)
_status.UpdateFilesExportedCount(exportedNativeCount, ++exportedPdfCount, exportedImageCount, exportedLongTextCount);
} else {
IList<ImageRequest> imagesByTargetFile = _imageRepository.GetImagesByTargetFile(targetFile);
if (imagesByTargetFile.Count > 0) {
ImageRequest imageRequest = imagesByTargetFile.FirstOrDefault((ImageRequest x) => !x.TransferCompleted);
if (imageRequest != null) {
imageRequest.TransferCompleted = true;
UpdateProcessedCountAndNotify(imageRequest.Artifact.ArtifactID, transferResult);
if (transferResult)
_status.UpdateFilesExportedCount(exportedNativeCount, exportedPdfCount, ++exportedImageCount, exportedLongTextCount);
}
} else
_logger.LogWarning("The process count isn't incremented for {TargetFile} because the native or image file doesn't exist in any repository.", new object[1] {
targetFile.Secure()
});
}
}
}
private void MarkAsCompleted(IList<FileRequest<ObjectExportInfo>> files, bool transferResult)
{
FileRequest<ObjectExportInfo> fileRequest = files.FirstOrDefault((FileRequest<ObjectExportInfo> x) => !x.TransferCompleted);
if (fileRequest != null) {
fileRequest.TransferCompleted = true;
UpdateProcessedCountAndNotify(fileRequest.Artifact.ArtifactID, transferResult);
}
}
public void MarkLongTextAsCompleted(string targetFile, int lineNumber, bool transferResult)
{
lock (_syncObject) {
_logger.LogVerbose("Marking {TargetFile} long text as completed.", new object[1] {
targetFile.Secure()
});
LongText byLineNumber = _longTextRepository.GetByLineNumber(lineNumber);
if (byLineNumber != null) {
byLineNumber.TransferCompleted = true;
UpdateProcessedCountAndNotify(byLineNumber.ArtifactId, transferResult);
if (transferResult)
_status.UpdateFilesExportedCount(exportedNativeCount, exportedPdfCount, exportedImageCount, ++exportedLongTextCount);
} else
_logger.LogWarning("The process count isn't incremented for {TargetFile} because the long text file doesn't exist in the long text repository.", new object[1] {
targetFile.Secure()
});
}
}
private void UpdateProcessedCountAndNotify(int artifactId, bool transferResult)
{
_logger.LogVerbose("Updating processed document count after artifact {ArtifactId} transfer has been completed with transfer result {TransferResult}.", new object[2] {
artifactId,
transferResult
});
if (UpdateProcessedCount(artifactId, false)) {
FileRequest<ObjectExportInfo> fileRequest = _nativeRepository.GetFileRequest(artifactId);
if (fileRequest != null) {
_logger.LogVerbose("Document {identifierValue} export completed with transfer result {TransferResult}.", new object[2] {
fileRequest.Artifact.IdentifierValue,
transferResult
});
string text = $"""{artifactId}""";
_status.WriteStatusLine(EventType2.Progress, "Document " + fileRequest.Artifact.IdentifierValue + " export completed " + text + ".", false);
}
}
}
private bool UpdateProcessedCount(int artifactId, bool finalizing)
{
if ((!finalizing && !IsDocumentProcessed(artifactId)) || _artifactsProcessed.Contains(artifactId))
return false;
_artifactsProcessed.Add(artifactId);
PublishProcessedCount();
return true;
}
private bool IsDocumentProcessed(int artifactId)
{
FileRequest<ObjectExportInfo> fileRequest = _nativeRepository.GetFileRequest(artifactId);
if (fileRequest == null)
return false;
artifactId = fileRequest.Artifact.ArtifactID;
if (!fileRequest.TransferCompleted)
return false;
if (_imageRepository.GetArtifactImages(artifactId).Any((ImageRequest x) => !x.TransferCompleted))
return false;
if (_longTextRepository.GetArtifactLongTexts(artifactId).Any((LongText x) => !x.TransferCompleted))
return false;
FileRequest<ObjectExportInfo> fileRequest2 = _pdfRepository.GetFileRequest(artifactId);
if (fileRequest2 != null && !fileRequest2.TransferCompleted)
return false;
return true;
}
private void PublishProcessedCount()
{
_status.UpdateDocumentExportedCount(_artifactsProcessed.Count);
}
}
}