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