public void Log(IImportLogger importLogger) { if (importLogger.Status.Is(NotificationType.Warning)) { importLogger.Log.Each(x => this.AddWarning(x)); } }
public NotificationImportService(INotificationMapper notificationMapper, INotificationRepository notificationRepository, INotificationImportRepository notificationImportRepository, IImportLogger logger, IHub sentryHub, IMigratedNotificationsMarker migratedNotificationsMarker, ISpecimenImportService specimenImportService, IImportValidator importValidator, IClusterImportService clusterImportService, ICultureAndResistanceService cultureAndResistanceService, IDrugResistanceProfileService drugResistanceProfileService, ICaseManagerImportService caseManagerImportService) { sentryHub.ConfigureScope(s => { s.SetTag("context", "migration"); }); _notificationMapper = notificationMapper; _notificationRepository = notificationRepository; _notificationImportRepository = notificationImportRepository; _logger = logger; _migratedNotificationsMarker = migratedNotificationsMarker; _specimenImportService = specimenImportService; _importValidator = importValidator; _clusterImportService = clusterImportService; _cultureAndResistanceService = cultureAndResistanceService; _drugResistanceProfileService = drugResistanceProfileService; _caseManagerImportService = caseManagerImportService; }
public ExistingRowPasteProcessor(ICopyParser copyParser, View view, IImportLogger logger) { this.copyParser = copyParser; this.view = view; this.pasteUtils = new PasteUtils(); this.offlinePasteUtils = new OfflinePasteUtils(logger); }
public override void GlobalContext() { base.GlobalContext(); _logger = A.Fake <IImportLogger>(); var individual = DomainFactoryForSpecs.CreateStandardIndividual(); var containerTask = IoC.Resolve <IContainerTask>(); _allParameters = containerTask.CacheAllChildren <IParameter>(individual); }
protected override void Context() { _genderRepository = A.Fake <IGenderRepository>(); A.CallTo(() => _genderRepository.FindByIndex(1)).Returns(_male); A.CallTo(() => _genderRepository.FindByIndex(2)).Returns(_female); _populationRepository = A.Fake <IPopulationRepository>(); A.CallTo(() => _populationRepository.FindByIndex(0)).Returns(_population); _logger = A.Fake <IImportLogger>(); sut = new IndividualPropertiesCacheImporter(_genderRepository, _populationRepository); }
public CaseManagerImportService( IUserRepository userRepository, IReferenceDataRepository referenceDataRepository, IMigrationRepository migrationRepository, IImportLogger logger) { this._userRepository = userRepository; this._referenceDataRepository = referenceDataRepository; this._migrationRepository = migrationRepository; _logger = logger; }
public XpoFieldMapper(IImportLogger logger) { if (logger == null) { this.logger = new NullImportLogger(); } else { this.logger = logger; } xpoFieldValueReader = new XpoFieldValueReader(this.logger); }
private void validate(IndividualPropertiesCache individualValues, IImportLogger logger) { foreach (var parameterPath in individualValues.AllParameterPaths().ToList()) { if (allParametersContains(parameterPath)) { continue; } logger.AddWarning(PKSimConstants.Warning.ParameterWithPathNotFoundInBaseIndividual(parameterPath)); individualValues.Remove(parameterPath); } }
public OfflinePasteUtils(IXpoFieldValueReader xpoFieldReader, IImportLogger logger) { this.xpoFieldValueReader = xpoFieldReader; if (logger == null) { this.logger = new SimpleImportLogger(); } else { this.logger = logger; } this.xpoFieldMapper = new XpoFieldMapper(logger); }
public NotificationMapper(IMigrationRepository migrationRepository, IReferenceDataRepository referenceDataRepository, IImportLogger logger, IPostcodeService postcodeService) { _migrationRepository = migrationRepository; _referenceDataRepository = referenceDataRepository; _logger = logger; _postcodeService = postcodeService; // This is a database-based value, but static from the runtime point of view, so we fetch it once here. _postMortemOutcomeType = _referenceDataRepository.GetTreatmentOutcomeForTypeAndSubType( TreatmentOutcomeType.Died, TreatmentOutcomeSubType.Unknown).Result; }
public NewRowPasteProcessor(ICopyParser copyParser, View view, IImportLogger logger) { if (view == null) { throw new ArgumentException("Parameter 'view' cannot be null", "view"); } if (copyParser == null) { throw new ArgumentException("Parameter 'copyParser' cannot be null", "copyParser"); } this.copyParser = copyParser; this.view = view; this.pasteUtils = new PasteUtils(); this.offlinePasteUtils = new OfflinePasteUtils(logger); }
public IndividualPropertiesCache ImportFrom(string fileFullPath, IImportLogger logger) { try { foreach (var delimiter in _allowedDelimiters) { var individualPropertyCache = individualPropertiesCacheFrom(fileFullPath, logger, delimiter); //we found at least one individual, this is a valid file for the delimiter and we can exit if (individualPropertyCache.Count > 0) { return(individualPropertyCache); } } return(new IndividualPropertiesCache()); } catch (Exception e) { logger.AddError(e.FullMessage()); return(new IndividualPropertiesCache()); } }
public NotificationImportService(INotificationMapper notificationMapper, INotificationRepository notificationRepository, INotificationImportRepository notificationImportRepository, IImportLogger logger, IHub sentryHub, IMigrationRepository migrationRepository, IMigratedNotificationsMarker migratedNotificationsMarker, ISpecimenService specimenService, IImportValidator importValidator) { sentryHub.ConfigureScope(s => { s.SetTag("context", "migration"); }); _notificationMapper = notificationMapper; _notificationRepository = notificationRepository; _notificationImportRepository = notificationImportRepository; _logger = logger; _migrationRepository = migrationRepository; _migratedNotificationsMarker = migratedNotificationsMarker; _specimenService = specimenService; _importValidator = importValidator; }
public IndividualPropertiesCache ImportFrom(string fileFullPath, IImportLogger logger) { try { foreach (var delimiter in ALLOWED_DELIMITERS) { var individualPropertyCache = individualPropertiesCacheFrom(fileFullPath, delimiter); //we found at least one individual, this is a valid file for the delimiter and we can exit if (individualPropertyCache?.Count > 0) { return(individualPropertyCache); } } //no match. Log logger.AddError(PKSimConstants.Warning.PopulationFileFormatIsNotSupported); return(new IndividualPropertiesCache()); } catch (Exception e) { logger.AddError(e.FullMessage()); return(new IndividualPropertiesCache()); } }
public IndividualValuesCache ImportFrom(string populationFileFullPath, IImportLogger logger, PathCache <IParameter> allParameters = null) { try { foreach (var delimiter in ALLOWED_DELIMITERS) { var individualValuesCache = individualValuesCacheFrom(populationFileFullPath, delimiter); //we found at least one individual, this is a valid file for the delimiter and we can exit if (individualValuesCache?.Count > 0) { return(withPathsContainingUnitsUpdated(individualValuesCache, allParameters, logger)); } } //no match. Log logger.AddError(Warning.PopulationFileFormatIsNotSupported); return(new IndividualValuesCache()); } catch (Exception e) { logger.AddError(e.FullMessage()); return(new IndividualValuesCache()); } }
public XpoFieldValueReader(IImportLogger logger) { if (logger == null) { this.logger = new NullImportLogger(); } else { this.logger = logger; } lookupValueConverter = new LookupValueConverter() { UnmatchedLookupLogger = LogXpObjectsNotFound }; lookupCacheDictionary = new CachedXPCollections(); cachedLookupValueConverter = new CachedLookupValueConverter(lookupCacheDictionary) { UnmatchedLookupLogger = LogXpObjectsNotFound }; lookupsNotFound = new Dictionary <Type, List <string> >(); }
public SpecimenImportService(IImportLogger logger, ISpecimenService specimenService) { _logger = logger; _specimenService = specimenService; }
public OfflinePasteUtils() { xpoFieldValueReader = new XpoFieldValueReader(); this.logger = new SimpleImportLogger(); this.xpoFieldMapper = new XpoFieldMapper(logger); }
private IndividualPropertiesCache individualPropertiesCacheFrom(string fileFullPath, IImportLogger logger, char delimiter) { var individualPropertiesCache = new IndividualPropertiesCache(); using (var reader = new CsvReaderDisposer(fileFullPath, delimiter)) { var csv = reader.Csv; var headers = csv.GetFieldHeaders(); if (headers.Contains(Constants.Population.INDIVIDUAL_ID_COLUMN)) { loadNewCSVFormat(individualPropertiesCache, csv, headers); } else { loadOldCSVFormat(individualPropertiesCache, csv); logger.AddWarning(PKSimConstants.Warning.PopulationFileIsUsingOldFormatAndWontBeSupportedInTheNextVersion); } } return(individualPropertiesCache); }
public IEnumerable <IndividualResults> ImportFrom(string fileFullPath, IModelCoreSimulation simulation, IImportLogger logger) { //do not define this variables as member variable to be thread safe var cacheQuantitiesValues = new Cache <QuantityValues, List <float> >(); var cacheTimeValues = new Cache <IndividualResults, List <float> >(); try { var individualResults = new Cache <int, IndividualResults>(x => x.IndividualId); using (var reader = new CsvReaderDisposer(fileFullPath)) { var csv = reader.Csv; var headers = csv.GetFieldHeaders(); validateHeaders(headers); //skip the first two indexes that are individual id and time var allQuantityPaths = retrieveQuantityPathsFromHeader(headers, simulation); while (csv.ReadNextRecord()) { int individualId = retrieveParameterId(csv); if (!individualResults.Contains(individualId)) { individualResults.Add(createIndividualResults(individualId, cacheTimeValues)); } addRecordToIndividualResults(individualResults[individualId], allQuantityPaths, csv, cacheTimeValues, cacheQuantitiesValues); } } updateResults(cacheTimeValues, cacheQuantitiesValues); return(individualResults); } catch (Exception e) { logger.AddError(e.FullMessage()); return(Enumerable.Empty <IndividualResults>()); } finally { cacheQuantitiesValues.Clear(); cacheTimeValues.Clear(); } }
public CsvDataSourceFile(IImportLogger logger, ICsvSeparatorSelector csvSeparatorSelector) : base(logger) { _csvSeparatorSelector = csvSeparatorSelector; }
private IndividualValuesCache withPathsContainingUnitsUpdated(IndividualValuesCache individualValuesCache, PathCache <IParameter> allParameters, IImportLogger logger) { // No parameters to check from, return as IS if (allParameters == null) { return(individualValuesCache); } //Use TO LIST here because collection might be modified foreach (var parameterValue in individualValuesCache.AllParameterValues.ToList()) { var parameterPath = parameterValue.ParameterPath; if (allParameters.Contains(parameterPath)) { continue; } var pathWithUnitsRemoved = parameterPath.StripUnit(); if (allParameters.Contains(pathWithUnitsRemoved)) { individualValuesCache.RenamePath(parameterPath, pathWithUnitsRemoved); parameterValue.ParameterPath = pathWithUnitsRemoved; continue; } logger.AddWarning(Warning.ParameterWithPathNotFoundInBaseIndividual(parameterPath)); individualValuesCache.Remove(parameterPath); } return(individualValuesCache); }
public ImportValidator(IImportLogger logger, IReferenceDataRepository referenceDataRepository) { _logger = logger; _referenceDataRepository = referenceDataRepository; }
public IEnumerable <QuantityPKParameter> ImportPKParameters(string fileFullPath, IImportLogger logger) { try { _importedPK = new Cache <string, QuantityPKParameter>(x => x.Id); //cache containing a list of tupe<individual Id, value in core unit> _valuesCache = new Cache <QuantityPKParameter, List <Tuple <int, float> > >(); using (var reader = new CsvReaderDisposer(fileFullPath)) { var csv = reader.Csv; var headers = csv.GetFieldHeaders(); validateFileFormat(headers); while (csv.ReadNextRecord()) { var pkParameter = retrieveOrCreatePKParameterFor(csv); addValues(pkParameter, csv); } } foreach (var keyValue in _valuesCache.KeyValues) { var pkParameter = keyValue.Key; var values = keyValue.Value; //0-based id var maxIndividualId = values.Select(x => x.Item1).Max(); pkParameter.SetNumberOfIndividuals(maxIndividualId + 1); foreach (var value in values) { pkParameter.SetValue(value.Item1, value.Item2); } } return(_valuesCache.Keys.ToList()); } catch (Exception e) { logger.AddError(e.FullMessage()); return(Enumerable.Empty <QuantityPKParameter>()); } finally { _importedPK.Clear(); _valuesCache.Clear(); } }
public IReadOnlyList <PKParameterSensitivity> ImportFrom(string fileFullPath, IModelCoreSimulation simulation, IImportLogger logger) { try { foreach (var delimiter in ALLOWED_DELIMITERS) { var pkParameterSensitivities = pkParameterSensitivitiesFrom(fileFullPath, delimiter); //we found at least one individual, this is a valid file for the delimiter and we can exit if (pkParameterSensitivities.Any()) { return(pkParameterSensitivities); } } //no match. Log logger.AddError(Warning.SensitivityAnalysisFileFormatIsNotSupported); return(Array.Empty <PKParameterSensitivity>()); } catch (Exception e) { logger.AddError(e.FullMessage()); return(Array.Empty <PKParameterSensitivity>()); } }
public ExcelDataSourceFile(IImportLogger logger) : base(logger) { }
public IndividualValuesCache ImportFrom(string fileFullPath, PathCache <IParameter> allParameters, IImportLogger logger) { var individualValuesCache = _individualValuesCacheImporter.ImportFrom(fileFullPath, logger, allParameters); return(withUpdatedGenderAndRace(individualValuesCache)); }