public void Update_withoutFileId_Test()
{
var resultArchive = _resultArchiveUploadRepository.GetById(_validResultArchiveId);
resultArchive.Id = _validResultArchiveId;
resultArchive.Status = ResultArchiveUploadStatus.UploadFailed;
_resultArchiveUploadRepository.Save(resultArchive);
}
public void Parse()
{
long eventId;
long uploadedBy;
try
{
var resultArchive = _resultArchiveUploadRepository.GetById(_resultArchiveId);
eventId = resultArchive.EventId;
uploadedBy = resultArchive.UploadedByOrgRoleUserId;
var location = _mediaRepository.GetScannedDocumentStorageFileLocation(eventId);
_pathforScannedFiles = location.PhysicalPath;
}
catch (ObjectNotFoundInPersistenceException <ResultArchive> ex)
{
//Put the log file entries here.
_logger.Error("Invalid record provided for Parsing! Error: " + ex.Message + "\n\t" + ex.StackTrace);
throw;
}
var isNewResultFlow = _eventRepository.IsEventHasNewResultFlow(eventId);
string corpCode = "";
try
{
var account = _corporateAccountRepository.GetForEventIdWithOrganizationDetail(eventId);
if (account != null)
{
corpCode = account.Name.Trim();
}
}
catch (Exception ex)
{
_logger.Error("Exception while getting corp code. Message: " + ex.Message);
}
while (true)
{
var bioSoundFolderPath = GetFolderPathfor(_compressedFolderPath, NameforBiosoundFolder);
var cardioFolderPath = GetFolderPathfor(_compressedFolderPath, NameforCardioFolder);
var bloodworksFolderPath = GetFolderPathfor(_compressedFolderPath, NameforBloodworksFolder);
var ekgFolderPath = GetFolderPathfor(_compressedFolderPath, _nameforEkgFolder);
var ekgCardioCardFolderPath = GetFolderPathfor(_compressedFolderPath, _nameforEkgCardioCardFolder);
var geFolderPath = GetFolderPathfor(_compressedFolderPath, NameforGeFolder);
var pftFolderPath = GetFolderPathfor(_compressedFolderPath, NameforPftFolder);
var kynFolderPath = GetFolderPathfor(_compressedFolderPath, NameforKynFolder);
var eventFilesPath = GetFolderPathfor(_compressedFolderPath, NameforEventfilesFolder);
var ultrasoundTransducerPath = GetFolderPathfor(_compressedFolderPath, NameforSonoTransducerFolder);
var awvPreventionPlanFolderPath = GetFolderPathfor(_compressedFolderPath, NameForAwvPreventionPlanFolder);
var awvSnapShotFolder = GetFolderPathfor(_compressedFolderPath, NameForAwvSnapShotFolder);
var floChecFolderPath = GetFolderPathfor(_compressedFolderPath, NameforFloChecAbiParser);
var quantaFloFolderPath = GetFolderPathfor(_compressedFolderPath, NameforQuantaFloABIParser);
var focAttestationPath = GetFolderPathfor(_compressedFolderPath, NameForFocAttestationParser);
var SpiroFolderPath = GetFolderPathfor(_compressedFolderPath, nameforSpiroFolder);
var dpnFolderPath = GetFolderPathfor(_compressedFolderPath, NameForDpnFolder, true);
if (string.IsNullOrEmpty(ultrasoundTransducerPath))
{
ultrasoundTransducerPath = GetFolderPathfor(_compressedFolderPath, AltNameforSonoTransducerFolder);
}
if (string.IsNullOrEmpty(bioSoundFolderPath) && string.IsNullOrEmpty(cardioFolderPath) && string.IsNullOrEmpty(bloodworksFolderPath) && string.IsNullOrEmpty(ekgFolderPath) &&
string.IsNullOrEmpty(geFolderPath) && string.IsNullOrEmpty(pftFolderPath) && string.IsNullOrEmpty(kynFolderPath) && string.IsNullOrEmpty(eventFilesPath) &&
string.IsNullOrEmpty(ultrasoundTransducerPath) && string.IsNullOrEmpty(awvPreventionPlanFolderPath) && string.IsNullOrEmpty(awvSnapShotFolder) &&
string.IsNullOrEmpty(floChecFolderPath) && string.IsNullOrEmpty(focAttestationPath) && string.IsNullOrEmpty(quantaFloFolderPath) && string.IsNullOrEmpty(ekgCardioCardFolderPath) &&
string.IsNullOrEmpty(SpiroFolderPath) && string.IsNullOrEmpty(dpnFolderPath)
)
{
break;
}
if (!string.IsNullOrEmpty(bloodworksFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== Bloodworks Parsing - " + Directory.GetParent(bloodworksFolderPath).Name + "\\" + (new DirectoryInfo(bloodworksFolderPath)).Name + " ===========================================\n");
//_bloodworksParser = new BloodworksResultParser(bloodworksFolderPath, eventId, _logger, uploadedBy);
//var bloodworksCustomerScreeningData = _bloodworksParser.Parse();
//Save(bloodworksCustomerScreeningData, uploadedBy);
//SaveResultArchiveLogs(_bloodworksParser.ResultArchiveLogs);
_bloodworksParser = new BloodworksResultParser2(eventId, bloodworksFolderPath, _logger, _basicBiometricRepository, _eventCustomerRepository, uploadedBy, _lipidParserHelper);
var bloodworksCustomerScreeningData = _bloodworksParser.Parse();
Save(bloodworksCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_bloodworksParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Bloodworks parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(bloodworksFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Blood works folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(kynFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== KYN Parsing - " + Directory.GetParent(kynFolderPath).Name + "\\" + (new DirectoryInfo(kynFolderPath)).Name + " ===========================================\n");
_kynParser = new KynResultParser(eventId, corpCode, _resultArchiveId, kynFolderPath, _settings, _logger, _customerRepository, _basicBiometricRepository, _eventCustomerRepository, uploadedBy, _lipidParserHelper, _customerService);
var testData = _kynParser.Parse();
Save(testData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_kynParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("KYN parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(kynFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Kyn folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(eventFilesPath))
{
try
{
_logger.Info("\n\n\n====================================== Moving Event Files - " + Directory.GetParent(eventFilesPath).Name + "\\" + (new DirectoryInfo(eventFilesPath)).Name + " ===========================================\n");
MoveEventFiles(eventFilesPath, _pathforScannedFiles);
}
catch (Exception ex)
{
_logger.Error("Event Files: " + ex.Message + "\n" + ex.StackTrace, ex);
}
finally
{
Directory.Delete(eventFilesPath, true);
}
}
if (!string.IsNullOrEmpty(ultrasoundTransducerPath))
{
try
{
_logger.Info("\n\n\n====================================== Ultrasound Transducer Parsing - " + Directory.GetParent(ultrasoundTransducerPath).Name + "\\" + (new DirectoryInfo(ultrasoundTransducerPath)).Name + " ===========================================\n");
var ultrasoundParser = new UltrasoundTransducerResultParser(ultrasoundTransducerPath, eventId, _logger, _settings);
var ultrasoundEventCustomerScreeningData = ultrasoundParser.Parse();
Save(ultrasoundEventCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(ultrasoundParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Ultrasound Parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(ultrasoundTransducerPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Ultrasound folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(bioSoundFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== BioSound Parsing - " + Directory.GetParent(bioSoundFolderPath).Name + "\\" + (new DirectoryInfo(bioSoundFolderPath)).Name + " ===========================================\n");
if (IsNewBiosoundRequired(bioSoundFolderPath, _logger))
{
_bioSoundResultParser = new BioSound2ResultParser(bioSoundFolderPath, eventId, _logger);
var bioSoundEventCustomerScreeningData = _bioSoundResultParser.Parse();
Save(bioSoundEventCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_bioSoundResultParser.ResultArchiveLogs);
}
else
{
_bioSoundResultParser = new BioSoundResultParser(bioSoundFolderPath, _settings, eventId, _logger);
var bioSoundEventCustomerScreeningData = _bioSoundResultParser.Parse();
Save(bioSoundEventCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_bioSoundResultParser.ResultArchiveLogs);
}
}
catch (Exception ex)
{
_logger.Error("BioSound parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(bioSoundFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Biosound folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(pftFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== PFT Parsing - " + Directory.GetParent(pftFolderPath).Name + "\\" + (new DirectoryInfo(pftFolderPath)).Name + " ===========================================\n");
_pftParser = new PftFileParser(pftFolderPath, eventId, _logger);
var pftEventCustomerScreeningData = _pftParser.Parse();
Save(pftEventCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_pftParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("PFT parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(pftFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting PFT folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(cardioFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== Cardiovision Parsing - " + Directory.GetParent(cardioFolderPath).Name + "\\" + (new DirectoryInfo(cardioFolderPath)).Name + " ===========================================\n");
_cardioResultParser = new CardiovisionResultParser(cardioFolderPath, eventId, _logger, isNewResultFlow);
var cardioEventCustomerScreeningData = _cardioResultParser.Parse();
Save(cardioEventCustomerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_cardioResultParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Cardiovision parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(cardioFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Cardiovision folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(ekgFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== EKG Parsing - " + Directory.GetParent(ekgFolderPath).Name + "\\" + (new DirectoryInfo(ekgFolderPath)).Name + " ===========================================\n");
if (_ekgFileParsertoUse.ToLower().Equals("ekgfileparser2"))
{
_ekgParser = new EkgFileParser2(ekgFolderPath, eventId, _logger, _settings, isNewResultFlow);
}
else
{
_ekgParser = new EkgFileParser(ekgFolderPath, eventId, _logger);
}
var customerScreeningData = _ekgParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_ekgParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Ekg parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(ekgFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting EKG folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(geFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== GE Parsing - " + Directory.GetParent(geFolderPath).Name + "\\" + (new DirectoryInfo(geFolderPath)).Name + " ===========================================\n");
_geParser = new GeResultParser(eventId, geFolderPath, _logger, new ExcelReader());
var customerScreeningData = _geParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_geParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("GE parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(geFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting GE folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(awvPreventionPlanFolderPath) || !string.IsNullOrEmpty(awvSnapShotFolder))
{
try
{
if (!string.IsNullOrEmpty(awvSnapShotFolder))
{
_logger.Info("\n\n\n====================================== AWV Test(s) Parsing - " + Directory.GetParent(awvSnapShotFolder).Name + "\\" + (new DirectoryInfo(awvSnapShotFolder)).Name + " ===========================================\n");
}
if (!string.IsNullOrEmpty(awvPreventionPlanFolderPath))
{
_logger.Info("\n\n\n====================================== AWV Test(s) Parsing - " + Directory.GetParent(awvPreventionPlanFolderPath).Name + "\\" + (new DirectoryInfo(awvPreventionPlanFolderPath)).Name + " ===========================================\n");
}
_awvParser = new AwvParser(awvPreventionPlanFolderPath, awvSnapShotFolder, eventId, _logger);
var customerScreeningData = _awvParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_awvParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("AWV Test(s) parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
if (!string.IsNullOrEmpty(awvSnapShotFolder))
{
Directory.Delete(awvSnapShotFolder, true);
}
if (!string.IsNullOrEmpty(awvPreventionPlanFolderPath))
{
Directory.Delete(awvPreventionPlanFolderPath, true);
}
}
catch (Exception ex)
{
_logger.Error("Deleting AWV folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(floChecFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== FloChec-ABI Parsing - " + Directory.GetParent(floChecFolderPath).Name + "\\" + (new DirectoryInfo(floChecFolderPath)).Name + " ===========================================\n");
_floChecABIParser = new FloChecABIParser(floChecFolderPath, eventId, _logger, _mediaRepository);
var customerScreeningData = _floChecABIParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_floChecABIParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("FloChec-ABI parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(floChecFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting FloChec-ABI folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(quantaFloFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== QuantaFlo-ABI Parsing - " + Directory.GetParent(quantaFloFolderPath).Name + "\\" + (new DirectoryInfo(quantaFloFolderPath)).Name + " ===========================================\n");
_quantaFloAbiParser = new QuantaFloABIParser(quantaFloFolderPath, eventId, _logger, _mediaRepository);
var customerScreeningData = _quantaFloAbiParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_quantaFloAbiParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("QuantaFlo-ABI parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(quantaFloFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting QuantaFlo-ABI folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(focAttestationPath))
{
try
{
_logger.Info("\n\n\n====================================== FOC-Attestation Parsing - " + Directory.GetParent(focAttestationPath).Name + "\\" + (new DirectoryInfo(focAttestationPath)).Name + " ===========================================\n");
_focAttestationParser = new FOCAttestationParser(focAttestationPath, eventId, _logger, _mediaRepository);
var customerScreeningData = _focAttestationParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_focAttestationParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("FOC-Attestation Parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(focAttestationPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting FOC-Attestation folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(ekgCardioCardFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== EKG Parsing - " + Directory.GetParent(ekgCardioCardFolderPath).Name + "\\" + (new DirectoryInfo(ekgCardioCardFolderPath)).Name + " ===========================================\n");
_ekgParser = new EkgCardioCardFileParser(ekgCardioCardFolderPath, eventId, _logger);
var customerScreeningData = _ekgParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_ekgParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Ekg parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(ekgCardioCardFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting EKG folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(SpiroFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== Spiro Parsing - " + Directory.GetParent(SpiroFolderPath).Name + "\\" + (new DirectoryInfo(SpiroFolderPath)).Name + " ===========================================\n");
_spiroParser = new SpiroParser(SpiroFolderPath, eventId, _logger);
var customerScreeningData = _spiroParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_spiroParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("Spiro parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(SpiroFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting Spiro folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (!string.IsNullOrEmpty(dpnFolderPath))
{
try
{
_logger.Info("\n\n\n====================================== DPN Parsing - " + Directory.GetParent(dpnFolderPath).Name + "\\" + (new DirectoryInfo(dpnFolderPath)).Name + " ===========================================\n");
_dpnParser = new DpnParser(dpnFolderPath, eventId, _logger, isNewResultFlow);
var customerScreeningData = _dpnParser.Parse();
Save(customerScreeningData, uploadedBy, isNewResultFlow);
SaveResultArchiveLogs(_dpnParser.ResultArchiveLogs);
}
catch (Exception ex)
{
_logger.Error("DPN parsing: " + ex.Message + "\n" + ex.StackTrace, ex);
}
try
{
Directory.Delete(dpnFolderPath, true);
}
catch (Exception ex)
{
_logger.Error("Deleting DPN folder: " + ex.Message + "\n" + ex.StackTrace, ex);
}
}
if (Directory.GetDirectories(_compressedFolderPath).Length < 1)
{
break;
}
}
}
public ActionResult Detail(long id = 0)
{
ResultArchiveUploadLogListModel model = null;
if (id > 0)
{
model = new ResultArchiveUploadLogListModel();
var resultArchiveLogRecords = _resultArchiveUploadLogRepository.GetbyResultArchiveId(id);
var resultArchive = _resultArchiveUploadRepository.GetById(id);
model.ResultArchive = AutoMapper.Mapper.Map <ResultArchive, ResultArchiveUploadViewModel>(resultArchive);
var theEvent = _eventRepository.GetById(resultArchive.EventId);
model.ResultArchive.EventDate = theEvent.EventDate;
model.ResultArchive.EventName = theEvent.Name;
if (resultArchive.FileId.HasValue)
{
var file = _fileRepository.GetById(resultArchive.FileId.Value);
model.ResultArchive.File = file;
}
if (resultArchiveLogRecords != null)
{
model.ResultArchiveLogRecords =
AutoMapper.Mapper.Map
<IEnumerable <ResultArchiveLog>, IEnumerable <ResultArchiveUploadLogViewModel> >(
resultArchiveLogRecords);
var orgRoleUserIds = resultArchiveLogRecords.Select(r => r.CustomerId).ToArray();
orgRoleUserIds = orgRoleUserIds.Concat(new long[] { resultArchive.UploadedByOrgRoleUserId }).ToArray();
var userIdNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds);
var userIdNamepair =
userIdNamePairs.Where(p => p.FirstValue == resultArchive.UploadedByOrgRoleUserId).
SingleOrDefault();
if (userIdNamepair != null)
{
model.ResultArchive.UploadedBy = userIdNamepair.SecondValue;
}
var testIds = resultArchiveLogRecords.Select(r => (long)r.TestId).Distinct().ToArray();
var tests = ((IUniqueItemRepository <Test>)_testRepository).GetByIds(testIds);
foreach (var resultArchiveLogRecord in model.ResultArchiveLogRecords)
{
resultArchiveLogRecord.CustomerName =
userIdNamePairs.Where(p => p.FirstValue == resultArchiveLogRecord.CustomerId).
SingleOrDefault().
SecondValue;
resultArchiveLogRecord.TestName =
tests.Where(t => t.Id == (long)resultArchiveLogRecord.TestId).Single().Name;
}
}
else
{
model.ResultArchive.UploadedBy = _organizationRoleUserRepository.GetNameIdPairofUsers(new long[] { resultArchive.UploadedByOrgRoleUserId }).FirstOrDefault().SecondValue;
}
}
return(View(model));
}
