protected override void Context()
{
base.Context();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
_newMoleculeName = "CYP";
_newName = CoreConstants.ContainerName.ExpressionProfileName(_newMoleculeName, _expressionProfile.Species, "SICK");
}
public ICommand UpdateExpressionFromQuery(ExpressionProfile expressionProfile, QueryExpressionResults queryResults)
{
var(molecule, individual) = expressionProfile;
molecule.QueryConfiguration = queryResults.QueryConfiguration;
return(new EditIndividualMoleculeExpressionInSimulationSubjectFromQueryCommand(molecule, queryResults, individual)
.Run(_executionContext));
}
protected override void Context()
{
_speciesRepository = A.Fake <ISpeciesRepository>();
_usedMoleculeRepository = A.Fake <IUsedMoleculeRepository>();
_projectRetriever = A.Fake <IPKSimProjectRetriever>();
_moleculePropertiesMapper = A.Fake <IMoleculePropertiesMapper>();
_usedExpressionProfileCategoryRepository = A.Fake <IUsedExpressionProfileCategoryRepository>();
sut = new ExpressionProfileToExpressionProfileDTOMapper(
_speciesRepository,
_usedMoleculeRepository,
_projectRetriever,
_moleculePropertiesMapper,
_usedExpressionProfileCategoryRepository);
A.CallTo(() => _usedMoleculeRepository.All()).Returns(new[] { "A", "B" });
A.CallTo(() => _usedExpressionProfileCategoryRepository.All()).Returns(new[] { "CatA", "CatB" });
A.CallTo(() => _speciesRepository.All()).Returns(new[] { new Species {
Name = "Human"
}, new Species {
Name = "Rat"
} });
_expressionProfile1 = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>("DOG", "CYP3A4", "Sick");
A.CallTo(() => _projectRetriever.Current.All <ExpressionProfile>()).Returns(new[] { _expressionProfile1 });
}
protected override void Context()
{
base.Context();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
A.CallTo(() => _moleculePropertiesMapper.MoleculeIconFor(_expressionProfile.Molecule)).Returns(ApplicationIcons.Enzyme);
A.CallTo(() => _moleculePropertiesMapper.MoleculeDisplayFor(_expressionProfile.Molecule)).Returns("Display");
}
public void Edit(ExpressionProfile expressionProfile)
{
_expressionProfile = expressionProfile;
_expressionProfileDTO = _expressionProfileDTOMapper.MapFrom(expressionProfile);
_view.BindTo(_expressionProfileDTO);
activateMoleculeExpressionPresenter();
}
public override void GlobalContext()
{
base.GlobalContext();
var moleculeExpressionTask = IoC.Resolve <IMoleculeExpressionTask <Individual> >();
_templateIndividual = DomainFactoryForSpecs.CreateStandardIndividual();
_templateExpressionProfileCYP3A4 = DomainFactoryForSpecs.CreateExpressionProfile <IndividualEnzyme>("CYP3A4");
moleculeExpressionTask.AddExpressionProfile(_templateIndividual, _templateExpressionProfileCYP3A4);
_templateIndividualUsingSameProfile = DomainFactoryForSpecs.CreateStandardIndividual().WithName("IND2");
moleculeExpressionTask.AddExpressionProfile(_templateIndividualUsingSameProfile, _templateExpressionProfileCYP3A4);
_templateIndividualUsingAnotherProfile = DomainFactoryForSpecs.CreateStandardIndividual().WithName("IND3");
_templateExpressionProfileCYP2D6 = DomainFactoryForSpecs.CreateExpressionProfile <IndividualEnzyme>("CYP2D6");
moleculeExpressionTask.AddExpressionProfile(_templateIndividualUsingAnotherProfile, _templateExpressionProfileCYP2D6);
var compound = DomainFactoryForSpecs.CreateStandardCompound();
var protocol = DomainFactoryForSpecs.CreateStandardIVBolusProtocol();
_simulation = DomainFactoryForSpecs.CreateSimulationWith(_templateIndividual, compound, protocol) as IndividualSimulation;
var project = new PKSimProject();
project.AddBuildingBlock(compound);
project.AddBuildingBlock(protocol);
project.AddBuildingBlock(_simulation);
project.AddBuildingBlock(_templateIndividual);
project.AddBuildingBlock(_templateIndividualUsingSameProfile);
project.AddBuildingBlock(_templateIndividualUsingAnotherProfile);
project.AddBuildingBlock(_templateExpressionProfileCYP3A4);
project.AddBuildingBlock(_templateExpressionProfileCYP2D6);
var workspace = IoC.Resolve <ICoreWorkspace>();
workspace.Project = project;
}
protected override void Context()
{
_view = A.Fake <IExpressionProfileSelectionView>();
_moleculePropertiesMapper = A.Fake <IMoleculePropertiesMapper>();
_buildingBlockRepository = A.Fake <IBuildingBlockRepository>();
_expressionProfileTask = A.Fake <IExpressionProfileTask>();
sut = new ExpressionProfileSelectionPresenter(_view, _moleculePropertiesMapper, _buildingBlockRepository, _expressionProfileTask);
A.CallTo(() => _view.BindTo(A <ExpressionProfileSelectionDTO> ._))
.Invokes(x => _dto = x.GetArgument <ExpressionProfileSelectionDTO>(0));
_individual = DomainHelperForSpecs.CreateIndividual(speciesName: "Human");
_expressionProfile1 = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>(speciesName: "Human");
_expressionProfile2 = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>(speciesName: "Human");
_expressionProfile3 = DomainHelperForSpecs.CreateExpressionProfile <IndividualTransporter>(speciesName: "Human");
_expressionProfile4 = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>(speciesName: "Dog");
_expressionProfile5 = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>(speciesName: "Human");
_allExpressionProfiles = new List <ExpressionProfile> {
_expressionProfile1, _expressionProfile2
};
A.CallTo(() => _buildingBlockRepository.All(A <Func <ExpressionProfile, bool> > ._))
.Invokes(x => _predicate = x.GetArgument <Func <ExpressionProfile, bool> >(0))
.Returns(_allExpressionProfiles);
_individual.AddExpressionProfile(_expressionProfile5);
}
protected override void Context()
{
_view = A.Fake <IExpressionProfileMoleculesView>();
_expressionProfileFactory = A.Fake <IExpressionProfileFactory>();
_applicationController = A.Fake <IApplicationController>();
_mapper = A.Fake <IExpressionProfileToExpressionProfileDTOMapper>();
_enzymePresenter = A.Fake <IIndividualEnzymeExpressionsPresenter <Individual> >();
_expressionProfileUpdater = A.Fake <IExpressionProfileUpdater>();
_expressionProfileProteinDatabaseTask = A.Fake <IExpressionProfileProteinDatabaseTask>();
_moleculeParameterTask = A.Fake <IMoleculeParameterTask>();
sut = new ExpressionProfileMoleculesPresenter(
_view,
_expressionProfileFactory,
_applicationController,
_mapper,
_expressionProfileProteinDatabaseTask,
_expressionProfileUpdater,
_moleculeParameterTask);
sut.InitializeWith(new PKSimMacroCommand());
_expressionProfile = A.Fake <ExpressionProfile>();
_expressionProfileDTO = new ExpressionProfileDTO();
_enzyme = new IndividualEnzyme();
A.CallTo(() => _expressionProfile.Molecule).Returns(_enzyme);
A.CallTo(() => _mapper.MapFrom(_expressionProfile)).Returns(_expressionProfileDTO);
A.CallTo(() => _applicationController.Start <IIndividualEnzymeExpressionsPresenter <Individual> >()).Returns(_enzymePresenter);
}
public ICommand UpdateMoleculeName(ExpressionProfile expressionProfile, string newMoleculeName)
{
var command = new PKSimMacroCommand();
var oldMoleculeName = expressionProfile.MoleculeName;
//we are not renaming anything
if (string.Equals(newMoleculeName, oldMoleculeName))
{
return(command);
}
var(_, individual) = expressionProfile;
var mainCommand = renameMoleculeReferences(individual, oldMoleculeName, newMoleculeName);
command.Add(mainCommand);
command.UpdatePropertiesFrom(mainCommand);
allSimulationSubjectsUsing(expressionProfile).Each(x =>
{
_lazyLoadTask.Load(x);
command.Add(renameMoleculeReferences(x, oldMoleculeName, newMoleculeName));
});
return(command);
}
public override void GlobalContext()
{
base.GlobalContext();
LoadSnapshot("ind_expression_trans_v9");
_expressionProfileTrans = FindByName <ExpressionProfile>("TRANS2|Human|Individual");
}
protected override void Context()
{
base.Context();
_addCommand = A.Fake <ICommand>();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
A.CallTo(() => _expressionProfileSelectionPresenter.SelectExpressionProfile <IndividualProtein>(_individual)).Returns(_expressionProfile);
A.CallTo(() => _moleculeExpressionTask.AddExpressionProfile(_individual, _expressionProfile)).Returns(_addCommand);
}
public void SynchronizeExpressionProfileWithExpressionProfile(ExpressionProfile sourceExpressionProfile, ExpressionProfile targetExpressionProfile)
{
var(sourceMolecule, sourceIndividual) = sourceExpressionProfile;
var(targetMolecule, targetIndividual) = targetExpressionProfile;
// ExpressionProfile To ExpressionProfile. We do not update the parameter origin id in the target entities as we are updating one building block from another one
synchronizeExpressionProfiles(sourceMolecule, sourceIndividual, targetMolecule, targetIndividual, updateParameterOriginId: false);
}
public override void GlobalContext()
{
base.GlobalContext();
LoadSnapshot("ind_expression_v9");
_individual = FindByName <Individual>("Ind");
_expressionProfileCYP3A4 = FindByName <ExpressionProfile>("CYP3A4|Human|Ind");
_expressionProfileCYP2C8 = FindByName <ExpressionProfile>("CYP2C8|Human|Ind");
}
public override void GlobalContext()
{
base.GlobalContext();
LoadSnapshot("ind_expression_v11");
_individual = FindByName <Individual>("Ind");
_expressionProfileEnzyme = FindByName <ExpressionProfile>("CYP3A4|Human|Ind");
_expressionProfileTransporter = FindByName <ExpressionProfile>("UGT8|Human|Ind");
}
public ICommand AddExpressionProfile(TSimulationSubject simulationSubject, ExpressionProfile expressionProfile)
{
var moleculeFactory = _individualMoleculeFactoryResolver.FactoryFor(expressionProfile.Molecule);
var molecule = moleculeFactory.AddMoleculeTo(simulationSubject, expressionProfile.MoleculeName);
simulationSubject.AddExpressionProfile(expressionProfile);
_expressionProfileUpdater.SynchroniseSimulationSubjectWithExpressionProfile(simulationSubject, expressionProfile);
return(_simulationSubjectExpressionTask.AddMoleculeTo(molecule, simulationSubject));
}
protected override void Because()
{
//add an expression profile with the name
_existingExpressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>(_ind.Species.Name, "CYP3A4", _ind.Name);
_project.AddBuildingBlock(_existingExpressionProfile);
//now load to trigger conversion
Load(_ind);
}
protected override void Context()
{
base.Context();
_expressionProfile = new ExpressionProfile();
_individual.AddExpressionProfile(_expressionProfile);
A.CallTo(() => _buildingBlockTask.SaveAsTemplate(A <ICache <IPKSimBuildingBlock, IReadOnlyList <IPKSimBuildingBlock> > > ._, TemplateDatabaseType.User))
.Invokes(x => _cache = x.GetArgument <ICache <IPKSimBuildingBlock, IReadOnlyList <IPKSimBuildingBlock> > >(0));
}
public void SetDefaultFor(ExpressionProfile expressionProfile, string moleculeName = null)
{
var(molecule, individual) = expressionProfile;
var moleculeNameToUse = moleculeName ?? molecule.Name;
setDefaultSettingsForTransporter(molecule, individual, moleculeNameToUse);
setDefaultOntogeny(molecule, individual, moleculeNameToUse);
SetDefaultMoleculeParameters(molecule, moleculeNameToUse);
}
protected override void Context()
{
base.Context();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
_querySettings = A.Fake <QueryExpressionSettings>();
_queryResults = A.Fake <QueryExpressionResults>();
A.CallTo(() => _querySettingsMapper.MapFrom(_expressionProfile.Molecule, _expressionProfile.Individual, "NAME")).Returns(_querySettings);
A.CallTo(() => _proteinExpressionPresenter.Start()).Returns(true);
A.CallTo(() => _proteinExpressionPresenter.GetQueryResults()).Returns(_queryResults);
}
public static ExpressionProfile CreateExpressionProfile <TMolecule>(string speciesName = "Species", string moleculeName = "CYP3A4", string category = "Healthy") where TMolecule : IndividualMolecule, new()
{
var expressionProfile = new ExpressionProfile();
var individual = CreateIndividual(speciesName);
individual.AddMolecule(new TMolecule().WithName(moleculeName));
expressionProfile.Individual = individual;
expressionProfile.Category = category;
return(expressionProfile);
}
public SetTransportTypeCommand(IndividualTransporter individualTransporter, TransportType transportType, IExecutionContext context)
{
_expressionProfile = context.BuildingBlockContaining(individualTransporter).DowncastTo <ExpressionProfile>();
_individualTransporter = individualTransporter;
_transportType = transportType;
BuildingBlockId = _expressionProfile.Id;
_transporterId = _individualTransporter.Id;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildingBlockPropertiesInCommand(this, _expressionProfile);
}
protected override void Context()
{
base.Context();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
_individual = DomainHelperForSpecs.CreateIndividual();
_individual.AddExpressionProfile(_expressionProfile);
_usedBuildingBlock = new UsedBuildingBlock(_expressionProfile.Id, _expressionProfile.BuildingBlockType);
_simulation1.AddUsedBuildingBlock(_usedBuildingBlock);
A.CallTo(() => _buildingBlockRepository.All(A <Func <ISimulationSubject, bool> > ._))
.Returns(new[] { _individual });
}
protected override void Context()
{
_sourceIndividual = DomainHelperForSpecs.CreateIndividual();
_targetIndividual = DomainHelperForSpecs.CreateIndividual();
_expressionProfile1 = new ExpressionProfile();
_targetIndividualOtherSpecies = DomainHelperForSpecs.CreateIndividual(speciesName: "OTHER_SPECIES");
_moleculeExpressionTask = A.Fake <IMoleculeExpressionTask <Individual> >();
_dialogCreator = A.Fake <IDialogCreator>();
sut = new IndividualExpressionsUpdater(_moleculeExpressionTask, _dialogCreator);
_sourceIndividual.AddExpressionProfile(_expressionProfile1);
}
public void SynchroniseSimulationSubjectWithExpressionProfile(ISimulationSubject simulationSubject, ExpressionProfile expressionProfile)
{
_lazyLoadTask.Load(simulationSubject);
var moleculeInIndividual = simulationSubject.MoleculeByName(expressionProfile.MoleculeName);
var(sourceMolecule, sourceIndividual) = expressionProfile;
// ExpressionProfile => SimulationSubject, we want to make sure that the parameters in simulation subject are linked to their expression profile origin parameters
synchronizeExpressionProfiles(sourceMolecule, sourceIndividual, moleculeInIndividual, simulationSubject, updateParameterOriginId: true);
//Once the synchronization was performed, apply changes to simulation subject molecules based on disease state
updateMoleculeParametersForDiseaseState(simulationSubject, moleculeInIndividual);
}
protected override void Context()
{
_projectRetriever = A.Fake <IPKSimProjectRetriever>();
sut = new UsedExpressionProfileCategoryRepository(_projectRetriever);
_expressionProfile1 = new ExpressionProfile {
Category = "ZZ_2"
};
_expressionProfile2 = new ExpressionProfile {
Category = "ZZ_1"
};
A.CallTo(() => _projectRetriever.Current.All <ExpressionProfile>()).Returns(new[] { _expressionProfile1, _expressionProfile2 });
}
public SetTransportDirectionCommand(TransporterExpressionContainer transporterContainer, TransportDirectionId newTransportDirection,
IExecutionContext context)
{
_transporterContainer = transporterContainer;
_newTransportDirection = newTransportDirection;
_transporterContainerId = _transporterContainer.Id;
_expressionProfile = context.BuildingBlockContaining(_transporterContainer).DowncastTo <ExpressionProfile>();
BuildingBlockId = _expressionProfile.Id;
_oldTransportDirection = _transporterContainer.TransportDirection;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildingBlockPropertiesInCommand(this, _expressionProfile);
}
protected override void Context()
{
base.Context();
_expressionProfile = new ExpressionProfile();
_forbiddenNames = new List <string>();
_entityType = "Type";
_expressionProfileDTO = new ExpressionProfileDTO();
A.CallTo(() => _mapper.MapFrom(_expressionProfile)).Returns(_expressionProfileDTO);
_expressionProfileDTO.MoleculeName = "MOLECULE";
_expressionProfileDTO.Category = "NEW_CATEGORY";
_expressionProfileDTO.Species = new Species {
DisplayName = "Human"
};
}
protected override void Context()
{
_project = new PKSimProject();
_projectRetriever = A.Fake <IPKSimProjectRetriever>();
_transporterContainerTemplateRepository = A.Fake <ITransporterContainerTemplateRepository>();
A.CallTo(() => _projectRetriever.Current).Returns(_project);
_compound1 = A.Fake <Compound>();
_compound1.IsLoaded = false;
_compound2 = new Compound {
IsLoaded = true
};
_compound2.AddProcess(new EnzymaticProcess {
MoleculeName = "ProjA", Name = "P1"
});
_compound2.AddProcess(new EnzymaticProcess {
MoleculeName = "ProjC", Name = "P2"
});
_compound2.AddProcess(new EnzymaticProcess {
MoleculeName = "ProjB", Name = "P3"
});
_ontogenyRepository = A.Fake <IOntogenyRepository>();
_moleculeParameterRepository = A.Fake <IMoleculeParameterRepository>();
_expressionProfile = A.Fake <ExpressionProfile>();
_expressionProfile.IsLoaded = true;
A.CallTo(() => _expressionProfile.MoleculeName).Returns("ProjE");
_project.AddBuildingBlock(_compound1);
_project.AddBuildingBlock(_compound2);
_project.AddBuildingBlock(_expressionProfile);
sut = new UsedMoleculeRepository(_projectRetriever, _ontogenyRepository, _moleculeParameterRepository, _transporterContainerTemplateRepository);
var molParam1 = new MoleculeParameter {
MoleculeName = "DbB"
};
var molParam2 = new MoleculeParameter {
MoleculeName = "DbA"
};
A.CallTo(() => _moleculeParameterRepository.All()).Returns(new[] { molParam1, molParam2 });
A.CallTo(() => _transporterContainerTemplateRepository.AllTransporterNames).Returns(new[] { "ATRANS1", "TRANS2" });
A.CallTo(() => _ontogenyRepository.AllFor(CoreConstants.Species.HUMAN)).Returns(new[] { new DatabaseOntogeny {
Name = "OntoC"
} });
}
public void SynchronizeExpressionProfileWithSimulationSubject(ExpressionProfile expressionProfile, ISimulationSubject simulationSubject)
{
var moleculeInIndividual = simulationSubject.MoleculeByName(expressionProfile.MoleculeName);
var(targetMolecule, targetIndividual) = expressionProfile;
// SimulationSubject To ExpressionProfile. We do not update the parameter origin id in the target entities (expression profile)
synchronizeExpressionProfiles(moleculeInIndividual, simulationSubject, targetMolecule, targetIndividual, updateParameterOriginId: false);
//however we need to make sure that we reference the expression profile parameter in the source individual
var allExpressionProfileParameters = allMoleculeParametersFor(targetIndividual, targetMolecule);
var allIndividualParameters = allMoleculeParametersFor(simulationSubject, moleculeInIndividual);
_parameterIdUpdater.UpdateParameterIds(allExpressionProfileParameters, allIndividualParameters);
}
public ExpressionProfileDTO MapFrom(ExpressionProfile expressionProfile)
{
var dto = new ExpressionProfileDTO
{
Icon = _moleculePropertiesMapper.MoleculeIconFor(expressionProfile.Molecule),
Species = expressionProfile.Species,
Category = expressionProfile.Category,
MoleculeName = moleculeNameFor(expressionProfile),
AllMolecules = _usedMoleculeRepository.All(),
AllCategories = _usedExpressionProfileCategoryRepository.All(),
AllSpecies = _speciesRepository.All(),
MoleculeType = _moleculePropertiesMapper.MoleculeDisplayFor(expressionProfile.Molecule),
};
dto.AddExistingExpressionProfileNames(_projectRetriever.Current.All <ExpressionProfile>().AllNames().Except(new[] { expressionProfile.Name }));
return(dto);
}
private bool UpdateProfileLiteSync(string scenario, string profileResourceId, string displayName, string personalStatus, string freeText, int flag)
{
MsnServiceState serviceState = new MsnServiceState(scenario, "UpdateProfile", false);
StorageService storageService = (StorageService)CreateService(MsnServiceType.Storage, serviceState);
UpdateProfileRequestType updateProfileRequest = new UpdateProfileRequestType();
updateProfileRequest.profile = new UpdateProfileRequestTypeProfile();
updateProfileRequest.profile.ResourceID = profileResourceId;
ExpressionProfile expProf = new ExpressionProfile();
expProf.FreeText = freeText;
expProf.DisplayName = displayName;
expProf.Flags = flag;
expProf.FlagsSpecified = true;
if (!string.IsNullOrEmpty(personalStatus))
{
expProf.PersonalStatus = personalStatus == null ? string.Empty : personalStatus;
}
updateProfileRequest.profile.ExpressionProfile = expProf;
NSMessageHandler.ContactService.Deltas.Profile.DisplayName = displayName;
NSMessageHandler.ContactService.Deltas.Profile.PersonalMessage = personalStatus;
NSMessageHandler.ContactService.Deltas.Save(true); //Save no matter the request succeed or fail.
try
{
ChangeCacheKeyAndPreferredHostForSpecifiedMethod(storageService, MsnServiceType.Storage, serviceState, updateProfileRequest);
storageService.UpdateProfile(updateProfileRequest);
}
catch (Exception ex)
{
OnServiceOperationFailed(storageService, new ServiceOperationFailedEventArgs("UpdateProfile", ex));
Trace.WriteLineIf(Settings.TraceSwitch.TraceError, "UpdateProfile error: " + ex.Message, GetType().Name);
return false;
}
return true;
}
