Пример #1
0
        public static SrmDocument ApplyPeak(SrmDocument doc, PeptideTreeNode nodePepTree, TransitionGroupDocNode nodeTranGroup,
            int resultsIndex, int? resultsFile, bool subsequent, ILongWaitBroker longWaitBroker)
        {
            nodeTranGroup = nodeTranGroup ?? PickTransitionGroup(doc, nodePepTree, resultsIndex);

            PeakMatchData referenceTarget;
            PeakMatchData[] referenceMatchData;
            DateTime? runTime;
            GetReferenceData(doc, nodePepTree.DocNode, nodeTranGroup, resultsIndex, resultsFile, out referenceTarget, out referenceMatchData, out runTime);

            var chromatograms = doc.Settings.MeasuredResults.Chromatograms;
            for (int i = 0; i < chromatograms.Count; i++)
            {
                var chromSet = chromatograms[i];
                for (int j = 0; j < chromSet.MSDataFileInfos.Count; j++)
                {
                    var fileInfo = chromSet.MSDataFileInfos[j];
                    if ((i == resultsIndex && (!resultsFile.HasValue || resultsFile.Value == j)) ||
                        (subsequent && runTime != null && fileInfo.RunStartTime < runTime))
                    {
                        continue;
                    }

                    var bestMatch = GetPeakMatch(doc, chromSet, fileInfo, nodeTranGroup, referenceTarget, referenceMatchData);
                    if (bestMatch != null)
                        doc = bestMatch.ChangePeak(doc, nodePepTree, nodeTranGroup, chromSet.Name, fileInfo.FilePath);
                }
                longWaitBroker.SetProgressCheckCancel(i + 1, chromatograms.Count);
            }
            return doc;
        }
Пример #2
0
        private void QueryPeptideProteins(ILongWaitBroker longWaitBroker)
        {
            List <HashSet <Protein> > peptideProteins = new List <HashSet <Protein> >();

            if (BackgroundProteome != null)
            {
                using (var proteomeDb = BackgroundProteome.OpenProteomeDb())
                {
                    Digestion digestion = BackgroundProteome.GetDigestion(proteomeDb, SrmDocument.Settings.PeptideSettings);
                    foreach (var peptideDocNode in _peptideDocNodes)
                    {
                        HashSet <Protein> proteins = new HashSet <Protein>();
                        if (digestion != null)
                        {
                            if (longWaitBroker.IsCanceled)
                            {
                                return;
                            }
                            foreach (Protein protein in digestion.GetProteinsWithSequence(peptideDocNode.Peptide.Sequence))
                            {
                                if (protein.Sequence == PeptideGroupDocNode.PeptideGroup.Sequence)
                                {
                                    _targetIsInBackgroundProteome = true;
                                    continue;
                                }
                                proteins.Add(protein);
                            }
                        }
                        peptideProteins.Add(proteins);
                    }
                }
            }
            _peptideProteins = peptideProteins;
        }
Пример #3
0
        private IEnumerable <string> DownloadPackages(ILongWaitBroker waitBroker, IEnumerable <string> packagesToDownload)
        {
            ICollection <string> downloadPaths   = new Collection <string>();
            ICollection <string> failedDownloads = new Collection <string>();

            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(waitBroker, PackageUris.Count))
            {
                foreach (var package in packagesToDownload)
                {
                    Match  file         = Regex.Match(package, @"[^/]*$");
                    string downloadPath = Path.GetTempPath() + file;
                    if (webClient.DownloadFileAsync(new Uri(package), downloadPath))
                    {
                        downloadPaths.Add(downloadPath);
                    }
                    else
                    {
                        failedDownloads.Add(package);
                    }
                }
            }

            if (failedDownloads.Count != 0)
            {
                throw new ToolExecutionException(
                          TextUtil.LineSeparate(
                              Resources.PythonInstaller_DownloadPackages_Failed_to_download_the_following_packages_,
                              string.Empty,
                              TextUtil.LineSeparate(failedDownloads),
                              string.Empty,
                              Resources.PythonInstaller_DownloadPython_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
            }
            return(downloadPaths);
        }
Пример #4
0
        private void DownloadR(ILongWaitBroker longWaitBroker)
        {
            // the repository containing the downloadable R exes
            const string baseUri = "http://cran.r-project.org/bin/windows/base/";

            // format the file name, e.g. R-2.15.2-win.exe
            string exe = @"R-" + _version + @"-win.exe";

            // create the download path for the file
            DownloadPath = Path.GetTempPath() + exe;

            // create the webclient
            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(longWaitBroker, 2))
            {
                // First try downloading it as if it is the most recent release of R. The most
                // recent version is stored in a different location of the CRAN repo than older versions.
                // Otherwise, check and see if it is an older release

                var recentUri = new Uri(baseUri + exe);
                var olderUri  = new Uri(baseUri + @"old/" + _version + @"/" + exe);

                if (!webClient.DownloadFileAsync(recentUri, DownloadPath) && !webClient.DownloadFileAsync(olderUri, DownloadPath))
                {
                    throw new ToolExecutionException(
                              TextUtil.LineSeparate(
                                  Resources.RInstaller_DownloadR_Download_failed_,
                                  Resources
                                  .RInstaller_DownloadPackages_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
                }
            }
        }
Пример #5
0
        public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
        {
            if (FailDownload)
            {
                throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Error_downloading_tool);
            }

            if (TestDownloadPath != null)
            {
                return(TestDownloadPath);
            }

            foreach (var item in ToolStoreItems ?? GetToolStoreItems())
            {
                if (item.Identifier.Equals(packageIdentifier))
                {
                    string fileName = Path.GetFileName(item.FilePath);
                    if (fileName == null)
                    {
                        throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Error_downloading_tool);
                    }

                    string path = Path.Combine(directory, fileName);
                    File.Copy(item.FilePath, path, true);
                    return(path);
                }
            }

            throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Cannot_find_a_file_with_that_identifier_);
        }
Пример #6
0
        private void FindDataFiles(string directory, bool overwrite, ILongWaitBroker longWaitBroker)
        {
            // Don't search if every spectrum source file has an exact match and an alternate match
            if (directory == null || !Directory.Exists(directory) || (!overwrite && SpectrumSourceFiles.Values.All(s => s.HasMatches)))
            {
                return;
            }

            if (longWaitBroker != null)
            {
                longWaitBroker.Message =
                    string.Format(Resources.ImportResultsControl_FindResultsFiles_Searching_for_matching_results_files_in__0__, directory);
            }

            try
            {
                foreach (string entry in Directory.EnumerateFileSystemEntries(directory))
                {
                    if (longWaitBroker != null && longWaitBroker.IsCanceled)
                    {
                        return;
                    }

                    if (entry != null && DataSourceUtil.IsDataSource(entry))
                    {
                        TryMatch(entry, overwrite);
                    }
                }
            }
            // ReSharper disable once EmptyGeneralCatchClause
            catch (Exception)
            {
                // No permissions on folder
            }
        }
Пример #7
0
        /// <summary>
        /// Pastes tab delimited data into rows and columns starting from the current cell.
        /// If an error is encountered (e.g. type conversion), then a message is displayed,
        /// and the focus is left in the cell which had an error.
        /// Returns true if any changes were made to the document, false if there were no
        /// changes.
        /// </summary>
        private bool Paste(ILongWaitBroker longWaitBroker, TextReader reader)
        {
            bool anyChanges            = false;
            var  columnsByDisplayIndex =
                DataGridView.Columns.Cast <DataGridViewColumn>().Where(column => column.Visible).ToArray();

            Array.Sort(columnsByDisplayIndex, (col1, col2) => col1.DisplayIndex.CompareTo(col2.DisplayIndex));
            int iFirstCol;
            int iFirstRow;

            if (null == DataGridView.CurrentCell)
            {
                iFirstRow = 0;
                iFirstCol = 0;
            }
            else
            {
                iFirstCol = columnsByDisplayIndex.IndexOf(col => col.Index == DataGridView.CurrentCell.ColumnIndex);
                iFirstRow = DataGridView.CurrentCell.RowIndex;
            }

            for (int iRow = iFirstRow; iRow < DataGridView.Rows.Count; iRow++)
            {
                if (longWaitBroker.IsCanceled)
                {
                    return(anyChanges);
                }
                longWaitBroker.Message = string.Format(Resources.DataGridViewPasteHandler_Paste_Pasting_row__0_, iRow + 1);
                string line = reader.ReadLine();
                if (null == line)
                {
                    return(anyChanges);
                }
                var row = DataGridView.Rows[iRow];
                using (var values = SplitLine(line).GetEnumerator())
                {
                    for (int iCol = iFirstCol; iCol < columnsByDisplayIndex.Length; iCol++)
                    {
                        if (!values.MoveNext())
                        {
                            break;
                        }
                        var column = columnsByDisplayIndex[iCol];
                        if (column.ReadOnly)
                        {
                            continue;
                        }
                        if (!TrySetValue(row.Cells[column.Index], values.Current))
                        {
                            return(anyChanges);
                        }
                        anyChanges = true;
                    }
                }
            }
            return(anyChanges);
        }
Пример #8
0
        // Extract
        public void ExtractTutorial(ILongWaitBroker waitBroker)
        {
            using (ZipFile zip = ZipFile.Read(getTempPath()))
            {
                ExpectedSize = zip.Entries.Sum(entry => entry.UncompressedSize);

                zip.ExtractProgress += (s, e) => TutorialFile_ExtractProgress(s, e, waitBroker);
                var extractDir    = getExtractPath();
                var skyFileToOpen = Path.Combine(extractDir ?? string.Empty, SkyFileLocationInZip);
                foreach (var entry in zip.Entries.ToList())
                {
                    entry.FileName = entry.FileName.Substring(entry.FileName.IndexOf('/')); // Gets rid of everything up to and including first '/'.
                    if (string.IsNullOrEmpty(entry.FileName))
                    {
                        continue;
                    }
                    if (waitBroker.IsCanceled)
                    {
                        break;
                    }
                    try
                    {
                        entry.Extract(extractDir);

                        ExtractedSize += entry.UncompressedSize;
                    }
                    catch (Exception)
                    {
                        if (!waitBroker.IsCanceled)
                        {
                            throw;
                        }
                    }
                }
                Program.MainWindow.BeginInvoke(new Action(() =>
                {
                    if (!string.IsNullOrEmpty(SkyFileLocationInZip) && !string.IsNullOrEmpty(ExtractPath))
                    {
                        Program.MainWindow.OpenFile(skyFileToOpen);
                    }
                    else
                    {
                        Program.MainWindow.NewDocument(true);
                    }
                    if (string.IsNullOrEmpty(SkyFileLocationInZip))
                    {
                        MessageDlg.Show(Program.MainWindow,
                                        string.Format(Resources.ActionTutorial_client_DownloadFileCompleted_File_saved_at___0_, extractDir));
                    }
                    Process.Start(PdfFileLocation); // Opens Tutorial PDF in users default browser.
                }));
            }
        }
Пример #9
0
        // Download
        public void DownloadTutorials(ILongWaitBroker waitBroker)
        {
            WaitBroker = waitBroker;
            WaitBroker.ProgressValue = Convert.ToInt32(Progress * 100);
            WebClient client = new WebClient
            {
                CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore),
            };

            client.DownloadProgressChanged += client_DownloadProgressChanged;
            client.DownloadFile(new Uri(TutorialZipFileLocation), getTempPath());
        }
Пример #10
0
        private static void CopyOldTools(string outerToolsFolderPath, ILongWaitBroker broker)
        {
            //Copy tools to a different folder then Directory.Move if successful.
            string tempOuterToolsFolderPath = string.Concat(outerToolsFolderPath, @"_installing");

            if (Directory.Exists(tempOuterToolsFolderPath))
            {
                DirectoryEx.SafeDelete(tempOuterToolsFolderPath);
                // Not sure this is necessay, but just to be safe
                if (Directory.Exists(tempOuterToolsFolderPath))
                {
                    throw new Exception(Resources.Program_CopyOldTools_Error_copying_external_tools_from_previous_installation);
                }
            }

            // Must create the tools directory to avoid ending up here again next time
            Directory.CreateDirectory(tempOuterToolsFolderPath);

            ToolList  toolList      = Settings.Default.ToolList;
            int       numTools      = toolList.Count;
            const int endValue      = 100;
            int       progressValue = 0;
            // ReSharper disable once UselessBinaryOperation (in case we decide to start at progress>0 for display purposes)
            int increment = (endValue - progressValue) / (numTools + 1);

            foreach (var tool in toolList)
            {
                string toolDirPath = tool.ToolDirPath;
                if (!string.IsNullOrEmpty(toolDirPath) && Directory.Exists(toolDirPath))
                {
                    string foldername = Path.GetFileName(toolDirPath);
                    string newDir     = Path.Combine(outerToolsFolderPath, foldername);
                    string tempNewDir = Path.Combine(tempOuterToolsFolderPath, foldername);
                    if (!Directory.Exists(tempNewDir))
                    {
                        DirectoryEx.DirectoryCopy(toolDirPath, tempNewDir, true);
                    }
                    tool.ToolDirPath          = newDir; // Update the tool to point to its new directory.
                    tool.ArgsCollectorDllPath = tool.ArgsCollectorDllPath.Replace(toolDirPath, newDir);
                }
                if (broker.IsCanceled)
                {
                    // Don't leave around a corrupted directory
                    DirectoryEx.SafeDelete(tempOuterToolsFolderPath);
                    return;
                }

                progressValue       += increment;
                broker.ProgressValue = progressValue;
            }
            Directory.Move(tempOuterToolsFolderPath, outerToolsFolderPath);
            Settings.Default.ToolList = ToolList.CopyTools(toolList);
        }
Пример #11
0
 private void update_ProgressChanged(UpdateProgress e, ILongWaitBroker broker)
 {
     if (broker.IsCanceled)
     {
         AppDeployment.UpdateAsyncCancel();
     }
     else
     {
         long updateBytes = Math.Max(_updateInfo.UpdateSizeBytes ?? 0, e.BytesTotal);
         broker.Message       = GetProgressMessage(e.BytesCompleted, updateBytes);
         broker.ProgressValue = updateBytes == 0
             ? 0 : (int)Math.Min(99, e.BytesCompleted * 100 / updateBytes);
     }
 }
Пример #12
0
        private void QueryPeptideProteins(ILongWaitBroker longWaitBroker)
        {
            List <HashSet <Protein> > peptideProteins = new List <HashSet <Protein> >();

            if (BackgroundProteome != null)
            {
                using (var proteomeDb = BackgroundProteome.OpenProteomeDb(longWaitBroker.CancellationToken))
                {
                    Digestion digestion = proteomeDb.GetDigestion();
                    if (digestion != null)
                    {
                        var peptidesOfInterest   = _peptideDocNodes.Select(node => node.Item2.Peptide.Target.Sequence);
                        var sequenceProteinsDict = digestion.GetProteinsWithSequences(peptidesOfInterest);
                        if (longWaitBroker.IsCanceled)
                        {
                            return;
                        }
                        foreach (var tuple in _peptideDocNodes)
                        {
                            if (longWaitBroker.IsCanceled)
                            {
                                return;
                            }
                            var peptideGroup                   = (PeptideGroup)tuple.Item1.GetIdentity(0);
                            var peptideDocNode                 = tuple.Item2;
                            HashSet <Protein> proteins         = new HashSet <Protein>();
                            var            peptideGroupDocNode = PeptideGroupDocNodes.First(g => ReferenceEquals(g.PeptideGroup, peptideGroup));
                            List <Protein> proteinsForSequence;
                            if (sequenceProteinsDict.TryGetValue(peptideDocNode.Peptide.Target.Sequence, out proteinsForSequence))
                            {
                                if (peptideGroupDocNode != null)
                                {
                                    foreach (var protein in proteinsForSequence)
                                    {
                                        if (protein.Sequence == peptideGroupDocNode.PeptideGroup.Sequence)
                                        {
                                            _peptidesInBackgroundProteome.Add(tuple.Item1);
                                            continue;
                                        }
                                        proteins.Add(protein);
                                    }
                                }
                            }
                            peptideProteins.Add(proteins);
                        }
                    }
                }
            }
            _peptideProteins = peptideProteins;
        }
Пример #13
0
        private static void FindInputFiles(string dir, ICollection <string> inputFiles,
                                           ILongWaitBroker broker, double start, double stop)
        {
            broker.Message = TextUtil.LineSeparate(Resources.BuildLibraryDlg_FindInputFiles_Finding_library_input_files_in,
                                                   PathEx.ShortenPathForDisplay(dir));

            string[] fileNames = Directory.GetFiles(dir);
            Array.Sort(fileNames);
            string[] dirs = Directory.GetDirectories(dir);
            Array.Sort(dirs);

            double startSub  = start;
            double increment = (stop - start) / (dirs.Length + 1);

            const string extPep = BiblioSpecLiteBuilder.EXT_PEP_XML_ONE_DOT;
            const string extIdp = BiblioSpecLiteBuilder.EXT_IDP_XML;
            bool         hasIdp = fileNames.Contains(f => PathEx.HasExtension(f, extIdp));

            foreach (string fileName in fileNames)
            {
                if (IsValidInputFile(fileName))
                {
                    // If the directory has any .idpXML files, then do not add the
                    // supporting .pepXML files.
                    if (!hasIdp || !PathEx.HasExtension(fileName, extPep))
                    {
                        inputFiles.Add(fileName);
                    }
                }
                if (broker.IsCanceled)
                {
                    return;
                }
            }

            startSub            += increment;
            broker.ProgressValue = (int)startSub;

            foreach (string dirSub in dirs)
            {
                FindInputFiles(dirSub, inputFiles, broker, startSub, startSub + increment);
                if (broker.IsCanceled)
                {
                    return;
                }
                startSub            += increment;
                broker.ProgressValue = (int)startSub;
            }
        }
Пример #14
0
        public IEnumerable <FindResult> FindAll(ILongWaitBroker longWaitBroker, SrmDocument document)
        {
            longWaitBroker.Message = Resources.FindPredicate_FindAll_Found_0_matches;
            var customMatches = new HashSet <Bookmark> [FindOptions.CustomFinders.Count];

            for (int iFinder = 0; iFinder < FindOptions.CustomFinders.Count; iFinder++)
            {
                var customFinder = FindOptions.CustomFinders[iFinder];
                var bookmarkSet  = new HashSet <Bookmark>();
                longWaitBroker.Message = string.Format(Resources.FindPredicate_FindAll_Searching_for__0__, customFinder.DisplayName);
                foreach (var bookmark in customFinder.FindAll(document))
                {
                    if (longWaitBroker.IsCanceled)
                    {
                        yield break;
                    }
                    bookmarkSet.Add(bookmark);
                }
                customMatches[iFinder] = bookmarkSet;
            }
            var bookmarkEnumerator = new BookmarkEnumerator(document);
            int matchCount         = 0;

            do
            {
                bookmarkEnumerator.MoveNext();
                if (longWaitBroker.IsCanceled)
                {
                    yield break;
                }
                FindMatch findMatch = null;
                for (int iFinder = 0; iFinder < FindOptions.CustomFinders.Count; iFinder++)
                {
                    if (customMatches[iFinder].Contains(bookmarkEnumerator.Current))
                    {
                        findMatch = FindOptions.CustomFinders[iFinder].Match(bookmarkEnumerator);
                    }
                }
                findMatch = findMatch ?? MatchInternal(bookmarkEnumerator);
                if (findMatch != null)
                {
                    matchCount++;
                    longWaitBroker.Message = matchCount == 1
                                                 ? Resources.FindPredicate_FindAll_Found_1_match
                                                 : string.Format(Resources.FindPredicate_FindAll_Found__0__matches, matchCount);
                    yield return(new FindResult(this, bookmarkEnumerator, findMatch));
                }
            } while (!bookmarkEnumerator.AtStart);
        }
Пример #15
0
 public IEnumerable<FindResult> FindAll(ILongWaitBroker longWaitBroker, SrmDocument document)
 {
     longWaitBroker.Message = Resources.FindPredicate_FindAll_Found_0_matches;
     var customMatches = new HashSet<Bookmark>[FindOptions.CustomFinders.Count];
     for (int iFinder = 0; iFinder < FindOptions.CustomFinders.Count; iFinder++)
     {
         var customFinder = FindOptions.CustomFinders[iFinder];
         var bookmarkSet = new HashSet<Bookmark>();
         longWaitBroker.Message = string.Format(Resources.FindPredicate_FindAll_Searching_for__0__, customFinder.DisplayName);
         foreach (var bookmark in customFinder.FindAll(document))
         {
             if (longWaitBroker.IsCanceled)
             {
                 yield break;
             }
             bookmarkSet.Add(bookmark);
         }
         customMatches[iFinder] = bookmarkSet;
     }
     var bookmarkEnumerator = new BookmarkEnumerator(document);
     int matchCount = 0;
     do
     {
         bookmarkEnumerator.MoveNext();
         if (longWaitBroker.IsCanceled)
         {
             yield break;
         }
         FindMatch findMatch = null;
         for (int iFinder = 0; iFinder < FindOptions.CustomFinders.Count; iFinder++)
         {
             if (customMatches[iFinder].Contains(bookmarkEnumerator.Current))
             {
                 findMatch = FindOptions.CustomFinders[iFinder].Match(bookmarkEnumerator);
             }
         }
         findMatch = findMatch ?? MatchInternal(bookmarkEnumerator);
         if (findMatch != null)
         {
             matchCount++;
             longWaitBroker.Message = matchCount == 1
                                          ? Resources.FindPredicate_FindAll_Found_1_match
                                          : string.Format(Resources.FindPredicate_FindAll_Found__0__matches, matchCount);
             yield return new FindResult(this, bookmarkEnumerator, findMatch);
         }
     } while (!bookmarkEnumerator.AtStart);
 }
Пример #16
0
        public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
        {
            WebClient  webClient = new WebClient();
            UriBuilder uri       = new UriBuilder(TOOL_STORE_URI)
            {
                Path  = DOWNLOAD_TOOL_URL,
                Query = "lsid=" + packageIdentifier     // Not L10N
            };

            byte[] toolZip            = webClient.DownloadData(uri.Uri.AbsoluteUri);                                 // Not L10N
            string contentDisposition = webClient.ResponseHeaders.Get("Content-Disposition");                        // Not L10N
            // contentDisposition is filename="ToolBasename.zip"
            Match  match          = Regex.Match(contentDisposition, "^filename=\"(.+)\"$", RegexOptions.IgnoreCase); // Not L10N
            string downloadedFile = directory + match.Groups[1].Value;

            File.WriteAllBytes(downloadedFile, toolZip);
            return(downloadedFile);
        }
Пример #17
0
        private void QueryPeptideProteins(ILongWaitBroker longWaitBroker)
        {
            List <HashSet <Protein> > peptideProteins = new List <HashSet <Protein> >();

            if (BackgroundProteome != null)
            {
                using (var proteomeDb = BackgroundProteome.OpenProteomeDb())
                {
                    Digestion digestion = BackgroundProteome.GetDigestion(proteomeDb, SrmDocument.Settings.PeptideSettings);
                    if (digestion != null)
                    {
                        var peptidesOfInterest   = _peptideDocNodes.Select(node => node.Peptide.Sequence);
                        var sequenceProteinsDict = digestion.GetProteinsWithSequences(peptidesOfInterest, null);
                        if (longWaitBroker.IsCanceled)
                        {
                            return;
                        }
                        foreach (var peptideDocNode in _peptideDocNodes)
                        {
                            HashSet <Protein> proteins         = new HashSet <Protein>();
                            var            peptideGroupDocNode = PeptideGroupDocNodes.First(g => g.Peptides.Contains(peptideDocNode));
                            List <Protein> proteinsForSequence;
                            if (sequenceProteinsDict.TryGetValue(peptideDocNode.Peptide.Sequence, out proteinsForSequence))
                            {
                                if (peptideGroupDocNode != null)
                                {
                                    foreach (var protein in proteinsForSequence)
                                    {
                                        if (protein.Sequence == peptideGroupDocNode.PeptideGroup.Sequence)
                                        {
                                            _peptidesInBackgroundProteome.Add(peptideDocNode);
                                            continue;
                                        }
                                        proteins.Add(protein);
                                    }
                                }
                            }
                            peptideProteins.Add(proteins);
                        }
                    }
                }
            }
            _peptideProteins = peptideProteins;
        }
Пример #18
0
        /// <summary>
        /// The asynchronous download client links a webClient to a LongWaitBroker. It supports
        /// multiple asynchronous downloads, and updates the associated broker's progress value.
        /// </summary>
        /// <param name="waitBroker">The associated LongWaitBroker</param>
        /// <param name="files">The numbers of file this instance is expected to download. This
        /// is used to accurately update the broker's progress value</param>
        public MultiFileAsynchronousDownloadClient(ILongWaitBroker waitBroker, int files)
        {
            _longWaitBroker = waitBroker;
            _webClient      = new WebClient();
            FilesDownloaded = 0;

            _webClient.DownloadProgressChanged += (sender, args) =>
            {
                _longWaitBroker.ProgressValue = (int)Math.Min(100, ((((double)FilesDownloaded) / files) * 100)
                                                              + ((1.0 / files) * args.ProgressPercentage));
            };

            _webClient.DownloadFileCompleted += (sender, args) =>
            {
                FilesDownloaded++;
                DownloadSucceeded = (args.Error == null);
                DownloadComplete  = true;
            };
        }
Пример #19
0
        // Consider: the location of the following python links is assumed to be relatively stable, but could change. We
        // might want to package these scripts with Skyline itself to assure that they are available

        private void DownloadPip(ILongWaitBroker longWaitBroker)
        {
            // location of the setuptools install script
            const string setupToolsScript = "https://bitbucket.org/pypa/setuptools/downloads/ez_setup.py";

            SetupToolsPath = Path.GetTempPath() + @"ez_setup.py";

            // location of the pip install script
            const string pipScript = "https://raw.github.com/pypa/pip/master/contrib/get-pip.py";

            PipPath = Path.GetTempPath() + @"get-pip.py";

            using (var webClient = TestPipDownloadClient ?? new MultiFileAsynchronousDownloadClient(longWaitBroker, 2))
            {
                if (!webClient.DownloadFileAsync(new Uri(setupToolsScript), SetupToolsPath) ||
                    !webClient.DownloadFileAsync(new Uri(pipScript), PipPath))
                {
                    throw new ToolExecutionException(Resources.PythonInstaller_DownloadPip_Download_failed__Check_your_network_connection_or_contact_Skyline_developers_);
                }
            }
        }
Пример #20
0
        private void DownloadPython(ILongWaitBroker waitBroker)
        {
            // the base Url for python releases
            const string baseUri = "http://python.org/ftp/python/";

            // the installer file name, e.g. python-2.7.msi
            string fileName = @"python-" + _version + @".msi";

            // the fully formed Uri, e.g. http://python.org/ftp/python/2.7/python-2.7.msi
            var downloadUri = new Uri(baseUri + _version + @"/" + fileName);

            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(waitBroker, 1))
            {
                if (!webClient.DownloadFileAsync(downloadUri, DownloadPath = Path.GetTempPath() + fileName))
                {
                    throw new ToolExecutionException(TextUtil.LineSeparate(
                                                         Resources.PythonInstaller_DownloadPython_Download_failed_,
                                                         Resources.PythonInstaller_DownloadPython_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
                }
            }
        }
Пример #21
0
        private bool DoFillDown(ILongWaitBroker longWaitBroker, PropertyDescriptor[] propertyDescriptors, int firstRowIndex, int lastRowIndex)
        {
            bool anyChanges     = false;
            var  firstRowValues = propertyDescriptors.Select(pd => pd.GetValue(BindingListSource[firstRowIndex])).ToArray();
            int  totalRows      = lastRowIndex - firstRowIndex + 1;

            for (int iRow = firstRowIndex + 1; iRow <= lastRowIndex; iRow++)
            {
                if (longWaitBroker.IsCanceled)
                {
                    return(anyChanges);
                }
                longWaitBroker.ProgressValue = 100 * (iRow - firstRowIndex) / totalRows;
                longWaitBroker.Message       = string.Format(Resources.DataboundGridControl_DoFillDown_Filling__0___1__rows, iRow - firstRowIndex, totalRows);
                var row = BindingListSource[iRow];
                for (int icol = 0; icol < propertyDescriptors.Length; icol++)
                {
                    var propertyDescriptor = propertyDescriptors[icol];
                    try
                    {
                        propertyDescriptor.SetValue(row, firstRowValues[icol]);
                        anyChanges = true;
                    }
                    catch (Exception e)
                    {
                        MessageDlg.ShowWithException(this, TextUtil.LineSeparate(Resources.DataboundGridControl_DoFillDown_Error_setting_value_,
                                                                                 e.Message), e);
                        var column = DataGridView.Columns.OfType <DataGridViewColumn>()
                                     .FirstOrDefault(col => col.DataPropertyName == propertyDescriptor.Name);
                        if (null != column)
                        {
                            DataGridView.CurrentCell = DataGridView.Rows[iRow].Cells[column.Index];
                        }
                        return(anyChanges);
                    }
                }
            }
            return(anyChanges);
        }
Пример #22
0
        private bool ClearCells(ILongWaitBroker longWaitBroker)
        {
            if (DataGridView.SelectedRows.Count > 0)
            {
                return(false);
            }
            var columnIndexes = DataGridView.SelectedCells.Cast <DataGridViewCell>().Select(cell => cell.ColumnIndex).Distinct().ToArray();

            if (columnIndexes.Any(columnIndex => DataGridView.Columns[columnIndex].ReadOnly))
            {
                return(false);
            }
            bool anyChanges = false;
            var  cellsByRow = DataGridView.SelectedCells.Cast <DataGridViewCell>().ToLookup(cell => cell.RowIndex).ToArray();

            Array.Sort(cellsByRow, (g1, g2) => g1.Key.CompareTo(g2.Key));
            for (int iGrouping = 0; iGrouping < cellsByRow.Length; iGrouping++)
            {
                if (longWaitBroker.IsCanceled)
                {
                    return(anyChanges);
                }
                longWaitBroker.ProgressValue = 100 * iGrouping / cellsByRow.Length;
                longWaitBroker.Message       = string.Format(Resources.DataGridViewPasteHandler_ClearCells_Cleared__0___1__rows, iGrouping, cellsByRow.Length);
                var rowGrouping = cellsByRow[iGrouping];
                var cells       = rowGrouping.ToArray();
                Array.Sort(cells, (c1, c2) => c1.ColumnIndex.CompareTo(c2.ColumnIndex));
                foreach (var cell in cells)
                {
                    if (!TrySetValue(cell, string.Empty))
                    {
                        return(anyChanges);
                    }
                    anyChanges = true;
                }
            }
            return(anyChanges);
        }
Пример #23
0
        private void DownloadTools(ILongWaitBroker waitBroker,
                                   IEnumerable <ToolUpdateInfo> tools,
                                   out ICollection <ToolUpdateInfo> successfulDownloads,
                                   out ICollection <string> failedDownloads)
        {
            successfulDownloads = new Collection <ToolUpdateInfo>();
            failedDownloads     = new Collection <string>();
            ToolDir             = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "ToolDir")); // Not L10N

            foreach (var tool in tools)
            {
                var individualDir = Directory.CreateDirectory(Path.Combine(ToolDir.FullName, tool._packageName));
                try
                {
                    tool.FilePath = _updateHelper.GetToolZipFile(waitBroker, tool._packageIdentifer, individualDir.FullName);
                    successfulDownloads.Add(tool);
                }
                catch (ToolExecutionException)
                {
                    failedDownloads.Add(tool._packageName);
                }
            }
        }
Пример #24
0
        /// <summary>
        /// Matches library peptides to the current document settings and adds them to the document.
        /// This needs to be one function so that we can use one LongWaitDlg.
        /// </summary>
        public void AddAllPeptidesToDocument(ILongWaitBroker broker, AuditLogEntryCreatorList entryCreators)
        {
            MatchAllPeptides(broker);
            if (broker.IsCanceled)
            {
                return;
            }

            if (MatchedPeptideCount == 0)
            {
                return;
            }

            if (broker.ShowDialog(wnd => EnsureDuplicateProteinFilter(wnd, entryCreators)) == DialogResult.Cancel)
            {
                return;
            }

            IdentityPath selectedPath;
            IdentityPath toPath = AddAllPeptidesSelectedPath;

            DocAllPeptides             = AddPeptides(_document, broker, toPath, out selectedPath);
            AddAllPeptidesSelectedPath = selectedPath;
        }
Пример #25
0
        public void UpdateSpectrumSourceFilesFromDirs(IEnumerable <string> dirPaths, bool overwrite, ILongWaitBroker longWaitBroker)
        {
            if (!overwrite && SpectrumSourceFiles.Values.All(s => s.HasMatches))
            {
                return;
            }

            Array.ForEach(dirPaths.Distinct().ToArray(), dir => FindDataFiles(dir, overwrite, longWaitBroker));
        }
Пример #26
0
        private void DownloadPython(ILongWaitBroker waitBroker)
        {
            // the base Url for python releases
            const string baseUri = "http://python.org/ftp/python/"; // Not L10N

            // the installer file name, e.g. python-2.7.msi
            string fileName = "python-" + _version + ".msi"; // Not L10N

            // the fully formed Uri, e.g. http://python.org/ftp/python/2.7/python-2.7.msi
            var downloadUri = new Uri(baseUri + _version + "/" + fileName); // Not L10N

            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(waitBroker, 1))
            {
                if (!webClient.DownloadFileAsync(downloadUri, DownloadPath = Path.GetTempPath() + fileName))
                    throw new ToolExecutionException(TextUtil.LineSeparate(
                        Resources.PythonInstaller_DownloadPython_Download_failed_,
                        Resources.PythonInstaller_DownloadPython_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
            }
        }
Пример #27
0
 private static void FindInputFiles(string dir, ICollection<string> inputFiles, ILongWaitBroker broker)
 {
     broker.ProgressValue = 0;
     FindInputFiles(dir, inputFiles, broker, 0, 100);
 }
Пример #28
0
        private static void FindInputFiles(string dir, ICollection<string> inputFiles,
            ILongWaitBroker broker, double start, double stop)
        {
            broker.Message = TextUtil.LineSeparate(Resources.BuildLibraryDlg_FindInputFiles_Finding_library_input_files_in,
                                                   PathEx.ShortenPathForDisplay(dir));

            string[] fileNames = Directory.GetFiles(dir);
            Array.Sort(fileNames);
            string[] dirs = Directory.GetDirectories(dir);
            Array.Sort(dirs);

            double startSub = start;
            double increment = (stop - start) / (dirs.Length + 1);

            const string extPep = BiblioSpecLiteBuilder.EXT_PEP_XML_ONE_DOT;
            const string extIdp = BiblioSpecLiteBuilder.EXT_IDP_XML;
            bool hasIdp = fileNames.Contains(f => PathEx.HasExtension(f, extIdp));

            foreach (string fileName in fileNames)
            {
                if (IsValidInputFile(fileName))
                {
                    // If the directory has any .idpXML files, then do not add the
                    // supporting .pepXML files.
                    if (!hasIdp || !PathEx.HasExtension(fileName, extPep))
                        inputFiles.Add(fileName);
                }
                if (broker.IsCanceled)
                    return;
            }

            startSub += increment;
            broker.ProgressValue = (int) startSub;

            foreach (string dirSub in dirs)
            {
                FindInputFiles(dirSub, inputFiles, broker, startSub, startSub + increment);
                if (broker.IsCanceled)
                    return;
                startSub += increment;
                broker.ProgressValue = (int)startSub;
            }
        }
Пример #29
0
 public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
 {
     WebClient webClient = new WebClient();
     UriBuilder uri = new UriBuilder(TOOL_STORE_URI)
         {
             Path = DOWNLOAD_TOOL_URL,
             Query = "lsid=" + packageIdentifier // Not L10N
         };
     byte[] toolZip = webClient.DownloadData(uri.Uri.AbsoluteUri);  // Not L10N
     string contentDisposition = webClient.ResponseHeaders.Get("Content-Disposition");   // Not L10N
     // contentDisposition is filename="ToolBasename.zip"
     Match match = Regex.Match(contentDisposition, "^filename=\"(.+)\"$", RegexOptions.IgnoreCase);  // Not L10N
     string downloadedFile = directory + match.Groups[1].Value;
     File.WriteAllBytes(downloadedFile, toolZip);
     return downloadedFile;
 }
Пример #30
0
        private SrmDocument ImportFiles(SrmDocument docOrig,
            ILongWaitBroker longWaitBroker,
            IList<string> filePaths,
            MeasuredResults.MergeAction resultsAction,
            bool mergePeptides,
            IdentityPath to,
            out IdentityPath firstAdded)
        {
            firstAdded = null;

            var docResult = docOrig;
            int filesRead = 0;

            // Add files in reverse order, so their nodes will end up in the right order.
            IdentityPath first = null;
            foreach (var filePath in filePaths)
            {
                if (longWaitBroker != null)
                {
                    if (longWaitBroker.IsCanceled || longWaitBroker.IsDocumentChanged(docOrig))
                        return docOrig;
                    longWaitBroker.ProgressValue = filesRead*100/filePaths.Count;
                    longWaitBroker.Message = string.Format(Resources.SkylineWindow_ImportFiles_Importing__0__, Path.GetFileName(filePath));
                }

                using (var reader = new StreamReader(filePath))
                {
                    IdentityPath firstAddedForFile, nextAdd;
                    docResult = docResult.ImportDocumentXml(reader,
                                                filePath,
                                                resultsAction,
                                                mergePeptides,
                                                FindSpectralLibrary,
                                                Settings.Default.StaticModList,
                                                Settings.Default.HeavyModList,
                                                to,
                                                out firstAddedForFile,
                                                out nextAdd,
                                                false);
                    // Add the next document at the specified location
                    to = nextAdd;
                    // Store the first added node only for the first document
                    if (first == null)
                        first = firstAddedForFile;
                }

                filesRead++;
            }
            firstAdded = first;
            return docResult;
        }
Пример #31
0
 // Download
 public void DownloadTutorials(ILongWaitBroker waitBroker)
 {
     WaitBroker = waitBroker;
     WaitBroker.ProgressValue = Convert.ToInt32(Progress * 100);
     WebClient client = new WebClient
     {
         CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore),
     };
     client.DownloadProgressChanged += client_DownloadProgressChanged;
     client.DownloadFile(new Uri(TutorialZipFileLocation), getTempPath());
 }
Пример #32
0
 public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
 {
     return _client.GetToolZipFile(waitBroker, packageIdentifier, directory);
 }
Пример #33
0
        public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
        {
            var client = ToolStoreUtil.CreateClient();

            return(client.GetToolZipFile(waitBroker, packageIdentifier, directory));
        }
Пример #34
0
 public void PerformWork(ILongWaitBroker broker)
 {
     _performWork();
 }
Пример #35
0
        private void TutorialFile_ExtractProgress(object sender, ExtractProgressEventArgs e, ILongWaitBroker waitBroker)
        {
            if (waitBroker != null)
            {
                if (waitBroker.IsCanceled)
                {
                    e.Cancel = true;
                    return;
                }

                int progressValue = (int)Math.Round((ExtractedSize + e.BytesTransferred) * 100.0 / ExpectedSize);

                if (progressValue != WaitBroker.ProgressValue)
                {
                    waitBroker.ProgressValue = progressValue;
                    waitBroker.Message = (string.Format(Resources.SrmDocumentSharing_SrmDocumentSharing_ExtractProgress_Extracting__0__,
                                                              e.CurrentEntry.FileName));
                }
            }
        }
Пример #36
0
        // Extract
        public void ExtractTutorial(ILongWaitBroker waitBroker)
        {
            using (ZipFile zip = ZipFile.Read(getTempPath()))
            {
                ExpectedSize = zip.Entries.Sum(entry => entry.UncompressedSize);

                zip.ExtractProgress += (s,e) => TutorialFile_ExtractProgress(s,e, waitBroker);
                var extractDir = getExtractPath();
                var skyFileToOpen = Path.Combine(extractDir ?? string.Empty, SkyFileLocationInZip);
                foreach (var entry in zip.Entries.ToList())
                {
                    entry.FileName = entry.FileName.Substring(entry.FileName.IndexOf('/')); // Gets rid of everything up to and including first '/'.
                    if (string.IsNullOrEmpty(entry.FileName))
                    {
                        continue;
                    }
                    if (waitBroker.IsCanceled)
                        break;
                    try
                    {
                        entry.Extract(extractDir);

                        ExtractedSize += entry.UncompressedSize;
                    }
                    catch (Exception)
                    {
                        if (!waitBroker.IsCanceled)
                            throw;
                    }
                }
                Program.MainWindow.BeginInvoke(new Action(() =>
                {
                    if (!string.IsNullOrEmpty(SkyFileLocationInZip) && !string.IsNullOrEmpty(ExtractPath))
                    {
                        Program.MainWindow.OpenFile(skyFileToOpen);
                    }
                    else
                    {
                        Program.MainWindow.NewDocument(true);
                    }
                    if (string.IsNullOrEmpty(SkyFileLocationInZip))
                    {
                        MessageDlg.Show(Program.MainWindow,
                            string.Format(Resources.ActionTutorial_client_DownloadFileCompleted_File_saved_at___0_, extractDir));
                    }
                    Process.Start(PdfFileLocation); // Opens Tutorial PDF in users default browser.
                }));

            }
        }
Пример #37
0
        public static SrmDocument ApplyPeak(SrmDocument doc, PeptideTreeNode nodePepTree, ref TransitionGroupDocNode nodeTranGroup,
                                            int resultsIndex, ChromFileInfoId resultsFile, bool subsequent, ReplicateValue groupBy, object groupByValue, ILongWaitBroker longWaitBroker)
        {
            nodeTranGroup = nodeTranGroup ?? PickTransitionGroup(doc, nodePepTree, resultsIndex);
            GetReferenceData(doc, nodePepTree.DocNode, nodeTranGroup, resultsIndex, resultsFile, out var referenceTarget, out var referenceMatchData, out var runTime);

            var annotationCalculator = new AnnotationCalculator(doc);
            var chromatograms        = doc.Settings.MeasuredResults.Chromatograms;

            for (var i = 0; i < chromatograms.Count; i++)
            {
                var chromSet = chromatograms[i];

                if (groupBy != null)
                {
                    if (!Equals(groupByValue, groupBy.GetValue(annotationCalculator, chromSet)))
                    {
                        continue;
                    }
                }

                for (var j = 0; j < chromSet.MSDataFileInfos.Count; j++)
                {
                    var fileInfo = chromSet.MSDataFileInfos[j];
                    if ((i == resultsIndex && (resultsFile == null || ReferenceEquals(resultsFile, fileInfo.FileId))) ||
                        (subsequent && runTime != null && fileInfo.RunStartTime < runTime))
                    {
                        continue;
                    }

                    var bestMatch = GetPeakMatch(doc, chromSet, fileInfo, nodeTranGroup, referenceTarget, referenceMatchData);
                    if (bestMatch != null)
                    {
                        doc = bestMatch.ChangePeak(doc, nodePepTree, nodeTranGroup, chromSet.Name, fileInfo.FilePath);
                    }
                }
                longWaitBroker.SetProgressCheckCancel(i + 1, chromatograms.Count);
            }
            return(doc);
        }
Пример #38
0
        /// <summary>
        /// Adds all peptides which can be matched to a background proteome to the
        /// proteins in the background proteins, and returns a new document with those
        /// proteins and peptides added.
        /// </summary>
        /// <param name="document">The starting document</param>
        /// <param name="dictCopy">A dictionary of peptides to peptide matches. All added
        /// peptides are removed</param>
        /// <param name="broker">For reporting long wait status</param>
        /// <param name="toPath">Path to the location in the document to add new items</param>
        /// <param name="selectedPath">Path to item in the document that should be selected
        /// after this operation is complete</param>
        /// <returns>A new document with matching peptides and their proteins addded</returns>
        private SrmDocument AddProteomePeptides(SrmDocument document,
            Dictionary<PeptideSequenceModKey, PeptideMatch> dictCopy,
            ILongWaitBroker broker,
            IdentityPath toPath,
            out IdentityPath selectedPath)
        {
            // Build a list of new PeptideGroupDocNodes to add to the document.
            var dictPeptideGroupsNew = new Dictionary<string, PeptideGroupDocNode>();

            // Get starting progress values
            int startPercent = (broker != null ? broker.ProgressValue : 0);
            int processedPercent = 0;
            int processedCount = 0;
            int totalMatches = dictCopy.Count;

            // Just to make sure this is set
            selectedPath = toPath;

            foreach (PeptideMatch pepMatch in dictCopy.Values)
            {
                // Show progress, if in a long wait
                if (broker != null)
                {
                    if (broker.IsCanceled)
                    {
                        selectedPath = toPath;
                        return document;
                    }
                    // All peptides with protein get processed in this loop.  Peptides
                    // without proteins get added later.
                    if (pepMatch.Proteins != null)
                        processedCount++;
                    int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
                    if (processedPercent != processPercentNow)
                    {
                        processedPercent = processPercentNow;
                        broker.ProgressValue = startPercent + processedPercent;
                    }
                }
                // Peptide should be added to the document,
                // unless the NoDuplicates radio was selected and the peptide has more than 1 protein associated with it.
                if (pepMatch.Proteins == null ||
                    (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.NoDuplicates && pepMatch.Proteins.Count > 1))
                    continue;

                foreach (ProteinInfo protein in pepMatch.Proteins)
                {
                    // Look for the protein in the document.
                    string name = protein.ProteinMetadata.Name;
                    var peptideGroupDocNode = FindPeptideGroupDocNode(document, name);
                    bool foundInDoc = peptideGroupDocNode != null;
                    bool foundInList = false;
                    if (!foundInDoc)
                    {
                        // If the protein is not already in the document,
                        // check to see if we have already created a PeptideGroupDocNode for it.
                        if (dictPeptideGroupsNew.TryGetValue(name, out peptideGroupDocNode))
                            foundInList = true;
                        // If not, create a new PeptideGroupDocNode.
                        else
                        {
                            List<ProteinMetadata> alternativeProteins = new List<ProteinMetadata>(protein.Alternatives);
                            peptideGroupDocNode = new PeptideGroupDocNode(
                                    new FastaSequence(name, protein.ProteinMetadata.Description, alternativeProteins, protein.Sequence),
                                    null, null, new PeptideDocNode[0]);
                        }
                    }
                    // Create a new peptide that matches this protein.
                    var fastaSequence = peptideGroupDocNode.PeptideGroup as FastaSequence;
                    var peptideSequence = pepMatch.NodePep.Peptide.Sequence;
                    // ReSharper disable PossibleNullReferenceException
                    var begin = fastaSequence.Sequence.IndexOf(peptideSequence, StringComparison.Ordinal);
                    // ReSharper restore PossibleNullReferenceException
                    // Create a new PeptideDocNode using this peptide.
                    var newPeptide = new Peptide(fastaSequence, peptideSequence, begin, begin + peptideSequence.Length,
                                                 Settings.PeptideSettings.Enzyme.CountCleavagePoints(peptideSequence));
                    // Make sure we keep the same children.
                    PeptideMatch match = pepMatch;
                    var newNodePep = ((PeptideDocNode) new PeptideDocNode(newPeptide, pepMatch.NodePep.ExplicitMods, pepMatch.NodePep.ExplicitRetentionTime)
                            .ChangeChildren(pepMatch.NodePep.Children.ToList().ConvertAll(nodeGroup =>
                                {
                                    // Create copies of the children in order to prevent transition groups with the same
                                    // global indices.
                                    var nodeTranGroup = (TransitionGroupDocNode) nodeGroup;
                                    if(match.Proteins != null && match.Proteins.Count() > 1)
                                    {
                                        nodeTranGroup = (TransitionGroupDocNode) nodeTranGroup.CopyId();
                                        nodeTranGroup = (TransitionGroupDocNode) nodeTranGroup.ChangeChildren(
                                            nodeTranGroup.Children.ToList().ConvertAll(nodeTran => nodeTran.CopyId()));
                                    }
                                    return (DocNode) nodeTranGroup;
                                })).ChangeAutoManageChildren(false)).ChangeSettings(document.Settings, SrmSettingsDiff.ALL);
                    // If this PeptideDocNode is already a child of the PeptideGroupDocNode,
                    // ignore it.
                    if (peptideGroupDocNode.Children.Contains(nodePep => Equals(((PeptideDocNode) nodePep).Key, newNodePep.Key)))
                    {
                        Console.WriteLine(Resources.ViewLibraryPepMatching_AddProteomePeptides_Skipping__0__already_present, newNodePep.Peptide.Sequence);
                        continue;
                    }
                    // Otherwise, add it to the list of children for the PeptideGroupNode.
                    var newChildren = peptideGroupDocNode.Children.Cast<PeptideDocNode>().ToList();
                    newChildren.Add(newNodePep);
                    newChildren.Sort(FastaSequence.ComparePeptides);

                    // Store modified proteins by global index in a HashSet for second pass.
                    var newPeptideGroupDocNode = peptideGroupDocNode.ChangeChildren(newChildren.Cast<DocNode>().ToArray())
                        .ChangeAutoManageChildren(false);
                    // If the protein was already in the document, replace with the new PeptideGroupDocNode.
                    if (foundInDoc)
                        document = (SrmDocument)document.ReplaceChild(newPeptideGroupDocNode);
                    // Otherwise, update the list of new PeptideGroupDocNodes to add.
                    else
                    {
                        if (foundInList)
                            dictPeptideGroupsNew.Remove(peptideGroupDocNode.Name);
                        dictPeptideGroupsNew.Add(peptideGroupDocNode.Name, (PeptideGroupDocNode) newPeptideGroupDocNode);
                    }
                    // If we are only adding a single node, select it.
                    if (PeptideMatches.Count == 1)
                        selectedPath = new IdentityPath(new[] {peptideGroupDocNode.Id, newNodePep.Peptide});
                    // If the user only wants to add the first protein found,
                    // we break the foreach loop after peptide has been added to its first protein.)
                    if (FilterMultipleProteinMatches == BackgroundProteome.DuplicateProteinsFilter.FirstOccurence)
                        break;
                }
            }

            if (dictPeptideGroupsNew.Count == 0)
            {
                return document;
            }

            // Sort the peptides.
            var nodePepGroupsSortedChildren = new List<PeptideGroupDocNode>();
            foreach(PeptideGroupDocNode nodePepGroup in dictPeptideGroupsNew.Values)
            {
                var newChildren = nodePepGroup.Children.ToList();
                // Have to cast all children to PeptideDocNodes in order to sort.
                var newChildrenNodePeps = newChildren.Cast<PeptideDocNode>().ToList();
                newChildrenNodePeps.Sort(FastaSequence.ComparePeptides);
                nodePepGroupsSortedChildren.Add((PeptideGroupDocNode)
                    nodePepGroup.ChangeChildren(newChildrenNodePeps.Cast<DocNode>().ToArray()));
            }
            // Sort the proteins.
            nodePepGroupsSortedChildren.Sort((node1, node2) => Comparer<string>.Default.Compare(node1.Name, node2.Name));
            IdentityPath selPathTemp = selectedPath, nextAdd;
            document = document.AddPeptideGroups(nodePepGroupsSortedChildren, false,
                toPath, out selectedPath, out nextAdd);
            selectedPath = PeptideMatches.Count == 1 ? selPathTemp : selectedPath;
            return document;
        }
Пример #39
0
 public BackgroundWorker(MinimizeResultsDlg dlg, ILongWaitBroker longWaitBroker)
 {
     _dlg = dlg;
     _longWaitBroker = longWaitBroker;
 }
Пример #40
0
        private void DownloadTools(ILongWaitBroker waitBroker,
            IEnumerable<ToolUpdateInfo> tools,
            out ICollection<ToolUpdateInfo> successfulDownloads,
            out ICollection<string> failedDownloads)
        {
            successfulDownloads = new Collection<ToolUpdateInfo>();
            failedDownloads = new Collection<string>();
            ToolDir = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "ToolDir")); // Not L10N

            foreach (var tool in tools)
            {
                var individualDir = Directory.CreateDirectory(Path.Combine(ToolDir.FullName, tool._packageName));
                try
                {
                    tool.FilePath = _updateHelper.GetToolZipFile(waitBroker, tool._packageIdentifer, individualDir.FullName);
                    successfulDownloads.Add(tool);
                }
                catch (ToolExecutionException)
                {
                    failedDownloads.Add(tool._packageName);
                }
            }
        }
Пример #41
0
        public static SrmDocument ApplyPeak(SrmDocument doc, PeptideTreeNode nodePepTree, ref TransitionGroupDocNode nodeTranGroup,
                                            int resultsIndex, int?resultsFile, bool subsequent, ILongWaitBroker longWaitBroker)
        {
            nodeTranGroup = nodeTranGroup ?? PickTransitionGroup(doc, nodePepTree, resultsIndex);

            PeakMatchData referenceTarget;

            PeakMatchData[] referenceMatchData;
            DateTime?       runTime;

            GetReferenceData(doc, nodePepTree.DocNode, nodeTranGroup, resultsIndex, resultsFile, out referenceTarget, out referenceMatchData, out runTime);

            var chromatograms = doc.Settings.MeasuredResults.Chromatograms;

            for (int i = 0; i < chromatograms.Count; i++)
            {
                var chromSet = chromatograms[i];
                for (int j = 0; j < chromSet.MSDataFileInfos.Count; j++)
                {
                    var fileInfo = chromSet.MSDataFileInfos[j];
                    if ((i == resultsIndex && (!resultsFile.HasValue || resultsFile.Value == j)) ||
                        (subsequent && runTime != null && fileInfo.RunStartTime < runTime))
                    {
                        continue;
                    }

                    var bestMatch = GetPeakMatch(doc, chromSet, fileInfo, nodeTranGroup, referenceTarget, referenceMatchData);
                    if (bestMatch != null)
                    {
                        doc = bestMatch.ChangePeak(doc, nodePepTree, nodeTranGroup, chromSet.Name, fileInfo.FilePath);
                    }
                }
                longWaitBroker.SetProgressCheckCancel(i + 1, chromatograms.Count);
            }
            return(doc);
        }
Пример #42
0
 public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
 {
     var client = ToolStoreUtil.CreateClient();
     return client.GetToolZipFile(waitBroker, packageIdentifier, directory);
 }
Пример #43
0
        public string GetToolZipFile(ILongWaitBroker waitBroker, string packageIdentifier, string directory)
        {
            if (FailDownload)
                throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Error_downloading_tool);

            if (TestDownloadPath != null)
                return TestDownloadPath;

            foreach (var item in ToolStoreItems ?? GetToolStoreItems())
            {
                if (item.Identifier.Equals(packageIdentifier))
                {
                    string fileName = Path.GetFileName(item.FilePath);
                    if (fileName == null)
                        throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Error_downloading_tool);

                    string path = Path.Combine(directory, fileName);
                    File.Copy(item.FilePath, path, true);
                    return path;
                }
            }

            throw new ToolExecutionException(Resources.TestToolStoreClient_GetToolZipFile_Cannot_find_a_file_with_that_identifier_);
        }
Пример #44
0
        private static SrmDocument AddPeptidesToLibraryGroup(SrmDocument document,
            ICollection<PeptideMatch> listMatches,
            ILongWaitBroker broker,
            IdentityPath toPath,
            out IdentityPath selectedPath)
        {
            // Get starting progress values
            int startPercent = (broker != null ? broker.ProgressValue : 0);
            int processedPercent = 0;
            int processedCount = 0;
            int totalMatches = listMatches.Count;

            var listPeptides = new List<PeptideDocNode>();
            foreach (var match in listMatches)
            {
                // Show progress, if in a long wait
                if (broker != null)
                {
                    if (broker.IsCanceled)
                    {
                        selectedPath = null;
                        return document;
                    }
                    processedCount++;
                    int processPercentNow = processedCount * (100 - startPercent) / totalMatches;
                    if (processedPercent != processPercentNow)
                    {
                        processedPercent = processPercentNow;
                        broker.ProgressValue = startPercent + processedPercent;
                    }
                }

                listPeptides.Add(match.NodePep.ChangeSettings(document.Settings, SrmSettingsDiff.ALL));
            }

            bool hasVariable =
                listPeptides.Contains(nodePep => nodePep.HasExplicitMods && nodePep.ExplicitMods.IsVariableStaticMods);

            // Use existing group by this name, if present.
            var nodePepGroupNew = FindPeptideGroupDocNode(document, Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides);
            if(nodePepGroupNew != null)
            {
                var newChildren = nodePepGroupNew.Children.ToList();
                newChildren.AddRange(listPeptides.ConvertAll(nodePep => (DocNode) nodePep));
                selectedPath = (listPeptides.Count == 1 ? new IdentityPath(nodePepGroupNew.Id, listPeptides[0].Id) : toPath);
                nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeChildren(newChildren);
                if (hasVariable)
                    nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeAutoManageChildren(false);
                return (SrmDocument) document.ReplaceChild(nodePepGroupNew);
            }
            else
            {
                nodePepGroupNew = new PeptideGroupDocNode(new PeptideGroup(),
                                                          Resources.ViewLibraryPepMatching_AddPeptidesToLibraryGroup_Library_Peptides,
                                                          string.Empty, listPeptides.ToArray());
                if (hasVariable)
                    nodePepGroupNew = (PeptideGroupDocNode) nodePepGroupNew.ChangeAutoManageChildren(false);
                IdentityPath nextAdd;
                document = document.AddPeptideGroups(new[] { nodePepGroupNew }, true,
                    toPath, out selectedPath, out nextAdd);
                selectedPath = new IdentityPath(selectedPath, nodePepGroupNew.Children[0].Id);
                return document;
            }
        }
Пример #45
0
 private static void FindInputFiles(string dir, ICollection <string> inputFiles, ILongWaitBroker broker)
 {
     broker.ProgressValue = 0;
     FindInputFiles(dir, inputFiles, broker, 0, 100);
 }
Пример #46
0
        /// <summary>
        /// Tries to match each library peptide to document settings.
        /// </summary>
        public void MatchAllPeptides(ILongWaitBroker broker)
        {
            _chargeSettingsMap = new SrmSettings[128];

            // Build a dictionary mapping sequence to proteins because getting this information is slow.
            var dictSequenceProteins = new Dictionary<string, IList<ProteinInfo>>();
            var dictNewNodePeps = new Dictionary<PeptideSequenceModKey, PeptideMatch>();

            PeptideMatches = null;
            MatchedPeptideCount = 0;

            int peptides = 0;
            int totalPeptides = _libraryPepInfos.Length;

            foreach (ViewLibraryPepInfo pepInfo in _libraryPepInfos)
            {
                if (broker.IsCanceled)
                    return;

                int charge = pepInfo.Key.Charge;
                // Find the matching peptide.
                var nodePepMatched = AssociateMatchingPeptide(pepInfo, charge).PeptideNode;
                if (nodePepMatched != null)
                {
                    MatchedPeptideCount++;

                    PeptideMatch peptideMatchInDict;
                    // If peptide is already in the dictionary of peptides to add, merge the children.
                    if (!dictNewNodePeps.TryGetValue(nodePepMatched.SequenceKey, out peptideMatchInDict))
                    {
                        IList<ProteinInfo> matchedProteins = null;

                        var sequence = nodePepMatched.Peptide.Sequence;
                        // This is only set if the user has checked the associate peptide box.
                        if (_backgroundProteome != null)
                        {
                            // We want to query the background proteome as little as possible,
                            // so sequences are mapped to protein lists in a dictionary.
                            if (!dictSequenceProteins.TryGetValue(sequence, out matchedProteins))
                            {
                                using (var proteomeDb = _backgroundProteome.OpenProteomeDb())
                                {
                                    var digestion = _backgroundProteome.GetDigestion(proteomeDb, Settings.PeptideSettings);
                                    if (digestion != null)
                                    {
                                        matchedProteins = digestion.GetProteinsWithSequence(sequence).Select(protein=>new ProteinInfo(protein)).ToList();
                                        dictSequenceProteins.Add(sequence, matchedProteins);
                                    }
                                }
                            }

                        }
                        dictNewNodePeps.Add(nodePepMatched.SequenceKey,
                            new PeptideMatch(nodePepMatched, matchedProteins,
                                MatchesFilter(sequence, charge)));
                    }
                    else
                    {
                        PeptideDocNode nodePepInDictionary = peptideMatchInDict.NodePep;
                        if (!nodePepInDictionary.HasChildCharge(charge))
                        {
                            List<DocNode> newChildren = nodePepInDictionary.Children.ToList();
                            newChildren.AddRange(nodePepMatched.Children);
                            newChildren.Sort(Peptide.CompareGroups);
                            var key = nodePepMatched.SequenceKey;
                            dictNewNodePeps.Remove(key);
                            dictNewNodePeps.Add(key,
                                new PeptideMatch((PeptideDocNode)nodePepInDictionary.ChangeChildren(newChildren),
                                    peptideMatchInDict.Proteins, peptideMatchInDict.MatchesFilterSettings));
                        }
                    }
                }
                peptides++;
                int progressValue = (int)((peptides + 0.0) / totalPeptides * PERCENT_PEPTIDE_MATCH);
                broker.ProgressValue = progressValue;
            }
            PeptideMatches = dictNewNodePeps;
        }
Пример #47
0
 public void PerformWork(ILongWaitBroker broker)
 {
     _performWork();
 }
Пример #48
0
        private void DownloadR(ILongWaitBroker longWaitBroker)
        {
            // the repository containing the downloadable R exes
            const string baseUri = "http://cran.r-project.org/bin/windows/base/"; // Not L10N

            // format the file name, e.g. R-2.15.2-win.exe
            string exe = "R-" + _version + "-win.exe"; // Not L10N

            // create the download path for the file
            DownloadPath = Path.GetTempPath() + exe;

            // create the webclient
            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(longWaitBroker, 2))
            {

                // First try downloading it as if it is the most recent release of R. The most
                // recent version is stored in a different location of the CRAN repo than older versions.
                // Otherwise, check and see if it is an older release

                var recentUri = new Uri(baseUri + exe);
                var olderUri = new Uri(baseUri + "old/" + _version + "/" + exe); // Not L10N

                if (!webClient.DownloadFileAsync(recentUri, DownloadPath) && !webClient.DownloadFileAsync(olderUri, DownloadPath))
                    throw new ToolExecutionException(
                        TextUtil.LineSeparate(
                            Resources.RInstaller_DownloadR_Download_failed_,
                            Resources
                                .RInstaller_DownloadPackages_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
            }
        }
Пример #49
0
 public void PerformWork(ILongWaitBroker broker)
 {
     _broker = broker;
     _performWork(this);
 }
Пример #50
0
        /// <summary>
        /// Adds a list of PeptideDocNodes found in the library to the current document.
        /// </summary>
        public SrmDocument AddPeptides(SrmDocument document, ILongWaitBroker broker, IdentityPath toPath, out IdentityPath selectedPath)
        {
            if (toPath != null &&
                toPath.Depth == (int)SrmDocument.Level.MoleculeGroups &&
                ReferenceEquals(toPath.GetIdentity((int)SrmDocument.Level.MoleculeGroups), SequenceTree.NODE_INSERT_ID))
            {
                toPath = null;
            }

            SkippedPeptideCount = 0;
            var dictCopy = new Dictionary<PeptideSequenceModKey, PeptideMatch>();

            // Make heavy mods explicit
            if (PeptideMatches.Values.Contains(match => match.NodePep.HasExplicitMods
                    && match.NodePep.ExplicitMods.HeavyModifications != null))
            {
                _matcher.ConvertAllHeavyModsExplicit();
            }

            // Call ensure mods on all peptides to be added to the document.
            var listDefStatMods = new MappedList<string, StaticMod>();
            listDefStatMods.AddRange(Properties.Settings.Default.StaticModList);
            listDefStatMods.AddRange(document.Settings.PeptideSettings.Modifications.StaticModifications);

            var listDefHeavyMods = new MappedList<string, StaticMod>();
            listDefHeavyMods.AddRange(Properties.Settings.Default.HeavyModList);
            listDefHeavyMods.AddRange(document.Settings.PeptideSettings.Modifications.HeavyModifications);

            foreach (var key in PeptideMatches.Keys)
            {
                var match = PeptideMatches[key];
                var nodePepDocSet = match.NodePep;
                if (_matcher.MatcherPepMods != null)
                    nodePepDocSet = match.NodePep.EnsureMods(_matcher.MatcherPepMods,
                        document.Settings.PeptideSettings.Modifications,
                        listDefStatMods, listDefHeavyMods);
                if (!dictCopy.ContainsKey(nodePepDocSet.SequenceKey))
                    dictCopy.Add(nodePepDocSet.SequenceKey,
                        new PeptideMatch(nodePepDocSet, match.Proteins,
                        match.MatchesFilterSettings));
            }

            if (!Properties.Settings.Default.LibraryPeptidesKeepFiltered)
            {
                // TODO: This removes entire peptides where only a single
                //       precursor does not match.  e.g. the library contains
                //       a singly charged precursor match, but also doubly charged
                dictCopy = dictCopy.Where(match => match.Value.MatchesFilterSettings)
                                   .ToDictionary(match => match.Key, match => match.Value);
            }
            SrmDocument newDocument = UpdateExistingPeptides(document, dictCopy, toPath, out selectedPath);
            toPath = selectedPath;

            // If there is an associated background proteome, add peptides that can be
            // matched to the proteins from the background proteom.
            if (_backgroundProteome != null)
            {
                newDocument = AddProteomePeptides(newDocument, dictCopy, broker,
                    toPath, out selectedPath);
            }
            toPath = selectedPath;

            // Add all remaining peptides as a peptide list.
            if (_backgroundProteome == null ||  Properties.Settings.Default.LibraryPeptidesAddUnmatched)
            {
                var listPeptidesToAdd = dictCopy.Values.ToList();
                listPeptidesToAdd.RemoveAll(match => match.Proteins != null && match.Proteins.Count > 0);
                if (listPeptidesToAdd.Count > 0)
                {
                    newDocument = AddPeptidesToLibraryGroup(newDocument, listPeptidesToAdd, broker,
                                                            toPath, out selectedPath);
                }
            }

            return newDocument;
        }
Пример #51
0
        // Consider: the location of the following python links is assumed to be relatively stable, but could change. We
        // might want to package these scripts with Skyline itself to assure that they are available
        private void DownloadPip(ILongWaitBroker longWaitBroker)
        {
            // location of the setuptools install script
            const string setupToolsScript = "https://bitbucket.org/pypa/setuptools/downloads/ez_setup.py";  // Not L10N
            SetupToolsPath = Path.GetTempPath() + "ez_setup.py";    // Not L10N

            // location of the pip install script
            const string pipScript = "https://raw.github.com/pypa/pip/master/contrib/get-pip.py";   // Not L10N
            PipPath = Path.GetTempPath() + "get-pip.py";    // Not L10N

            using (var webClient = TestPipDownloadClient ?? new MultiFileAsynchronousDownloadClient(longWaitBroker, 2))
            {
                if (!webClient.DownloadFileAsync(new Uri(setupToolsScript), SetupToolsPath) ||
                    !webClient.DownloadFileAsync(new Uri(pipScript), PipPath))
                {
                    throw new ToolExecutionException(Resources.PythonInstaller_DownloadPip_Download_failed__Check_your_network_connection_or_contact_Skyline_developers_);
                }
            }
        }
Пример #52
0
        /// <summary>
        /// Matches library peptides to the current document settings and adds them to the document.
        /// This needs to be one function so that we can use one LongWaitDlg. 
        /// </summary>
        public void AddAllPeptidesToDocument(ILongWaitBroker broker)
        {
            MatchAllPeptides(broker);
            if (broker.IsCanceled)
                return;

            if (MatchedPeptideCount == 0)
                return;

            if (broker.ShowDialog(EnsureDuplicateProteinFilter) == DialogResult.Cancel)
                return;

            IdentityPath selectedPath;
            IdentityPath toPath = AddAllPeptidesSelectedPath;

             DocAllPeptides = AddPeptides(_document, broker, toPath, out selectedPath);
            AddAllPeptidesSelectedPath = selectedPath;
        }
Пример #53
0
        private IEnumerable<string> DownloadPackages(ILongWaitBroker waitBroker, IEnumerable<string> packagesToDownload)
        {
            ICollection<string> downloadPaths = new Collection<string>();
            ICollection<string> failedDownloads = new Collection<string>();

            using (var webClient = TestDownloadClient ?? new MultiFileAsynchronousDownloadClient(waitBroker, PackageUris.Count))
            {
                foreach (var package in packagesToDownload)
                {
                    Match file = Regex.Match(package, @"[^/]*$"); // Not L10N
                    string downloadPath = Path.GetTempPath() + file;
                    if (webClient.DownloadFileAsync(new Uri(package), downloadPath))
                    {
                        downloadPaths.Add(downloadPath);
                    }
                    else
                    {
                        failedDownloads.Add(package);
                    }
                }
            }

            if (failedDownloads.Count != 0)
            {
                throw new ToolExecutionException(
                        TextUtil.LineSeparate(
                            Resources.PythonInstaller_DownloadPackages_Failed_to_download_the_following_packages_,
                            string.Empty,
                            TextUtil.LineSeparate(failedDownloads),
                            string.Empty,
                            Resources.PythonInstaller_DownloadPython_Check_your_network_connection_or_contact_the_tool_provider_for_installation_support_));
            }
            return downloadPaths;
        }
Пример #54
0
 private void QueryPeptideProteins(ILongWaitBroker longWaitBroker)
 {
     List<HashSet<Protein>> peptideProteins = new List<HashSet<Protein>>();
     if (BackgroundProteome != null)
     {
         using (var proteomeDb = BackgroundProteome.OpenProteomeDb())
         {
             Digestion digestion = BackgroundProteome.GetDigestion(proteomeDb, SrmDocument.Settings.PeptideSettings);
             foreach (var peptideDocNode in _peptideDocNodes)
             {
                 HashSet<Protein> proteins = new HashSet<Protein>();
                 if (digestion != null)
                 {
                     if (longWaitBroker.IsCanceled)
                     {
                         return;
                     }
                     foreach (Protein protein in digestion.GetProteinsWithSequence(peptideDocNode.Peptide.Sequence))
                     {
                         if (protein.Sequence == PeptideGroupDocNode.PeptideGroup.Sequence)
                         {
                             _targetIsInBackgroundProteome = true;
                             continue;
                         }
                         proteins.Add(protein);
                     }
                 }
                 peptideProteins.Add(proteins);
             }
         }
     }
     _peptideProteins = peptideProteins;
 }
Пример #55
0
 private void BeginUpdate(ILongWaitBroker broker)
 {
     AppDeployment.UpdateAsync(ev => update_ProgressChanged(ev, broker), update_Complete);
 }
Пример #56
0
 private void OptimizeCache(string fileName, ILongWaitBroker progress)
 {
     // Optimize the results cache to get rid of any unnecessary
     // chromatogram data.
     var settings = Document.Settings;
     if (settings.HasResults)
     {
         var results = settings.MeasuredResults;
         if (results.IsLoaded)
         {
             var resultsNew = results.OptimizeCache(fileName, _chromatogramManager.StreamManager, progress);
             if (!ReferenceEquals(resultsNew, results))
             {
                 SrmDocument docNew, docCurrent;
                 do
                 {
                     docCurrent = Document;
                     docNew = docCurrent.ChangeMeasuredResults(resultsNew);
                 }
                 while (!SetDocument(docNew, docCurrent));
             }
         }
     }
     else
     {
         string cachePath = ChromatogramCache.FinalPathForName(DocumentFilePath, null);
         FileEx.SafeDelete(cachePath, true);
     }
 }
Пример #57
0
        private static void CopyOldTools(string outerToolsFolderPath, ILongWaitBroker broker)
        {
            //Copy tools to a different folder then Directory.Move if successful.
            string tempOuterToolsFolderPath = string.Concat(outerToolsFolderPath, "_installing"); // Not L10N
            if (Directory.Exists(tempOuterToolsFolderPath))
            {
                DirectoryEx.SafeDelete(tempOuterToolsFolderPath);
                // Not sure this is necessay, but just to be safe
                if (Directory.Exists(tempOuterToolsFolderPath))
                    throw new Exception(Resources.Program_CopyOldTools_Error_copying_external_tools_from_previous_installation);
            }

            // Must create the tools directory to avoid ending up here again next time
            Directory.CreateDirectory(tempOuterToolsFolderPath);

            ToolList toolList = Settings.Default.ToolList;
            int numTools = toolList.Count;
            const int endValue = 100;
            int progressValue = 0;
            int increment = (endValue - progressValue)/(numTools +1);

            foreach (var tool in toolList)
            {
                string toolDirPath = tool.ToolDirPath;
                if (!string.IsNullOrEmpty(toolDirPath) && Directory.Exists(toolDirPath))
                {
                    string foldername = Path.GetFileName(toolDirPath);
                    string newDir = Path.Combine(outerToolsFolderPath, foldername);
                    string tempNewDir = Path.Combine(tempOuterToolsFolderPath, foldername);
                    if (!Directory.Exists(tempNewDir))
                        DirectoryEx.DirectoryCopy(toolDirPath, tempNewDir, true);
                    tool.ToolDirPath = newDir; // Update the tool to point to its new directory.
                    tool.ArgsCollectorDllPath = tool.ArgsCollectorDllPath.Replace(toolDirPath, newDir);
                }
                if (broker.IsCanceled)
                {
                    // Don't leave around a corrupted directory
                    DirectoryEx.SafeDelete(tempOuterToolsFolderPath);
                    return;
                }

                progressValue += increment;
                broker.ProgressValue = progressValue;
            }
            Directory.Move(tempOuterToolsFolderPath, outerToolsFolderPath);
            Settings.Default.ToolList = ToolList.CopyTools(toolList);
        }
Пример #58
0
        /// <summary>
        /// The asynchronous download client links a webClient to a LongWaitBroker. It supports
        /// multiple asynchronous downloads, and updates the associated broker's progress value.
        /// </summary>
        /// <param name="waitBroker">The associated LongWaitBroker</param>
        /// <param name="files">The numbers of file this instance is expected to download. This
        /// is used to accurately update the broker's progress value</param>
        public MultiFileAsynchronousDownloadClient(ILongWaitBroker waitBroker, int files)
        {
            _longWaitBroker = waitBroker;
            _webClient = new WebClient();
            FilesDownloaded = 0;

            _webClient.DownloadProgressChanged += (sender, args) =>
                {
                    _longWaitBroker.ProgressValue = (int) Math.Min(100, ((((double) FilesDownloaded)/files)*100)
                                                                        + ((1.0/files)*args.ProgressPercentage));
                };

            _webClient.DownloadFileCompleted += (sender, args) =>
                {
                    FilesDownloaded++;
                    DownloadSucceeded = (args.Error == null);
                    DownloadComplete = true;
                };
        }
Пример #59
0
 public BackgroundWorker(MinimizeResultsDlg dlg, ILongWaitBroker longWaitBroker)
 {
     _dlg            = dlg;
     _longWaitBroker = longWaitBroker;
 }
Пример #60
0
        private void FindDataFiles(string directory, bool overwrite, ILongWaitBroker longWaitBroker)
        {
            // Don't search if every spectrum source file has an exact match and an alternate match
            if (directory == null || !Directory.Exists(directory) || (!overwrite && SpectrumSourceFiles.Values.All(s => s.HasMatches)))
                return;

            if (longWaitBroker != null)
            {
                longWaitBroker.Message =
                    string.Format(Resources.ImportResultsControl_FindResultsFiles_Searching_for_matching_results_files_in__0__, directory);
            }

            try
            {
                foreach (string entry in Directory.EnumerateFileSystemEntries(directory))
                {
                    if (longWaitBroker != null && longWaitBroker.IsCanceled)
                        return;

                    if (entry != null && DataSourceUtil.IsDataSource(entry))
                        TryMatch(entry, overwrite);
                }
            }
            // ReSharper disable once EmptyGeneralCatchClause
            catch (Exception)
            {
                // No permissions on folder
            }
        }