public LabellingsViewModel(ExperimentViewModel experimentViewModel)
{
_experimentViewModel = experimentViewModel;
ViewModel = experimentViewModel.Samples;
Add = new DelegateCommand<string>(OnAdd);
Remove = new DelegateCommand<LabelingViewModel>(OnRemove, CanRemove);
}
public void TestInitialize()
{
ProjectBase project = TestHelper.CreateTestProject();
Experiment experiment = project.Experiments.First() as Experiment;
experimentViewModel = new ExperimentViewModel(experiment);
viewModel = new ProteinStatesViewModel(experimentViewModel);
}
public ImportPeptidesViewModel(ExperimentViewModel experimentViewModel)
{
_experimentViewModel = experimentViewModel;
ViewModel = experimentViewModel.Samples;
_selectedDataPath = Properties.Settings.Default.LastBrowsePeptideDataPath;
LoadRecentLocations();
}
private void DistanceRangeCollectionChangeSubscribe(ExperimentViewModel experimentViewModel)
{
if (experimentViewModel.DistanceRange != null)
{
experimentViewModel.DistanceRange.CollectionChanged += (o, e) => DistanceRangeOnCollectionChanged(o, e, experimentViewModel);
}
}
public async Task <IActionResult> GetExperiment([FromRoute] int id)
{
try
{
var item = await _dm.ExperimentAccessor.GetExperiment(id);
if (item == null)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.NotFound
}));
}
ExperimentViewModel model = item.ToExperimentViewModel();
return(Ok(model));
}
catch (Exception ex)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.ServerError, Description = ex.Message
}));
}
}
public static ExperimentViewModel ToExperimentViewModel(this ExperimentEntity entity)
{
ExperimentViewModel model = new ExperimentViewModel();
model.Id = entity.Id;
model.Name = entity.Name;
if (entity.PhysicalProperty != null)
{
model.PhysicalPropertyId = entity.PhysicalProperty.Id;
model.PhysicalProperty = entity.PhysicalProperty.ToPhysicalPropertyViewModel();
}
if (entity.Setup != null)
{
model.SetupId = entity.Setup.Id;
model.Setup = entity.Setup.ToSetupViewModel();
}
if (entity.Fluorophore != null)
{
model.FluorophoreId = entity.Fluorophore.Id;
model.Fluorophore = entity.Fluorophore.ToFluorophoreViewModel();
}
if (entity.ResearchObject != null)
{
model.ResearchObjectId = entity.ResearchObject.Id;
model.ResearchObject = entity.ResearchObject.ToResearchObjectViewModel();
}
return(model);
}
public static ExperimentViewModel ToViewModel([NotNull] this ExperimentEntity experimentEntity)
{
var experimentViewModel = new ExperimentViewModel
{
DateTime = experimentEntity.DateTime,
BaseDistance = experimentEntity.BaseDistance,
Category = experimentEntity.Category,
DistanceRange = new ObservableCollection <double>(experimentEntity.DistanceRange),
ExperimentStatus = experimentEntity.ExperimentStatus,
Name = experimentEntity.Name,
PhysicModel = experimentEntity.PhysicModel == null? null : ParamsRetrieverManager.GetParamsRetrievers().FirstOrDefault(x => x.Name == experimentEntity.PhysicModel),
SpectrometerName = experimentEntity.Spectrometer,
WaveMax = experimentEntity.WaveMax,
WaveMin = experimentEntity.WaveMin,
RetrievedParams = (experimentEntity.RetrievedParams ?? new List <Params>()).ToArray(),
SavedData = experimentEntity.Data == null? null : new ExperimentEntityDataViewModel()
{
WaveLengthArray = experimentEntity.Data.WaveLengthArray,
DataItems = new FullyObservableCollection <ExperimentEntityDataItemViewModel>(experimentEntity.Data.DataItems.Select(x => x.ToViewModel()))
}
};
//todo move to other place
EntityDataProvider <ExperimentEntity> .Instance.SaveManager.Map(experimentViewModel, experimentEntity);
return(experimentViewModel);
}
public ActionResult Add(ExperimentViewModel viewModel, int hidNumVariables)
{
try
{
if (ModelState.IsValid)
{
viewModel.Experiment.CreatedBy = HttpContext.User.Identity.Name;
viewModel.Experiment.Variables = new List <string>();
for (int i = 0; i < hidNumVariables; i++)
{
var variable = Request["variable-" + i];
if (!string.IsNullOrEmpty(variable))
{
viewModel.Experiment.Variables.Add(variable);
}
}
viewModel.Experiment = experimentRepository.Add(viewModel.Experiment);
return(Redirect("/Experiments/"));
}
else
{
ViewBag.ErrorMessage = "There is a problem with one of your responses.";
}
}
catch (Exception ex)
{
ViewBag.ErrorMessage = "An Error Occurred while attempting to save that experiment.";
}
viewModel.Cohorts = cohortRepository.GetAll().ToList();
return(View(viewModel));
}
public ProteinStatesViewModel(ExperimentViewModel experimentViewModel)
{
_experimentViewModel = experimentViewModel;
ViewModel = experimentViewModel.Samples;
Add = new DelegateCommand<string>(OnAdd);
Remove = new DelegateCommand<ProteinStateViewModel>(OnRemove, CanRemove);
}
public DataProviderViewModel(ExperimentViewModel experimentViewModel, IServiceLocator serviceLocator)
{
this.serviceLocator = serviceLocator;
_experimentViewModel = experimentViewModel;
ViewModel = experimentViewModel;
dataProviders = serviceLocator.GetAllInstances<IDataProvider>().ToList();
selectedDataProvider = dataProviders.First();
}
private void SetReady(ExperimentViewModel experimentViewModel, bool isReady = true)
{
if (_mapper.ContainsKey(experimentViewModel))
{
_mapper[experimentViewModel].IsReadyToSave = isReady;
}
NotifyReadyToSaveChanged();
}
private void SavedDataPropertyChangedSubscribe(ExperimentViewModel experimentViewModel)
{
if (experimentViewModel.SavedData == null)
{
return;
}
experimentViewModel.SavedData.PropertyChanged += (o, e) => SavedDataOnPropertyChanged(o, e, experimentViewModel);
DataItemsChangedSubscribe(experimentViewModel);
}
private void DataItemsChangedSubscribe(ExperimentViewModel experimentViewModel)
{
if (experimentViewModel.SavedData?.DataItems == null)
{
return;
}
experimentViewModel.SavedData.DataItems.ItemPropertyChanged += (o, e) => DataItemsOnItemPropertyChanged(o, e, experimentViewModel);
experimentViewModel.SavedData.DataItems.CollectionChanged += (o, e) => DataItemsOnCollectionChanged(o, e, experimentViewModel);
}
public ActionResult Add()
{
ExperimentViewModel viewModel = new ExperimentViewModel();
viewModel.Experiment = null;
viewModel.Cohorts = cohortRepository.GetAll().ToList();
viewModel.Goals = goalRepository.GetAll().ToList();
return(View(viewModel));
}
public ActionResult Update(int Id)
{
ExperimentViewModel viewModel = new ExperimentViewModel();
viewModel.Experiment = experimentRepository.Get(Id);
viewModel.Cohorts = cohortRepository.GetAll().ToList();
viewModel.Goals = goalRepository.GetAll().ToList();
return(View(viewModel));
}
public async Task <ResponseModel> SaveExperiment(ExperimentViewModel model)
{
string uri = "api/experiment/Save";
var request = await _http.PostAsJsonAsync <ExperimentViewModel>(uri, model);
var response = await request.Content.ReadFromJsonAsync <ResponseModel>();
return(response);
}
public RunsViewModel(ExperimentViewModel experimentViewModel)
{
_experimentViewModel = experimentViewModel;
ViewModel = experimentViewModel.Samples;
AddRunData = new DelegateCommand<IList>(OnAddRunData, CanAddRunData);
RemoveRunData = new DelegateCommand<object>(OnRemoveRunData, CanRemoveRunData);
_selectedDataPath = Properties.Settings.Default.LastBrowseDataPath;
LoadRecentLocations();
LoadFiles();
}
public void TestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
mockServiceLocator = new Mock<IServiceLocator>();
mockServiceLocator.Setup(mock => mock.GetAllInstances<IDataProvider>()).Returns(new List<IDataProvider>() { new ProteoWizardDataProvider(mockEventAggregator.Object) });
ProjectBase project = TestHelper.CreateTestProject();
experiment = project.Experiments.First() as Experiment;
experimentViewModel = new ExperimentViewModel(experiment);
viewModel = new DataProviderViewModel(experimentViewModel, mockServiceLocator.Object);
}
public async Task <IActionResult> Save([FromBody] ExperimentViewModel model)
{
try
{
ExperimentEntity entity = null;
if (!ModelState.IsValid)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.NotValidData
}));
}
var item = await _dm.ExperimentAccessor.GetExperiment(model.SetupId, model.ResearchObjectId, model.FluorophoreId, model.PhysicalPropertyId);
if (item != null && item.Id != model.Id)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.AlreadyExists
}));
}
if (model.Id <= 0)
{
entity = new ExperimentEntity();
}
else
{
entity = await _dm.ExperimentAccessor.GetExperiment(model.Id);
if (entity == null)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.AlreadyExists
}));
}
}
var entityToSave = model.ToExperimentEntity();
await _dm.ExperimentAccessor.SaveExperiment(entityToSave);
return(Ok(new ResponseModel()
{
Result = ResultCode.Success
}));
}
catch (Exception ex)
{
return(Ok(new ResponseModel()
{
Result = ResultCode.ServerError, Description = ex.Message
}));
}
}
public HydraExperimentWizardController(IRegionManager regionManager, IServiceLocator serviceLocator, Experiment experiment)
{
_regionManager = regionManager;
_experiment = experiment;
_serviceLocator = serviceLocator;
_wizardViewModels = new List<WizardStepViewModel>();
ExperimentViewModel experimentViewModel = new ExperimentViewModel(experiment);
_wizardViewModels.Add(new ProteinStatesViewModel(experimentViewModel));
_wizardViewModels.Add(new LabellingsViewModel(experimentViewModel));
_wizardViewModels.Add(new DataProviderViewModel(experimentViewModel, serviceLocator));
_wizardViewModels.Add(new RunsViewModel(experimentViewModel));
_wizardViewModels.Add(new ImportPeptidesViewModel(experimentViewModel));
}
public static ExperimentEntity ToExperimentEntity(this ExperimentViewModel model)
{
ExperimentEntity entity = new ExperimentEntity();
if (model.Id > 0)
{
entity.Id = model.Id;
}
entity.Name = model.Name;
entity.PhysicalPropertyId = model.PhysicalPropertyId;
entity.SetupId = model.SetupId;
entity.FluorophoreId = model.FluorophoreId;
entity.ResearchObjectId = model.ResearchObjectId;
return(entity);
}
private bool Save(ExperimentViewModel viewModel, bool isRaiseEvent = false)
{
if (!_mapper.ContainsKey(viewModel))
{
return(false);
}
if (!_mapper[viewModel].IsReadyToSave)
{
return(false);
}
try
{
var experimentsDirectory = "experiments";
if (!Directory.Exists(experimentsDirectory))
{
Directory.CreateDirectory(experimentsDirectory);
}
var oldEntity = _mapper[viewModel].Entity;
var newEntity = viewModel.ToEntity();
if (oldEntity.Name != newEntity.Name)
{
var oldPath = $"{experimentsDirectory}\\{oldEntity.Name.ToFileName()}.json";
if (File.Exists(oldPath))
{
File.Delete(oldPath);
}
}
var newPath = $"{experimentsDirectory}\\{newEntity.Name.ToFileName()}.json";
//if (File.Exists(newPath))
//{
// newPath = $"{experimentsDirectory}\\{newEntity.Name}_{Guid.NewGuid()}.json";
//}
File.WriteAllText(newPath, JsonConvert.SerializeObject(newEntity, _settings));
_mapper[viewModel].Entity = newEntity;
_mapper[viewModel].IsReadyToSave = false;
if (isRaiseEvent)
{
NotifyReadyToSaveChanged();
}
return(true);
}
catch (Exception)
{
return(false);
}
}
private async void CreateExperimentAction()
{
var dialog = (BaseMetroDialog)Application.Current.Windows.OfType <MainWindow>().First().Resources["ExperimentDialog"];
var experimentDialogViewModel = new ExperimentDialogViewModel
{
DialogCloseAction = async(vm) =>
{
await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
},
DialogAddAction = async(vm) =>
{
var newExperimentVm = new ExperimentViewModel();
newExperimentVm.InitFieldsFrom(vm);
ExperimentListViewModel.ExperimentTileCollection.Add(newExperimentVm);
EntityDataProvider <ExperimentEntity> .Instance.SaveManager.Map(newExperimentVm);
Logger.Info(StringResourceProvider.Instance[StringResourceProvider.Keys.Experiment_PLACE_WasAdded].Value, newExperimentVm.Name);
//todo save previous selected item data
ExperimentListViewModel.SelectedExperimentTile = null;
await Task.Delay(300);
ExperimentListViewModel.SelectedExperimentTile = newExperimentVm;
await MetroDialogCoordinator.HideMetroDialogAsync(this, dialog);
},
Name = "Experiment #" + DateTime.Now.ToString("yyyy MMMM dd HH:mm"),
DateTime = DateTime.Now,
Category = "Spectrum",
WaveMax = 720,
WaveMin = 430,
ExperimentStatus = ExperimentStatus.Unknown,
//DistanceRange = new ObservableCollection<double>() { 1.25, 1.5, 1.75, 2, 2.5 },
DistanceRange = new ObservableCollection <double>()
{
1.25, 1.375, 1.5, 1.625, 1.75, 1.875, 2, 2.25, 2.5
},
SpectrometerName = "LOTIS CMS-400",
BaseDistance = 1.25,
DistanceToAdd = 2
};
//dialog.Content = experimentDialogViewModel;
dialog.DataContext = experimentDialogViewModel;
experimentDialogViewModel.PhysicModel = ParamsRetrieverManager.GetParamsRetrievers().FirstOrDefault();
await MetroDialogCoordinator.ShowMetroDialogAsync(this, dialog);
}
public static async Task Run(string prefix, string outputPath, string repositoryPath)
{
Console.WriteLine("Connecting...");
var sStorage = new SecretStorage(Settings.Default.AADApplicationId, Settings.Default.AADApplicationCertThumbprint, Settings.Default.KeyVaultUrl);
string cString = await sStorage.GetSecret(Settings.Default.ConnectionStringSecretId);
AzureSummaryManager sMan = new AzureSummaryManager(cString, Helpers.GetDomainResolver());
AzureExperimentManager aeMan = AzureExperimentManager.Open(cString);
Tags tags = await Helpers.GetTags(Settings.Default.SummaryName, sMan);
Console.WriteLine("Loading timeline...");
Timeline timeline = await Helpers.GetTimeline(Settings.Default.SummaryName, aeMan, sMan, cString);
// Numbers: 4.5.0 = 8023; suspect 8308 -> 8312
Directory.CreateDirectory(outputPath);
int refId = 8023;
Console.WriteLine("Loading reference #{0}...", refId);
ComparableExperiment refE = await Helpers.GetComparableExperiment(refId, aeMan);
List <Task> tasks = new List <Task>();
for (int i = 0; i < timeline.Experiments.Length; i++)
{
ExperimentViewModel e = timeline.Experiments[i];
if (e.Id < refId)
{
continue;
}
//tasks.Add(GeneratePlot(aeMan, tags, prefix, refE, refId, e.Id, outputPath));
//GeneratePlot(aeMan, tags, prefix, refE, refId, e.Id, outputPath);
if (i > 0 && e.Id != refId)
{
GenerateLog(repositoryPath, outputPath, timeline.Experiments[i - 1].Id, e.Id, timeline.Experiments[i - 1].SubmissionTime, e.SubmissionTime);
}
//if (e.Id == 8099) break;
}
//ParallelOptions popts = new ParallelOptions();
//popts.MaxDegreeOfParallelism = 1;
//ParallelLoopResult r = Parallel.ForEach(tasks, popts, t => t.Wait());
//Task.WaitAll(tasks.ToArray());
//await Task.WhenAll(tasks);
}
static public string SaveExperiment(ExperimentViewModel experiment)
{
//set culture as invariant to write numbers as in english
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
if (!experiment.Validate())
{
Data.CaliburnUtility.ShowWarningDialog("The configuration couldn't be validated in " + experiment.Name
+ ". Please check it", "VALIDATION ERROR");
return(null);
}
var sfd = SaveFileDialog(ExperimentFileTypeDescription, ExperimentFilter);
if (sfd.ShowDialog() == DialogResult.OK)
{
experiment.Save(sfd.FileName, SaveMode.AsExperiment);
return(sfd.FileName);
}
return(null);
}
public static ExperimentEntity ToEntity([NotNull] this ExperimentViewModel experimentVm)
{
return(new ExperimentEntity
{
DateTime = experimentVm.DateTime,
BaseDistance = experimentVm.BaseDistance,
Category = experimentVm.Category,
DistanceRange = experimentVm.DistanceRange.ToList(),
ExperimentStatus = experimentVm.ExperimentStatus,
Name = experimentVm.Name,
PhysicModel = experimentVm.PhysicModel.Name,
RetrievedParams = (experimentVm.RetrievedParams ?? new List <Params>()).ToArray(),
Spectrometer = experimentVm.SpectrometerName,
WaveMax = experimentVm.WaveMax,
WaveMin = experimentVm.WaveMin,
Data = experimentVm.SavedData == null ? null : new ExperimentEntityData()
{
WaveLengthArray = experimentVm.SavedData.WaveLengthArray,
DataItems = experimentVm.SavedData.DataItems?.Select(x => x.ToEntity())
}
});
}
//EXPERIMENT file: LOAD
/// <summary>
///
/// </summary>
/// <param name="appDefinitions"></param>
/// <returns></returns>
static public ExperimentViewModel LoadExperiment(Dictionary <string, string> appDefinitions, string filename = null)
{
//set culture as invariant to write numbers as in english
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
if (filename == null)
{
bool isOpen = OpenFileDialog(ref filename, ExperimentFileTypeDescription, ExperimentFilter);
if (!isOpen)
{
return(null);
}
}
// Open the config file to retrive the app's name before loading it
XmlDocument configDocument = new XmlDocument();
configDocument.Load(filename);
XmlNode rootNode = configDocument.LastChild;
ExperimentViewModel newExperiment = new ExperimentViewModel(appDefinitions[rootNode.Name], filename);
return(newExperiment);
}
void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
ApplicationViewModelWrapper appvm = (ApplicationViewModelWrapper)DataContext;
ExperimentViewModel experimentVM = null;
if (appvm.ExperimentDocumentWrapper != null)
{
experimentVM = appvm.ExperimentDocumentWrapper[0] as ExperimentViewModel;
if (experimentVM != null && experimentVM.IsModified)
{
var result = MessageBox.Show(TraceLab.Core.Messages.ClosingUnsavedDocumentWarning,
"Modified Experiment Not Saved", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.No)
{
e.Cancel = true;
return;
}
}
}
appvm.SettingsViewModel.MainWindowRect.Height = Height;
appvm.SettingsViewModel.MainWindowRect.Width = Width;
appvm.SettingsViewModel.MainWindowRect.Left = Left;
appvm.SettingsViewModel.MainWindowRect.Top = Top;
appvm.SaveSettings();
appvm.SaveUserTags();
DockManager.SaveLayout(TraceLab.Core.Settings.Settings.LayoutPath);
if (experimentVM != null && String.IsNullOrEmpty(experimentVM.TopLevel.ExperimentInfo.FilePath) == true)
{
//experiment was never saved, so delete its units from the workspace
appvm.WorkspaceViewModel.DeleteExperimentUnits();
}
}
public ExperimentDialogViewModel(ExperimentViewModel vm)
{
this.InitFieldsFrom(vm);
}
public void TestInitialize()
{
project = TestHelper.CreateTestProject();
viewModel = new ExperimentViewModel(project.Experiments.First() as Experiment);
importPeptidesViewModel = new ImportPeptidesViewModel(viewModel);
}
private void DataItemsOnItemPropertyChanged(object sender, ItemPropertyChangedEventArgs itemPropertyChangedEventArgs, ExperimentViewModel experimentViewModel)
{
SetReady(experimentViewModel);
}
private void DistanceRangeOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs notifyCollectionChangedEventArgs, ExperimentViewModel experimentViewModel)
{
SetReady(experimentViewModel);
}
public void TestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
ProjectBase project = TestHelper.CreateTestProject();
Experiment experiment = project.Experiments.First() as Experiment;
experiment.DataProvider = new ProteoWizardDataProvider(mockEventAggregator.Object);
experimentViewModel = new ExperimentViewModel(experiment);
viewModel = new RunsViewModel(experimentViewModel);
}
private void SavedDataOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs, ExperimentViewModel experimentViewModel)
{
if (propertyChangedEventArgs.PropertyName == "DataItems")
{
DataItemsChangedSubscribe(experimentViewModel);
}
SetReady(experimentViewModel);
}
