ImportImageFileProcess
using kCura.EDDS.WebAPI.AuditManagerBase;
using kCura.EDDS.WebAPI.BulkImportManagerBase;
using kCura.WinEDDS.Service;
using Microsoft.VisualBasic.CompilerServices;
using Monitoring;
using Monitoring.Sinks;
using Relativity.DataExchange;
using Relativity.DataExchange.Io;
using Relativity.DataExchange.Logger;
using Relativity.DataExchange.Process;
using Relativity.DataExchange.Service;
using Relativity.DataExchange.Transfer;
using Relativity.Logging;
using System;
using System.Collections;
using System.IO;
using System.Runtime.CompilerServices;
namespace kCura.WinEDDS
{
public class ImportImageFileProcess : MonitoredProcessBase
{
public ImageLoadFile ImageLoadFile;
[CompilerGenerated]
[AccessedThroughProperty("_imageFileImporter")]
private BulkImageFileImporter __imageFileImporter;
[CompilerGenerated]
[AccessedThroughProperty("_ioReporterContext")]
private IoReporterContext __ioReporterContext;
private int _errorCount;
private int _perBatchErrorCount;
private int _warningCount;
private string _uploadModeText;
private bool _disableUserSecurityCheck;
private ImportAuditLevel _importAuditLevel;
private bool? _disableImageTypeValidation;
private bool? _disableImageLocationValidation;
[CompilerGenerated]
private TelemetryConstants.TransferDirection _TransferDirection;
[CompilerGenerated]
private int? _MaximumErrorCount;
[CompilerGenerated]
private bool? _SkipExtractedTextEncodingCheck;
[CompilerGenerated]
private bool _CloudInstance;
private virtual BulkImageFileImporter _imageFileImporter {
[CompilerGenerated]
get {
return __imageFileImporter;
}
[MethodImpl(MethodImplOptions.Synchronized)]
[CompilerGenerated]
set {
BulkImageFileImporter.StatusMessageEventHandler obj = _imageFileImporter_StatusMessage;
BulkImageFileImporter.FatalErrorEventEventHandler obj2 = _imageFileImporter_FatalErrorEvent;
BulkImageFileImporter.ReportErrorEventEventHandler obj3 = _imageFileImporter_ReportErrorEvent;
ImportTapiBase.UploadModeChangeEventEventHandler obj4 = _loadFileImporter_UploadModeChangeEvent;
BulkImageFileImporter.EndRunEventHandler obj5 = _imageFileImporter_EndRun;
ImportTapiBase.BatchCompletedEventHandler obj6 = _imageFileImporter_OnBatchCompleted;
BulkImageFileImporter _imageFileImporter = __imageFileImporter;
if (_imageFileImporter != null) {
_imageFileImporter.StatusMessage -= obj;
_imageFileImporter.FatalErrorEvent -= obj2;
_imageFileImporter.ReportErrorEvent -= obj3;
_imageFileImporter.UploadModeChangeEvent -= obj4;
_imageFileImporter.EndRun -= obj5;
_imageFileImporter.BatchCompleted -= obj6;
}
__imageFileImporter = value;
_imageFileImporter = __imageFileImporter;
if (_imageFileImporter != null) {
_imageFileImporter.StatusMessage += obj;
_imageFileImporter.FatalErrorEvent += obj2;
_imageFileImporter.ReportErrorEvent += obj3;
_imageFileImporter.UploadModeChangeEvent += obj4;
_imageFileImporter.EndRun += obj5;
_imageFileImporter.BatchCompleted += obj6;
}
}
}
protected virtual IoReporterContext _ioReporterContext {
[CompilerGenerated]
get {
return __ioReporterContext;
}
[MethodImpl(MethodImplOptions.Synchronized)]
[CompilerGenerated]
set {
EventHandler<IoWarningEventArgs> value2 = _imageFileImporter_IoErrorEvent;
IoReporterContext _ioReporterContext = __ioReporterContext;
if (_ioReporterContext != null)
_ioReporterContext.IoWarningEvent -= value2;
__ioReporterContext = value;
_ioReporterContext = __ioReporterContext;
if (_ioReporterContext != null)
_ioReporterContext.IoWarningEvent += value2;
}
}
public bool DisableImageTypeValidation {
set {
_disableImageTypeValidation = value;
}
}
public bool DisableImageLocationValidation {
set {
_disableImageLocationValidation = value;
}
}
public bool DisableUserSecurityCheck {
set {
_disableUserSecurityCheck = value;
}
}
public ImportAuditLevel AuditLevel {
set {
_importAuditLevel = value;
}
}
protected override TelemetryConstants.TransferDirection TransferDirection { get; }
protected override TapiClient TapiClient {
get {
if (_imageFileImporter != null)
return _imageFileImporter.TapiClient;
return TapiClient.None;
}
}
private ImportStatistics ImportStatistics => _imageFileImporter.Statistics;
protected override Statistics Statistics => ImportStatistics;
public int? MaximumErrorCount { get; set; }
public bool? SkipExtractedTextEncodingCheck { get; set; }
public bool CloudInstance { get; set; }
[Obsolete("This constructor is marked for deprecation. Please use the constructor that requires a logger instance.")]
public ImportImageFileProcess(Func<string> correlationIdFunc)
: this(new MetricService(new ImportApiMetricSinkConfig()), new RunningContext(), correlationIdFunc)
{
}
[Obsolete("This constructor is marked for deprecation. Please use the constructor that requires a logger instance.")]
public ImportImageFileProcess(IMetricService metricService, IRunningContext runningContext, Func<string> correlationIdFunc)
: this(metricService, runningContext, RelativityLogger.Instance, correlationIdFunc)
{
}
public ImportImageFileProcess(IMetricService metricService, IRunningContext runningContext, ILog logger, Func<string> correlationIdFunc)
: base(metricService, runningContext, logger, correlationIdFunc)
{
_uploadModeText = null;
_importAuditLevel = Config.AuditLevel;
_TransferDirection = TelemetryConstants.TransferDirection.Import;
}
protected override bool Run()
{
_imageFileImporter.ReadFile(ImageLoadFile.FileName);
base.RunId = _imageFileImporter.RunId;
return !_hasFatalErrorOccured;
}
protected override bool HasErrors()
{
return _imageFileImporter.HasErrors;
}
protected override bool IsCancelled()
{
return _imageFileImporter.IsCancelledByUser;
}
protected override long GetTotalRecordsCount()
{
return _imageFileImporter.TotalRecords;
}
protected override long GetCompletedRecordsCount()
{
return _imageFileImporter.CompletedRecords;
}
protected override void OnSuccess()
{
base.OnSuccess();
base.Context.PublishProcessEnded(Statistics.FileTransferredBytes, Statistics.MetadataTransferredBytes, Statistics.GetSqlProcessRate());
base.Context.PublishProcessCompleted(false, "", true);
}
protected override void OnHasErrors()
{
base.OnHasErrors();
base.Context.PublishProcessEnded(Statistics.FileTransferredBytes, Statistics.MetadataTransferredBytes, Statistics.GetSqlProcessRate());
base.Context.PublishProcessCompleted(false, Guid.NewGuid().ToString(), true);
}
protected override void Initialize()
{
base.Initialize();
_warningCount = 0;
_errorCount = 0;
_perBatchErrorCount = 0;
base.Context.InputArgs = ImageLoadFile.FileName;
_imageFileImporter = GetImageFileImporter();
if (_disableImageTypeValidation.HasValue)
_imageFileImporter.DisableImageTypeValidation = _disableImageTypeValidation.Value;
if (_disableImageLocationValidation.HasValue)
_imageFileImporter.DisableImageLocationValidation = _disableImageLocationValidation.Value;
_imageFileImporter.DisableUserSecurityCheck = _disableUserSecurityCheck;
_imageFileImporter.AuditLevel = _importAuditLevel;
if (MaximumErrorCount.HasValue && MaximumErrorCount.Value > 0 && MaximumErrorCount.Value < 2147483647)
_imageFileImporter.MaxNumberOfErrorsInGrid = checked(MaximumErrorCount.Value + 1);
_imageFileImporter.SkipExtractedTextEncodingCheck = SkipExtractedTextEncodingCheck.GetValueOrDefault(false);
}
protected override void SetBaseMetrics(MetricJobBase metric)
{
base.SetBaseMetrics(metric);
metric.ImportObjectType = ImportStatistics.ImportObjectType;
}
protected override MetricJobProgress BuildProgressMetric(Statistics statistics)
{
MetricJobProgress metricJobProgress = base.BuildProgressMetric(statistics);
ImportStatistics importStatistics = statistics as ImportStatistics;
if (importStatistics != null) {
metricJobProgress.SqlBulkLoadThroughputRecordsPerSecond = Statistics.CalculateThroughput(checked(importStatistics.DocumentsCreated + importStatistics.DocumentsUpdated), statistics.MassImportDuration.TotalSeconds);
return metricJobProgress;
}
base.Logger.LogWarning("Unable to parse ImportStatistics in BuildProgressMetric", new object[0]);
return metricJobProgress;
}
protected override MetricJobEndReport BuildEndMetric(TelemetryConstants.JobStatus jobStatus)
{
MetricJobEndReport metricJobEndReport = base.BuildEndMetric(jobStatus);
metricJobEndReport.SqlBulkLoadThroughputRecordsPerSecond = Statistics.CalculateThroughput(checked(ImportStatistics.DocumentsCreated + ImportStatistics.DocumentsUpdated), Statistics.MassImportDuration.TotalSeconds);
return metricJobEndReport;
}
protected virtual BulkImageFileImporter GetImageFileImporter()
{
_ioReporterContext = new IoReporterContext(base.FileSystem, base.AppSettings, new WaitAndRetryPolicy(base.AppSettings));
IIoReporter reporter = CreateIoReporter(_ioReporterContext);
return new BulkImageFileImporter(ImageLoadFile.DestinationFolderID, ImageLoadFile, base.Context, reporter, base.Logger, base.ProcessId, true, base.CancellationTokenSource, _correlationIdFunc, base.RunningContext.ExecutionSource);
}
private void AuditRun(string runID)
{
checked {
try {
ImageImportStatistics imageImportStatistics = new ImageImportStatistics();
imageImportStatistics.DestinationFolderArtifactID = ImageLoadFile.DestinationFolderID;
imageImportStatistics.BatchSizes = _imageFileImporter.BatchSizeHistoryList.ToArray();
if (ImageLoadFile.ProductionArtifactID > 0)
imageImportStatistics.DestinationProductionArtifactID = ImageLoadFile.ProductionArtifactID;
imageImportStatistics.ExtractedTextReplaced = ImageLoadFile.ReplaceFullText;
imageImportStatistics.ExtractedTextDefaultEncodingCodePageID = 0;
if (imageImportStatistics.ExtractedTextReplaced)
imageImportStatistics.ExtractedTextDefaultEncodingCodePageID = ImageLoadFile.FullTextEncoding.CodePage;
if (ImageLoadFile.CopyFilesToDocumentRepository)
imageImportStatistics.FilesCopiedToRepository = ImageLoadFile.SelectedCasePath;
else
imageImportStatistics.FilesCopiedToRepository = string.Empty;
imageImportStatistics.LoadFileName = Path.GetFileName(ImageLoadFile.FileName);
imageImportStatistics.NumberOfDocumentsCreated = _imageFileImporter.Statistics.DocumentsCreated;
imageImportStatistics.NumberOfDocumentsUpdated = _imageFileImporter.Statistics.DocumentsUpdated;
imageImportStatistics.NumberOfErrors = _errorCount;
imageImportStatistics.NumberOfFilesLoaded = _imageFileImporter.Statistics.FilesProcessed;
imageImportStatistics.NumberOfWarnings = _warningCount;
imageImportStatistics.OverlayIdentifierFieldArtifactID = ImageLoadFile.IdentityFieldId;
if (ImageLoadFile.ProductionArtifactID > 0)
imageImportStatistics.OverlayIdentifierFieldArtifactID = ImageLoadFile.BeginBatesFieldArtifactID;
switch (Conversions.ToInteger(Enum.Parse(typeof(ImportOverwriteType), ImageLoadFile.Overwrite, true))) {
case 2:
imageImportStatistics.Overwrite = kCura.EDDS.WebAPI.AuditManagerBase.OverwriteType.Both;
break;
case 1:
imageImportStatistics.Overwrite = kCura.EDDS.WebAPI.AuditManagerBase.OverwriteType.Overlay;
break;
default:
imageImportStatistics.Overwrite = kCura.EDDS.WebAPI.AuditManagerBase.OverwriteType.Append;
break;
}
switch (_imageFileImporter.UploadConnection) {
case TapiClient.Web:
imageImportStatistics.RepositoryConnection = RepositoryConnectionType.Web;
break;
case TapiClient.Direct:
imageImportStatistics.RepositoryConnection = RepositoryConnectionType.Direct;
break;
}
imageImportStatistics.RunTimeInMilliseconds = (int)Math.Round(DateTime.Now.Subtract(base.StartTime).TotalMilliseconds);
imageImportStatistics.SupportImageAutoNumbering = ImageLoadFile.AutoNumberImages;
imageImportStatistics.StartLine = (int)Math.Min(ImageLoadFile.StartLineNumber, 2147483647);
imageImportStatistics.TotalFileSize = _imageFileImporter.Statistics.FileTransferredBytes;
imageImportStatistics.TotalMetadataBytes = _imageFileImporter.Statistics.MetadataTransferredBytes;
imageImportStatistics.SendNotification = ImageLoadFile.SendEmailOnLoadCompletion;
ManagerFactory.CreateAuditManager(ImageLoadFile.Credential, ImageLoadFile.CookieContainer, base.GetCorrelationId).AuditImageImport(ImageLoadFile.CaseInfo.ArtifactID, runID, _hasFatalErrorOccured, imageImportStatistics);
} catch (Exception ex) {
ProjectData.SetProjectError(ex);
Exception ex2 = ex;
base.Logger.LogError(ex2, "An error has occurred during audit", new object[0]);
ProjectData.ClearProjectError();
}
}
}
private unsafe void _imageFileImporter_StatusMessage(StatusEventArgs e)
{
lock (base.Context) {
IDictionary metadata = null;
if (e.AdditionalInfo != null)
metadata = (IDictionary)e.AdditionalInfo;
checked {
long currentRecordIndex;
switch (e.EventType) {
case EventType2.End:
case EventType2.ResetProgress:
break;
case EventType2.Error: {
if (e.CountsTowardsTotal) {
ref int warningCount;
*(ref warningCount = ref _errorCount) = warningCount + 1;
*(ref warningCount = ref _perBatchErrorCount) = warningCount + 1;
}
base.Context.PublishProgress(e.TotalRecords, e.CurrentRecordIndex, _warningCount, _errorCount, base.StartTime, default(DateTime), e.Statistics.MetadataTransferThroughput, e.Statistics.FileTransferThroughput, base.ProcessId, null, null, metadata);
ProcessContext context2 = base.Context;
currentRecordIndex = e.CurrentRecordIndex;
context2.PublishErrorEvent(currentRecordIndex.ToString(), e.Message);
break;
}
case EventType2.Progress: {
ProcessContext context3 = base.Context;
currentRecordIndex = e.CurrentRecordIndex;
context3.PublishStatusEvent(currentRecordIndex.ToString(), e.Message);
base.Context.PublishProgress(e.TotalRecords, e.CurrentRecordIndex, _warningCount, _errorCount, base.StartTime, default(DateTime), e.Statistics.MetadataTransferThroughput, e.Statistics.FileTransferThroughput, base.ProcessId, null, null, metadata);
base.Context.PublishRecordProcessed(e.CurrentRecordIndex);
break;
}
case EventType2.Statistics:
SendMetricJobProgress(e.Statistics, true);
break;
case EventType2.Status: {
ProcessContext context4 = base.Context;
currentRecordIndex = e.CurrentRecordIndex;
context4.PublishStatusEvent(currentRecordIndex.ToString(), e.Message);
break;
}
case EventType2.Warning: {
if (e.CountsTowardsTotal) {
ref int warningCount;
*(ref warningCount = ref _warningCount) = warningCount + 1;
}
ProcessContext context = base.Context;
currentRecordIndex = e.CurrentRecordIndex;
context.PublishWarningEvent(currentRecordIndex.ToString(), e.Message);
break;
}
case EventType2.Count:
base.Context.PublishRecordCountIncremented();
break;
case EventType2.ResetStartTime:
SetStartTime();
break;
}
}
}
}
private void _imageFileImporter_FatalErrorEvent(string message, Exception ex)
{
if (!_hasFatalErrorOccured) {
lock (base.Context) {
base.Context.PublishFatalException(ex);
base.Context.PublishProcessEnded(Statistics.FileTransferredBytes, Statistics.MetadataTransferredBytes, Statistics.GetSqlProcessRate());
base.Context.PublishProcessCompleted(false, _imageFileImporter.ErrorLogFileName, true);
_hasFatalErrorOccured = true;
}
}
}
private void _imageFileImporter_ReportErrorEvent(IDictionary row)
{
base.Context.PublishErrorReport(row);
}
private void _loadFileImporter_UploadModeChangeEvent(string statusBarText)
{
if (_uploadModeText == null)
_uploadModeText = TapiModeHelper.BuildDocText();
OnTapiClientChanged();
base.Context.PublishStatusBarChanged(statusBarText, _uploadModeText);
}
private void _imageFileImporter_IoErrorEvent(object sender, IoWarningEventArgs e)
{
lock (base.Context) {
base.Context.PublishWarningEvent(checked(e.CurrentLineNumber + 1).ToString(), e.Message);
}
}
private void _imageFileImporter_EndRun(string runID)
{
Statistics.DocsErrorsCount = _errorCount;
AuditRun(runID);
}
private void _imageFileImporter_OnBatchCompleted(BatchInformation batchInformation)
{
batchInformation.NumberOfRecordsWithErrors = _perBatchErrorCount;
_perBatchErrorCount = 0;
SendMetricJobBatch(batchInformation);
}
}
}