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));
}
