Example #1
0
        private void ParseDataforLipid(long customerId, string filePath)
        {
            var isTestPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Lipid);

            if (isTestPurchased)
            {
                var testResult = _kynAppLipidParser.Parse(customerId, filePath, TestType.Lipid);
                _resultParserHelper.AddTestResulttoEventCustomerAggregate(_eventCustomerScreeningAggregates, _eventId, customerId, testResult);
                _resultParserHelper.AddResultArchiveLog(_kynAppLipidParser.ErrorSummary, TestType.Lipid, customerId, MedicalEquipmentTag.KynDataProcessor, true);
            }
            else
            {
                _logger.Info(string.Format("Lipid is not availed by Customer : [{0}]", customerId));
            }
        }
        private void ParseDataForHypertension(long customerId, BasicBiometric basicBiometric)
        {
            var isTestPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Hypertension);

            try
            {
                if (isTestPurchased)
                {
                    var testResult = new HypertensionTestResult
                    {
                        Systolic = new ResultReading <int?> {
                            Reading = basicBiometric.SystolicPressure
                        },
                        Diastolic = new ResultReading <int?> {
                            Reading = basicBiometric.DiastolicPressure
                        },
                        RightArmBpMeasurement = new ResultReading <bool> {
                            Reading = basicBiometric.IsRightArmBpMeasurement
                        },
                        BloodPressureElevated = new ResultReading <bool> {
                            Reading = basicBiometric.SystolicPressure >= 140 || basicBiometric.DiastolicPressure >= 90
                        }
                    };

                    _resultParserHelper.AddTestResulttoEventCustomerAggregate(_eventCustomerScreeningAggregates, _eventId, customerId, testResult);
                    _resultParserHelper.AddResultArchiveLog(_bloodworkAppLipidParser.ErrorSummary, TestType.Hypertension, customerId, MedicalEquipmentTag.Bloodworks, true);
                }
                else
                {
                    _logger.Info(string.Format("Hypertension is not availed by Customer : [{0}]", customerId));
                }
            }
            catch (Exception exception)
            {
                _logger.Error(string.Format("Some error occured while parsing data of Hypertension Test for customerId {0} and event Id {1} \nMessage:{2} \nStack Trace: {3}", customerId, _eventId, exception.Message, exception.StackTrace));
            }
        }
Example #3
0
        private void ParseDataForThyroid(DataRow dr, BloodTestResultParserLog log, long customerId, long eventId)
        {
            var    isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(eventId, customerId, (long)TestType.Thyroid);
            var    isEmpty = IsDataRowItemEmpty(dr[ColumnThyroid]);
            string message;

            if (isEmpty && !isTestPurchasedByCustomer)
            {
                message = string.Format("For Customer Id {0} - EventId {1}, no data for TSH", customerId, eventId);
                _logger.Info(message);
                return;
            }

            if (isEmpty)
            {
                message = string.Format("For Customer Id {0} - EventId {1}, no data for TSH", customerId, eventId);
                AppendTestResultLog(log, message, false);
                _logger.Info(message);
            }
            else if (!isTestPurchasedByCustomer)
            {
                message = string.Format("TSH is not availed by CustomerId {0} - EventId {1}.", customerId, eventId);
                AppendTestResultLog(log, message, false);
                _logger.Info(message);
            }
            else
            {
                var testResult = new ThyroidTestResult
                {
                    TSHSCR = new ResultReading <string>(ReadingLabels.TSHSCR)
                    {
                        ReadingSource = ReadingSource.Automatic,
                        Reading       = dr[ColumnThyroid].ToString()
                    }
                };
                _resultParserHelper.AddTestResulttoEventCustomerAggregate(_eventCustomerScreeningAggregates, eventId, customerId, testResult);
            }
        }
Example #4
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            foreach (var filePath in Directory.GetFiles(directoryPath))
            {
                _isSpiroFile = false;
                // IsEkgIppeFile = false;

                if (Path.GetExtension(filePath).ToLower().Contains("pdf"))
                {
                    var fileName = Path.GetFileName(filePath);

                    if (fileName.ToLower().StartsWith(SpiroFilePrefix.ToLower()))
                    {
                        _isSpiroFile = true;
                    }

                    //if (fileName.ToLower().StartsWith(EkgIppeFilePreFix.ToLower()))
                    //    IsEkgIppeFile = true;

                    var customerIdString = "";

                    if (_isSpiroFile)
                    {
                        var tempFileName = fileName.Substring(fileName.IndexOf("_") + 1);
                        customerIdString = tempFileName.Substring(0, tempFileName.IndexOf("_"));
                    }
                    //else if (IsEkgIppeFile)
                    //{
                    //    if (fileName.ToLower().StartsWith(EkgIppeFilePreFix.ToLower()))
                    //    {
                    //        var tempFileName = fileName.Substring(fileName.IndexOf("_") + 1);
                    //        customerIdString = tempFileName.Substring(0, tempFileName.IndexOf("_"));
                    //    }
                    //    else
                    //        customerIdString = fileName.Substring(0, fileName.IndexOf("_"));
                    //}
                    else
                    {
                        if (fileName.ToLower().StartsWith(EkgFilePrefix.ToLower()))
                        {
                            var tempFileName = fileName.Substring(fileName.IndexOf("_") + 1);
                            customerIdString = tempFileName.Substring(0, tempFileName.IndexOf("_"));
                        }
                        else
                        {
                            customerIdString = fileName.Substring(0, fileName.IndexOf("_"));
                        }
                    }

                    long customerId = 0;
                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("CustomerId not found on Pdf file" + filePath);
                        continue;
                    }

                    bool isSpiroTestPurchasedByCustomer    = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Spiro);
                    bool isAwvSpiroTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvSpiro);

                    bool isEkgTestPurchasedByCustomer        = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.EKG);
                    bool isAwvEkgTestPurchasedByCustomer     = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvEkg);
                    bool isAwvEkgIppeTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvEkgIPPE);

                    try
                    {
                        if (_isSpiroFile)
                        {
                            if (!isSpiroTestPurchasedByCustomer && !isAwvSpiroTestPurchasedByCustomer)
                            {
                                _logger.Info("Spiro is not availed by CustomerId[" + customerId + "].\n");
                                continue;
                            }
                        }
                        else
                        {
                            if (!isEkgTestPurchasedByCustomer && !isAwvEkgTestPurchasedByCustomer && !isAwvEkgIppeTestPurchasedByCustomer)
                            {
                                _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "].\n");
                                continue;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (_isSpiroFile)
                        {
                            _logger.Info("Spiro is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        }
                        else
                        {
                            _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        }
                        continue;
                    }

                    try
                    {
                        TestType   testType;
                        TestResult testResult = null;
                        if (_isSpiroFile)
                        {
                            testType = TestType.Spiro;

                            if (isAwvSpiroTestPurchasedByCustomer)
                            {
                                testType = TestType.AwvSpiro;
                            }

                            string folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                            var resultMedia = GetMediaFromPdfFile(filePath, folderToSaveImage, testType.ToString(), false);

                            if (resultMedia != null)
                            {
                                if (isAwvSpiroTestPurchasedByCustomer)
                                {
                                    testResult = new AwvSpiroTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                }
                                else if (isSpiroTestPurchasedByCustomer)
                                {
                                    testResult = new SpiroTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                }
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);

                                _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.Schiller);

                                _logger.Info(string.Concat("\nParsing succeeded for Spiro for Customer Id: ", customerId, "\n"));
                            }
                        }
                        else
                        {
                            testType = TestType.EKG;

                            if (isAwvEkgIppeTestPurchasedByCustomer) //&& IsEkgIppeFile
                            {
                                testType = TestType.AwvEkgIPPE;
                            }
                            else if (isAwvEkgTestPurchasedByCustomer)
                            {
                                testType = TestType.AwvEkg;
                            }

                            string folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                            var resultMedia = GetMediaFromPdfFile(filePath, folderToSaveImage, testType.ToString());

                            if (resultMedia != null)
                            {
                                switch (testType)
                                {
                                case TestType.EKG:
                                    testResult = new EKGTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;

                                case TestType.AwvEkg:
                                    testResult = new AwvEkgTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;

                                case TestType.AwvEkgIPPE:
                                    testResult = new AwvEkgIppeTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;
                                }

                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                                _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.Schiller);

                                _logger.Info(string.Concat("\nParsing succeeded for EKG  for Customer Id: ", customerId, "\n"));
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (_isSpiroFile)
                        {
                            _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, isAwvSpiroTestPurchasedByCustomer ? TestType.AwvSpiro : TestType.Spiro, customerId, MedicalEquipmentTag.Schiller, false);
                        }
                        else
                        {
                            _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, isAwvEkgIppeTestPurchasedByCustomer ? TestType.AwvEkgIPPE : isAwvEkgTestPurchasedByCustomer ? TestType.AwvEkg : TestType.EKG, customerId, MedicalEquipmentTag.Schiller, false);
                        }
                    }
                }
            }
            return(eventCustomerAggregates);
        }
Example #5
0
        private void ParseforFilePath(string filePath, List <EventCustomerScreeningAggregate> eventCustomerAggregates)
        {
            if (!string.IsNullOrEmpty(filePath))
            {
                long customerId = 0;
                var  headerType = GetHeaderTypeFromFile(filePath, out customerId).ToLower();

                var reportKind = "";
                if (headerType.Contains(ReportKindAaa))
                {
                    reportKind = ReportKindAaa;
                }
                else if (headerType.Contains(ReportKindStroke))
                {
                    reportKind = ReportKindStroke;
                }
                else if (headerType.Contains(ReportKindEcho))
                {
                    reportKind = ReportKindEcho;
                }
                else if (headerType.Contains(ReportKindThyroid))
                {
                    reportKind = ReportKindThyroid;
                }
                else if (headerType.Contains(ReportKindImt))
                {
                    reportKind = ReportKindImt;
                }
                else if (headerType.Contains(ReportKindLead))
                {
                    reportKind = ReportKindLead;
                }

                if (!string.IsNullOrEmpty(headerType) && customerId > 0)
                {
                    var mediaFilePath = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId);
                    switch (reportKind)
                    {
                    case ReportKindAaa:

                        bool isPpAaaPurchased  = false;
                        bool isHcpAaaPurchased = false;
                        bool isAwvAaaPurchased = false;
                        try
                        {
                            _logger.Info("\n\n ===================> AAA Parsing for CustomerId : " + customerId + "\n");
                            bool isAaaPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AAA);
                            isPpAaaPurchased  = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.PPAAA);
                            isHcpAaaPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.HCPAAA);
                            isAwvAaaPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvAAA);

                            if (!isAaaPurchased && !isPpAaaPurchased && !isHcpAaaPurchased && !isAwvAaaPurchased)
                            {
                                _logger.Info("AAA is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            ITestParser aaaParser = null;
                            if (isPpAaaPurchased)
                            {
                                aaaParser = new BioSoundPpAaaParser(filePath, mediaFilePath.PhysicalPath, _logger);

                                var ppAaaTestResult = aaaParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, ppAaaTestResult);
                                _resultParserHelper.AddResultArchiveLog(aaaParser.ErrorSummary, TestType.PPAAA, customerId, MedicalEquipmentTag.BioSound);
                            }
                            else if (isHcpAaaPurchased)
                            {
                                aaaParser = new BioSoundHcpAaaParser(filePath, mediaFilePath.PhysicalPath, _logger);

                                var hcpAaaTestResult = aaaParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, hcpAaaTestResult);
                                _resultParserHelper.AddResultArchiveLog(aaaParser.ErrorSummary, TestType.HCPAAA, customerId, MedicalEquipmentTag.BioSound);
                            }
                            else if (isAwvAaaPurchased)
                            {
                                aaaParser = new BioSoundAwvAaaParser(filePath, mediaFilePath.PhysicalPath, _logger, _eventId, customerId);

                                var awvAaaTestResult = aaaParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, awvAaaTestResult);
                                _resultParserHelper.AddResultArchiveLog(aaaParser.ErrorSummary, TestType.AwvAAA, customerId, MedicalEquipmentTag.BioSound);
                            }

                            if (isAaaPurchased)
                            {
                                if (_aaaParserToUse.ToLower().Equals("biosoundaaaparser"))
                                {
                                    aaaParser = new BioSoundAaaParser(filePath, mediaFilePath.PhysicalPath, _logger);
                                }
                                else
                                {
                                    aaaParser = new BioSoundAaaParser2(filePath, mediaFilePath.PhysicalPath, _logger);
                                }

                                var aaaTestResult = aaaParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, aaaTestResult);
                                _resultParserHelper.AddResultArchiveLog(aaaParser.ErrorSummary, TestType.AAA, customerId, MedicalEquipmentTag.BioSound);
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message,
                                                                    (isPpAaaPurchased ? TestType.PPAAA :
                                                                     (isHcpAaaPurchased ? TestType.HCPAAA :
                                                                      (isAwvAaaPurchased ? TestType.AwvAAA : TestType.AAA)))
                                                                    , customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;

                    case ReportKindEcho:
                        var testEchoType = TestType.Echocardiogram;
                        try
                        {
                            _logger.Info("\n\n ===================> Echo Parsing for CustomerId : " + customerId + "\n");

                            var isEchoPurchasedByCustomer    = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Echocardiogram);
                            var isPpEchoPurchasedByCustomer  = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.PPEcho);
                            var isHcpEchoPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.HCPEcho);
                            var isAwvEchoPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvEcho);


                            if (!isEchoPurchasedByCustomer && !isPpEchoPurchasedByCustomer && !isHcpEchoPurchasedByCustomer && !isAwvEchoPurchasedByCustomer)
                            {
                                _logger.Info("Echocardiogram is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            if (isPpEchoPurchasedByCustomer)
                            {
                                testEchoType = TestType.PPEcho;
                            }
                            else if (isHcpEchoPurchasedByCustomer)
                            {
                                testEchoType = TestType.HCPEcho;
                            }
                            else if (isAwvEchoPurchasedByCustomer)
                            {
                                testEchoType = TestType.AwvEcho;
                            }

                            ITestParser echoParser     = new BioSoundEchoParser(filePath, mediaFilePath.PhysicalPath, _logger, testEchoType);
                            var         echoTestResult = echoParser.Parse();
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, echoTestResult);
                            _resultParserHelper.AddResultArchiveLog(echoParser.ErrorSummary, testEchoType, customerId, MedicalEquipmentTag.BioSound);
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, testEchoType, customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;

                    case ReportKindStroke:
                        bool isHcpCarotidPurchased = false;
                        bool isAwvCarotidPurchased = false;
                        try
                        {
                            _logger.Info("\n\n ===================> Stroke Parsing for CustomerId : " + customerId + "\n");
                            bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Stroke);
                            isHcpCarotidPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.HCPCarotid);
                            isAwvCarotidPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvCarotid);
                            if (!isTestPurchasedByCustomer && !isHcpCarotidPurchased && !isAwvCarotidPurchased)
                            {
                                _logger.Info("Stroke is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            if (isHcpCarotidPurchased)
                            {
                                ITestParser hcpCarotidParser     = new BioSoundHcpCarotidParser(filePath, mediaFilePath.PhysicalPath, _logger);
                                var         hcpCarotidTestResult = hcpCarotidParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, hcpCarotidTestResult);
                                _resultParserHelper.AddResultArchiveLog(hcpCarotidParser.ErrorSummary, TestType.HCPCarotid, customerId, MedicalEquipmentTag.BioSound);
                            }
                            else if (isAwvCarotidPurchased)
                            {
                                ITestParser awvCarotidParser     = new BioSoundAwvCarotidParser(filePath, mediaFilePath.PhysicalPath, _logger);
                                var         hcpCarotidTestResult = awvCarotidParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, hcpCarotidTestResult);
                                _resultParserHelper.AddResultArchiveLog(awvCarotidParser.ErrorSummary, TestType.AwvCarotid, customerId, MedicalEquipmentTag.BioSound);
                            }
                            else
                            {
                                ITestParser strokeParser     = new BioSoundStrokeParser(filePath, mediaFilePath.PhysicalPath, _logger);
                                var         strokeTestResult = strokeParser.Parse();
                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, strokeTestResult);
                                _resultParserHelper.AddResultArchiveLog(strokeParser.ErrorSummary, TestType.Stroke, customerId, MedicalEquipmentTag.BioSound);
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, isHcpCarotidPurchased ? TestType.HCPCarotid : (isAwvCarotidPurchased ? TestType.AwvCarotid : TestType.Stroke), customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;

                    case ReportKindLead:
                        try
                        {
                            _logger.Info("\n\n ===================> Lead Parsing for CustomerId : " + customerId + "\n");
                            bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Lead);
                            if (!isTestPurchasedByCustomer)
                            {
                                _logger.Info("Lead is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            ITestParser leadParser     = new BioSoundLeadParser(filePath, mediaFilePath.PhysicalPath, _logger);
                            var         leadTestResult = leadParser.Parse();
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, leadTestResult);
                            _resultParserHelper.AddResultArchiveLog(leadParser.ErrorSummary, TestType.Lead, customerId, MedicalEquipmentTag.BioSound);
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.Lead, customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;


                    case ReportKindThyroid:
                        try
                        {
                            _logger.Info("\n\n ===================> Thyroid Parsing for CustomerId : " + customerId + "\n");
                            bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Thyroid);
                            if (!isTestPurchasedByCustomer)
                            {
                                _logger.Info("Thyroid is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            ITestParser thyroidParser     = new BioSoundThyroidParser(filePath, mediaFilePath.PhysicalPath, _logger);
                            var         thyroidTestResult = thyroidParser.Parse();
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, thyroidTestResult);
                            _resultParserHelper.AddResultArchiveLog(thyroidParser.ErrorSummary, TestType.Thyroid, customerId, MedicalEquipmentTag.BioSound);
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.Thyroid, customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;


                    case ReportKindImt:
                        try
                        {
                            _logger.Info("\n\n ===================> IMT Parsing for CustomerId : " + customerId + "\n");
                            bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.IMT);
                            if (!isTestPurchasedByCustomer)
                            {
                                _logger.Info("IMT is not availed by CustomerId[" + customerId + "]. But is recorded for. Not parsing the record. \n");
                                break;
                            }

                            ITestParser imtParser     = new BioSoundImtParser(filePath, mediaFilePath.PhysicalPath, _logger);
                            var         imtTestResult = imtParser.Parse();
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, imtTestResult);
                            _resultParserHelper.AddResultArchiveLog(imtParser.ErrorSummary, TestType.IMT, customerId, MedicalEquipmentTag.BioSound);
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Error: " + ex.Message + " \n\t " + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.IMT, customerId, MedicalEquipmentTag.BioSound, false);
                        }
                        break;
                    }
                }
            }
        }
Example #6
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            foreach (var filePath in DirectoryOperationsHelper.GetFiles(directoryPath))
            {
                if (Path.GetExtension(filePath).ToLower().Contains("pdf"))
                {
                    _logger.Info("Parsing file : " + filePath);
                    var customerIdString = "";
                    var fileName         = Path.GetFileName(filePath);
                    try
                    {
                        customerIdString = fileName.Split('_')[2];
                    }
                    catch
                    {
                        customerIdString = fileName;
                    }

                    // var customerIdString = fileName.IndexOf("_") > 0 ? fileName.Substring(0, fileName.IndexOf("_")) : fileName;

                    long customerId;

                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("Customer ID not found on Pdf file : " + filePath);
                        continue;
                    }

                    bool isSpiroTestPurchasedByCustomer    = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Spiro);
                    bool isAwvSpiroTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvSpiro);

                    try
                    {
                        if (!isSpiroTestPurchasedByCustomer && !isAwvSpiroTestPurchasedByCustomer)
                        {
                            _logger.Info("SPIRO/AWVSPIRO is not availed by CustomerId[" + customerId + "].\n");
                            continue;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("SPIRO/AWVSPIRO is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        continue;
                    }

                    try
                    {
                        TestResult testResult = null;
                        var        testType   = TestType.Spiro;

                        if (isAwvSpiroTestPurchasedByCustomer)
                        {
                            testType = TestType.AwvSpiro;
                        }

                        var folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                        var resultMedia = GetMediaFromPdfFile(filePath, folderToSaveImage, testType.ToString());
                        resultMedia.ReadingSource = ReadingSource.Automatic;

                        if (resultMedia != null)
                        {
                            switch (testType)
                            {
                            case TestType.Spiro:
                                testResult = new SpiroTestResult
                                {
                                    ResultImage = resultMedia
                                };
                                break;

                            case TestType.AwvSpiro:
                                testResult = new AwvSpiroTestResult
                                {
                                    ResultImage = resultMedia
                                };
                                break;
                            }

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.CardioCard);

                            _logger.Info(string.Concat("\nParsing succeeded for SPIRO/AWVSPIRO  for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, isSpiroTestPurchasedByCustomer ? TestType.Spiro : TestType.AwvSpiro, customerId, MedicalEquipmentTag.CardioCard, false);
                    }
                }
            }
            return(eventCustomerAggregates);
        }
Example #7
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            var testType = TestType.QuantaFloABI;

            foreach (var filePath in Directory.GetFiles(directoryPath))
            {
                long customerId = 0;

                if (string.IsNullOrEmpty(filePath) || !Path.GetExtension(filePath).ToLower().Contains("pdf"))
                {
                    _logger.Info("file path empty or not contain pdf");
                    continue;
                }

                var fileName = Path.GetFileName(filePath);

                try
                {
                    if (fileName.Split('_').Length > 2)
                    {
                        long.TryParse(fileName.Split('_')[2], out customerId);
                    }
                }
                catch (Exception exception)
                {
                    _logger.Error(string.Format("some Error occured while extracting customerId from file Path  {0} exception : {1} \n stacktrace: {2}", filePath, exception.Message, exception.StackTrace));
                    continue;
                }
                if (customerId <= 0)
                {
                    _logger.Error(string.Format("customerId not found in file Path  {0}", filePath));
                    continue;
                }

                try
                {
                    bool isQuantaFloAbiPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)testType);

                    if (!isQuantaFloAbiPurchased)
                    {
                        _logger.Info("QuantaFlo ABI is not availed by CustomerId[" + customerId + "].\n");
                        continue;
                    }

                    var foldertoSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                    var resultMedia = GetMediaFromPdfFile(filePath, foldertoSaveImage, testType.ToString());

                    if (resultMedia != null)
                    {
                        var mediaFilePath = foldertoSaveImage + Path.GetFileNameWithoutExtension(resultMedia.File.Path) + ".pdf";
                        File.Copy(filePath, mediaFilePath);
                    }

                    var testResult = new QuantaFloABITestResult {
                        ResultImage = resultMedia
                    };

                    _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                    _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.QuantaFlo);

                    _logger.Info(string.Concat("\nParsing succeeded for QuantaFlo-ABI  for Customer Id: ", customerId, "\n"));
                }
                catch (Exception ex)
                {
                    _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                    _resultParserHelper.AddResultArchiveLog(ex.Message, testType, customerId, MedicalEquipmentTag.QuantaFlo, false);
                }
            }

            return(eventCustomerAggregates);
        }
Example #8
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            var pdfFiles = DirectoryOperationsHelper.GetFiles(directoryPath, "*.pdf"); //GetPdfFiles(directoryPath);

            if (pdfFiles != null && pdfFiles.Any())
            {
                _logger.Info("Number of Files to Parse : " + pdfFiles.Count());

                foreach (var filePath in pdfFiles)
                {
                    var fileName = Path.GetFileName(filePath);

                    long   customerId   = 0;
                    string errorMessage = string.Empty;

                    _logger.Info("=============== Parsing Started for file: " + fileName + " =================");

                    var pdfText = GetTextFromPdf(filePath);
                    if (string.IsNullOrWhiteSpace(pdfText))
                    {
                        continue;
                    }

                    var lstText          = pdfText.Replace("\r", "").Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
                    var customerIdString = lstText.Where(x => x.Contains("Patient ID:")).FirstOrDefault();

                    if (string.IsNullOrWhiteSpace(customerIdString) || !long.TryParse(customerIdString.Replace("Patient ID:", "").Trim(), out customerId))
                    {
                        errorMessage = "DPN: CustomerId could be blank or not an numeric value in Pdf file @" + filePath + " and text is: " + customerIdString;
                        _logger.Info(errorMessage);
                        continue;
                    }

                    var eventCustomer = _eventCustomerRepository.Get(_eventId, customerId);

                    if (eventCustomer == null)
                    {
                        errorMessage = "DPN: Customer: " + customerId + " is not registered on Event Id :" + _eventId
                                       + " for file path: " + filePath;

                        _logger.Info(errorMessage);
                        continue;
                    }

                    var isTestPurchased = _eventCustomerRepository.IsTestPurchasedByEventIdCustomerId(_eventId, customerId, (long)TestType.DPN);

                    if (!isTestPurchased)
                    {
                        errorMessage = "DPN: Test not purchased for Customer Id :" + customerId + " Event Id :" + _eventId
                                       + " and file path: " + filePath;

                        _logger.Info(errorMessage);

                        continue;
                    }

                    var resultState = _eventCustomerResultRepository.GetByCustomerIdAndEventId(customerId, _eventId);

                    if (resultState != null && _isNewResultFlow && resultState.ResultState >= (int)NewTestResultStateNumber.PostAuditNew)
                    {
                        errorMessage = "DPN (New Result Flow): Pdf can not parsed because current result state is "
                                       + NewTestResultStateNumber.PostAuditNew.ToString() + " for Customer Id :" + customerId + " Event Id :"
                                       + _eventId + " and file path: " + filePath;

                        _logger.Info(errorMessage);
                        continue;
                    }

                    if (resultState != null && !_isNewResultFlow && resultState.ResultState >= (int)TestResultStateNumber.PostAudit)
                    {
                        errorMessage = "DPN (Old Result Flow): Pdf can not parsed because current result state is "
                                       + TestResultStateNumber.PostAudit.ToString() + " for Customer Id :" + customerId + " Event Id :"
                                       + _eventId + " and file path: " + filePath;

                        _logger.Info(errorMessage);
                        continue;
                    }

                    try
                    {
                        string folderToSavePdf = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var    resultMedia     = GetMediaFromPdfFile(filePath, folderToSavePdf, TestType.DPN);

                        if (resultMedia != null)
                        {
                            resultMedia.ReadingSource = ReadingSource.Automatic;

                            TestResult testResult = new DpnTestResult {
                                ResultImage = resultMedia
                            };

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.DPN, customerId, MedicalEquipmentTag.Vatica);

                            _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        errorMessage = "DPN: System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace;
                        _logger.Error(errorMessage);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.DPN, customerId, MedicalEquipmentTag.Vatica, false);
                    }

                    _logger.Info("=============== Parsing Ended for file: " + fileName + " =================");
                }
            }

            return(eventCustomerAggregates);
        }
Example #9
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();
            var testType      = TestType.FocAttestation;
            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            var pdfFiles = Directory.GetFiles(directoryPath, "*.pdf");

            if (pdfFiles.IsNullOrEmpty())
            {
                _logger.Info("file path empty or not contain pdf");

                return(eventCustomerAggregates);
            }

            foreach (var filePath in pdfFiles)
            {
                long customerId = 0;

                try
                {
                    var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);

                    long.TryParse(fileNameWithoutExtension, out customerId);

                    if (customerId <= 0)
                    {
                        _logger.Error(string.Format("customerId not found in file Path  {0}", filePath));
                        continue;
                    }
                }
                catch (Exception exception)
                {
                    _logger.Error(string.Format("some Error occured while extracting customerId from file Path  {0} exception : {1} \n stacktrace: {2}", filePath, exception.Message, exception.StackTrace));
                    continue;
                }

                try
                {
                    bool isFOCAttestationPurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)testType);

                    if (!isFOCAttestationPurchased)
                    {
                        _logger.Info("FOC Attestation is not availed by CustomerId[" + customerId + "].\n");
                        continue;
                    }

                    var foldertoSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                    var resultMedia = GetMediaFromPdfFile(filePath, foldertoSaveImage, testType.ToString());

                    if (resultMedia != null)
                    {
                        resultMedia.ReadingSource = ReadingSource.Automatic;

                        var testResult = new FocAttestationTestResult {
                            ResultImage = resultMedia
                        };

                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                        _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.FocAttestation);

                        _logger.Info(string.Concat("\nParsing succeeded for FOC Attestation  for Customer Id: ", customerId, "\n"));
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                    _resultParserHelper.AddResultArchiveLog(ex.Message, testType, customerId, MedicalEquipmentTag.FocAttestation, false);
                }
            }

            return(eventCustomerAggregates);
        }
Example #10
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            var filePathsForXml = Directory.GetFiles(directoryPath, "*.xml").OrderBy(m => m).ToArray();
            var filePathsForJpg = Directory.GetFiles(directoryPath, "*.jpg").OrderBy(m => m).ToArray();

            //var fileNameArray = filePathsForXml.Select(Path.GetFileNameWithoutExtension).ToList();
            //.AddRange(filePathsForJpg.Select(Path.GetFileNameWithoutExtension));

            if (filePathsForXml.Count() > 0)
            {
                foreach (var xmlFilePath in filePathsForXml)
                {
                    var fileName = Path.GetFileName(xmlFilePath);

                    long customerId = GetCustomerId(fileName);
                    if (customerId < 1)
                    {
                        _logger.Info("CustomerId not found on XML file " + xmlFilePath);
                        continue;
                    }

                    try
                    {
                        bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.EKG);
                        if (!isTestPurchasedByCustomer)
                        {
                            _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "].\n");
                            continue;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        continue;
                    }

                    try
                    {
                        var imageFilePath =
                            filePathsForJpg.Where(
                                f => Path.GetFileNameWithoutExtension(f) == Path.GetFileNameWithoutExtension(xmlFilePath)).
                            FirstOrDefault();
                        if (string.IsNullOrEmpty(imageFilePath))
                        {
                            imageFilePath = filePathsForJpg.Where(f => f.Contains(customerId.ToString())).FirstOrDefault();
                            if (!string.IsNullOrEmpty(imageFilePath))
                            {
                                filePathsForJpg = filePathsForJpg.Where(f => f != imageFilePath).Select(f => f).ToArray();
                            }
                        }

                        var testResult = new EKGTestResult();

                        string folderToSaveImage =
                            _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var resultMedia = string.IsNullOrEmpty(imageFilePath)
                                              ? null
                                              : _mediaHelper.GetfromImageFile(new FileInfo(imageFilePath),
                                                                              TestType.EKG.ToString(), folderToSaveImage,
                                                                              _settings.HideEkgSection);

                        var resultData = GetDatafromXml(xmlFilePath, testResult);

                        if (!resultData && resultMedia == null)
                        {
                            _logger.Info(string.Concat("\nNo Data found for Id: ", customerId, "\n"));
                            continue;
                        }

                        testResult.ResultImage = resultMedia;

                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId,
                                                                                  customerId, testResult);
                        _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.EKG, customerId,
                                                                MedicalEquipmentTag.Schiller);

                        _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.EKG, customerId, MedicalEquipmentTag.Schiller, false);
                    }
                }
            }

            if (filePathsForJpg.Count() > 0)
            {
                foreach (var jpgFilePath in filePathsForJpg)
                {
                    var imageFilePath = filePathsForXml.Where(f => Path.GetFileNameWithoutExtension(f) == Path.GetFileNameWithoutExtension(jpgFilePath)).FirstOrDefault();
                    if (!string.IsNullOrEmpty(imageFilePath))
                    {
                        continue;
                    }

                    var  fileName   = Path.GetFileName(jpgFilePath);
                    long customerId = GetCustomerId(fileName);
                    if (customerId < 1)
                    {
                        _logger.Info("CustomerId not found on XML file " + filePathsForJpg);
                        continue;
                    }

                    try
                    {
                        bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.EKG);
                        if (!isTestPurchasedByCustomer)
                        {
                            _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "].\n");
                            continue;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        continue;
                    }
                    try
                    {
                        EKGTestResult ekgTestResult;
                        var           testResult = _testResultRepository.GetTestResults(customerId, _eventId, _isNewResultFlow);
                        if (testResult == null)
                        {
                            ekgTestResult = new EKGTestResult();
                        }
                        else
                        {
                            ekgTestResult = (EKGTestResult)testResult;
                        }

                        string folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var    resultMedia       = _mediaHelper.GetfromImageFile(new FileInfo(jpgFilePath), TestType.EKG.ToString(), folderToSaveImage, _settings.HideEkgSection);
                        if (resultMedia == null)
                        {
                            _logger.Info(string.Concat("\nNo Data found for Id: ", customerId, "\n"));
                            continue;
                        }

                        ekgTestResult.ResultImage = resultMedia;

                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, ekgTestResult);
                        _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.EKG, customerId, MedicalEquipmentTag.Schiller);

                        _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.EKG, customerId, MedicalEquipmentTag.Schiller, false);
                    }
                }
            }

            return(eventCustomerAggregates);
        }
Example #11
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();
            var mediaLocation           = _mediaRepository.GetEawvHraResultMediaLocation();
            var mediaArchiveLocation    = _mediaRepository.GetEawvHraResultArchiveMediaLocation();

            try
            {
                var xmlFilePaths = Directory.GetFiles(mediaLocation.PhysicalPath, "*.xml");

                foreach (var xmlfile in xmlFilePaths)
                {
                    _logger.Info("reading xml File: " + xmlfile);
                    HraResultTags eawvHraResult = null;
                    try
                    {
                        eawvHraResult = _eawvHraSerializer.Deserialize(xmlfile);
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("Some error occurred while reading xml. Message: " + ex.Message);
                        _logger.Error("Stack Trace: " + ex.StackTrace);
                        File.Move(xmlfile, Path.Combine(mediaArchiveLocation.PhysicalPath, Path.GetFileName(xmlfile)));
                    }

                    if (eawvHraResult == null)
                    {
                        _logger.Info("Some error occurred while reading xml.");
                        File.Move(xmlfile, Path.Combine(mediaArchiveLocation.PhysicalPath, Path.GetFileName(xmlfile)));
                    }

                    if (eawvHraResult.Events.IsNullOrEmpty())
                    {
                        _logger.Info("No Event Data found for Tag: " + eawvHraResult.Name);
                        File.Move(xmlfile, Path.Combine(mediaArchiveLocation.PhysicalPath, Path.GetFileName(xmlfile)));
                        continue;
                    }

                    var eventid = eawvHraResult.Events.First().EventId;

                    var account = _corporateAccountRepository.GetbyEventId(eventid);

                    if (account == null)
                    {
                        _logger.Info("No Corporate Account For Event Id: " + eventid);
                        File.Move(xmlfile, Path.Combine(mediaArchiveLocation.PhysicalPath, Path.GetFileName(xmlfile)));
                        continue;
                    }

                    _logger.Info("Running for corporate Account " + account.Tag);

                    var theEvent = _eventRepository.GetById(eventid);

                    QuestionnaireType questionnaireType = QuestionnaireType.None;
                    if (account != null && account.IsHealthPlan && theEvent != null)
                    {
                        questionnaireType = _accountHraChatQuestionnaireHistoryServices.QuestionnaireTypeByAccountIdandEventDate(account.Id, theEvent.EventDate);
                    }

                    if (questionnaireType != QuestionnaireType.HraQuestionnaire)
                    {
                        _logger.Info("HRA Questionnaire is not started");
                        continue;
                    }

                    var eawvTestNotPurchsed = new HraResultTags
                    {
                        Name   = eawvHraResult.Name,
                        Events = new List <HraResultEvent>()
                    };

                    foreach (var hraResultEvent in eawvHraResult.Events)
                    {
                        var eventCustomers = _eventCustomerRepository.GetbyEventId(hraResultEvent.EventId);

                        if (eventCustomers.IsNullOrEmpty())
                        {
                            _logger.Info("No Event Cusotmer found");
                            continue;
                        }

                        var customeridNotToParse = eventCustomers.Where(x => x.NoShow || x.LeftWithoutScreeningReasonId.HasValue).Select(x => x.CustomerId);

                        var snapshotFolderPath     = Path.Combine(mediaLocation.PhysicalPath, eawvHraResult.Name, hraResultEvent.EventId.ToString(), HraFolderSnapshot);
                        var preventionFolderPlan   = Path.Combine(mediaLocation.PhysicalPath, eawvHraResult.Name, hraResultEvent.EventId.ToString(), HraFolderPreventionPlan);
                        var resultReportFolderPath = Path.Combine(mediaLocation.PhysicalPath, eawvHraResult.Name, hraResultEvent.EventId.ToString(), HraFolderResultReport);

                        var snapShotCustomerIds       = (hraResultEvent.Snapshot != null && !hraResultEvent.Snapshot.CustomerId.IsNullOrEmpty()) ? hraResultEvent.Snapshot.CustomerId.Where(c => !customeridNotToParse.Contains(c)).Select(c => c).Distinct() : new List <long>();
                        var preventionPlanCustomerIds = (hraResultEvent.PreventionPlan != null && !hraResultEvent.PreventionPlan.CustomerId.IsNullOrEmpty()) ? hraResultEvent.PreventionPlan.CustomerId.Where(c => !customeridNotToParse.Contains(c)).Select(c => c).Distinct() : new List <long>();
                        var resultReportCustomerIds   = (hraResultEvent.ResultReport != null && !hraResultEvent.ResultReport.CustomerId.IsNullOrEmpty()) ? hraResultEvent.ResultReport.CustomerId.Where(c => !customeridNotToParse.Contains(c)).Select(c => c).Distinct() : new List <long>();

                        _logger.Info(string.Format("============================Reading Snapshot for Tag:{0} EventId {1}=================================", eawvHraResult.Name, hraResultEvent.EventId));
                        _logger.Info(string.Format("snapshot folder Path: {0}", snapshotFolderPath));

                        var customerTestNotPurchased = new List <long>();
                        if (Directory.Exists(snapshotFolderPath))
                        {
                            _logger.Info("Count: " + snapShotCustomerIds.Count());
                            foreach (var customerId in snapShotCustomerIds)
                            {
                                var snapShotFilePath = Path.Combine(snapshotFolderPath, customerId + ".pdf");

                                if (!File.Exists(snapShotFilePath))
                                {
                                    _logger.Info("SnapShot File does not exist at following location: " + snapShotFilePath);
                                    continue;
                                }

                                _logger.Info("SnapShot File exists at location: " + snapShotFilePath);

                                var isEAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(hraResultEvent.EventId, customerId, (long)TestType.eAWV);

                                if (!isEAwvTestPurchasedByCustomer)
                                {
                                    customerTestNotPurchased.Add(customerId);
                                    _logger.Info("EAWV : EAWV tests is not availed by CustomerId [" + customerId + "].\n");
                                    continue;
                                }

                                try
                                {
                                    var mediaFiles = new List <ResultMedia>();

                                    string folderToSavePdf = _mediaRepository.GetResultMediaFileLocation(customerId, hraResultEvent.EventId).PhysicalPath;
                                    _logger.Info("Get Snapshot Media");
                                    var snapShotResultMedia = GetMediaFromPdfFile(snapShotFilePath, folderToSavePdf, TestType.eAWV, AwvFileTypes.SnapShot);

                                    if (snapShotResultMedia != null)
                                    {
                                        _logger.Info("Inside SpanShot Result Media");

                                        snapShotResultMedia.ReadingSource = ReadingSource.Automatic;

                                        mediaFiles.Add(snapShotResultMedia);

                                        if (preventionPlanCustomerIds.Any(c => c == customerId))
                                        {
                                            var preventionPlanFile = Path.Combine(preventionFolderPlan,
                                                                                  customerId + ".pdf");

                                            if (File.Exists(preventionPlanFile))
                                            {
                                                var preventionPlanMedia = GetMediaFromPdfFile(preventionPlanFile,
                                                                                              folderToSavePdf, TestType.eAWV, AwvFileTypes.PreventionPlan);
                                                if (preventionFolderPlan != null)
                                                {
                                                    preventionPlanMedia.ReadingSource = ReadingSource.Automatic;
                                                    mediaFiles.Add(preventionPlanMedia);
                                                    preventionPlanCustomerIds =
                                                        preventionPlanCustomerIds.Where(c => c != customerId).ToList();
                                                }
                                            }
                                            else
                                            {
                                                _logger.Info(
                                                    "Prevention Plan File does not exist at following location: " +
                                                    preventionPlanFile);
                                            }
                                        }

                                        if (resultReportCustomerIds.Any(c => c == customerId))
                                        {
                                            var resultReportFile = Path.Combine(resultReportFolderPath,
                                                                                customerId + ".pdf");

                                            if (File.Exists(resultReportFile))
                                            {
                                                var resultExportMedia = GetMediaFromPdfFile(resultReportFile,
                                                                                            folderToSavePdf, TestType.eAWV, AwvFileTypes.ResultExport);
                                                if (resultExportMedia != null)
                                                {
                                                    resultExportMedia.ReadingSource = ReadingSource.Automatic;
                                                    mediaFiles.Add(resultExportMedia);

                                                    resultReportCustomerIds =
                                                        resultReportCustomerIds.Where(c => c != customerId).ToList();
                                                }
                                            }
                                            else
                                            {
                                                _logger.Info(
                                                    "Result Report File does not exist at following location: " +
                                                    resultReportFile);
                                            }
                                        }
                                        var testResult = new EAwvTestResult {
                                            ResultImages = mediaFiles
                                        };

                                        _logger.Info("Inside SnapShot for adding Customer Aggregate");
                                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(
                                            eventCustomerAggregates, hraResultEvent.EventId, customerId, testResult);
                                        _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.eAWV, customerId,
                                                                                MedicalEquipmentTag.HRA);
                                    }
                                    else
                                    {
                                        _logger.Info("SpanShot Result Media Not Found");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _logger.Error("EAwv HRA: System Failure! Message: " + ex.Message + "\n\t Stack Trace: " + ex.StackTrace);
                                    _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.eAWV, customerId, MedicalEquipmentTag.HRA);
                                }
                            }
                        }
                        else
                        {
                            _logger.Info("Snapshot Directory does not exit for EventId " + hraResultEvent.EventId);
                            _logger.Info("Snapshot Directory Path " + hraResultEvent.EventId);
                        }

                        _logger.Info(string.Format("============================Reading Prevention Plan for Tag:{0} EventId {1}=================================", eawvHraResult.Name, hraResultEvent.EventId));
                        _logger.Info(string.Format("Prevention Plan folder Path: {0}", preventionFolderPlan));


                        if (Directory.Exists(preventionFolderPlan))
                        {
                            foreach (var customerId in preventionPlanCustomerIds)
                            {
                                var preventionFilePath = Path.Combine(preventionFolderPlan, customerId + ".pdf");

                                if (!File.Exists(preventionFilePath))
                                {
                                    _logger.Info("Prevention Plan File does not exist at following location: " + preventionFilePath);
                                    continue;
                                }

                                var isEAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(hraResultEvent.EventId, customerId, (long)TestType.eAWV);

                                if (!isEAwvTestPurchasedByCustomer)
                                {
                                    customerTestNotPurchased.Add(customerId);
                                    _logger.Info("EAWV : EAWV tests is not availed by CustomerId [" + customerId + "].\n");
                                    continue;
                                }
                                try
                                {
                                    var    mediaFiles                = new List <ResultMedia>();
                                    string folderToSavePdf           = _mediaRepository.GetResultMediaFileLocation(customerId, hraResultEvent.EventId).PhysicalPath;
                                    var    preventionPlanResultMedia = GetMediaFromPdfFile(preventionFilePath, folderToSavePdf, TestType.eAWV, AwvFileTypes.PreventionPlan);

                                    if (preventionPlanResultMedia != null)
                                    {
                                        preventionPlanResultMedia.ReadingSource = ReadingSource.Automatic;
                                        mediaFiles.Add(preventionPlanResultMedia);

                                        if (resultReportCustomerIds.Any(c => c == customerId))
                                        {
                                            var resultReportFile = Path.Combine(resultReportFolderPath, customerId + ".pdf");

                                            if (File.Exists(resultReportFile))
                                            {
                                                var resultExportaMedia = GetMediaFromPdfFile(resultReportFile, folderToSavePdf, TestType.eAWV, AwvFileTypes.ResultExport);
                                                if (resultExportaMedia != null)
                                                {
                                                    resultExportaMedia.ReadingSource = ReadingSource.Automatic;
                                                    mediaFiles.Add(resultExportaMedia);

                                                    resultReportCustomerIds = resultReportCustomerIds.Where(c => c != customerId).ToList();
                                                }
                                            }
                                            else
                                            {
                                                _logger.Info("Result Report File does not exist at following location: " + resultReportFile);
                                            }
                                        }
                                        var testResult = new EAwvTestResult {
                                            ResultImages = mediaFiles
                                        };
                                        _logger.Info("Inside PreventionPLan for adding Customer Aggregate");
                                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, hraResultEvent.EventId, customerId, testResult);
                                        _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.eAWV, customerId, MedicalEquipmentTag.HRA);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _logger.Error("EAwv HRA: System Failure! Message: " + ex.Message + "\n\t Stack Trace: " + ex.StackTrace);
                                    _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.eAWV, customerId, MedicalEquipmentTag.HRA);
                                }
                            }
                        }
                        else
                        {
                            _logger.Info("Prevention Plan Directory does not exit for EventId " + hraResultEvent.EventId);
                            _logger.Info("Prevention Plan Directory Path " + hraResultEvent.EventId);
                        }

                        _logger.Info(string.Format("============================Reading Result Report for Tag:{0} EventId {1}=================================", eawvHraResult.Name, hraResultEvent.EventId));
                        _logger.Info(string.Format("Result Report folder Path: {0}", resultReportFolderPath));


                        if (Directory.Exists(resultReportFolderPath))
                        {
                            foreach (var customerId in resultReportCustomerIds)
                            {
                                var resultReportFilePath = Path.Combine(resultReportFolderPath, customerId + ".pdf");

                                if (!File.Exists(resultReportFilePath))
                                {
                                    _logger.Info("Result Report File does not exist at following location: " + resultReportFilePath);
                                    continue;
                                }

                                var isEAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(hraResultEvent.EventId, customerId, (long)TestType.eAWV);

                                if (!isEAwvTestPurchasedByCustomer)
                                {
                                    customerTestNotPurchased.Add(customerId);
                                    _logger.Info("EAWV : EAWV tests is not availed by CustomerId [" + customerId + "].\n");
                                    continue;
                                }
                                try
                                {
                                    var    mediaFiles        = new List <ResultMedia>();
                                    string folderToSavePdf   = _mediaRepository.GetResultMediaFileLocation(customerId, hraResultEvent.EventId).PhysicalPath;
                                    var    resultExportMedia = GetMediaFromPdfFile(resultReportFilePath, folderToSavePdf, TestType.eAWV, AwvFileTypes.ResultExport);

                                    if (resultExportMedia != null)
                                    {
                                        resultExportMedia.ReadingSource = ReadingSource.Automatic;
                                        mediaFiles.Add(resultExportMedia);

                                        var testResult = new EAwvTestResult {
                                            ResultImages = mediaFiles
                                        };
                                        _logger.Info("Inside Result Report for adding Customer Aggregate");
                                        _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, hraResultEvent.EventId, customerId, testResult);
                                        _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.eAWV, customerId, MedicalEquipmentTag.HRA);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _logger.Error("EAwv HRA: System Failure! Message: " + ex.Message + "\n\t Stack Trace: " + ex.StackTrace);
                                    _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.eAWV, customerId, MedicalEquipmentTag.HRA);
                                }
                            }
                        }
                        else
                        {
                            _logger.Info("Result Report Directory does not exit for EventId " + hraResultEvent.EventId);
                            _logger.Info("Result Report Directory Path " + hraResultEvent.EventId);
                        }

                        if (!customerTestNotPurchased.IsNullOrEmpty())
                        {
                            eawvTestNotPurchsed.Events.Add(new HraResultEvent
                            {
                                EventId        = hraResultEvent.EventId,
                                PreventionPlan = new HraResultPreventionPlan {
                                    CustomerId = customerTestNotPurchased.ToList()
                                },
                                Snapshot = new HraResultSnapshot {
                                    CustomerId = customerTestNotPurchased.ToList()
                                },
                                ResultReport = new HraResultReport()
                                {
                                    CustomerId = customerTestNotPurchased.ToList()
                                }
                            });
                        }
                    }
                    if (!eawvTestNotPurchsed.Events.IsNullOrEmpty())
                    {
                        _eawvHraSerializer.SerializeandSave(Path.Combine(mediaLocation.PhysicalPath, "customerNotPurchaseTest_" + DateTime.Now.ToFileTime() + ".xml"), eawvTestNotPurchsed);
                    }

                    try
                    {
                        var archiveFileName = Path.Combine(mediaArchiveLocation.PhysicalPath, Path.GetFileName(xmlfile));
                        if (File.Exists(archiveFileName))
                        {
                            File.Delete(archiveFileName);
                        }
                        File.Move(xmlfile, archiveFileName);
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("Error while moving XML File in Archive folder");
                        _logger.Info(string.Format("Message: {0}", ex.Message));
                        _logger.Info(string.Format("stackTrace: {0}", ex.StackTrace));
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error("Some Error occurred while parsing Eawv Result");
                _logger.Error("Message: " + ex.Message);
                _logger.Error("Stack Trace: " + ex.StackTrace);
            }

            _logger.Info("EAWVParser eventCustomerAggregates count " + eventCustomerAggregates.Count);
            return(eventCustomerAggregates);
        }
        private void GetDataImportedtoSystem(long customerId, IEnumerable <string> allImageFiles, IEnumerable <string> allXmlFiles)
        {
            bool strokeFound = false;
            bool aaaFound    = false;

            var aaaPurchased    = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AAA);
            var strokePurchased = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Stroke);

            var mediaLocation = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

            var aaaTestResult = new AAATestResult
            {
                ResultImages = new List <ResultMedia>()
            };

            var strokeTestResult = new StrokeTestResult
            {
                ResultImages = new List <ResultMedia>()
            };

            foreach (var imageFile in allImageFiles)
            {
                var    fileName  = Path.GetFileNameWithoutExtension(imageFile);
                string imageType = string.Empty;
                string xmlFile   = "";

                if (allXmlFiles.Count() == 0)
                {
                    if (strokePurchased)
                    {
                        imageType = StrokeImageIdentifier;
                    }
                    else if (aaaPurchased)
                    {
                        imageType = AaaImageIdentifier;
                    }
                }
                else
                {
                    var startIndex = fileName.IndexOf("[");
                    var endIndex   = fileName.IndexOf("]");

                    if (startIndex < 0 || endIndex < 0)
                    {
                        continue;
                    }

                    var identifier = fileName.Substring(startIndex + 1, endIndex - (startIndex + 1)).ToLower();
                    xmlFile = allXmlFiles.Where(f => Path.GetFileNameWithoutExtension(f).ToLower().Contains(identifier)).SingleOrDefault();
                    if (string.IsNullOrEmpty(xmlFile))
                    {
                        continue;
                    }

                    imageType = GetImageTypefromXmlFile(xmlFile);
                }

                if (string.IsNullOrEmpty(imageType))
                {
                    continue;
                }

                imageType = imageType.ToLower();

                if (imageType == AaaImageIdentifier)
                {
                    aaaFound = true;
                    if (!aaaPurchased)
                    {
                        continue;
                    }

                    var resultMedia = _mediaHelper.GetfromImageFile(new FileInfo(imageFile), "Aaa", mediaLocation);
                    aaaTestResult.ResultImages.Add(resultMedia);
                }
                else if (imageType == StrokeImageIdentifier)
                {
                    strokeFound = true;
                    if (!strokePurchased)
                    {
                        continue;
                    }

                    var resultMedia = _mediaHelper.GetfromImageFile(new FileInfo(imageFile), "Stroke", mediaLocation);
                    strokeTestResult.ResultImages.Add(resultMedia);
                }
                else
                {
                    _logger.Info(string.Format("Invalid Image Identifier = [{0}] from XML = [{1}].", imageType, xmlFile));
                }
            }

            if (!aaaPurchased && aaaFound)
            {
                _logger.Info(string.Format("AAA not purchased by Customer [{0}], but files are found.", customerId));
            }
            else if (aaaPurchased && aaaFound)
            {
                _resultParserHelper.AddTestResulttoEventCustomerAggregate(_eventCustomerScreeningAggregates, _eventId, customerId, aaaTestResult);
                _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.AAA, customerId, MedicalEquipmentTag.UltrasoundTransducer);
            }
            else if (aaaPurchased)
            {
                _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.AAA, customerId, MedicalEquipmentTag.UltrasoundTransducer, false);
            }

            if (!strokePurchased && strokeFound)
            {
                _logger.Info(string.Format("Stroke not purchased by Customer [{0}], but files are found.", customerId));
            }
            else if (strokePurchased && strokeFound)
            {
                _resultParserHelper.AddTestResulttoEventCustomerAggregate(_eventCustomerScreeningAggregates, _eventId, customerId, strokeTestResult);
                _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.Stroke, customerId, MedicalEquipmentTag.UltrasoundTransducer);
            }
            else if (strokePurchased)
            {
                _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.Stroke, customerId, MedicalEquipmentTag.UltrasoundTransducer, false);
            }
        }
Example #13
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var       eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();
            var       pdfResults     = DirectoryOperationsHelper.GetFiles(_labReportOutputPath, "*.pdf");
            var       rawTxtFile     = DirectoryOperationsHelper.GetFiles(_labReportOutputPath, "*.txt");
            DataTable dtRawDataTable = new DataTable();

            if (rawTxtFile != null && rawTxtFile.Count() > 0)
            {
                _loggerForClient.Info("Total " + rawTxtFile.Count() + " Text File found.");
                foreach (var file in rawTxtFile)
                {
                    string txtFilename = new FileInfo(file).Name;
                    try
                    {
                        dtRawDataTable = GetRecordsFromTextFile(file, txtFilename, dtRawDataTable);
                    }
                    catch (Exception ex)
                    {
                        _loggerForClient.Info("File name :" + txtFilename + " is blank. Exception :" + ex.Message);
                        MovedParsedFile(file);
                    }
                }

                if (dtRawDataTable != null)
                {
                    _loggerForClient.Info("Total " + dtRawDataTable.Rows.Count() + " records found from all text file ");
                }
            }
            else
            {
                _loggerForClient.Info("There is not any text file availble");
            }

            var standardFinding = _standardFindingRepository.GetAllStandardFindings <decimal?>((int)TestType.IFOBT);

            if (pdfResults != null && pdfResults.Any())
            {
                _loggerForClient.Info("Number of Files to be Parse : " + pdfResults.Count());

                foreach (var filePath in pdfResults)
                {
                    string   errorMessage = string.Empty;
                    long     customerId   = 0;
                    long     eventId      = 0;
                    TestType testTypeId;

                    var fileName  = Path.GetFileNameWithoutExtension(filePath);
                    var extension = Path.GetExtension(filePath);

                    if (extension != ".pdf")
                    {
                        errorMessage = "file with pdf extension supported only";
                        _loggerForClient.Error(errorMessage);
                        MovedParsedFile(filePath);
                        continue;
                    }

                    _loggerForClient.Info("=============== Parsing Started for file: " + fileName + " =================");
                    _loggerForClient.Info("Parsing Started for File: " + fileName);

                    if (!ParseValidationCheck(fileName, filePath, out eventId, out customerId, out testTypeId))
                    {
                        continue;
                    }

                    try
                    {
                        string folderToSavePdf = _mediaRepository.GetResultMediaFileLocation(customerId, eventId).PhysicalPath;
                        var    resultMedia     = GetMediaFromPdfFile(filePath, folderToSavePdf, testTypeId);
                        MovedParsedFile(filePath);

                        if (resultMedia != null && testTypeId == TestType.IFOBT)
                        {
                            var finding = new StandardFinding <int>();
                            finding = GetIFOBTFinding(dtRawDataTable, eventId, customerId, testTypeId, fileName, standardFinding);
                            resultMedia.ReadingSource = ReadingSource.Automatic;

                            TestResult testResult = new IFOBTTestResult {
                                ResultImage = resultMedia, Finding = finding
                            };
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.IFOBT, customerId, MedicalEquipmentTag.LabReportParser);

                            _labParseEventLogger.Info(string.Concat("\nPDF Filename(" + fileName + "): Parsing successfully for Customer Id: ", customerId, " ,Event Id: ", eventId, " TestType :", TestType.IFOBT, "\n"));
                            _loggerForClient.Info(string.Concat("\nPDF Filename (" + fileName + "): parsing successfully for Customer Id: ", customerId, " ,Event Id: ", eventId, " ,TestType :", TestType.IFOBT, "\n"));
                        }
                        else if (resultMedia != null && testTypeId == TestType.UrineMicroalbumin)
                        {
                            ResultReading <string> microAlbuminValue = new ResultReading <string>();
                            microAlbuminValue         = GetUrineMicroAlbuminValue(dtRawDataTable, eventId, customerId, testTypeId, fileName);
                            resultMedia.ReadingSource = ReadingSource.Automatic;

                            TestResult testResult = new UrineMicroalbuminTestResult {
                                ResultImage = resultMedia, MicroalbuminValue = microAlbuminValue
                            };
                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.UrineMicroalbumin, customerId, MedicalEquipmentTag.LabReportParser);

                            _labParseEventLogger.Info(string.Concat("\nFilename(" + fileName + "): Parsing successfully for Customer Id: ", customerId, " ,Event Id: ", eventId, " TestType :", TestType.UrineMicroalbumin, "\n"));
                            _loggerForClient.Info(string.Concat("\nFilename (" + fileName + "): Parsing successfully for Customer Id: ", customerId, " ,Event Id: ", eventId, " ,TestType :", TestType.UrineMicroalbumin, "\n"));
                        }
                        else
                        {
                            var message = string.Concat("\nFilename(" + fileName + "): Test(" + testTypeId + ") is an invalid test for parsing for Customer Id: ", customerId, " ,Event Id: ", eventId, " TestType :", testTypeId, "\n");
                            _labParseEventLogger.Info(message);
                            _loggerForClient.Info(message);
                        }
                    }
                    catch (Exception ex)
                    {
                        errorMessage = " System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace;
                        _labParseEventLogger.Error(errorMessage);
                        _loggerForClient.Error("Parsing failed for filename :" + fileName + ".Please contact to Administrator.");

                        MovedParsedFile(filePath);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, testTypeId, customerId, MedicalEquipmentTag.LabReportParser, false);
                    }
                }
            }
            if (dtRawDataTable != null && dtRawDataTable.Columns.Count() > 0 && dtRawDataTable.Rows.Count > 0)
            {
                var rows = dtRawDataTable.Select("IsParse=false");
                if (rows != null && rows.Any())
                {
                    dtRawDataTable = rows.CopyToDataTable();

                    if (dtRawDataTable.Rows.Count > 0)
                    {
                        eventCustomerAggregates = SaveResultWithoutMedia(eventCustomerAggregates, dtRawDataTable, standardFinding);
                    }
                }
            }
            return(eventCustomerAggregates);
        }
Example #14
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath) && string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }


            List <string> pdfFiles = null;

            if (!string.IsNullOrEmpty(directoryPath))
            {
                pdfFiles = GetPdfFiles(directoryPath);
            }

            if (pdfFiles != null && pdfFiles.Any())
            {
                _logger.Info("Number of Files to Parse : " + pdfFiles.Count());

                foreach (var filePath in pdfFiles)
                {
                    var fileNameWithExtention = Path.GetFileName(filePath);
                    if (!string.IsNullOrEmpty(fileNameWithExtention))
                    {
                        fileNameWithExtention = fileNameWithExtention.ToLower();
                    }

                    var fileName = Path.GetFileNameWithoutExtension(filePath);
                    if (!string.IsNullOrEmpty(fileName))
                    {
                        fileName = fileName.ToLower();
                    }

                    long   customerId   = 0;
                    long   eventId      = 0;
                    string errorMessage = string.Empty;

                    _logger.Info("=============== Parsing Started for file: " + fileName + " =================");

                    try
                    {
                        var temp             = fileName.Substring(fileName.IndexOf("_mrn_") + 5);
                        var customerIdString = temp.Substring(0, temp.IndexOf("_"));

                        if (!long.TryParse(customerIdString, out customerId))
                        {
                            errorMessage = "Diabetic Retinopathy: CustomerId not found on Pdf file" + filePath;
                            _logger.Info(errorMessage);
                            SaveDiabeticRetinopathyParserlog(fileNameWithExtention, customerId, eventId, errorMessage);
                            continue;
                        }
                    }
                    catch (Exception)
                    {
                        errorMessage = "File name is not in correct formate. ";
                        _logger.Error(errorMessage);
                        SaveDiabeticRetinopathyParserlog(fileNameWithExtention, customerId, eventId, errorMessage);
                        continue;
                    }


                    try
                    {
                        eventId = _eventCustomerRepository.GetEventIdAttendedByCustomerForTest(customerId, (long)TestType.DiabeticRetinopathy, _settings.DiabeticRetinopathyNoOfDaysToCheckForEvent);
                        if (eventId <= 0)
                        {
                            errorMessage = string.Format("Diabetic Retinopathy: No Event attended by customer {0} in last {1} days.", customerId, _settings.DiabeticRetinopathyNoOfDaysToCheckForEvent);
                            _logger.Info(errorMessage);
                            SaveDiabeticRetinopathyParserlog(fileNameWithExtention, customerId, eventId, errorMessage);
                            continue;
                        }
                    }
                    catch (Exception ex)
                    {
                        errorMessage = "Diabetic Retinopathy:  CustomerId [" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace;
                        _logger.Info(errorMessage);
                        SaveDiabeticRetinopathyParserlog(fileNameWithExtention, customerId, eventId, errorMessage);

                        continue;
                    }

                    try
                    {
                        string folderToSavePdf = _mediaRepository.GetResultMediaFileLocation(customerId, eventId).PhysicalPath;
                        var    resultMedia     = GetMediaFromPdfFile(filePath, folderToSavePdf, TestType.DiabeticRetinopathy);

                        if (resultMedia != null)
                        {
                            TestResult testResult = new DiabeticRetinopathyTestResult {
                                ResultImage = resultMedia
                            };

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.DiabeticRetinopathy, customerId, MedicalEquipmentTag.Vatica);

                            _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        errorMessage = "Diabetic Retinopathy: System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace;
                        _logger.Error(errorMessage);
                        SaveDiabeticRetinopathyParserlog(fileNameWithExtention, customerId, eventId, errorMessage);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.DiabeticRetinopathy, customerId, MedicalEquipmentTag.Vatica, false);
                    }


                    _logger.Info("=============== Parsing Ended for file: " + fileName + " =================");
                }
            }

            return(eventCustomerAggregates);
        }
Example #15
0
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPreventionPlanPath = GetFolderPathfor(_resultOutputPreventionPlanPath);
            var directorySnapShotPath       = GetFolderPathfor(_resultOutputSanpShotPath);

            if (string.IsNullOrEmpty(directoryPreventionPlanPath) && string.IsNullOrEmpty(directorySnapShotPath))
            {
                return(null);
            }

            List <string> snapShotFiles       = null;
            List <string> preventionPlanFiles = null;

            if (!string.IsNullOrEmpty(directorySnapShotPath))
            {
                snapShotFiles = GetPdfFiles(directorySnapShotPath);
            }

            if (!string.IsNullOrEmpty(directoryPreventionPlanPath))
            {
                preventionPlanFiles = GetPdfFiles(directoryPreventionPlanPath);
            }

            if (snapShotFiles != null && snapShotFiles.Any())
            {
                foreach (var filePath in snapShotFiles)
                {
                    var customerIdString = Path.GetFileNameWithoutExtension(filePath);

                    long customerId = 0;
                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("AWV Snap Shot: CustomerId not found on Pdf file" + filePath);
                        continue;
                    }

                    bool isAwvTestPurchasedByCustomer      = false;
                    bool isMedicareTestPurchasedByCustomer = false;

                    try
                    {
                        isAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AWV);
                        if (!isAwvTestPurchasedByCustomer)
                        {
                            isMedicareTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Medicare);
                            if (!isMedicareTestPurchasedByCustomer)
                            {
                                bool isAwvSubsequentTestPurchadedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvSubsequent);
                                if (!isAwvSubsequentTestPurchadedByCustomer)
                                {
                                    _logger.Info("AWV Snap Shot: None of AWV tests is availed by CustomerId[" + customerId + "].\n");
                                    continue;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("AWV Snap Shot: None of the AWV tests is availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);

                        continue;
                    }

                    TestType testType;

                    if (isAwvTestPurchasedByCustomer)
                    {
                        testType = TestType.AWV;
                    }
                    else if (isMedicareTestPurchasedByCustomer)
                    {
                        testType = TestType.Medicare;
                    }
                    else
                    {
                        testType = TestType.AwvSubsequent;
                    }

                    try
                    {
                        string folderToSavePdf     = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var    snapShotResultMedia = GetMediaFromPdfFile(filePath, folderToSavePdf, testType, AwvFileTypes.SnapShot);

                        var mediaFiles = new List <ResultMedia>();
                        if (snapShotResultMedia != null)
                        {
                            mediaFiles.Add(snapShotResultMedia);

                            if (preventionPlanFiles != null && preventionPlanFiles.Any())
                            {
                                var preventionPlanFile = preventionPlanFiles.Where(ppf => Path.GetFileNameWithoutExtension(ppf) == customerIdString).Select(ppf => ppf).SingleOrDefault();
                                if (!string.IsNullOrEmpty(preventionPlanFile))
                                {
                                    var preventionPlanrResultMedia = GetMediaFromPdfFile(preventionPlanFile, folderToSavePdf, testType, AwvFileTypes.PreventionPlan);
                                    mediaFiles.Add(preventionPlanrResultMedia);
                                    preventionPlanFiles.Remove(preventionPlanFile);
                                }
                            }

                            TestResult testResult = null;
                            if (testType == TestType.AWV)
                            {
                                testResult = new AwvTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;
                            else if (testType == TestType.Medicare)
                            {
                                testResult = new MedicareTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;
                            else if (testType == TestType.AwvSubsequent)
                            {
                                testResult = new AwvSubsequentTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.AWVPP);

                            _logger.Info(string.Concat("\n AWV Snap Shot.Parsing succeeded for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("AWV Snap Shot: System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, testType, customerId, MedicalEquipmentTag.AWVPP, false);
                    }
                }
            }

            //Prevention Plan Files
            if (preventionPlanFiles != null && preventionPlanFiles.Any())
            {
                foreach (var filePath in preventionPlanFiles)
                {
                    var customerIdString = Path.GetFileNameWithoutExtension(filePath);

                    long customerId = 0;
                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("AWV Prevention Plan: CustomerId not found on Pdf file" + filePath);
                        continue;
                    }

                    bool isAwvTestPurchasedByCustomer           = false;
                    bool isMedicareTestPurchasedByCustomer      = false;
                    bool isAwvSubsequentTestPurchadedByCustomer = false;

                    try
                    {
                        isAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AWV);
                        if (!isAwvTestPurchasedByCustomer)
                        {
                            isMedicareTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Medicare);
                            if (!isMedicareTestPurchasedByCustomer)
                            {
                                isAwvSubsequentTestPurchadedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvSubsequent);
                                if (!isAwvSubsequentTestPurchadedByCustomer)
                                {
                                    var isEAwvTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.eAWV);
                                    if (!isEAwvTestPurchasedByCustomer)
                                    {
                                        _logger.Info("AWV Prevention Plan: None of AWV tests is availed by CustomerId[" + customerId + "].\n");
                                        continue;
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("AWV Prevention Plan: None of the AWV tests is availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);

                        continue;
                    }

                    TestType testType;

                    if (isAwvTestPurchasedByCustomer)
                    {
                        testType = TestType.AWV;
                    }
                    else if (isMedicareTestPurchasedByCustomer)
                    {
                        testType = TestType.Medicare;
                    }
                    else if (isAwvSubsequentTestPurchadedByCustomer)
                    {
                        testType = TestType.AwvSubsequent;
                    }
                    else
                    {
                        testType = TestType.eAWV;
                    }

                    try
                    {
                        string folderToSavePdf            = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var    preventionPlanrResultMedia = GetMediaFromPdfFile(filePath, folderToSavePdf, testType, AwvFileTypes.PreventionPlan);

                        var mediaFiles = new List <ResultMedia>();
                        if (preventionPlanrResultMedia != null)
                        {
                            mediaFiles.Add(preventionPlanrResultMedia);

                            TestResult testResult = null;
                            if (testType == TestType.AWV)
                            {
                                testResult = new AwvTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;
                            else if (testType == TestType.Medicare)
                            {
                                testResult = new MedicareTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;
                            else if (testType == TestType.AwvSubsequent)
                            {
                                testResult = new AwvSubsequentTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;
                            else if (testType == TestType.eAWV)
                            {
                                testResult = new EAwvTestResult {
                                    ResultImages = mediaFiles
                                }
                            }
                            ;

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.AWVPP);

                            _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("AWV Prevention Plan: System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, testType, customerId, MedicalEquipmentTag.AWVPP, false);
                    }
                }
            }

            return(eventCustomerAggregates);
        }
Example #16
0
        public IEnumerable<EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List<EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);
            if (string.IsNullOrEmpty(directoryPath)) return null;

            foreach (var filePath in Directory.GetFiles(directoryPath))
            {
                if (Path.GetExtension(filePath).ToLower().Contains("pdf"))
                {
                    var fileName = Path.GetFileName(filePath);
                    var customerIdString = fileName.Substring(0, fileName.IndexOf("."));

                    long customerId = 0;
                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("CustomerId not found on Pdf file" + filePath);
                        continue;
                    }

                    try
                    {
                        bool isTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.PulmonaryFunction);
                        if (!isTestPurchasedByCustomer)
                        {
                            _logger.Info("Pulmonary is not availed by CustomerId[" + customerId + "].\n");
                            continue;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Info("Pulmonary is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                        continue;
                    }

                    try
                    {
                        string folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;
                        var resultMedia = _mediaHelper.GetMediaFromPdfFile(filePath, folderToSaveImage, TestType.PulmonaryFunction.ToString());

                        if (resultMedia != null)
                        {
                            var testResult = new PulmonaryFunctionTestResult
                            {
                                ResultImage = resultMedia
                            };

                            _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                            _resultParserHelper.AddResultArchiveLog(string.Empty, TestType.EKG, customerId, MedicalEquipmentTag.PulmonaryMachine);
                            _logger.Info(string.Concat("\nParsing succeeded for Customer Id: ", customerId, "\n"));
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                        _resultParserHelper.AddResultArchiveLog(ex.Message, TestType.EKG, customerId, MedicalEquipmentTag.PulmonaryMachine, false);
                    }
                }
            }
            return eventCustomerAggregates;
        }
        public IEnumerable <EventCustomerScreeningAggregate> Parse()
        {
            var eventCustomerAggregates = new List <EventCustomerScreeningAggregate>();

            var directoryPath = GetFolderPathfor(_resultOutputPath);

            if (string.IsNullOrEmpty(directoryPath))
            {
                return(null);
            }

            foreach (var filePath in DirectoryOperationsHelper.GetFiles(directoryPath))
            {
                if (Path.GetExtension(filePath).ToLower().Contains("pdf"))
                {
                    _logger.Info("Parsing file : " + filePath);
                    var  fileName = Path.GetFileName(filePath);
                    bool isSpiro  = false;
                    var  fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
                    isSpiro = fileNameWithoutExtension.ToLower().EndsWith(SpiroFilePrefix);


                    var searchPattern = fileName.Substring(0, GetIndexOfNthOccurence(fileName, '_', 5)) + "*" + (isSpiro ? "_spiro.pdf" : "_ecg.pdf");

                    var versionedFiles = DirectoryOperationsHelper.GetFiles(directoryPath, searchPattern).Select(Path.GetFileName);;

                    var latestVersion = versionedFiles.OrderByDescending(x => x).First();

                    if (Path.GetFileName(filePath) != latestVersion)
                    {
                        _logger.Info("A more recent version of this file is present : " + latestVersion);
                        continue;
                    }

                    var customerIdString = fileName.IndexOf("_") > 0 ? fileName.Substring(0, fileName.IndexOf("_")) : fileName;

                    long customerId;

                    if (!long.TryParse(customerIdString, out customerId))
                    {
                        _logger.Info("Customer ID not found on Pdf file : " + filePath);
                        continue;
                    }

                    if (!isSpiro)
                    {
                        bool isEkgTestPurchasedByCustomer        = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.EKG);
                        bool isAwvEkgTestPurchasedByCustomer     = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvEkg);
                        bool isAwvEkgIppeTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvEkgIPPE);

                        try
                        {
                            if (!isEkgTestPurchasedByCustomer && !isAwvEkgTestPurchasedByCustomer && !isAwvEkgIppeTestPurchasedByCustomer)
                            {
                                _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "].\n");
                                continue;
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Info("EKG/ECG is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                            continue;
                        }

                        try
                        {
                            TestResult testResult = null;
                            var        testType   = TestType.EKG;

                            if (isAwvEkgIppeTestPurchasedByCustomer) //&& IsEkgIppeFile
                            {
                                testType = TestType.AwvEkgIPPE;
                            }
                            else if (isAwvEkgTestPurchasedByCustomer)
                            {
                                testType = TestType.AwvEkg;
                            }

                            var folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                            var resultMedia = GetMediaFromPdfFile(filePath, folderToSaveImage, testType.ToString());
                            resultMedia.ReadingSource = ReadingSource.Automatic;

                            if (resultMedia != null)
                            {
                                switch (testType)
                                {
                                case TestType.EKG:
                                    testResult = new EKGTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;

                                case TestType.AwvEkg:
                                    testResult = new AwvEkgTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;

                                case TestType.AwvEkgIPPE:
                                    testResult = new AwvEkgIppeTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;
                                }

                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                                _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.CardioCard);

                                _logger.Info(string.Concat("\nParsing succeeded for EKG  for Customer Id: ", customerId, "\n"));
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, isAwvEkgIppeTestPurchasedByCustomer ? TestType.AwvEkgIPPE : isAwvEkgTestPurchasedByCustomer ? TestType.AwvEkg : TestType.EKG, customerId, MedicalEquipmentTag.CardioCard, false);
                        }
                    }
                    else if (isSpiro)
                    {
                        bool isSpiroTestPurchasedByCustomer    = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.Spiro);
                        bool isAwvSpiroTestPurchasedByCustomer = _testResultService.IsTestPurchasedByCustomer(_eventId, customerId, (long)TestType.AwvSpiro);

                        try
                        {
                            if (!isSpiroTestPurchasedByCustomer && !isAwvSpiroTestPurchasedByCustomer)
                            {
                                _logger.Info("SPIRO/AWVSPIRO is not availed by CustomerId[" + customerId + "].\n");
                                continue;
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Info("SPIRO/AWVSPIRO is not availed by CustomerId[" + customerId + "]. Exception Caused.\n Message: " + ex.Message + ".\t Stack Trace:" + ex.StackTrace);
                            continue;
                        }

                        try
                        {
                            TestResult testResult = null;
                            var        testType   = TestType.Spiro;

                            if (isAwvSpiroTestPurchasedByCustomer)
                            {
                                testType = TestType.AwvSpiro;
                            }

                            var folderToSaveImage = _mediaRepository.GetResultMediaFileLocation(customerId, _eventId).PhysicalPath;

                            var resultMedia = GetMediaFromPdfFile(filePath, folderToSaveImage, testType.ToString(), false);
                            resultMedia.ReadingSource = ReadingSource.Automatic;

                            if (resultMedia != null)
                            {
                                switch (testType)
                                {
                                case TestType.Spiro:
                                    testResult = new SpiroTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;

                                case TestType.AwvSpiro:
                                    testResult = new AwvSpiroTestResult
                                    {
                                        ResultImage = resultMedia
                                    };
                                    break;
                                }

                                _resultParserHelper.AddTestResulttoEventCustomerAggregate(eventCustomerAggregates, _eventId, customerId, testResult);
                                _resultParserHelper.AddResultArchiveLog(string.Empty, testType, customerId, MedicalEquipmentTag.CardioCard);

                                _logger.Info(string.Concat("\nParsing succeeded for SPIRO/AWVSPIRO  for Customer Id: ", customerId, "\n"));
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("System Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                            _resultParserHelper.AddResultArchiveLog(ex.Message, isSpiroTestPurchasedByCustomer ? TestType.Spiro : TestType.AwvSpiro, customerId, MedicalEquipmentTag.CardioCard, false);
                        }
                    }
                }
            }
            return(eventCustomerAggregates);
        }