public override Response Execute()
{
var response = new Response()
{
Success = true, Message = ""
};
try
{
var artifactQueries = new ArtifactQueries();
var workspaceArtifactId = Helper.GetActiveCaseID();
var svcManager = Helper.GetServicesManager();
var identityCurrentUser = ExecutionIdentity.CurrentUser;
var activeArtifactId = ActiveArtifact.ArtifactID;
var logger = GetLoggerAsync().Result;
var exportJob = new ExportJob(svcManager, artifactQueries, workspaceArtifactId, identityCurrentUser, activeArtifactId, logger);
response = exportJob.ExecutePreDelete().Result;
}
catch (Exception ex)
{
response.Success = false;
response.Exception = new SystemException("Pre Delete Failure: " + ex.Message);
}
return(response);
}
public override Response Execute()
{
var response = new Response()
{
Success = true, Message = ""
};
try
{
var artifactQueries = new ArtifactQueries();
var sqlQueryHelper = new Helpers.SQL.SqlQueryHelper();
var workspaceArtifactId = Helper.GetActiveCaseID();
var svcManager = Helper.GetServicesManager();
var identityCurrentUser = ExecutionIdentity.CurrentUser;
var tempTableName = TempTableNameWithParentArtifactsToDelete;
var logger = GetLoggerAsync().Result;
var dbContext = Helper.GetDBContext(workspaceArtifactId);
var exportJob = new ExportJob(svcManager, sqlQueryHelper, artifactQueries, workspaceArtifactId, identityCurrentUser, dbContext, tempTableName, logger);
response = exportJob.ExecutePreCascadeDelete().Result;
}
catch (Exception ex)
{
response.Success = false;
response.Exception = new SystemException("Pre Cascade Delete Failure: " + ex.Message);
}
return(response);
}
public async Task <UserAdminObject> ConvertUserResultToUserAdminObjectAsync(kCura.Relativity.Client.DTOs.User userResult)
{
return(new UserAdminObject()
{
ArtifactId = userResult.ArtifactID,
FirstName = { Data = userResult.FirstName },
LastName = { Data = userResult.LastName },
EmailAddress = { Data = userResult.EmailAddress },
Type = { Data = await ArtifactQueries.GetChoiceNameByArtifactID(RsapiRepositoryGroup.ChoiceRepository, RsapiApiOptions, userResult.Type.ArtifactID) },
Client = { Data = await ArtifactQueries.GetClientNameByArtifactID(RsapiRepositoryGroup.ClientRepository, RsapiApiOptions, userResult.Client.ArtifactID) },
RelativityAccess = { Data = userResult.RelativityAccess.ToString() },
DocumentSkip = { Data = await ArtifactQueries.GetChoiceNameByArtifactID(RsapiRepositoryGroup.ChoiceRepository, RsapiApiOptions, userResult.DocumentSkip.ArtifactID) },
BetaUser = { Data = userResult.BetaUser.ToString() },
ChangeSettings = { Data = userResult.ChangeSettings.ToString() },
KeyboardShortcuts = { Data = userResult.KeyboardShortcuts.ToString() },
ItemListPageLength = { Data = userResult.ItemListPageLength.ToString() },
DefaultSelectedFileType = { Data = await ArtifactQueries.GetChoiceNameByArtifactID(RsapiRepositoryGroup.ChoiceRepository, RsapiApiOptions, userResult.DefaultSelectedFileType.ArtifactID) },
SkipDefaultPreference = { Data = await ArtifactQueries.GetChoiceNameByArtifactID(RsapiRepositoryGroup.ChoiceRepository, RsapiApiOptions, userResult.SkipDefaultPreference.ArtifactID) },
EnforceViewerCompatibility = { Data = userResult.EnforceViewerCompatibility.ToString() },
AdvancedSearchPublicByDefault = { Data = userResult.AdvancedSearchPublicByDefault.ToString() },
NativeViewerCacheAhead = { Data = userResult.NativeViewerCacheAhead.ToString() },
ChangeDocumentViewer = { Data = userResult.CanChangeDocumentViewer.ToString() },
DocumentViewer = { Data = await ArtifactQueries.GetChoiceNameByArtifactID(RsapiRepositoryGroup.ChoiceRepository, RsapiApiOptions, userResult.DocumentViewer.ArtifactID) },
Keywords = { Data = null },
Notes = { Data = null },
Groups = { Data = null },
WindowsAccount = { Data = null },
UserMustChangePasswordOnNextLogin = { Data = userResult.ChangePasswordNextLogin.GetValueOrDefault().ToString() },
CanChangePassword = { Data = userResult.ChangePassword.GetValueOrDefault().ToString() },
MaximumPasswordAgeInDays = { Data = userResult.MaximumPasswordAge.GetValueOrDefault().ToString() },
TwoFactorMode = { Data = null },
TwoFactorInfo = { Data = null }
});
}
private async Task <Boolean> AfterProcessingAllLinesAsync()
{
string errorContext = $"An error occured when updating total redaction count on the import job. [ImportJobArtifactId: {_importJobArtifactId}]";
try
{
//update import file redaction count field on import job
await ArtifactQueries.UpdateImportJobRedactionCountFieldValueAsync(
AgentHelper.GetServicesManager(),
ExecutionIdentity.CurrentUser,
WorkspaceArtifactId,
_importJobArtifactId,
Constant.Guids.Field.MarkupUtilityImportJob.ImportFileRedactionCount,
_importFileRedactionCount);
RaiseMessage($"Updated import file redaction count ({_importFileRedactionCount})");
//update expected redaction count field on import job
await ArtifactQueries.UpdateImportJobRedactionCountFieldValueAsync(
AgentHelper.GetServicesManager(),
ExecutionIdentity.CurrentUser,
WorkspaceArtifactId,
_importJobArtifactId,
Constant.Guids.Field.MarkupUtilityImportJob.ExpectedRedactionCount,
_expectedRedactionCount);
RaiseMessage($"Updated expected redaction count ({_expectedRedactionCount})");
}
catch (Exception ex)
{
throw new MarkupUtilityException(errorContext, ex);
}
return(true);
}
public override kCura.EventHandler.Response Execute()
{
var response = new kCura.EventHandler.Response {
Success = true, Message = String.Empty
};
var artifactQueries = new ArtifactQueries();
var servicesMgr = Helper.GetServicesManager();
var workspaceArtifactId = Helper.GetActiveCaseID();
try
{
List <ExtractorRegullarExpression> regExList = PopulateRegExList();
//Populates Regular Expressions
foreach (var regEx in regExList)
{
artifactQueries.CreateExtractorRegularExpressionRecord(servicesMgr, Relativity.API.ExecutionIdentity.System, workspaceArtifactId, regEx.Name, regEx.RegularExpression, regEx.Description);
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = "Post-Install regular expression population failed with message: " + ex;
}
return(response);
}
public void Execute()
{
int expectedArtifactID;
//create field
expectedArtifactID = ArtifactQueries.CreateFixedLengthTextField(WorkspaceArtifactId, SvcManager, CurrentUserIdentity);
if (expectedArtifactID == 0)
{
throw new Exception("Field failed to create field");
}
//fix
//In a real scenario, workspace Artifact id would be coming in from a manager queue record.
//Check to see if field exists
/* const int newWorkspaceArtifactId = 1018783;
*
* _fieldArtifactId = ArtifactQueries.GetFieldArtifactId("Demo Document Field", AgentHelper.GetDBContext(newWorkspaceArtifactId));
* if (_fieldArtifactId == 0)
* {
* Console.WriteLine("Field is already present in the database :)");
* }
*
* expectedArtifactID = ArtifactQueries.CreateFixedLengthTextField(newWorkspaceArtifactId, SvcManager, CurrentUserIdentity);*/
}
public async Task AttachFileToExportJobAsync(ExportManagerQueueRecord exportManagerQueueRecord, String fileLocation)
{
try
{
Int32 fileFieldArtifactId = await ArtifactQueries.RetrieveFieldArtifactIdByGuid(
rsapiApiOptions : RsapiApiOptions,
workspaceArtifactId : exportManagerQueueRecord.WorkspaceArtifactId,
fieldRepository : RsapiRepositoryGroup.FieldRepository,
fieldGuid : Constant.Guids.Field.ExportUtilityJob.ExportFile
);
await ArtifactQueries.AttachFileToExportJob(
rsapiClient : AgentHelper.GetServicesManager().CreateProxy <IRSAPIClient>(ExecutionIdentity.CurrentUser),
rsapiApiOptions : RsapiApiOptions,
workspaceArtifactId : exportManagerQueueRecord.WorkspaceArtifactId,
exportJobArtifactId : exportManagerQueueRecord.ExportJobArtifactId,
fileFieldArtifactId : fileFieldArtifactId,
fileLocation : fileLocation
);
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.AttachFileToExportJobError, ex);
}
}
private async Task UpdateRedactionCountFieldValueAsync(Guid countFieldGuid)
{
var countFieldName = await GetCountFieldNameAsync(countFieldGuid);
var countFieldValue = await GetCountFieldValueAsync(countFieldGuid);
RaiseMessage($"Retrieving current {countFieldName}");
//retrieve imported redaction count field on import job
var currentRedactionCount = await ArtifactQueries.RetrieveImportJobRedactionCountFieldValueAsync(
AgentHelper.GetServicesManager(),
_executionIdentity,
WorkspaceArtifactId,
_importJobArtifactId,
countFieldGuid);
RaiseMessage($"Current {countFieldName} = {currentRedactionCount}");
var newRedactionCount = currentRedactionCount + countFieldValue;
RaiseMessage($"New {countFieldName} = {newRedactionCount}");
RaiseMessage($"Updating current {countFieldName}");
//update imported redaction count field on import job
await ArtifactQueries.UpdateImportJobRedactionCountFieldValueAsync(
AgentHelper.GetServicesManager(),
_executionIdentity,
WorkspaceArtifactId,
_importJobArtifactId,
countFieldGuid,
newRedactionCount);
RaiseMessage($"Updated {countFieldName}");
}
public void Setup()
{
Sut = new ArtifactQueries();
MockUserRepository = new Mock <IGenericRepository <User> >();
MockGroupRepository = new Mock <IGenericRepository <Group> >();
MockRdoRepository = new Mock <IGenericRepository <RDO> >();
MockWorkspaceRepository = new Mock <IGenericRepository <Workspace> >();
RsapiApiOptions = new APIOptions();
}
public async Task CheckIfWorkersCompletedJob(IEnumerable <ExportManagerQueueRecord> exportManagerQueueRecords)
{
var jobsInTheWorkerQueue = exportManagerQueueRecords.Where(x => x.QueueStatus == Constant.Status.Queue.WAITING_FOR_WORKERS_TO_FINISH);
foreach (var exportManagerQueueRecord in jobsInTheWorkerQueue)
{
try
{
SetJobProperties(exportManagerQueueRecord);
Int32 numberOfWorkerRecords = await SqlQueryHelper.CountNumberOfExportWorkerRecordsAsync(
eddsDbContext : AgentHelper.GetDBContext(-1),
workspaceArtifactId : exportManagerQueueRecord.WorkspaceArtifactId,
exportJobArtifactId : exportManagerQueueRecord.ExportJobArtifactId);
if (numberOfWorkerRecords == 0)
{
FileInfo exportFileInfo = await ConstructExportFileNameAsync(exportManagerQueueRecord.ObjectType, exportManagerQueueRecord.ExportJobArtifactId);
//create export file
Int32 numberOfRecordsExported = await CreateExportFileAsync(exportManagerQueueRecord, exportFileInfo);
//attach export file to RDO
await AttachFileToExportJobAsync(exportManagerQueueRecord, exportFileInfo.FullName);
//delete export file from temp directory
await DeleteExportFileAsync(exportFileInfo);
//drop results table
await DropExportWorkerResultsTableAsync(exportManagerQueueRecord.ResultsTableName);
//delete record from export manager queue
await ClearRecordsFromQueueTables(exportManagerQueueRecord);
Boolean jobErrorsRecorded = await ArtifactQueries.JobErrorRecordExistsAsync(RsapiApiOptions, exportManagerQueueRecord.WorkspaceArtifactId, RsapiRepositoryGroup.RdoRepository, Constant.Guids.ObjectType.ExportUtilityJobErrors, Constant.Guids.Field.ExportUtilityJobErrors.ExportUtilityJob, exportManagerQueueRecord.ExportJobArtifactId);
await FinalizeJobStatiaticsAsync(exportManagerQueueRecord, numberOfRecordsExported);
//update status of export job to complete
if (jobErrorsRecorded)
{
await UpdateExportJobStatus(Constant.Status.Job.COMPLETED_WITH_ERRORS, exportManagerQueueRecord);
await SendEmail(exportManagerQueueRecord, Constant.Status.Job.COMPLETED_WITH_ERRORS);
}
else
{
await UpdateExportJobStatus(Constant.Status.Job.COMPLETED, exportManagerQueueRecord);
await SendEmail(exportManagerQueueRecord, Constant.Status.Job.COMPLETED);
}
}
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.CheckIfExportWorkersAreStillWorkingOnExportJobInExportWorkerQueueTableError, ex);
}
}
}
private async Task DeleteJobErrors(IServicesMgr svcManager, ExecutionIdentity identityCurrentUser, Int32 workspaceArtifactId, Int32 jobArtifactID)
{
var jobErrorArtifactIDs = await ArtifactQueries.QueryJobErrors(svcManager, identityCurrentUser, workspaceArtifactId, jobArtifactID, Constant.Guids.ObjectType.ImportUtilityJobErrors, Constant.Guids.Field.ImportUtilityJobErrors.ImportUtilityJob);
if (jobErrorArtifactIDs != null & jobErrorArtifactIDs.Any())
{
var artifactTypeId = SqlQueryHelper.RetrieveArtifactTypeIdByGuidAsync(DbContext, Constant.Guids.ObjectType.ImportUtilityJobErrors).Result;
await ArtifactQueries.DeleteJobErrors(svcManager, identityCurrentUser, workspaceArtifactId, jobErrorArtifactIDs.ToList(), artifactTypeId);
}
}
private async Task <MarkupUtilityImportJob> RetrieveImportJobAsync(int importJobArtifactId)
{
RaiseMessage($"Retrieving import job. {_errorContext}]");
return(await ArtifactQueries.RetrieveImportJobAsync(
AgentHelper.GetServicesManager(),
_executionIdentity,
WorkspaceArtifactId,
importJobArtifactId));
}
public async Task ExecuteAsync()
{
var queryHelper = new Query();
var resourceGroupIds = GetResourceGroupIDs();
IArtifactQueries artifactQueries = new ArtifactQueries();
IImportFileParser importFileParser = new ImportFileParser();
IWorkspaceQueries workspaceQueries = new WorkspaceQueries();
IErrorQueries errorQueries = new ErrorQueries();
IMarkupTypeHelper markupTypeHelper = new MarkupTypeHelper();
var job = new ImportManagerJob(
AgentID,
Helper,
queryHelper,
DateTime.Now,
resourceGroupIds,
artifactQueries,
importFileParser,
workspaceQueries,
errorQueries,
markupTypeHelper);
job.OnMessage += MessageRaised;
try
{
RaiseMessage(string.Empty, 10);
RaiseMessage("Enter Agent", 10);
await job.ExecuteAsync();
RaiseMessage("Exit Agent", 10);
RaiseMessage(string.Empty, 10);
}
catch (Exception ex)
{
//Raise an error on the agents tab and event viewer
RaiseError(ex.ToString(), ex.ToString());
//Add the error to our custom Errors table
queryHelper.InsertRowIntoImportErrorLogAsync(Helper.GetDBContext(-1), job.WorkspaceArtifactId, Constant.Tables.ImportManagerQueue, job.RecordId, job.AgentId, ex.ToString()).Wait();
//Add the error to the Relativity Errors tab
//this second try catch is in case we have a problem connecting to the RSAPI
try
{
errorQueries.WriteError(Helper.GetServicesManager(), ExecutionIdentity.System, job.WorkspaceArtifactId, ex);
}
catch (Exception rsapiException)
{
RaiseError(rsapiException.ToString(), rsapiException.ToString());
}
//Set the status in the queue to error
await queryHelper.UpdateStatusInImportManagerQueueAsync(Helper.GetDBContext(-1), Constant.Status.Queue.Error, job.RecordId);
}
}
public async Task <String> ValidateAsync(String input)
{
String validationMessage = null;
var returnGroups = new FieldValueList <Group>();
if (!String.IsNullOrWhiteSpace(input))
{
try
{
input = input.Trim(Constant.ViolationDelimiter.ToCharArray()[0]);
var groupList = input.Split(Constant.ViolationDelimiter.ToCharArray()[0]);
var missingGroupList = new List <String>();
var query = new ArtifactQueries();
var groupQueryResult = await query.QueryGroupsAsync(_apiOptions, _groupRepository, groupList);
if (groupQueryResult.Success && groupQueryResult.Results.Count > 0)
{
var results = groupQueryResult.Results;
foreach (var group in groupList)
{
var matchingGroup = results.FirstOrDefault(x => x.Artifact.Name == group.Trim());
if (matchingGroup == null)
{
missingGroupList.Add(group);
}
else
{
returnGroups.Add(new Group(matchingGroup.Artifact.ArtifactID));
}
}
if (missingGroupList.Any())
{
validationMessage = String.Format(Constant.Messages.Violations.GroupDoesNotExist, String.Join(Constant.ViolationDelimiter, missingGroupList));
}
}
else if (groupQueryResult.Success)
{
validationMessage = String.Format(Constant.Messages.Violations.GroupDoesNotExist, input);
}
else
{
validationMessage = groupQueryResult.Message;
}
}
catch (Exception ex)
{
validationMessage = String.Format(Constant.Messages.Violations.Exception, $"querying the following querying the groups related to this user: {input}", ex);
}
}
_callback(returnGroups);
return(validationMessage);
}
public void GetInstanceOfExtractorRegullarExpressionTest()
{
IntegrationSettings testSettings = new IntegrationSettings();
IntegrationServicesMgr testServiceManager = new IntegrationServicesMgr(testSettings.RsapiSettings);
ArtifactQueries artifactQueries = new ArtifactQueries();
ArtifactFactory artifactFactory = new ArtifactFactory(artifactQueries, testServiceManager, null);
var extractorRegEx = artifactFactory.GetInstanceOfExtractorRegullarExpression(ExecutionIdentity.System, 1016201, 1043028);
}
public async Task ExecuteAsync()
{
var sqlQueryHelper = new SqlQueryHelper();
var resourceGroupIds = GetResourceGroupIDs();
_logger = Helper.GetLoggerFactory().GetLogger();
var rsapiApiOptions = new APIOptions {
WorkspaceID = -1
};
var rsapiClient = Helper.GetServicesManager().CreateProxy <IRSAPIClient>(ExecutionIdentity.CurrentUser);
rsapiClient.APIOptions = rsapiApiOptions;
var rsapiGroupRepository = new RSAPIiRepositoryGroup(rsapiClient);
var artifactQueries = new ArtifactQueries();
var job = new ImportWorkerJob(AgentID, Helper, sqlQueryHelper, artifactQueries, DateTime.Now, rsapiGroupRepository, resourceGroupIds, _logger, rsapiApiOptions, new SerializationHelper());
job.OnMessage += MessageRaised;
try
{
RaiseMessage("Enter Agent", 10);
await job.ExecuteAsync();
RaiseMessage("Exit Agent", 10);
}
catch (Exception ex)
{
//Raise an error on the agents tab and event viewer
RaiseError(ex.ToString(), ex.ToString());
_logger.LogError(ex, $"{Constant.Names.ApplicationName} - {ex}");
//Add the error to our custom Errors table
sqlQueryHelper.InsertRowIntoImportErrorLogAsync(Helper.GetDBContext(-1), job.WorkspaceArtifactId, Constant.Tables.ExportWorkerQueue, job.TableRowId, job.AgentId, ex.ToString()).Wait();
//Add the error to the Relativity Errors tab
//this second try catch is in case we have a problem connecting to the RSAPI
try
{
ErrorQueries.WriteError(Helper.GetServicesManager(), ExecutionIdentity.System, job.WorkspaceArtifactId, ex);
}
catch (Exception rsapiException)
{
RaiseError(rsapiException.ToString(), rsapiException.ToString());
_logger.LogError(rsapiException, $"{Constant.Names.ApplicationName} - {rsapiException}");
}
}
finally
{
rsapiClient.Dispose();
}
}
public async Task <QueryResultSet <kCura.Relativity.Client.DTOs.User> > QueryAllUserArtifactIDs()
{
try
{
return(await ArtifactQueries.QueryAllUsersArtifactIDsAsync(
rsapiApiOptions : RsapiApiOptions,
userRepository : RsapiRepositoryGroup.UserRepository));
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.QueryAllUserAdminObjectsError, ex);
}
}
private async Task UpdateImportJobStatusFieldAsync(string status)
{
RaiseMessage($"Updating import job status to {status}. {_errorContext}]");
await ArtifactQueries.UpdateRdoJobTextFieldAsync(
AgentHelper.GetServicesManager(),
WorkspaceArtifactId,
ExecutionIdentity.CurrentUser,
Constant.Guids.ObjectType.MarkupUtilityImportJob,
_importJobArtifactId,
Constant.Guids.Field.MarkupUtilityImportJob.Status,
status);
}
private async Task UpdateImportJobDetailsFieldAsync(string details)
{
RaiseMessage($"Updating import job details. {_errorContext}");
await ArtifactQueries.UpdateRdoJobTextFieldAsync(
AgentHelper.GetServicesManager(),
WorkspaceArtifactId,
_executionIdentity,
Constant.Guids.ObjectType.MarkupUtilityImportJob,
_importJobArtifactId,
Constant.Guids.Field.MarkupUtilityImportJob.Details,
details);
}
public void Execute()
{
try
{
switch (ButtonName)
{
case Constant.Names.Console.SUBMIT:
//verify all necessary fields are provided
if (SavedSearchArtifactId == null || ExtractorProfileArtifactId == null || SourceLongTextFieldArtifactId == null)
{
throw new CustomExceptions.TextExtractorSetMissingFieldsException(Constant.ErrorMessages.EXTRACTION_SET_MISSING_FIELDS);
}
var dataRow = SqlQueryHelper.RetrieveSingleInManagerQueueByArtifactId(EddsDbContext, ActiveArtifactId, WorkspaceArtifactId);
if (dataRow == null)
{
//Insert record into Text Extractor Manager table
SqlQueryHelper.InsertRowIntoManagerQueue(EddsDbContext, WorkspaceArtifactId, SavedSearchArtifactId, ActiveArtifactId, ExtractorProfileArtifactId, SourceLongTextFieldArtifactId);
//Call RSAPI and update Status of Job to Submitted
ArtifactQueries.UpdateRdoStringFieldValue(SvcMgr, ExecutionCurrentUserIdentity, WorkspaceArtifactId, Constant.Guids.ObjectType.ExtractorSet, Constant.Guids.Fields.ExtractorSet.Status, ActiveArtifactId, Constant.ExtractorSetStatus.SUBMITTED);
}
break;
case Constant.Names.Console.CANCEL:
//Check if status of Extractor Set is not Complete
var extractorSetStatus = ArtifactQueries.GetExtractorSetStatus(SvcMgr, ExecutionCurrentUserIdentity, WorkspaceArtifactId, ActiveArtifactId);
if (extractorSetStatus != Constant.ExtractorSetStatus.COMPLETE)
{
//Update status of Extractor Set to Cancelled
ArtifactQueries.UpdateRdoStringFieldValue(SvcMgr, ExecutionCurrentUserIdentity, WorkspaceArtifactId, Constant.Guids.ObjectType.ExtractorSet, Constant.Guids.Fields.ExtractorSet.Status, ActiveArtifactId, Constant.ExtractorSetStatus.CANCELLED);
}
else
{
throw new CustomExceptions.TextExtractorSetConsoleCancelException(Constant.ErrorMessages.EXTRACTION_SET_RECORD_COMPLETE);
}
break;
}
}
catch (CustomExceptions.TextExtractorSetConsoleCancelException)
{
throw;
}
catch (Exception ex)
{
throw new Exception(string.Format("{0}, Error Message: {1}", Constant.ErrorMessages.DEFAULT_ERROR_PREPEND, ex));
}
}
public async Task ExecuteAsync()
{
try
{
switch (ButtonName)
{
case Constant.Buttons.SUBMIT:
Logger.LogDebug($"{Constant.Names.ApplicationName} - {Constant.Buttons.SUBMIT} button clicked.");
var recordExists = await DoesRecordExistAsync();
if (recordExists == false)
{
await DeleteJobErrors(SvcManager, IdentityCurrentUser, WorkspaceArtifactId, CurrentArtifactId);
//Add the record to the Export Manager queue table
var resourceGroupId = await ArtifactQueries.GetResourcePoolArtifactIdAsync(SvcManager, IdentitySystem, WorkspaceArtifactId);
await SqlQueryHelper.InsertRowIntoExportManagerQueueAsync(DbContextEdds, WorkspaceArtifactId, Priority, CurrentArtifactId, resourceGroupId, SelectedObjectType);
//Clear reset Job Statistics
await ResetJobStatisticsAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, CurrentArtifactId);
//Set the Export Job RDO status to Validating
await UpdateJobStatusAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, Constant.Guids.ObjectType.ExportUtilityJob, CurrentArtifactId, Constant.Guids.Field.ExportUtilityJob.Status, Constant.Status.Job.SUBMITTED);
}
break;
case Constant.Buttons.CANCEL:
Logger.LogDebug($"{Constant.Names.ApplicationName} - {Constant.Buttons.CANCEL} button clicked.");
var artifactId = await RetrieveIdByArtifactIdAsync();
//Clear reset Job Statistics
await ResetJobStatisticsAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, CurrentArtifactId);
if (artifactId > 0)
{
//Set the Export Job RDO status to Cancel Requested
await UpdateJobStatusAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, Constant.Guids.ObjectType.ExportUtilityJob, CurrentArtifactId, Constant.Guids.Field.ExportUtilityJob.Status, Constant.Status.Job.CANCELREQUESTED);
//Set the Export Job record in the Manager Queue to Cancel Requested
await UpdateJobStatusInManagerQueueAsync(DbContextEdds, WorkspaceArtifactId, CurrentArtifactId, Constant.Status.Queue.CANCELLATION_REQUESTED);
}
break;
}
}
catch (AdminMigrationUtilityException ex)
{
throw new AdminMigrationUtilityException(ex.Message);
}
}
public override void Execute()
{
var sqlQueryHelper = new SqlQueryHelper();
var artifactQueries = new ArtifactQueries();
var errorLogModel = new ErrorLogModel(sqlQueryHelper, Helper.GetDBContext(-1), AgentID, Constant.Tables.WorkerQueue);
var uniqueBatchTableName = "[" + Constant.Names.TablePrefix + "Worker_" + Guid.NewGuid() + "_" + AgentID + "]";
var artifactFactory = new ArtifactFactory(artifactQueries, Helper.GetServicesManager(), errorLogModel);
var agentWorkerJob = new WorkerJob(AgentID, Helper.GetServicesManager(), ExecutionIdentity.CurrentUser, new SqlQueryHelper(), new ArtifactQueries(), artifactFactory, Constant.AgentType.Worker, uniqueBatchTableName, Helper.GetDBContext(-1));
var textExtractorLog = new TextExtractorLog();
textExtractorLog.OnUpdate += MessageRaised;
agentWorkerJob.TextExtractorLog = textExtractorLog;
try
{
RaiseMessage("Enter Agent", 10);
agentWorkerJob.Execute();
RaiseMessage("Exit Agent", 10);
}
catch (Exception ex)
{
//Raise an error on the agents tab and event viewer
RaiseError(ex.ToString(), ex.ToString());
//Add the error to our custom Errors table
sqlQueryHelper.InsertRowIntoErrorLog(Helper.GetDBContext(-1), agentWorkerJob.WorkspaceArtifactId, Constant.Tables.WorkerQueue, agentWorkerJob.RecordId, agentWorkerJob.AgentId, ex.ToString());
//Add the error to the Relativity Errors tab
//this second try catch is in case we have a problem connecting to the RSAPI
try
{
ErrorQueries.WriteError(Helper.GetServicesManager(), ExecutionIdentity.CurrentUser, agentWorkerJob.WorkspaceArtifactId, ex);
}
catch (Exception rsapiException)
{
RaiseError(rsapiException.ToString(), rsapiException.ToString());
}
//Set the status in the queue to error
if (uniqueBatchTableName != string.Empty)
{
sqlQueryHelper.UpdateStatusInWorkerQueue(Helper.GetDBContext(-1), Constant.QueueStatus.Error, uniqueBatchTableName);
}
}
finally
{
textExtractorLog.RaiseUpdate("Dropping Worker Queue Batch table.");
//drop temp table
sqlQueryHelper.DropTable(Helper.GetDBContext(-1), uniqueBatchTableName);
}
}
public async Task UpdateExportJobExpectedNumberOfExports(Int32 expectedNumberOfExports, ExportManagerQueueRecord exportManagerQueueRecord)
{
try
{
RaiseAndLogDebugMessage("Updating export job expected number of exports.");
await ArtifactQueries.UpdateExportJobStatitics(RsapiRepositoryGroup.RdoRepository, RsapiApiOptions, exportManagerQueueRecord.WorkspaceArtifactId, exportManagerQueueRecord.ExportJobArtifactId, expectedNumberOfExports, 0, 0, 0);
RaiseAndLogDebugMessage("Updated export job expected number of exports.");
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.UpdateExportJobExpectedNumberError, ex);
}
}
public void CreateExtractorRegularExpressionRecordTest()
{
IntegrationSettings testSettings = new IntegrationSettings();
IntegrationDBContext testDBContext = new IntegrationDBContext(testSettings.DBContextSettings);
IntegrationServicesMgr testServiceManager = new IntegrationServicesMgr(testSettings.RsapiSettings);
SqlQueryHelper testSqlQueryHelpers = new SqlQueryHelper();
ArtifactQueries artifactQueries = new ArtifactQueries();
Int32 workspaceArtifactId = 1016201;
string regExName = "RegEx created from Unit Test";
string regEx = @"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
string description = "Matches emails";
artifactQueries.CreateExtractorRegularExpressionRecord(testServiceManager, ExecutionIdentity.CurrentUser, workspaceArtifactId, regExName, regEx, description);
}
private async Task <StreamReader> ReadImportJobFileContentsAsync(string tempFileLocation)
{
RaiseMessage($"Reading contents of import file for import job. {_errorContext}");
//Obtain ArtifactID of File Field on Markup Utility File object
var markupFileFieldArtifactId = await QueryHelper.GetArtifactIdByGuidAsync(AgentHelper.GetDBContext(WorkspaceArtifactId), Constant.Guids.Field.MarkupUtilityFile.File);
return(await ArtifactQueries.GetFileFieldContentsAsync(
AgentHelper.GetServicesManager(),
ExecutionIdentity.CurrentUser,
WorkspaceArtifactId,
markupFileFieldArtifactId,
_markupUtilityImportJob.FileArtifactId,
tempFileLocation));
}
private async Task QueryMarkupSetRelatedFieldValuesAsync(int markupSetArtifactId)
{
//retrieve markup set multipe choice field name
var markupSetName = await ArtifactQueries.RetreiveMarkupSetNameAsync(AgentHelper.GetServicesManager(), _executionIdentity, WorkspaceArtifactId, markupSetArtifactId);
string markupSetMultichoiceFieldName = $"{Constant.MarkupSet.MARKUP_SET_FIELD_NAME_PREFIX}{markupSetName}";
//retrieve markup set multipe choice field artifact id
_markupSetMultiplechoiceFieldChoiceTypeId = await ArtifactQueries.RetreiveMarkupSetMultipleChoiceFieldTypeIdAsync(AgentHelper.GetServicesManager(), _executionIdentity, WorkspaceArtifactId, markupSetMultichoiceFieldName);
//retrieve markup set multipe choice field choice values artifact id's
var choices = await ArtifactQueries.QueryAllMarkupSetMultipleChoiceFieldValuesAsync(AgentHelper.GetServicesManager(), _executionIdentity, WorkspaceArtifactId, markupSetMultichoiceFieldName);
_hasRedactionsChoiceModel = choices.First(x => x.Name.Equals(Constant.MarkupSet.MarkupSetMultiChoiceValues.HAS_REDACTIONS));
_hasHighlightsChoiceModel = choices.First(x => x.Name.Equals(Constant.MarkupSet.MarkupSetMultiChoiceValues.HAS_HIGHLIGHTS));
}
private async Task ProcessSingleImportJobAsync(DataRow dataRow)
{
_duplicateRedactionInserted = false;
try
{
//convert datarow to object
_importWorkerQueueRecord = new ImportWorkerQueueRecord(dataRow);
//set _imporJobArtifactId
_importJobArtifactId = _importWorkerQueueRecord.ImportJobArtifactId;
//create error context
_errorContext = $"[RecordId = {_importWorkerQueueRecord.Id}, WorkspaceArtifactId = {WorkspaceArtifactId}, ImportJobArtifactId = {_importWorkerQueueRecord.ImportJobArtifactId}]";
//retrieve import job
var markupUtilityImportJob = await RetrieveImportJobAsync(_importJobArtifactId);
//construct redaction data for history record
_redactionData = await ConstructRedactionDataAsync();
//get document artifact id
var documentArtifactId = await GetDocumentArtifactIdAsync();
//get fileGuid for the document and fileOrder
var fileGuid = await GetFileGuidForDocumentFileOrderAsync(documentArtifactId);
//check if markup set exists
await ArtifactQueries.VerifyIfMarkupSetExistsAsync(AgentHelper.GetServicesManager(), _executionIdentity, WorkspaceArtifactId, markupUtilityImportJob.MarkupSetArtifactId);
//insert redaction into redaction table
await InsertMarkupIntoRedactionTableAsync(fileGuid, markupUtilityImportJob, documentArtifactId);
}
catch (Exception ex)
{
RaiseMessage($"An exception occured when processing import job. {_errorContext}. [Error Message = {ex.Message}]");
//create Markup Utility history record as completed with errors
await CreateFailureHistoryRecordAsync(ex);
//update error redaction count
_errorRedactionCount++;
//log error
await LogErrorAsync(ex);
}
}
public async Task <Response> ExecutePreDelete()
{
Logger.LogDebug($"{Constant.Names.ApplicationName} - Entering ExecutePreDelete().");
var response = new Response {
Success = true, Message = string.Empty
};
try
{
var setStatus = await ArtifactQueries.RetrieveRdoJobStatusAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, ActiveArtifactId);
if (!string.IsNullOrEmpty(setStatus))
{
switch (setStatus)
{
case Constant.Status.Job.SUBMITTED:
case Constant.Status.Job.IN_PROGRESS_MANAGER:
case Constant.Status.Job.IN_PROGRESS_WORKER:
case Constant.Status.Job.COMPLETED_MANAGER:
case Constant.Status.Job.CANCELREQUESTED:
case Constant.Status.Job.RETRY:
response.Success = false;
response.Exception = new SystemException(Constant.ErrorMessages.NotSupportedJobDeletion);
break;
case Constant.Status.Job.CANCELLED:
case Constant.Status.Job.COMPLETED:
case Constant.Status.Job.COMPLETED_WITH_ERRORS:
case Constant.Status.Job.ERROR:
case Constant.Status.Job.NEW:
//Do nothing
break;
}
}
}
catch (Exception ex)
{
response.Success = false;
response.Exception = new SystemException($"{Constant.ErrorMessages.DefaultErrorPrepend}, Error Message: {ex}");
}
Logger.LogDebug($"{Constant.Names.ApplicationName} - Exiting ExecutePreDelete().");
return(response);
}
public async Task <IEnumerable <String> > QueryGroupsNamesUserIsPartOfAsync(kCura.Relativity.Client.DTOs.User user)
{
try
{
var userGroupArtifactIDs = user.Groups.Select(x => x.ArtifactID).ToList();
IEnumerable <String> groupNameList = await ArtifactQueries.QueryGroupsNamesForArtifactIdsAsync(
rsapiApiOptions : RsapiApiOptions,
eddsWorkspaceArtifactId : -1,
groupRepository : RsapiRepositoryGroup.GroupRepository,
groupArtifactIdList : userGroupArtifactIDs);
return(groupNameList);
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.QueryGroupNamesUserIsPartOfError, ex);
}
}
public async Task <Response> ExecutePreSave(bool isArtifactNew, Int32 statusFieldArtifactId)
{
var response = new Response {
Success = true, Message = string.Empty
};
try
{
ValidateEmailTo(response);
if (isArtifactNew)
{
//Update the Status field
ActiveArtifact.Fields[statusFieldArtifactId].Value.Value = Constant.Status.Job.NEW;
}
else
{
var status = await ArtifactQueries.RetrieveRdoJobStatusAsync(SvcManager, WorkspaceArtifactId, IdentityCurrentUser, ActiveArtifact.ArtifactID);
if (!string.IsNullOrEmpty(status))
{
switch (status)
{
case Constant.Status.Job.SUBMITTED:
case Constant.Status.Job.IN_PROGRESS:
case Constant.Status.Job.IN_PROGRESS_MANAGER:
case Constant.Status.Job.IN_PROGRESS_WORKER:
case Constant.Status.Job.COMPLETED_MANAGER:
case Constant.Status.Job.CANCELREQUESTED:
case Constant.Status.Job.RETRY:
response.Success = false;
response.Message = Constant.ErrorMessages.NotSupportedJobEdit;
break;
}
}
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = $"{Constant.ErrorMessages.DefaultErrorPrepend}, Error Message: {ex}";
}
return(response);
}
