/// <summary> /// Open a data set given raw file, id file, and feature file. /// </summary> /// <param name="dataSetViewModel">DataSetViewModel to associate open dataset with</param> /// <param name="rawFilePath">Path to raw file to open</param> /// <param name="idFilePath">Path to MS-GF+ or MS-PathFinder results file</param> /// <param name="featureFilePath">Path to feature list file</param> /// <param name="paramFilePath">Path to MSPathFinder parameter file.</param> /// <param name="toolType">Type of ID tool used for this data set</param> /// <param name="modIgnoreList">Modifications to ignore if found in ID list.</param> /// <returns>Task that opens the data set.</returns> public async Task OpenDataSet( DataSetViewModel dataSetViewModel, string rawFilePath, string idFilePath = "", string featureFilePath = "", string paramFilePath = "", ToolType?toolType = ToolType.MsPathFinder, IEnumerable <string> modIgnoreList = null) { // Open raw file, if not already open. if (!string.IsNullOrEmpty(rawFilePath) && dataSetViewModel.LcMs == null) { this.ReadingRawFiles = true; await Task.Delay(20).ConfigureAwait(false); await dataSetViewModel.InitializeAsync(rawFilePath).ConfigureAwait(false); this.ReadingRawFiles = false; } // Show neighboring charge state XICs by default for MSPathFinder results if (toolType != null && toolType == ToolType.MsPathFinder) { var precFragSeq = dataSetViewModel.XicViewModel.PrecursorPlotViewModel.FragmentationSequenceViewModel as PrecursorSequenceIonViewModel; if (precFragSeq != null) { precFragSeq.PrecursorViewMode = PrecursorViewMode.Charges; } } // Open ID file if (!string.IsNullOrEmpty(idFilePath)) { this.ReadingIdFiles = true; if (dataSetViewModel.MsPfParameters == null) { dataSetViewModel.SetMsPfParameters(string.IsNullOrWhiteSpace(paramFilePath) ? idFilePath : paramFilePath); } if (dataSetViewModel.MsPfParameters != null) { IcParameters.Instance.ProductIonTolerancePpm = dataSetViewModel.MsPfParameters.ProductIonTolerancePpm; IcParameters.Instance.PrecursorTolerancePpm = dataSetViewModel.MsPfParameters.PrecursorTolerancePpm; } await this.ReadIdFile(dataSetViewModel, idFilePath, modIgnoreList); this.ReadingIdFiles = false; } // Open feature file if (!string.IsNullOrEmpty(featureFilePath)) { this.ReadingFeatureFiles = true; dataSetViewModel.FeatureMapViewModel.OpenFeatureFile(featureFilePath); dataSetViewModel.FeatureMapViewModel.UpdateIds(dataSetViewModel.ScanViewModel.FilteredData); this.ReadingRawFiles = false; } }
public async Task <ActionResult> Edit(string id) { DataSetViewModel dsview = new DataSetViewModel(); await dsview.GetDataSet(Session, id); return(View(dsview)); }
public async Task <ActionResult> Patch(DataSetViewModel viewmodel) { await viewmodel.EditDataSet(Session); if (viewmodel.errorOccurred == true) { return(View(viewmodel)); } return(RedirectToAction("Edit", new { id = Convert.ToString(viewmodel.dataSetPatchView.id) })); }
public async Task <ActionResult> Post(DataSetViewModel viewmodel) { await viewmodel.AddDataSet(Session); if (viewmodel.errorOccurred == true) { return(RedirectToAction("Add", "DataSet")); } return(RedirectToAction("Index", "DataSet")); }
public async Task <ActionResult> Index() { DataSetViewModel dsviewmodel = new DataSetViewModel(); await dsviewmodel.GenerateDataSetView(Session); if (dsviewmodel.errorOccurred) { return(RedirectToAction("Index", "Authenticate")); } else { return(View(dsviewmodel)); } }
public void DatasetAsync(string id) { var vm = new DataSetViewModel(); var webApiBaseUrl = ConfigurationManager.AppSettings["DataCatalogWebApiUrl"]; var url = webApiBaseUrl + $"/GetDataset?graphId={id}"; AsyncManager.OutstandingOperations.Increment(); Task.Factory.StartNew(() => { DataSetViewModel result = DataStoreSrv.RunAsync(vm, url).Result; result.Id = id; AsyncManager.Parameters["dataset"] = result; AsyncManager.OutstandingOperations.Decrement(); }); }
/// <summary> /// Open and read ID file and add IDs to data set. /// </summary> /// <param name="dataSetViewModel">DataSetViewModel to add IDs to.</param> /// <param name="idFilePath">Path for ID file to read.</param> /// <param name="modIgnoreList">Modifications to ignore in identifications.</param> /// <returns>Task that reads ID file.</returns> public async Task ReadIdFile(DataSetViewModel dataSetViewModel, string idFilePath, IEnumerable <string> modIgnoreList = null) { var reader = IdFileReaderFactory.CreateReader(idFilePath); var ids = await reader.ReadAsync(modIgnoreList); var idList = ids.ToList(); foreach (var id in idList) { id.RawFileName = dataSetViewModel.Title; id.LcMs = dataSetViewModel.LcMs; } this.Modifications = reader.Modifications; dataSetViewModel.ScanViewModel.Data.AddRange(idList); dataSetViewModel.IdFileOpen = true; }
/// <summary> /// Open raw file /// </summary> /// <param name="rawFilePath">Path to raw file to open</param> /// <returns>Task that returns a DataSetViewModel for the data set.</returns> private async Task <DataSetViewModel> ReadRawFile(string rawFilePath) { var dataSetViewModel = new DataSetViewModel(this.dialogService); // create data set view model this.DataSets.Add(dataSetViewModel); // add data set view model. Can only add to ObservableCollection in thread that created it (gui thread) this.CreateSequenceViewModel.SelectedDataSetViewModel = this.DataSets[0]; try { await this.dataReader.OpenDataSet(dataSetViewModel, rawFilePath); } catch (Exception) { this.dialogService.ExceptionAlert(new Exception(string.Format("Cannot read {0}.", Path.GetFileNameWithoutExtension(rawFilePath)))); if (this.DataSets.Count > 0 && this.DataSets.Contains(dataSetViewModel)) { this.DataSets.Remove(dataSetViewModel); } } return(dataSetViewModel); }
public ActionResult DatasetCompleted(DataSetViewModel dataset) { if (string.IsNullOrEmpty(dataset.Publisher.Name)) { dataset.Publisher.Name = dataset.Publisher.Uri.Substring(dataset.Publisher.Uri.LastIndexOf('/') + 1).ToUpperInvariant(); } foreach (var dist in dataset.Distributions) { if (dist.Name == "WMS") { if (!dist.AccessUrl.Contains('?')) { dist.AccessUrl += "?service=WMS&version=1.3.0&request=GetCapabilities"; } } } return(View(dataset)); }
static async Task <DataSetViewModel> GetDatasetAsync(string path) { DataSetViewModel vm = null; var response = await _client.GetAsync(path, HttpCompletionOption.ResponseContentRead); if (!response.IsSuccessStatusCode) { return(null); } try { var json = response.Content.ReadAsStringAsync().Result; vm = Newtonsoft.Json.JsonConvert.DeserializeObject(json, typeof(DataSetViewModel)) as DataSetViewModel; return(vm); } catch (Exception ex) { _client.CancelPendingRequests(); throw new Exception("GetDatasetAsync caused an error: " + ex.Message, ex); } }
internal static async Task <DataSetViewModel> RunAsync(DataSetViewModel vm, string uri) { try { try { var datasets = await GetDatasetAsync(uri); vm = datasets; } catch (Exception ex) { throw ex; } return(vm); } catch (Exception ex) { _client.CancelPendingRequests(); throw new Exception("RunAsync caused an error: " + ex.Message, ex); } }
/// <summary> /// Attempt to open Ids from identification file and associate raw file with them. /// </summary> /// <param name="idFilePath">Name of id file.</param> /// <param name="dataSetViewModel">Data Set View model to associate with id file.</param> /// <returns>Task for opening identification file.</returns> private async Task ReadIdFile(string idFilePath, DataSetViewModel dataSetViewModel) { bool attemptToReadFile = true; var modIgnoreList = new List <string>(); do { try { await this.dataReader.OpenDataSet( dataSetViewModel, dataSetViewModel.Title, idFilePath, modIgnoreList : modIgnoreList); attemptToReadFile = false; } catch (IcFileReader.InvalidModificationNameException e) { // file contains an unknown modification var result = this.dialogService.ConfirmationBox( string.Format( "{0}\nWould you like to add this modification?\nIf not, all sequences containing this modification will be ignored.", e.Message), "Unknown Modification"); if (!result || !this.RegisterNewModification(e.ModificationName, true)) { modIgnoreList.Add(e.ModificationName); } } catch (KeyNotFoundException e) { // file does not have correct headers this.dialogService.ExceptionAlert(e); return; } catch (IOException e) { // unable to read or open file. this.dialogService.ExceptionAlert(e); return; } catch (Exception e) { // Most likely trying to open a synopsis file while missing some files. this.dialogService.ExceptionAlert(e); return; } }while (attemptToReadFile); var identifications = dataSetViewModel.ScanViewModel.Data.Where(p => p.Sequence.Count > 0).ToList(); this.RegisterUnknownModifications(this.dataReader.Modifications); this.ScanViewModel.Data.AddRange(identifications); foreach (var id in identifications) { if (!this.ScanViewModel.IdTree.Proteins.ContainsKey(id.ProteinName)) { this.ScanViewModel.IdTree.AddFastaEntry(new FastaEntry() { ProteinName = id.ProteinName, ProteinDescription = id.ProteinDesc, ProteinSequence = id.Sequence, ProteinSequenceText = id.SequenceText }); } } }
public ActionResult Add() { DataSetViewModel dsview = new DataSetViewModel(); return(View(dsview)); }
public async Task <IActionResult> Post() { if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType)) { return(BadRequest("Did not get multipart data")); } var formAccumulator = new KeyValueAccumulator(); string targetFilePath = null; string fileName = Guid.NewGuid().ToString().Trim(); string fileExtension = ""; var boundry = MultipartRequestHelper.GetBoundry(MediaTypeHeaderValue.Parse(Request.ContentType), defaultFormOptions.MultipartBoundaryLengthLimit); var reader = new MultipartReader(boundry, HttpContext.Request.Body); var section = await reader.ReadNextSectionAsync(); while (section != null) { ContentDispositionHeaderValue contentDisposition; var hasContentDisposition = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition); if (hasContentDisposition) { if (MultipartRequestHelper.HasFileContentDispostion(contentDisposition)) { fileExtension = Path.GetExtension(HeaderUtilities.RemoveQuotes(contentDisposition.FileName) + "").Trim(); targetFilePath = Path.Combine("DataSets", fileName) + fileExtension; using (var targetStream = System.IO.File.Create(targetFilePath)) { await section.Body.CopyToAsync(targetStream); } } else if (MultipartRequestHelper.HasFormDataContentDispostion(contentDisposition)) { var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name); var encoding = GetEncoding(section); using (var streamReader = new StreamReader( section.Body, encoding, detectEncodingFromByteOrderMarks: true, bufferSize: 1024, leaveOpen: true)) { var value = await streamReader.ReadToEndAsync(); if (string.Equals(value, "undefined", StringComparison.OrdinalIgnoreCase)) { value = string.Empty; } formAccumulator.Append(key + "", value); if (formAccumulator.ValueCount > defaultFormOptions.ValueCountLimit) { throw new InvalidDataException("Form key limit exceeded"); } } } } section = await reader.ReadNextSectionAsync(); } var dataSet = new DataSetViewModel(); var formValueProvider = new FormValueProvider(BindingSource.Form, new FormCollection(formAccumulator.GetResults()), CultureInfo.CurrentCulture); var bindingSuccessful = await TryUpdateModelAsync(dataSet, prefix : "", valueProvider : formValueProvider); if (bindingSuccessful) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } else { var _id = Guid.Parse(userManager.GetUserId(User)); Profile profile = dataCenterContext.Profiles.Where(x => x.Id == _id).First(); DataSet myDataSet = new DataSet { Id = Guid.Parse(fileName), Name = dataSet.Name, Description = dataSet.Description, URL = "/DataSets/" + fileName + fileExtension }; ProfileDataSet profileDataSet = new ProfileDataSet { DataSet = myDataSet, Profile = profile }; dataCenterContext.Add(profileDataSet); dataCenterContext.SaveChanges(); } } return(Ok("/DataSets/" + fileName + fileExtension)); }