protected int CompareTo(MsDataFilePath other)
{
// Culture specific sorting desirable in file paths
// ReSharper disable StringCompareToIsCultureSpecific
int result = FilePath.CompareTo(other.FilePath);
if (result != 0)
{
return(result);
}
result = SampleName.CompareTo(other.SampleName);
if (result != 0)
{
return(result);
}
result = SampleIndex.CompareTo(other.SampleIndex);
if (result != 0)
{
return(result);
}
result = CentroidMs1.CompareTo(other.CentroidMs1);
if (result != 0)
{
return(result);
}
result = CentroidMs2.CompareTo(other.CentroidMs2);
if (result != 0)
{
return(result);
}
return(LockMassParameters.CompareTo(other.LockMassParameters));
// ReSharper restore StringCompareToIsCultureSpecific
}
public static MsDataFileUri Parse(string url)
{
if (url.StartsWith(UnifiUrl.UrlPrefix))
{
return(new UnifiUrl(url));
}
return(MsDataFilePath.ParseUri(url));
}
protected MsDataFilePath(MsDataFilePath msDataFilePath)
{
FilePath = msDataFilePath.FilePath;
SampleName = msDataFilePath.SampleName;
SampleIndex = msDataFilePath.SampleIndex;
LockMassParameters = msDataFilePath.LockMassParameters;
CentroidMs1 = msDataFilePath.CentroidMs1;
CentroidMs2 = msDataFilePath.CentroidMs2;
}
protected bool Equals(MsDataFilePath other)
{
return(string.Equals(FilePath, other.FilePath) &&
string.Equals(SampleName, other.SampleName) &&
SampleIndex == other.SampleIndex &&
CentroidMs1 == other.CentroidMs1 &&
CentroidMs2 == other.CentroidMs2 &&
LockMassParameters.Equals(other.LockMassParameters));
}
protected MsDataFilePath(MsDataFilePath msDataFilePath)
{
FilePath = msDataFilePath.FilePath;
SampleName = msDataFilePath.SampleName;
SampleIndex = msDataFilePath.SampleIndex;
LockMassParameters = msDataFilePath.LockMassParameters;
LegacyCentroidMs1 = msDataFilePath.LegacyCentroidMs1;
LegacyCentroidMs2 = msDataFilePath.LegacyCentroidMs2;
LegacyCombineIonMobilitySpectra = msDataFilePath.LegacyCombineIonMobilitySpectra;
}
protected bool Equals(MsDataFilePath other)
{
return(string.Equals(FilePath, other.FilePath) &&
string.Equals(SampleName, other.SampleName) &&
SampleIndex == other.SampleIndex &&
LegacyCentroidMs1 == other.LegacyCentroidMs1 &&
LegacyCentroidMs2 == other.LegacyCentroidMs2 &&
LegacyCombineIonMobilitySpectra == other.LegacyCombineIonMobilitySpectra &&
LockMassParameters.Equals(other.LockMassParameters));
}
public static MsDataFileUri GetExistingDataFilePath(string cachePath, MsDataFileUri msDataFileUri)
{
MsDataFilePath msDataFilePath = msDataFileUri as MsDataFilePath;
if (null == msDataFilePath)
{
return(msDataFileUri);
}
string dataFilePathPartIgnore;
return(GetExistingDataFilePath(cachePath, msDataFilePath, out dataFilePathPartIgnore));
}
public ChorusResponseChromDataProvider(SrmDocument document, ChromFileInfo chromFileInfo, IProgressStatus progressStatus, int startPercent,
int endPercent, ILoadMonitor loader) : base(chromFileInfo, progressStatus, startPercent, endPercent, loader)
{
ChromatogramCache.RawData rawData;
MsDataFilePath msDataFilePath = (MsDataFilePath)chromFileInfo.FilePath;
IPooledStream stream = loader.StreamManager.CreatePooledStream(msDataFilePath.FilePath, false);
ChromatogramCache.LoadStructs(stream.Stream, out rawData);
var chromCacheFile = rawData.ChromCacheFiles[0];
rawData.ChromCacheFiles = new[]
{
new ChromCachedFile(chromFileInfo.FilePath, chromCacheFile.Flags, chromCacheFile.FileWriteTime,
chromCacheFile.RunStartTime, chromCacheFile.MaxRetentionTime, chromCacheFile.MaxIntensity,
chromCacheFile.InstrumentInfoList),
};
var cache = new ChromatogramCache("cachePath", rawData, stream); // Not L10N
_cachedChromatogramDataProvider = new CachedChromatogramDataProvider(cache, document,
chromFileInfo.FilePath, chromFileInfo, null, progressStatus, startPercent, endPercent, loader);
}
/// <summary>
/// Gets a full MSDataFile path to an existing file. If the original path is not found to
/// exist, the folder containing the chromatogram cache is tried with the filename part.
/// </summary>
/// <param name="cachePath">The path to the cache file</param>
/// <param name="dataFilePath">A full MSDataFile path, potentially including a sample part</param>
/// <param name="dataFilePathPart">A file path only to an existing file</param>
/// <returns>A full MSDataFile path, potentially including a sample part, to an existing file, or null if no file is found</returns>
public static MsDataFilePath GetExistingDataFilePath(string cachePath, MsDataFilePath dataFilePath, out string dataFilePathPart)
{
// Check file (directory for Waters) existence, because ProteoWizard can hang on this
if (File.Exists(dataFilePath.FilePath) || Directory.Exists(dataFilePath.FilePath))
{
dataFilePathPart = dataFilePath.FilePath;
return(dataFilePath);
}
string dataFileName = Path.GetFileName(dataFilePath.FilePath);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (null != dataFileName)
{
// Check the most common case where the file is in the same directory
// where the cache is being written.
// Also, for tests, check Program.ExtraRawFileSearchFolder
foreach (string folder in new[] {
Path.GetDirectoryName(cachePath),
Program.ExtraRawFileSearchFolder
})
{
if (null == folder)
{
continue;
}
var pathToCheck = Path.Combine(folder, dataFileName);
if (File.Exists(pathToCheck) || Directory.Exists(pathToCheck))
{
dataFilePathPart = pathToCheck;
return(dataFilePath.SetFilePath(pathToCheck));
}
}
}
dataFilePathPart = dataFilePath.FilePath;
return(null);
}
protected bool Equals(MsDataFilePath other)
{
return string.Equals(FilePath, other.FilePath) &&
string.Equals(SampleName, other.SampleName) &&
SampleIndex == other.SampleIndex &&
CentroidMs1 == other.CentroidMs1 &&
CentroidMs2 == other.CentroidMs2 &&
LockMassParameters.Equals(other.LockMassParameters);
}
/// <summary>
/// Gets a full MSDataFile path to an existing file. If the original path is not found to
/// exist, the folder containing the chromatogram cache is tried with the filename part.
/// </summary>
/// <param name="cachePath">The path to the cache file</param>
/// <param name="dataFilePath">A full MSDataFile path, potentially including a sample part</param>
/// <param name="dataFilePathPart">A file path only to an existing file</param>
/// <returns>A full MSDataFile path, potentially including a sample part, to an existing file, or null if no file is found</returns>
public static MsDataFilePath GetExistingDataFilePath(string cachePath, MsDataFilePath dataFilePath, out string dataFilePathPart)
{
// Check file (directory for Waters) existence, because ProteoWizard can hang on this
if (File.Exists(dataFilePath.FilePath) || Directory.Exists(dataFilePath.FilePath))
{
dataFilePathPart = dataFilePath.FilePath;
return dataFilePath;
}
string dataFileName = Path.GetFileName(dataFilePath.FilePath);
if (null != dataFileName)
{
// Check the most common case where the file is in the same directory
// where the cache is being written.
// Also, for tests, check Program.ExtraRawFileSearchFolder
foreach (string folder in new[] {
Path.GetDirectoryName(cachePath),
Program.ExtraRawFileSearchFolder })
{
if (null == folder)
{
continue;
}
var pathToCheck = Path.Combine(folder, dataFileName);
if (File.Exists(pathToCheck) || Directory.Exists(pathToCheck))
{
dataFilePathPart = pathToCheck;
return dataFilePath.SetFilePath(pathToCheck);
}
}
}
dataFilePathPart = dataFilePath.FilePath;
return null;
}
public void ConsoleMultiReplicateImportTest()
{
bool useRaw = ExtensionTestContext.CanImportThermoRaw && ExtensionTestContext.CanImportWatersRaw;
string testZipPath = useRaw
? @"TestA\ImportAllCmdLineTest.zip"
: @"TestA\ImportAllCmdLineTestMzml.zip";
string extRaw = useRaw
? ".raw"
: ".mzML";
var testFilesDir = new TestFilesDir(TestContext, testZipPath);
// Contents:
// ImportAllCmdLineTest
// -- REP01
// -- CE_Vantage_15mTorr_0001_REP1_01.raw|mzML
// -- CE_Vantage_15mTorr_0001_REP1_02.raw|mzML
// -- REP02
// -- CE_Vantage_15mTorr_0001_REP2_01.raw|mzML
// -- CE_Vantage_15mTorr_0001_REP2_02.raw|mzML
// -- 160109_Mix1_calcurve_070.mzML
// -- 160109_Mix1_calcurve_073.mzML
// -- 160109_Mix1_calcurve_071.raw (Waters .raw directory)
// -- 160109_Mix1_calcurve_074.raw (Waters .raw directory)
// -- bad_file.raw (Should not be imported. Only in ImportAllCmdLineTest.zip)
// -- bad_file_folder
// -- bad_file.raw (Should not be imported. Only in ImportAllCmdLineTest.zip)
// -- FullScan.RAW|mzML (should not be imported)
// -- FullScan_folder
// -- FullScan.RAW|mzML (should not be imported)
var docPath = testFilesDir.GetTestPath("test.sky");
var outPath1 = testFilesDir.GetTestPath("Imported_multiple1.sky");
FileEx.SafeDelete(outPath1);
var outPath2 = testFilesDir.GetTestPath("Imported_multiple2.sky");
FileEx.SafeDelete(outPath2);
var outPath3 = testFilesDir.GetTestPath("Imported_multiple3.sky");
FileEx.SafeDelete(outPath3);
var rawPath = new MsDataFilePath(testFilesDir.GetTestPath(@"REP01\CE_Vantage_15mTorr_0001_REP1_01" + extRaw));
// Test: Cannot use --import-file and --import-all options simultaneously
var msg = RunCommand("--in=" + docPath,
"--import-file=" + rawPath.FilePath,
"--import-replicate-name=Unscheduled01",
"--import-all=" + testFilesDir.FullPath,
"--out=" + outPath1);
Assert.IsTrue(msg.Contains(Resources.CommandArgs_ParseArgsInternal_Error____import_file_and___import_all_options_cannot_be_used_simultaneously_), msg);
// output file should not exist
Assert.IsFalse(File.Exists(outPath1));
// Test: Cannot use --import-replicate-name with --import-all
msg = RunCommand("--in=" + docPath,
"--import-replicate-name=Unscheduled01",
"--import-all=" + testFilesDir.FullPath,
"--out=" + outPath1);
Assert.IsTrue(msg.Contains(Resources.CommandArgs_ParseArgsInternal_Error____import_replicate_name_cannot_be_used_with_the___import_all_option_), msg);
// output file should not exist
Assert.IsFalse(File.Exists(outPath1));
// Test: Cannot use --import-naming-pattern with --import-file
msg = RunCommand("--in=" + docPath,
"--import-file=" + rawPath.FilePath,
"--import-naming-pattern=prefix_(.*)",
"--out=" + outPath1);
Assert.IsTrue(msg.Contains(Resources.CommandArgs_ParseArgsInternal_Error____import_naming_pattern_cannot_be_used_with_the___import_file_option_), msg);
// output file should not exist
Assert.IsFalse(File.Exists(outPath1));
// Test: invalid regular expression (1)
msg = RunCommand("--in=" + docPath,
"--import-all=" + testFilesDir.FullPath,
"--import-naming-pattern=A",
"--out=" + outPath1);
// output file should not exist
Assert.IsFalse(File.Exists(outPath1));
Assert.IsTrue(msg.Contains(string.Format(Resources.CommandArgs_ParseArgsInternal_Error__Regular_expression___0___does_not_have_any_groups___String, "A")), msg);
// Test: invalid regular expression (2)
msg = RunCommand("--in=" + docPath,
"--import-all=" + testFilesDir.FullPath,
"--import-naming-pattern=invalid",
"--out=" + outPath1);
// output file should not exist
Assert.IsTrue(!File.Exists(outPath1));
Assert.IsTrue(msg.Contains(string.Format(Resources.CommandArgs_ParseArgsInternal_Error__Regular_expression___0___does_not_have_any_groups___String, "invalid")), msg);
// Test: Import files in the "REP01" directory;
// Use a naming pattern that will cause the replicate names of the two files to be the same
msg = RunCommand("--in=" + docPath,
"--import-all=" + testFilesDir.GetTestPath("REP01"),
"--import-naming-pattern=.*_(REP[0-9]+)_(.+)",
"--out=" + outPath1);
Assert.IsFalse(File.Exists(outPath1));
Assert.IsTrue(msg.Contains(string.Format(Resources.CommandLine_ApplyNamingPattern_Error__Duplicate_replicate_name___0___after_applying_regular_expression_,"REP1")), msg);
// Test: Import files in the "REP01" directory; Use a naming pattern
msg = RunCommand("--in=" + docPath,
"--import-all=" + testFilesDir.GetTestPath("REP01"),
"--import-naming-pattern=.*_([0-9]+)",
"--out=" + outPath1);
Assert.IsTrue(File.Exists(outPath1), msg);
SrmDocument doc = ResultsUtil.DeserializeDocument(outPath1);
Assert.AreEqual(2, doc.Settings.MeasuredResults.Chromatograms.Count);
Assert.IsTrue(doc.Settings.MeasuredResults.ContainsChromatogram("01"));
Assert.IsTrue(doc.Settings.MeasuredResults.ContainsChromatogram("02"));
Assert.IsFalse(File.Exists(outPath2));
// Test: Import a single file
// Import REP01\CE_Vantage_15mTorr_0001_REP1_01.raw;
// Use replicate name "REP01"
msg = RunCommand("--in=" + docPath,
"--import-file=" + rawPath.FilePath,
"--import-replicate-name=REP01",
"--out=" + outPath2);
Assert.IsTrue(File.Exists(outPath2), msg);
doc = ResultsUtil.DeserializeDocument(outPath2);
Assert.AreEqual(1, doc.Settings.MeasuredResults.Chromatograms.Count);
int initialFileCount = 0;
foreach (var chromatogram in doc.Settings.MeasuredResults.Chromatograms)
{
initialFileCount += chromatogram.MSDataFilePaths.Count();
}
// Import another single file.
var rawPath2 = MsDataFileUri.Parse(testFilesDir.GetTestPath("160109_Mix1_calcurve_070.mzML"));
msg = RunCommand("--in=" + outPath2,
"--import-file=" + rawPath2.GetFilePath(),
"--import-replicate-name=160109_Mix1_calcurve_070",
"--save");
doc = ResultsUtil.DeserializeDocument(outPath2);
Assert.AreEqual(2, doc.Settings.MeasuredResults.Chromatograms.Count, msg);
ChromatogramSet chromatSet;
int idx;
doc.Settings.MeasuredResults.TryGetChromatogramSet("160109_Mix1_calcurve_070", out chromatSet, out idx);
Assert.IsNotNull(chromatSet, msg);
Assert.IsTrue(chromatSet.MSDataFilePaths.Contains(rawPath2));
// Test: Import all files and sub-folders in test directory
// The document should already contain a replicate named "REP01".
// Only one more file should be added to the "REP01" replicate.
// The document should also already contain replicate "160109_Mix1_calcurve_070".
// There should be notes about ignoring the two files that are already in the document.
msg = RunCommand("--in=" + outPath2,
"--import-all=" + testFilesDir.FullPath,
"--save");
// ExtensionTestContext.ExtThermo raw uses different case from file on disk
// which happens to make a good test case.
MsDataFilePath rawPathDisk = GetThermoDiskPath(rawPath);
// These messages are due to files that were already in the document.
Assert.IsTrue(msg.Contains(string.Format(Resources.CommandLine_RemoveImportedFiles__0______1___Note__The_file_has_already_been_imported__Ignoring___, "REP01", rawPathDisk)), msg);
Assert.IsTrue(msg.Contains(string.Format(Resources.CommandLine_RemoveImportedFiles__0______1___Note__The_file_has_already_been_imported__Ignoring___, "160109_Mix1_calcurve_070", rawPath2)), msg);
// Assert.IsTrue(msg.Contains(string.Format("160109_Mix1_calcurve_070 -> {0}",rawPath2)), msg);
doc = ResultsUtil.DeserializeDocument(outPath2);
Assert.IsTrue(doc.Settings.HasResults);
Assert.AreEqual(6, doc.Settings.MeasuredResults.Chromatograms.Count,
string.Format("Expected 6 replicates, found: {0}",
string.Join(", ", doc.Settings.MeasuredResults.Chromatograms.Select(chromSet => chromSet.Name).ToArray())));
// count the number of files imported into the document
int totalImportedFiles = 0;
foreach (var chromatogram in doc.Settings.MeasuredResults.Chromatograms)
{
totalImportedFiles += chromatogram.MSDataFilePaths.Count();
}
// We should have imported 7 more file
Assert.AreEqual(initialFileCount + 7, totalImportedFiles);
// In the "REP01" replicate we should have 2 files
ChromatogramSet chromatogramSet;
int index;
doc.Settings.MeasuredResults.TryGetChromatogramSet("REP01", out chromatogramSet, out index);
Assert.IsNotNull(chromatogramSet);
Assert.IsTrue(chromatogramSet.MSDataFilePaths.Count() == 2);
Assert.IsTrue(chromatogramSet.MSDataFilePaths.Contains(rawPath));
Assert.IsTrue(chromatogramSet.MSDataFilePaths.Contains(
new MsDataFilePath(testFilesDir.GetTestPath(@"REP01\CE_Vantage_15mTorr_0001_REP1_01" +
extRaw))));
Assert.IsTrue(!useRaw || chromatogramSet.MSDataFilePaths.Contains(
GetThermoDiskPath(new MsDataFilePath(testFilesDir.GetTestPath(@"REP01\CE_Vantage_15mTorr_0001_REP1_02" + extRaw)))));
Assert.IsFalse(File.Exists(outPath3));
// Test: Import a single file
// Import 160109_Mix1_calcurve_074.raw;
// Use replicate name "REP01"
var rawPath3 = testFilesDir.GetTestPath("160109_Mix1_calcurve_074" + extRaw);
msg = RunCommand("--in=" + docPath,
"--import-file=" + rawPath3,
"--import-replicate-name=REP01",
"--out=" + outPath3);
Assert.IsTrue(File.Exists(outPath3), msg);
doc = ResultsUtil.DeserializeDocument(outPath3);
Assert.AreEqual(1, doc.Settings.MeasuredResults.Chromatograms.Count);
// Now import all files and sub-folders in test directory.
// This should return an error since the replicate "REP01" that already
// exists in the document has an unexpected file: '160109_Mix1_calcurve_074.raw'.
msg = RunCommand("--in=" + outPath3,
"--import-all=" + testFilesDir.FullPath,
"--save");
Assert.IsTrue(
msg.Contains(
string.Format(
Resources.CommandLine_CheckReplicateFiles_Error__Replicate__0__in_the_document_has_an_unexpected_file__1__,"REP01",
rawPath3)), msg);
}
private static MsDataFilePath GetThermoDiskPath(MsDataFilePath pathToRaw)
{
return ExtensionTestContext.CanImportThermoRaw && ExtensionTestContext.CanImportWatersRaw
? pathToRaw.SetFilePath(Path.ChangeExtension(pathToRaw.FilePath, "raw"))
: pathToRaw;
}
private void sourcePathTextBox_KeyUp( object sender, KeyEventArgs e )
{
switch( e.KeyCode )
{
case Keys.Enter:
if( Directory.Exists( sourcePathTextBox.Text ) )
CurrentDirectory = new MsDataFilePath(sourcePathTextBox.Text);
else if( CurrentDirectory is MsDataFilePath && Directory.Exists( Path.Combine( ((MsDataFilePath) CurrentDirectory).FilePath, sourcePathTextBox.Text ) ) )
CurrentDirectory = new MsDataFilePath(Path.Combine(((MsDataFilePath)CurrentDirectory).FilePath, sourcePathTextBox.Text));
else if (CurrentDirectory is MsDataFilePath)
{
// check that all manually-entered paths are valid
string[] sourcePaths = sourcePathTextBox.Text.Split(" ".ToCharArray()); // Not L10N
List<string> invalidPaths = new List<string>();
foreach( string path in sourcePaths )
if( !File.Exists( path ) && !File.Exists( Path.Combine( ((MsDataFilePath)CurrentDirectory).FilePath, path ) ) )
invalidPaths.Add( path );
if( invalidPaths.Count == 0 )
{
DataSources = sourcePaths.Select(MsDataFileUri.Parse).ToArray();
DialogResult = DialogResult.OK;
Close();
}
else
{
MessageBox.Show(this, TextUtil.LineSeparate(invalidPaths),
Resources.OpenDataSourceDialog_sourcePathTextBox_KeyUp_Some_source_paths_are_invalid);
}
}
break;
case Keys.F5:
_abortPopulateList = true;
populateListViewFromDirectory( _currentDirectory ); // refresh
break;
}
}
private void ImportResults(string prefix, string[] paths, string optimization, bool addNew = true)
{
var importResultsDlg = ShowDialog<ImportResultsDlg>(SkylineWindow.ImportResults);
RunUI(() =>
{
if (addNew)
{
importResultsDlg.RadioAddNewChecked = true;
importResultsDlg.ReplicateName = prefix;
importResultsDlg.OptimizationName = optimization;
}
var files = new MsDataFileUri[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
files[i] = new MsDataFilePath(GetTestPath(paths[i]));
}
var keyPair = new KeyValuePair<string, MsDataFileUri[]>(prefix, files);
KeyValuePair<string, MsDataFileUri[]>[] pathHolder = addNew
? new[] {keyPair}
: importResultsDlg.GetDataSourcePathsFileReplicates(files);
importResultsDlg.NamedPathSets = pathHolder;
});
if (addNew)
OkDialog(importResultsDlg, importResultsDlg.OkDialog);
else
{
var keepPrefixDlg = ShowDialog<ImportResultsNameDlg>(importResultsDlg.OkDialog);
RunUI(keepPrefixDlg.NoDialog);
WaitForClosedForm(keepPrefixDlg);
WaitForClosedForm(importResultsDlg);
}
WaitForDocumentLoaded();
}
private void upOneLevelButton_Click( object sender, EventArgs e )
{
MsDataFileUri parent = null;
var chorusUrl = _currentDirectory as ChorusUrl;
var dataFilePath = _currentDirectory as MsDataFilePath;
if (chorusUrl != null)
{
parent = chorusUrl.GetParent();
}
else if (dataFilePath != null && !string.IsNullOrEmpty(dataFilePath.FilePath))
{
DirectoryInfo parentDirectory = Directory.GetParent(dataFilePath.FilePath);
if (parentDirectory != null)
{
parent = new MsDataFilePath(parentDirectory.FullName);
}
}
if (null != parent && !Equals(parent, _currentDirectory))
{
_previousDirectories.Push(_currentDirectory);
CurrentDirectory = parent;
}
}
protected int CompareTo(MsDataFilePath other)
{
// Culture specific sorting desirable in file paths
// ReSharper disable StringCompareToIsCultureSpecific
int result = FilePath.CompareTo(other.FilePath);
if (result != 0)
return result;
result = SampleName.CompareTo(other.SampleName);
if (result != 0)
return result;
result = SampleIndex.CompareTo(other.SampleIndex);
if (result != 0)
return result;
result = CentroidMs1.CompareTo(other.CentroidMs1);
if (result != 0)
return result;
result = CentroidMs2.CompareTo(other.CentroidMs2);
if (result != 0)
return result;
return LockMassParameters.CompareTo(other.LockMassParameters);
// ReSharper restore StringCompareToIsCultureSpecific
}
protected MsDataFilePath(MsDataFilePath msDataFilePath)
{
FilePath = msDataFilePath.FilePath;
SampleName = msDataFilePath.SampleName;
SampleIndex = msDataFilePath.SampleIndex;
LockMassParameters = msDataFilePath.LockMassParameters;
CentroidMs1 = msDataFilePath.CentroidMs1;
CentroidMs2 = msDataFilePath.CentroidMs2;
}
private void myDocumentsButton_Click( object sender, EventArgs e )
{
CurrentDirectory = new MsDataFilePath(Environment.GetFolderPath( Environment.SpecialFolder.MyDocuments ));
}
private void desktopButton_Click( object sender, EventArgs e )
{
CurrentDirectory = new MsDataFilePath(Environment.GetFolderPath( Environment.SpecialFolder.DesktopDirectory ));
}
private void ImportFoundResultsFiles(CommandArgs commandArgs, ImportPeptideSearch import)
{
foreach (var resultFile in import.GetFoundResultsFiles())
{
var filePath = new MsDataFilePath(resultFile.Path);
if (!_doc.Settings.HasResults || _doc.Settings.MeasuredResults.FindMatchingMSDataFile(filePath) == null)
{
if (!ImportResultsFile(filePath.ChangeParameters(_doc, commandArgs.LockMassParameters), resultFile.Name, null, null, null))
break; // Lots of work completed, still want to save
}
}
}
private bool ParseArgsInternal(IEnumerable<string> args)
{
foreach (string s in args)
{
var pair = new NameValuePair(s);
if (string.IsNullOrEmpty(pair.Name))
continue;
if (IsNameOnly(pair, "ui")) // Not L10N
{
// Handled by Program
}
else if (IsNameOnly(pair, "hideacg")) // Not L10N
{
HideAllChromatogramsGraph = true;
}
else if (IsNameOnly(pair, "noacg")) // Not L10N
{
NoAllChromatogramsGraph = true;
}
else if (IsNameValue(pair, "in")) // Not L10N
{
SkylineFile = GetFullPath(pair.Value);
// Set requiresInCommand to be true so if SkylineFile is null or empty it still complains.
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "dir")) // Not L10N
{
if (!Directory.Exists(pair.Value))
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__The_specified_working_directory__0__does_not_exist_, pair.Value);
return false;
}
Directory.SetCurrentDirectory(pair.Value);
}
else if (IsNameOnly(pair, "timestamp")) // Not L10N
{
_out.IsTimeStamped = true;
}
// A command that exports all the tools to a text file in a SkylineRunner form for --batch-commands
// Not advertised.
// ReSharper disable NonLocalizedString
else if (IsNameValue(pair, "tool-list-export"))
{
string pathToOutputFile = pair.Value;
using (StreamWriter sw = new StreamWriter(pathToOutputFile))
{
foreach (var tool in Settings.Default.ToolList)
{
string command = "--tool-add=" + "\"" + tool.Title + "\"" +
" --tool-command=" + "\"" + tool.Command + "\"" +
" --tool-arguments=" + "\"" + tool.Arguments + "\"" +
" --tool-initial-dir=" + "\"" + tool.InitialDirectory + "\"" +
" --tool-conflict-resolution=skip" +
" --tool-report=" + "\"" + tool.ReportTitle + "\"";
if (tool.OutputToImmediateWindow)
command += " --tool-output-to-immediate-window";
sw.WriteLine(command);
}
}
}
// ReSharper restore NonLocalizedString
// Import a skyr file.
else if (IsNameValue(pair, "report-add")) // Not L10N
{
ImportingSkyr = true;
SkyrPath = pair.Value;
}
else if (IsNameValue(pair, "report-conflict-resolution")) // Not L10N
{
string input = pair.Value.ToLowerInvariant();
if (input == "overwrite") // Not L10N
{
ResolveSkyrConflictsBySkipping = false;
}
if (input == "skip") // Not L10N
{
ResolveSkyrConflictsBySkipping = true;
}
}
else if (IsNameValue(pair, ARG_FULL_SCAN_PRECURSOR_RES))
{
RequiresSkylineDocument = true;
FullScanPrecursorRes = ParseDouble(pair.Value, ARG_FULL_SCAN_PRECURSOR_RES);
if (!FullScanPrecursorRes.HasValue)
return false;
}
else if (IsNameValue(pair, ARG_FULL_SCAN_PRECURSOR_RES_MZ))
{
RequiresSkylineDocument = true;
FullScanPrecursorResMz = ParseDouble(pair.Value, ARG_FULL_SCAN_PRECURSOR_RES_MZ);
if (!FullScanPrecursorResMz.HasValue)
return false;
}
else if (IsNameValue(pair, ARG_FULL_SCAN_PRODUCT_RES))
{
RequiresSkylineDocument = true;
FullScanProductRes = ParseDouble(pair.Value, ARG_FULL_SCAN_PRODUCT_RES);
if (!FullScanProductRes.HasValue)
return false;
}
else if (IsNameValue(pair, ARG_FULL_SCAN_PRODUCT_RES_MZ))
{
RequiresSkylineDocument = true;
FullScanProductResMz = ParseDouble(pair.Value, ARG_FULL_SCAN_PRODUCT_RES_MZ);
if (!FullScanProductResMz.HasValue)
return false;
}
else if (IsNameValue(pair, ARG_FULL_SCAN_RT_FILTER_TOLERANCE))
{
RequiresSkylineDocument = true;
FullScanRetentionTimeFilterLength = ParseDouble(pair.Value, ARG_FULL_SCAN_RT_FILTER_TOLERANCE);
if (!FullScanRetentionTimeFilterLength.HasValue)
return false;
}
else if (IsNameValue(pair, "tool-add-zip")) // Not L10N
{
InstallingToolsFromZip = true;
ZippedToolsPath = pair.Value;
}
else if (IsNameValue(pair, "tool-zip-conflict-resolution")) // Not L10N
{
string input = pair.Value.ToLowerInvariant();
if (input == "overwrite") // Not L10N
{
ResolveZipToolConflictsBySkipping = CommandLine.ResolveZipToolConflicts.overwrite;
}
if (input == "parallel") // Not L10N
{
ResolveZipToolConflictsBySkipping = CommandLine.ResolveZipToolConflicts.in_parallel;
}
}
else if (IsNameValue(pair, "tool-zip-overwrite-annotations")) // Not L10N
{
string input = pair.Value.ToLowerInvariant();
if (input == "true") // Not L10N
{
ResolveZipToolAnotationConflictsBySkipping = true;
}
if (input == "false") // Not L10N
{
ResolveZipToolAnotationConflictsBySkipping = false;
}
}
else if (IsNameValue(pair, "tool-program-macro")) // example --tool-program-macro=R,2.15.2 // Not L10N
{
string [] spliced = pair.Value.Split(',');
if (spliced.Count() > 2)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__Incorrect_Usage_of_the___tool_program_macro_command_);
}
else
{
string programName = spliced[0];
string programVersion = null;
if (spliced.Count() > 1)
{
// Extract the version if specified.
programVersion = spliced[1];
}
ZippedToolsProgramPathContainer = new ProgramPathContainer(programName, programVersion);
}
}
// ReSharper disable NonLocalizedString
else if (IsNameValue(pair, "tool-program-path"))
{
ZippedToolsProgramPathValue = pair.Value;
}
else if (IsNameOnly(pair, "tool-ignore-required-packages"))
{
ZippedToolsPackagesHandled = true;
}
else if (IsNameValue(pair, "tool-add"))
{
ImportingTool = true;
ToolName = pair.Value;
}
else if (IsNameValue(pair, "tool-command"))
{
ImportingTool = true;
ToolCommand = pair.Value;
}
else if (IsNameValue(pair, "tool-arguments"))
{
ImportingTool = true;
ToolArguments = pair.Value;
}
else if (IsNameValue(pair, "tool-initial-dir"))
{
ImportingTool = true;
ToolInitialDirectory = pair.Value;
}
else if (IsNameValue(pair, "tool-report"))
{
ImportingTool = true;
ToolReportTitle = pair.Value;
}
else if (IsNameOnly(pair, "tool-output-to-immediate-window"))
{
ImportingTool = true;
ToolOutputToImmediateWindow = true;
}
else if (IsNameValue(pair, "tool-conflict-resolution"))
{
string input = pair.Value.ToLowerInvariant();
if (input == "overwrite")
{
ResolveToolConflictsBySkipping = false;
}
if (input == "skip")
{
ResolveToolConflictsBySkipping = true;
}
}
else if (IsNameValue(pair, ARG_IMPORT_PEPTIDE_SEARCH_FILE))
{
RequiresSkylineDocument = true;
SearchResultsFiles.Add(GetFullPath(pair.Value));
CutoffScore = CutoffScore ?? Settings.Default.LibraryResultCutOff;
}
else if (IsNameValue(pair, ARG_IMPORT_PEPTIDE_SEARCH_CUTOFF))
{
double? cutoff;
try
{
cutoff = pair.ValueDouble;
if (cutoff < 0 || cutoff > 1)
{
cutoff = null;
}
}
catch
{
cutoff = null;
}
if (cutoff.HasValue)
{
CutoffScore = cutoff.Value;
}
else
{
var defaultScore = Settings.Default.LibraryResultCutOff;
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__The_cutoff_score__0__is_invalid__It_must_be_a_value_between_0_and_1_, pair.Value);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to__0__, defaultScore);
CutoffScore = defaultScore;
}
}
else if (IsNameOnly(pair, ARG_IMPORT_PEPTIDE_SEARCH_MODS))
{
AcceptAllModifications = true;
}
else if (IsNameOnly(pair, ARG_IMPORT_PEPTIDE_SEARCH_AMBIGUOUS))
{
IncludeAmbiguousMatches = true;
}
// Run each line of a text file like a SkylineRunner command
else if (IsNameValue(pair, "batch-commands"))
{
BatchCommandsPath = GetFullPath(pair.Value);
RunningBatchCommands = true;
}
else if (IsNameOnly(pair, "save"))
{
Saving = true;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "out"))
{
SaveFile = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "add-library-name"))
{
LibraryName = pair.Value;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "add-library-path"))
{
LibraryPath = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "import-fasta"))
{
FastaPath = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_IMPORT_TRANSITION_LIST))
{
TransitionListPath = GetFullPath(pair.Value);
IsTransitionListAssayLibrary = false;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_IMPORT_ASSAY_LIBRARY))
{
TransitionListPath = GetFullPath(pair.Value);
IsTransitionListAssayLibrary = true;
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, ARG_IGNORE_TRANSITION_ERRORS))
{
IsIgnoreTransitionErrors = true;
}
else if (IsNameValue(pair, ARG_IRT_STANDARDS_GROUP_NAME))
{
IrtGroupName = pair.Value;
}
else if (IsNameValue(pair, ARG_IRT_STANDARDS_FILE))
{
IrtStandardsPath = pair.Value;
}
else if (IsNameValue(pair, ARG_IRT_DATABASE_PATH))
{
IrtDatabasePath = pair.Value;
}
else if (IsNameValue(pair, ARG_IRT_CALC_NAME))
{
IrtCalcName = pair.Value;
}
else if (IsNameValue(pair, ARG_DECOYS_ADD))
{
if (pair.Value == "reversed")
AddDecoysType = DecoyGeneration.REVERSE_SEQUENCE;
else if (pair.Value == "shuffled")
AddDecoysType = DecoyGeneration.SHUFFLE_SEQUENCE;
else
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Invalid_value___0___for__1___use__reversed__or__shuffled__, pair.Value, ARG_DECOYS_ADD);
return false;
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_DECOYS_ADD_COUNT))
{
int count;
if (!int.TryParse(pair.Value, out count))
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__The_value___0___for__1__must_be_an_integer_, pair.Value, ARG_DECOYS_ADD_COUNT);
return false;
}
AddDecoysCount = count;
}
else if (IsNameOnly(pair, ARG_DECOYS_DISCARD))
{
DiscardDecoys = true;
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "keep-empty-proteins"))
{
KeepEmptyProteins = true;
}
else if (IsNameValue(pair, "import-file"))
{
if (pair.Value.StartsWith(ChorusUrl.ChorusUrlPrefix))
{
ReplicateFile = MsDataFileUri.Parse(pair.Value);
}
else
{
ReplicateFile = new MsDataFilePath(GetFullPath(pair.Value));
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "import-replicate-name"))
{
ReplicateName = pair.Value;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_IMPORT_LOCKMASS_POSITIVE))
{
LockmassPositive = ParseDouble(pair.Value, ARG_IMPORT_LOCKMASS_POSITIVE);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_IMPORT_LOCKMASS_NEGATIVE))
{
LockmassNegative = ParseDouble(pair.Value, ARG_IMPORT_LOCKMASS_NEGATIVE);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, ARG_IMPORT_LOCKMASS_TOLERANCE))
{
LockmassTolerance = ParseDouble(pair.Value, ARG_IMPORT_LOCKMASS_TOLERANCE);
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "import-append"))
{
ImportAppend = true;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "import-all"))
{
ImportSourceDirectory = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "import-no-join"))
{
ImportDisableJoining = true;
RequiresSkylineDocument = true;
}
// ReSharper restore NonLocalizedString
else if (IsNameValue(pair, "import-naming-pattern")) // Not L10N
{
var importNamingPatternVal = pair.Value;
RequiresSkylineDocument = true;
if (importNamingPatternVal != null)
{
try
{
ImportNamingPattern = new Regex(importNamingPatternVal);
}
catch (Exception e)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Regular_expression__0__cannot_be_parsed_, importNamingPatternVal);
_out.WriteLine(e.Message);
return false;
}
Match match = Regex.Match(importNamingPatternVal, @".*\(.+\).*"); // Not L10N
if (!match.Success)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Regular_expression___0___does_not_have_any_groups___String,
importNamingPatternVal);
return false;
}
}
}
else if (IsNameValue(pair, "import-optimizing")) // Not L10N
{
try
{
ImportOptimizeType = pair.Value;
}
catch (ArgumentException)
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__Invalid_optimization_parameter___0____Use__ce____dp___or__none____Defaulting_to_none_,
pair.Value);
}
}
else if (IsNameValue(pair, "import-before")) // Not L10N
{
var importBeforeDate = pair.Value;
if (importBeforeDate != null)
{
try
{
ImportBeforeDate = Convert.ToDateTime(importBeforeDate);
}
catch (Exception e)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Date__0__cannot_be_parsed_, importBeforeDate);
_out.WriteLine(e.Message);
return false;
}
}
}
else if (IsNameValue(pair, "import-on-or-after")) // Not L10N
{
var importAfterDate = pair.Value;
if (importAfterDate != null)
{
try
{
ImportOnOrAfterDate = Convert.ToDateTime(importAfterDate);
}
catch (Exception e)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Date__0__cannot_be_parsed_, importAfterDate);
_out.WriteLine(e.Message);
return false;
}
}
}
else if (IsNameValue(pair, "remove-all")) // Not L10N
{
RemovingResults = true;
RequiresSkylineDocument = true;
RemoveBeforeDate = null;
}
else if (IsNameValue(pair, "remove-before")) // Not L10N
{
var removeBeforeDate = pair.Value;
RemovingResults = true;
RequiresSkylineDocument = true;
if (removeBeforeDate != null)
{
try
{
RemoveBeforeDate = Convert.ToDateTime(removeBeforeDate);
}
catch (Exception e)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Date__0__cannot_be_parsed_, removeBeforeDate);
_out.WriteLine(e.Message);
return false;
}
}
}
else if (IsNameValue(pair, ARG_REINTEGRATE_MODEL_NAME))
{
ReintegratModelName = pair.Value;
}
else if (IsNameOnly(pair, ARG_REINTEGRATE_CREATE_MODEL))
{
IsCreateScoringModel = true;
if (!IsSecondBestModel)
IsDecoyModel = true;
}
else if (IsNameOnly(pair, ARG_REINTEGRATE_ANNOTATE_SCORING))
{
IsAnnotateScoring = true;
}
else if (IsNameOnly(pair, ARG_REINTEGRATE_OVERWRITE_PEAKS))
{
IsOverwritePeaks = true;
}
else if (IsNameOnly(pair, ARG_REINTEGRATE_MODEL_SECOND_BEST))
{
IsSecondBestModel = true;
IsDecoyModel = false;
}
else if (IsNameOnly(pair, ARG_REINTEGRATE_MODEL_BOTH))
{
IsSecondBestModel = IsDecoyModel = true;
}
else if (IsNameValue(pair, "report-name")) // Not L10N
{
ReportName = pair.Value;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "report-file")) // Not L10N
{
ReportFile = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "report-format")) // Not L10N
{
if (pair.Value.Equals("TSV", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
ReportColumnSeparator = TextUtil.SEPARATOR_TSV;
else if (pair.Value.Equals("CSV", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
ReportColumnSeparator = TextUtil.CsvSeparator;
else
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__The_report_format__0__is_invalid__It_must_be_either__CSV__or__TSV__,
pair.Value);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to_CSV_);
ReportColumnSeparator = TextUtil.CsvSeparator;
}
}
else if (IsName(pair, "report-invariant")) // Not L10N
{
IsReportInvariant = true;
}
else if (IsNameValue(pair, "chromatogram-file")) // Not L10N
{
ChromatogramsFile = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "chromatogram-precursors")) // Not L10N
{
ChromatogramsPrecursors = true;
}
else if (IsNameOnly(pair, "chromatogram-products")) // Not L10N
{
ChromatogramsProducts = true;
}
else if (IsNameOnly(pair, "chromatogram-base-peaks")) // Not L10N
{
ChromatogramsBasePeaks = true;
}
else if (IsNameOnly(pair, "chromatogram-tics")) // Not L10N
{
ChromatogramsTics = true;
}
else if (IsNameValue(pair, "exp-translist-instrument")) // Not L10N
{
try
{
TransListInstrumentType = pair.Value;
RequiresSkylineDocument = true;
}
catch (ArgumentException)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__The_instrument_type__0__is_not_valid__Please_choose_from_,
pair.Value);
foreach (string str in ExportInstrumentType.TRANSITION_LIST_TYPES)
{
_out.WriteLine(str);
}
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_No_transition_list_will_be_exported_);
}
}
else if (IsNameValue(pair, "exp-method-instrument")) // Not L10N
{
try
{
MethodInstrumentType = pair.Value;
RequiresSkylineDocument = true;
}
catch (ArgumentException)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__The_instrument_type__0__is_not_valid__Please_choose_from_,
pair.Value);
foreach (string str in ExportInstrumentType.METHOD_TYPES)
{
_out.WriteLine(str);
}
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_No_method_will_be_exported_);
}
}
else if (IsNameValue(pair, "exp-file")) // Not L10N
{
ExportPath = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-strategy")) // Not L10N
{
ExportStrategySet = true;
RequiresSkylineDocument = true;
string strategy = pair.Value;
if (strategy.Equals("single", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
{
//default
}
else if (strategy.Equals("protein", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
ExportStrategy = ExportStrategy.Protein;
else if (strategy.Equals("buckets", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
ExportStrategy = ExportStrategy.Buckets;
else
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__The_export_strategy__0__is_not_valid__It_must_be_one_of_the_following___string,
pair.Value);
//already set to Single
}
}
else if (IsNameValue(pair, "exp-method-type")) // Not L10N
{
var type = pair.Value;
RequiresSkylineDocument = true;
if (type.Equals("scheduled", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
{
ExportMethodType = ExportMethodType.Scheduled;
}
else if (type.Equals("triggered", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
{
ExportMethodType = ExportMethodType.Triggered;
}
else if (type.Equals("standard", StringComparison.CurrentCultureIgnoreCase)) // Not L10N
{
//default
}
else
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__The_method_type__0__is_invalid__It_must_be_one_of_the_following___standard____scheduled__or__triggered__,
pair.Value);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to_standard_);
}
}
else if (IsNameValue(pair, "exp-max-trans")) // Not L10N
{
//This one can't be kept within bounds because the bounds depend on the instrument
//and the document.
try
{
MaxTransitionsPerInjection = pair.ValueInt;
}
catch
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Warning__Invalid_max_transitions_per_injection_parameter___0___, pair.Value);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_It_must_be_a_number__Defaulting_to__0__, AbstractMassListExporter.MAX_TRANS_PER_INJ_DEFAULT);
MaxTransitionsPerInjection = AbstractMassListExporter.MAX_TRANS_PER_INJ_DEFAULT;
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-optimizing")) // Not L10N
{
try
{
ExportOptimizeType = pair.Value;
}
catch (ArgumentException)
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__Invalid_optimization_parameter___0____Use__ce____dp___or__none__,
pair.Value);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to_none_);
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-scheduling-replicate")) // Not L10N
{
SchedulingReplicate = pair.Value;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-template")) // Not L10N
{
TemplateFile = GetFullPath(pair.Value);
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "exp-ignore-proteins")) // Not L10N
{
IgnoreProteins = true;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-primary-count")) // Not L10N
{
try
{
PrimaryTransitionCount = pair.ValueInt;
}
catch
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__The_primary_transition_count__0__is_invalid__it_must_be_a_number_between__1__and__2__,
pair.Value,
AbstractMassListExporter.PRIMARY_COUNT_MIN, AbstractMassListExporter.PRIMARY_COUNT_MAX);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to__0__, AbstractMassListExporter.PRIMARY_COUNT_DEFAULT);
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-dwell-time")) // Not L10N
{
try
{
DwellTime = pair.ValueInt;
}
catch
{
_out.WriteLine(
Resources.CommandArgs_ParseArgsInternal_Warning__The_dwell_time__0__is_invalid__it_must_be_a_number_between__1__and__2__,
pair.Value,
AbstractMassListExporter.DWELL_TIME_MIN, AbstractMassListExporter.DWELL_TIME_MAX);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to__0__, AbstractMassListExporter.DWELL_TIME_DEFAULT);
}
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "exp-add-energy-ramp")) // Not L10N
{
AddEnergyRamp = true;
RequiresSkylineDocument = true;
}
else if (IsNameOnly(pair, "exp-use-s-lens")) // Not L10N
{
UseSlens = true;
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, "exp-run-length")) // Not L10N
{
try
{
RunLength = pair.ValueInt;
}
catch
{
_out.WriteLine(
Resources
.CommandArgs_ParseArgsInternal_Warning__The_run_length__0__is_invalid__It_must_be_a_number_between__1__and__2__,
pair.Value,
AbstractMassListExporter.RUN_LENGTH_MIN, AbstractMassListExporter.RUN_LENGTH_MAX);
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Defaulting_to__0__,
AbstractMassListExporter.RUN_LENGTH_DEFAULT);
}
RequiresSkylineDocument = true;
}
else if (IsNameValue(pair, PANORAMA_SERVER_URI))
{
PanoramaServerUri = pair.Value;
}
else if (IsNameValue(pair, PANORAMA_USERNAME))
{
PanoramaUserName = pair.Value;
}
else if (IsNameValue(pair, PANORAMA_PASSWD))
{
PanoramaPassword = pair.Value;
}
else if (IsNameValue(pair, PANORAMA_FOLDER))
{
PanoramaFolder = pair.Value;
}
else if (IsName(pair, "share-zip")) // Not L10N
{
SharingZipFile = true;
RequiresSkylineDocument = true;
if (!string.IsNullOrEmpty(pair.Value))
{
SharedFile = pair.Value;
}
}
else
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Unexpected_argument____0_, pair.Name);
return false;
}
}
if (Reintegrating)
RequiresSkylineDocument = true;
else
{
if (IsCreateScoringModel)
WarnArgRequirment(ARG_REINTEGRATE_MODEL_NAME, ARG_REINTEGRATE_CREATE_MODEL);
if (IsAnnotateScoring)
WarnArgRequirment(ARG_REINTEGRATE_MODEL_NAME, ARG_REINTEGRATE_ANNOTATE_SCORING);
if (IsOverwritePeaks)
WarnArgRequirment(ARG_REINTEGRATE_MODEL_NAME, ARG_REINTEGRATE_OVERWRITE_PEAKS);
}
if (FullScanPrecursorResMz.HasValue && !FullScanPrecursorRes.HasValue)
WarnArgRequirment(ARG_FULL_SCAN_PRECURSOR_RES, ARG_FULL_SCAN_PRECURSOR_RES_MZ);
if (FullScanProductResMz.HasValue && !FullScanProductRes.HasValue)
WarnArgRequirment(ARG_FULL_SCAN_PRODUCT_RES, ARG_FULL_SCAN_PRODUCT_RES_MZ);
if (!IsCreateScoringModel && IsSecondBestModel)
{
if (IsDecoyModel)
WarnArgRequirment(ARG_REINTEGRATE_CREATE_MODEL, ARG_REINTEGRATE_MODEL_BOTH);
else
WarnArgRequirment(ARG_REINTEGRATE_CREATE_MODEL, ARG_REINTEGRATE_MODEL_SECOND_BEST);
}
if (!AddDecoys && AddDecoysCount.HasValue)
{
WarnArgRequirment(ARG_DECOYS_ADD, ARG_DECOYS_ADD_COUNT);
}
if (!ImportingTransitionList)
{
if (IsIgnoreTransitionErrors)
WarnArgRequirment(ARG_IMPORT_TRANSITION_LIST, ARG_IGNORE_TRANSITION_ERRORS);
}
if (!ImportingTransitionList || !IsTransitionListAssayLibrary)
{
if (!string.IsNullOrEmpty(IrtGroupName))
WarnArgRequirment(ARG_IMPORT_ASSAY_LIBRARY, ARG_IRT_STANDARDS_GROUP_NAME);
if (!string.IsNullOrEmpty(IrtStandardsPath))
WarnArgRequirment(ARG_IMPORT_ASSAY_LIBRARY, ARG_IRT_STANDARDS_FILE);
}
if (!string.IsNullOrEmpty(PanoramaServerUri) || !string.IsNullOrEmpty(PanoramaFolder))
{
if (!PanoramaArgsComplete())
{
return false;
}
var serverUri = PanoramaUtil.ServerNameToUri(PanoramaServerUri);
if (serverUri == null)
{
_out.WriteLine(Resources.EditServerDlg_OkDialog_The_text__0__is_not_a_valid_server_name_,
PanoramaServerUri);
return false;
}
var panoramaClient = new WebPanoramaClient(serverUri);
var panoramaHelper = new PanoramaHelper(_out);
PanoramaServer = panoramaHelper.ValidateServer(panoramaClient, PanoramaUserName, PanoramaPassword);
if (PanoramaServer == null)
{
return false;
}
if (!panoramaHelper.ValidateFolder(panoramaClient, PanoramaServer, PanoramaFolder))
{
return false;
}
RequiresSkylineDocument = true;
PublishingToPanorama = true;
}
if (!ImportingSearch)
{
if (CutoffScore.HasValue)
WarnArgRequirment(ARG_IMPORT_PEPTIDE_SEARCH_FILE, ARG_IMPORT_PEPTIDE_SEARCH_CUTOFF);
if (AcceptAllModifications)
WarnArgRequirment(ARG_IMPORT_PEPTIDE_SEARCH_FILE, ARG_IMPORT_PEPTIDE_SEARCH_MODS);
if (IncludeAmbiguousMatches)
WarnArgRequirment(ARG_IMPORT_PEPTIDE_SEARCH_FILE, ARG_IMPORT_PEPTIDE_SEARCH_AMBIGUOUS);
}
// If skylineFile isn't set and one of the commands that requires --in is called, complain.
if (String.IsNullOrEmpty(SkylineFile) && RequiresSkylineDocument && !_isDocumentLoaded)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error__Use___in_to_specify_a_Skyline_document_to_open_);
return false;
}
if(ImportingReplicateFile && ImportingSourceDirectory)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error____import_file_and___import_all_options_cannot_be_used_simultaneously_);
return false;
}
if(ImportingReplicateFile && ImportNamingPattern != null)
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error____import_naming_pattern_cannot_be_used_with_the___import_file_option_);
return false;
}
if(ImportingSourceDirectory && !string.IsNullOrEmpty(ReplicateName))
{
_out.WriteLine(Resources.CommandArgs_ParseArgsInternal_Error____import_replicate_name_cannot_be_used_with_the___import_all_option_);
return false;
}
// Use the original file as the output file, if not told otherwise.
if (Saving && String.IsNullOrEmpty(SaveFile))
{
SaveFile = SkylineFile;
}
return true;
}
public static bool IsChorusResponse(MsDataFileUri msDataFileUri)
{
MsDataFilePath msDataFilePath = msDataFileUri as MsDataFilePath;
return(null != msDataFilePath && msDataFilePath.GetExtension() == DataSourceUtil.EXT_CHORUSRESPONSE);
}
public void InitializeSpectrumSourceFiles(SrmDocument document)
{
if (DocLib == null)
return;
var measuredResults = document.Settings.MeasuredResults;
foreach (var dataFile in DocLib.LibraryDetails.DataFiles)
{
var msDataFilePath = new MsDataFilePath(dataFile);
SpectrumSourceFiles[dataFile] = new FoundResultsFilePossibilities(msDataFilePath.GetFileNameWithoutExtension());
// If a matching file is already in the document, then don't include
// this library spectrum source in the set of files to find.
if (measuredResults != null && measuredResults.FindMatchingMSDataFile(MsDataFileUri.Parse(dataFile)) != null)
continue;
if (File.Exists(dataFile) && DataSourceUtil.IsDataSource(dataFile))
{
// We've found the dataFile in the exact location
// specified in the document library, so just add it
// to the "FOUND" list.
SpectrumSourceFiles[dataFile].ExactMatch = msDataFilePath.ToString();
}
}
DocLib.ReadStream.CloseStream();
}
