public async Task Clean(List <Guid> extractIds)
{
Log.Debug($"Executing ClearHtsExtracts command...");
await _historyRepository.ClearHistory(extractIds);
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientExtract), "clearing...")));
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientPartnerExtract), "clearing...")));
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientLinkageExtract), "clearing...")));
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(new HtsStatusNotification(extractId, ExtractStatus.Clearing));
}
_validatorRepository.ClearByDocket("HTS");
await _tempPatientExtractRepository.Clear();
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(new HtsStatusNotification(extractId, ExtractStatus.Cleared));
}
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientExtract), "cleared")));
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientPartnerExtract), "cleared")));
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HTSClientLinkageExtract), "cleared")));
}
public async Task <bool> Handle(ExtractAllergiesChronicIllness request, CancellationToken cancellationToken)
{
//Extract
int found = await _AllergiesChronicIllnessSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
//Validate
await _extractValidator.Validate(request.Extract.Id, found, nameof(AllergiesChronicIllnessExtract), $"{nameof(TempAllergiesChronicIllnessExtract)}s");
//Load
int loaded = await _AllergiesChronicIllnessLoader.Load(request.Extract.Id, found, request.DatabaseProtocol.SupportsDifferential);
int rejected =
_extractHistoryRepository.ProcessRejected(request.Extract.Id, found - loaded, request.Extract);
_extractHistoryRepository.ProcessExcluded(request.Extract.Id, rejected, request.Extract);
//notify loaded
DomainEvents.Dispatch(
new ExtractActivityNotification(request.Extract.Id, new DwhProgress(
nameof(AllergiesChronicIllnessExtract),
nameof(ExtractStatus.Loaded),
found, loaded, rejected, loaded, 0)));
return(true);
}
public async Task <bool> Handle(ExtractMetricMigration request, CancellationToken cancellationToken)
{
//Extract
int found = await _metricMigrationSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
//Validate
await _extractValidator.Validate(request.Extract.Id, found, "Migration", "TempMetricMigrationExtracts");
//Load
int loaded = await _migrationLoader.Load(request.Extract.Id, found);
int rejected =
// TODO: CHECK MGS Rejection
_extractHistoryRepository.ProcessRejected(request.Extract.Id, found - loaded, request.Extract, false);
_extractHistoryRepository.ProcessExcluded(request.Extract.Id, rejected, request.Extract, false);
//notify loaded
DomainEvents.Dispatch(
new MgsExtractActivityNotification(request.Extract.Id, new ExtractProgress(
nameof(MetricMigrationExtract),
nameof(ExtractStatus.Loaded),
found, loaded, rejected, loaded, 0)));
return(true);
}
public virtual async Task <GResult> CreateAsync(TEntity entity)
{
var errors = new List <GError>();
foreach (var v in _validators)
{
var result = await v.ValidateAsync(entity);
errors.AddRange(result);
}
if (errors.Count > 0)
{
return(GResult.Failed(errors.ToArray()));
}
await _repository.AddAsync(entity);
try
{
await _unitOfWork.SaveChangesAsync();
DomainEvents.Dispatch(new EntityCreatedEvent <TEntity>(entity));
return(GResult.Success);
}
catch
{
return(GResult.Failed(ErrorDescriber.DefaultError()));
}
}
public async Task <int> Load()
{
int count = 0;
try
{
/*
* DomainEvents.Dispatch(
* new ExtractActivityNotification(extractId, new DwhProgress(
* nameof(PatientExtract),
* nameof(ExtractStatus.Loading),
* found, 0, 0, 0, 0)));
*
*/
const int take = 1000;
var eCount = await _tempHtsClientsExtractRepository.GetCleanCount();
var pageCount = _tempHtsClientsExtractRepository.PageCount(take, eCount);
int page = 1;
while (page <= pageCount)
{
var tempHtsClients = await
_tempHtsClientsExtractRepository.GetAll(a => a.ErrorType == 0, page, take);
var batch = tempHtsClients.ToList();
count += batch.Count;
//Auto mapper
var extractRecords = Mapper.Map <List <TempHtsClients>, List <HtsClients> >(batch);
foreach (var record in extractRecords)
{
record.Id = LiveGuid.NewGuid();
}
//Batch Insert
var inserted = _htsClientsExtractRepository.BatchInsert(extractRecords);
if (!inserted)
{
Log.Error($"Extract {nameof(HtsClients)} not Loaded");
return(0);
}
Log.Debug("saved batch");
page++;
/*
* DomainEvents.Dispatch(
* new ExtractActivityNotification(extractId, new DwhProgress(
* nameof(PatientExtract),
* nameof(ExtractStatus.Loading),
* found, count, 0, 0, 0)));
*/
}
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HtsClients), "Loading...", Found, 0, 0, 0, 0)));
return(count);
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(HtsClients)} not Loaded");
throw;
}
}
public async Task <int> Clear(List <Guid> extractIds)
{
Log.Debug($"Executing ClearDwhExtracts command...");
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Clearing),
0, 0, 0, 0, 0)));
}
await _historyRepository.ClearHistory(extractIds);
_validatorRepository.ClearByDocket("NDWH");
await _tempPatientExtractRepository.Clear();
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Cleared),
0, 0, 0, 0, 0)));
}
return(1);
}
public Task <int> Load(bool diffSupport)
{
var mapper = diffSupport ? ExtractDiffMapper.Instance : ExtractMapper.Instance;
try
{
//load temp extracts without errors
var tempPatientExtracts = _tempPatientExtractRepository.GetAll().Where(a => a.CheckError == false).ToList();
//Auto mapper
var extractRecords = mapper.Map <List <TempMasterPatientIndex>, List <MasterPatientIndex> >(tempPatientExtracts);
//Batch Insert
// TODO PLEASE PAGE DIS
_patientExtractRepository.BatchInsert(extractRecords);
Log.Debug("saved batch");
DomainEvents.Dispatch(new CbsNotification(new ExtractProgress(nameof(MasterPatientIndex), "Loading...", Found, 0, 0, 0, 0)));
return(Task.FromResult(tempPatientExtracts.Count));
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(MasterPatientIndex)} not Loaded");
throw;
}
}
public async Task <bool> Handle(ExtractHtsClientTracing request, CancellationToken cancellationToken)
{
//Extract
int found = await _patientSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
//Validate
await _extractValidator.Validate(request.Extract.Id, found, "HtsClientTracingExtracts", "TempHtsClientTracingExtracts");
//Load
int loaded = await _patientLoader.Load(request.Extract.Id, found);
int rejected =
_extractHistoryRepository.ProcessRejected(request.Extract.Id, found - loaded, request.Extract);
_extractHistoryRepository.ProcessExcluded(request.Extract.Id, rejected, request.Extract);
//notify loaded
DomainEvents.Dispatch(
new HtsExtractActivityNotification(request.Extract.Id, new ExtractProgress(
nameof(HtsClientTracing),
nameof(ExtractStatus.Loaded),
found, loaded, rejected, loaded, 0)));
return(true);
}
private void DispatchEvents(AggregateRoot aggregateRoot)
{
foreach (IDomainEvent domainEvent in aggregateRoot.DomainEvents)
{
DomainEvents.Dispatch(domainEvent);
}
aggregateRoot.ClearEvents();
}
private static void DispararEventos(Entidade entidade)
{
foreach (var evento in entidade.Eventos)
{
DomainEvents.Dispatch(evento);
}
entidade.RemoverEventos();
}
public async Task <int> Load(Guid extractId, int found)
{
try
{
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientArtExtract),
nameof(ExtractStatus.Loading),
found, 0, 0, 0, 0)));
//load temp extracts without errors
StringBuilder querybuilder = new StringBuilder();
querybuilder.Append($" SELECT * FROM {nameof(TempPatientArtExtract)}s s");
querybuilder.Append($" INNER JOIN PatientExtracts p ON ");
querybuilder.Append($" s.PatientPK = p.PatientPK AND ");
querybuilder.Append($" s.SiteCode = p.SiteCode ");
querybuilder.Append($" WHERE s.CheckError = 0");
string query = querybuilder.ToString();
var tempPatientArtExtracts = _tempPatientArtExtractRepository.GetFromSql(query);
const int take = 1000;
int skip = 0;
var count = tempPatientArtExtracts.Count();
while (skip < count)
{
var batch = tempPatientArtExtracts.Skip(skip).Take(take).ToList();
//Auto mapper
var extractRecords = Mapper.Map <List <TempPatientArtExtract>, List <PatientArtExtract> >(batch);
foreach (var record in extractRecords)
{
record.Id = LiveGuid.NewGuid();
}
//Batch Insert
var inserted = _patientArtExtractRepository.BatchInsert(extractRecords);
if (!inserted)
{
Log.Error($"Extract {nameof(PatientArtExtract)} not Loaded");
return(0);
}
Log.Debug("saved batch");
skip = skip + take;
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientArtExtract),
nameof(ExtractStatus.Loading),
found, skip, 0, 0, 0)));
}
return(count);
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(PatientArtExtract)} not Loaded");
return(0);
}
}
private static void DispatchEvents(AggregateRoot aggregateRoot)
{
foreach (var domainEvent in aggregateRoot.DomainEvents)
{
DomainEvents.Dispatch(domainEvent);
}
aggregateRoot.ClearDomainEvents();
}
public async Task <int> Load(Guid extractId, int found, bool diffSupport)
{
int count = 0; var mapper = diffSupport ? ExtractDiffMapper.Instance : ExtractMapper.Instance;
try
{
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Loading),
found, 0, 0, 0, 0)));
const int take = 500;
var eCount = await _tempPatientExtractRepository.GetCleanCount();
var pageCount = _tempPatientExtractRepository.PageCount(take, eCount);
int page = 1;
while (page <= pageCount)
{
var tempPatientExtracts = await
_tempPatientExtractRepository.GetAll(a => a.ErrorType == 0, page, take);
var batch = tempPatientExtracts.ToList();
count += batch.Count;
//Auto mapper
var extractRecords = mapper.Map <List <TempPatientExtract>, List <PatientExtract> >(batch);
foreach (var record in extractRecords)
{
record.Id = LiveGuid.NewGuid();
}
//Batch Insert
var inserted = _patientExtractRepository.BatchInsert(extractRecords);
if (!inserted)
{
Log.Error($"Extract {nameof(PatientExtract)} not Loaded");
return(0);
}
Log.Debug("saved batch");
page++;
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Loading),
found, count, 0, 0, 0)));
}
await _mediator.Publish(new DocketExtractLoaded("NDWH", nameof(PatientExtract)));
return(count);
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(PatientExtract)} not Loaded");
throw;
}
}
public async Task <int> Extract(DbExtract extract, DbProtocol dbProtocol)
{
int batch = 500;
var list = new List <TempPatientAdverseEventExtract>();
int count = 0;
int loaded = 0;
using (var rdr = await _reader.ExecuteReader(dbProtocol, extract))
{
while (rdr.Read())
{
count++;
// AutoMapper profiles
var extractRecord = Mapper.Map <IDataRecord, TempPatientAdverseEventExtract>(rdr);
extractRecord.Id = LiveGuid.NewGuid();
if (extractRecord.HasData())
{
loaded++;
list.Add(extractRecord);
}
if (count == batch)
{
_extractRepository.BatchInsert(list);
count = 0;
DomainEvents.Dispatch(
new ExtractActivityNotification(extract.Id, new DwhProgress(
nameof(PatientAdverseEventExtract),
nameof(ExtractStatus.Finding),
loaded, 0, 0, 0, 0)));
list = new List <TempPatientAdverseEventExtract>();
}
}
if (count > 0)
{
// save remaining list;
_extractRepository.BatchInsert(list);
}
_extractRepository.CloseConnection();
}
// TODO: Notify Completed;
DomainEvents.Dispatch(
new ExtractActivityNotification(extract.Id, new DwhProgress(
nameof(PatientAdverseEventExtract),
nameof(ExtractStatus.Found),
loaded, 0, 0, 0, 0)));
return(loaded);
}
public Task <int> Extract(DbExtract extract, DbProtocol dbProtocol)
{
var mapper = dbProtocol.SupportsDifferential ? ExtractDiffMapper.Instance : ExtractMapper.Instance;
int batch = 500;
var list = new List <TempCwcVisitExtract>();
int count = 0;
int loaded = 0;
using (var rdr = _reader.ExecuteReaderSync(dbProtocol, extract))
{
while (rdr.Read())
{
count++;
loaded++;
// AutoMapper profiles
var extractRecord = mapper.Map <IDataRecord, TempCwcVisitExtract>(rdr);
extractRecord.Id = LiveGuid.NewGuid();
list.Add(extractRecord);
if (count == batch)
{
_extractRepository.BatchInsert(list);
count = 0;
DomainEvents.Dispatch(
new MnchExtractActivityNotification(extract.Id, new DwhProgress(
nameof(CwcVisitExtract),
nameof(ExtractStatus.Finding),
loaded, 0, 0, 0, 0)));
list = new List <TempCwcVisitExtract>();
}
}
if (count > 0)
{
// save remaining list;
_extractRepository.BatchInsert(list);
}
_extractRepository.CloseConnection();
}
// TODO: Notify Completed;
DomainEvents.Dispatch(
new MnchExtractActivityNotification(extract.Id, new DwhProgress(
nameof(CwcVisitExtract),
nameof(ExtractStatus.Found),
loaded, 0, 0, 0, 0)));
return(Task.FromResult(loaded));
}
public void DomainEvents_Raise()
{
bool eventFired = false;
DomainEvents.Register <object>((o) => { eventFired = true; });
DomainEvents.Dispatch(new object());
DomainEvents.Raise();
Assert.AreEqual(true, eventFired);
}
private void FireDomainEvents(IEnumerable <AggregateRoot> items)
{
foreach (var item in items)
{
foreach (IDomainEvent domainEvent in item.DomainEvents)
{
DomainEvents.Dispatch(domainEvent);
}
item.ClearDomainEvents();
}
}
public async Task <bool> Validate(Guid extractId, int extracted, string extractName, string sourceTable)
{
DomainEvents.Dispatch(
new MgsExtractActivityNotification(extractId, new ExtractProgress(
extractName,
nameof(ExtractStatus.Validating),
extracted, 0, 0, 0, 0)));
try
{
var validators = _validatorRepository.GetByExtract(sourceTable);
int count = 0;
var validatorList = validators.ToList();
foreach (var validator in validatorList)
{
using (var command = _validatorRepository.GetConnection().CreateCommand())
{
var provider = _validatorRepository.GetConnectionProvider();
command.CommandText = validator.GenerateValidateSql(provider);
try
{
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
}
await GetTask(command);
}
catch (Exception e)
{
Log.Debug(e.Message);
throw;
}
count++;
}
}
DomainEvents.Dispatch(
new MgsExtractActivityNotification(extractId, new ExtractProgress(
extractName,
nameof(ExtractStatus.Validated),
extracted, 0, 0, 0, 0)));
return(true);
}
catch (Exception e)
{
DomainEvents.Dispatch(
new MgsExtractActivityNotification(extractId, new ExtractProgress(
extractName,
nameof(ExtractStatus.Idle),
extracted, 0, 0, 0, 0)));
Console.WriteLine(e);
return(false);
}
}
public async Task Clean(Guid extractId)
{
_historyRepository.ClearHistory(extractId);
DomainEvents.Dispatch(new CbsNotification(new ExtractProgress(nameof(MasterPatientIndex), "clearing...")));
DomainEvents.Dispatch(new CbsStatusNotification(extractId, ExtractStatus.Clearing));
await _repository.Clear();
DomainEvents.Dispatch(new CbsStatusNotification(extractId, ExtractStatus.Cleared));
}
public async Task <List <SendMpiResponse> > SendClientsAsync(SendManifestPackageDTO sendTo, HtsMessageBag messageBag)
{
var responses = new List <SendMpiResponse>();
var client = new HttpClient();
int sendCound = 0;
int count = 0;
int total = messageBag.Messages.Count;
DomainEvents.Dispatch(new HtsStatusNotification(sendTo.ExtractId, ExtractStatus.Sending));
foreach (var message in messageBag.Messages)
{
count++;
try
{
var msg = JsonConvert.SerializeObject(message);
var response = await client.PostAsJsonAsync(sendTo.GetUrl($"{_endPoint.HasToEndsWith("/")}Clients"), message);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsJsonAsync <SendMpiResponse>();
responses.Add(content);
var sentIds = message.Clients.Select(x => x.Id).ToList();
sendCound += sentIds.Count;
DomainEvents.Dispatch(new HtsExtractSentEvent(sentIds, SendStatus.Sent, sendTo.ExtractName));
}
else
{
var error = await response.Content.ReadAsStringAsync();
DomainEvents.Dispatch(new HtsExtractSentEvent(message.Clients.Select(x => x.Id).ToList(), SendStatus.Failed, sendTo.ExtractName, error));
throw new Exception(error);
}
}
catch (Exception e)
{
Log.Error(e, $"Send Manifest Error");
throw;
}
DomainEvents.Dispatch(new HtsSendNotification(new SendProgress(nameof(HTSClientExtract), Common.GetProgress(count, total))));
}
DomainEvents.Dispatch(new HtsSendNotification(new SendProgress(nameof(HTSClientExtract), Common.GetProgress(count, total), true)));
DomainEvents.Dispatch(new HtsStatusNotification(sendTo.ExtractId, ExtractStatus.Sent, sendCound));
return(responses);
}
//allows us to dispatch domain events only after the persistence operation is completed, and thus preserve the unit of work
private void DispatchEvents(AggregateRoot aggregateRoot)
{
if (aggregateRoot == null)
{
return;
}
foreach (IDomainEvent domainEvent in aggregateRoot.DomainEvents)
{
DomainEvents.Dispatch(domainEvent);
}
aggregateRoot.ClearEvents();
}
private void DispatchEvents(Entity entity)
{
if (entity == null)
{
return;
}
foreach (IDomainEvent domainEvent in entity.DomainEvents)
{
DomainEvents.Dispatch(domainEvent);
}
entity.ClearEvents();
}
public async Task <int> Load(Guid extractId, int found)
{
try
{
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Loading),
found, 0, 0, 0, 0)));
//load temp extracts without errors
var tempPatientExtracts = _tempPatientExtractRepository.GetAll().Where(a => a.CheckError == false);
const int take = 1000;
int skip = 0;
var count = tempPatientExtracts.Count();
while (skip < count)
{
var batch = tempPatientExtracts.Skip(skip).Take(take).ToList();
//Auto mapper
var extractRecords = Mapper.Map <List <TempPatientExtract>, List <PatientExtract> >(batch);
foreach (var record in extractRecords)
{
record.Id = LiveGuid.NewGuid();
}
//Batch Insert
var inserted = _patientExtractRepository.BatchInsert(extractRecords);
if (!inserted)
{
Log.Error($"Extract {nameof(PatientExtract)} not Loaded");
return(0);
}
Log.Debug("saved batch");
skip = skip + take;
DomainEvents.Dispatch(
new ExtractActivityNotification(extractId, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Loading),
found, skip, 0, 0, 0)));
}
return(count);
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(PatientExtract)} not Loaded");
throw;
}
}
public virtual async Task <GResult> DeleteAsync(TEntity entity)
{
await _repository.DeleteAsync(entity);
try
{
await _unitOfWork.SaveChangesAsync();
DomainEvents.Dispatch(new EntityDeletedEvent <TEntity>(entity));
return(GResult.Success);
}
catch
{
return(GResult.Failed(ErrorDescriber.DefaultError()));
}
}
public async Task <bool> Handle(ExtractPatient request, CancellationToken cancellationToken)
{
//Extract
int found = await _patientSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
//Check for duplicate patients
var patientKeys = _tempPatientExtractRepository.GetAll().Select(k => k.PatientPK);
var distinct = new HashSet <int?>();
var duplicates = new HashSet <int?>();
foreach (var key in patientKeys)
{
if (!distinct.Add(key))
{
duplicates.Add(key);
}
}
if (duplicates.Any())
{
var readDuplicates = string.Join(", ", duplicates.ToArray());
throw new DuplicatePatientException($"Duplicate patient(s) with PatientPK(s) {readDuplicates} found");
}
//Validate
await _extractValidator.Validate(request.Extract.Id, found, nameof(PatientExtract), $"{nameof(TempPatientExtract)}s");
//Load
int loaded = await _patientLoader.Load(request.Extract.Id, found, request.DatabaseProtocol.SupportsDifferential);
int rejected =
_extractHistoryRepository.ProcessRejected(request.Extract.Id, found - loaded, request.Extract);
// _extractHistoryRepository.ProcessExcluded(request.Extract.Id, rejected,0);
_extractHistoryRepository.ProcessExcluded(request.Extract.Id, rejected, request.Extract);
//notify loaded
DomainEvents.Dispatch(
new ExtractActivityNotification(request.Extract.Id, new DwhProgress(
nameof(PatientExtract),
nameof(ExtractStatus.Loaded),
found, loaded, rejected, loaded, 0)));
return(true);
}
public async Task <int> Load(bool diffSupport)
{
var mapper = diffSupport ? ExtractDiffMapper.Instance : ExtractMapper.Instance;
int count = 0;
try
{
const int take = 1000;
var eCount = await _tempHtsClientsLinkageExtractRepository.GetCleanCount();
var pageCount = _tempHtsClientsLinkageExtractRepository.PageCount(take, eCount);
int page = 1;
while (page <= pageCount)
{
var tempHtsClientLinkages = await
_tempHtsClientsLinkageExtractRepository.GetAll(QueryUtil.Linkage, page, take);
var batch = tempHtsClientLinkages.ToList();
count += batch.Count;
//Auto mapper
var extractRecords = mapper.Map <List <TempHtsClientLinkage>, List <HtsClientLinkage> >(batch);
foreach (var record in extractRecords)
{
record.Id = LiveGuid.NewGuid();
}
//Batch Insert
var inserted = _clientsLinkageExtractRepository.BatchInsert(extractRecords);
if (!inserted)
{
Log.Error($"Extract {nameof(HtsClientLinkage)} not Loaded");
return(0);
}
Log.Debug("saved batch");
page++;
}
DomainEvents.Dispatch(new HtsNotification(new ExtractProgress(nameof(HtsClientLinkage), "Loading...", Found, 0, 0, 0, 0)));
return(count);
}
catch (Exception e)
{
Log.Error(e, $"Extract {nameof(HtsClientLinkage)} not Loaded");
throw;
}
}
public async Task <bool> Handle(ExtractMasterPatientIndex request, CancellationToken cancellationToken)
{
// clear
await _clearExtracts.Clean(request.Extract.Id);
// extract
int found = await _patientSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
DomainEvents.Dispatch(new CbsNotification(new ExtractProgress(nameof(MasterPatientIndex), "validating...")));
// await _patientValidator.Validate();
DomainEvents.Dispatch(new CbsNotification(new ExtractProgress(nameof(MasterPatientIndex), "loading...")));
int loaded = await _patientLoader.Load(request.Extract.Id, 0);
DomainEvents.Dispatch(new CbsNotification(new ExtractProgress(nameof(MasterPatientIndex), "loaded")));
//notify loaded
return(true);
}
public async Task NotifyPostSending(SendManifestPackageDTO sendTo, string version)
{
var notificationend = new HandshakeEnd("CTSendEnd", version);
DomainEvents.Dispatch(new DwhMessageNotification(false, $"Sending completed"));
await _mediator.Publish(new HandshakeEnd("CTSendEnd", version));
var client = Client ?? new HttpClient();
try
{
var session = _reader.GetSession(notificationend.EndName);
var response = await client.PostAsync(sendTo.GetUrl($"{_endPoint.HasToEndsWith("/")}Handshake?session={session}"), null);
}
catch (Exception e)
{
Log.Error(e, $"Send Handshake Error");
}
}
public async Task Clear(List <Guid> extractIds)
{
Log.Debug($"Executing ClearMetricExtracts command...");
await _historyRepository.ClearHistory(extractIds);
DomainEvents.Dispatch(new MgsNotification(new ExtractProgress(nameof(MetricMigrationExtract), "clearing...")));
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(new MgsStatusNotification(extractId, ExtractStatus.Clearing));
}
_validatorRepository.ClearByDocket("MGS");
await _tempMetricMigrationExtractRepository.Clear();
foreach (var extractId in extractIds)
{
DomainEvents.Dispatch(new MgsStatusNotification(extractId, ExtractStatus.Cleared));
}
}
public async Task <bool> Handle(ExtractPatientAdverseEvent request, CancellationToken cancellationToken)
{
//Extract
int found = await _patientAdverseEventSourceExtractor.Extract(request.Extract, request.DatabaseProtocol);
//Validate
await _extractValidator.Validate(request.Extract.Id, found, nameof(PatientAdverseEventExtract), $"{nameof(TempPatientAdverseEventExtract)}s");
//Load
int loaded = await _patientAdverseEventLoader.Load(request.Extract.Id, found);
int rejected = found - loaded;
//notify loaded
DomainEvents.Dispatch(
new ExtractActivityNotification(request.Extract.Id, new DwhProgress(
nameof(PatientAdverseEventExtract),
nameof(ExtractStatus.Loaded),
found, loaded, rejected, loaded, 0)));
return(true);
}
