private static IEnumerable<ProjectNode> CreateProjectNodes(IEnumerable<Project> projects, Package package) { var result = new List<ProjectNode>(); Parallel.ForEach(projects, project => { if (project.IsSupported() && project.IsCompatible(package)) { var children = new List<TreeNodeBase>(); switch (package.GetDeveloperLibraryType()) { case DeveloperLibraryType.VcLibrary: children = CreateConfigurationNode(project, package).ToList(); break; case DeveloperLibraryType.Net: children = CreateAssemblyNode(project, package).ToList(); break; } var projectNode = new ProjectNode(project, children); if (!children.Any()) projectNode.IsChecked = DetermineCheckState(package, project, null, null); lock (SpinLock) { result.Add(projectNode); } } }); return result; }
public Package GetHighestInstalledPackage(Package package) { var packages = PackagesViewModel.Packages.Where(m => m.Name == package.Name && m.Flavor == package.Flavor && m.Architecture == package.Architecture); var highestInstalled = packages.FirstOrDefault(n => n.IsHighestInstalled); return highestInstalled != null ? highestInstalled.PackageIdentity : null; }
public static SolutionNode Walk(Package package) { if (!Module.IsSolutionOpen) return null; var children = CreateProjectNodes(Module.DTE.Solution.Projects.OfType<Project>().Where(n => !string.IsNullOrEmpty(n.FullName)), package).ToArray(); return children.Any() ? new SolutionNode(Module.DTE.Solution.Properties.Item("Name").Value, children) : null; }
private static IEnumerable<TreeNodeBase> CreateConfigurationNode(Project project, Package package) { var configurations = project.GetCompatibleConfigurations(package.CanonicalName.Architecture); foreach (var configuration in configurations) { var children = CreateLibraryNode(project, package, configuration).ToArray(); yield return new ConfigurationNode(configuration, children); } }
public PackageItem(Package package) { PackageIdentity = package; _dependencies = Module.PackageManager.IdentifyOwnDependencies(PackageIdentity); if (Module.IsSolutionOpen) _inSolution = Module.DTE.Solution.Projects.OfType<Project>().Any(m => m.IsSupported() && m.HasPackage(PackageIdentity)); SetStatus(); }
private static IEnumerable<TreeNodeBase> CreateLibraryNode(Project project, Package package, string configuration) { var path = package.GetPackageDirectory() + "lib"; if (Directory.Exists(path)) { var files = Directory.GetFiles(path, "*.lib"); foreach (var filename in files.Select(Path.GetFileName)) { yield return new LibraryNode(filename) { IsChecked = DetermineCheckState(package, project, configuration, filename) }; } } }
private static IEnumerable<TreeNodeBase> CreateAssemblyNode(Project project, Package package) { var path = package.GetPackageDirectory() + "ReferenceAssemblies"; if (Directory.Exists(path)) { var files = Directory.GetFiles(path, "*.dll"); foreach (var filename in files.Select(Path.GetFileName)) { yield return new AssemblyNode(filename) { IsChecked = DetermineCheckState(package, project, null, filename) }; } } }
public IEnumerable<Package> IdentifyPackageAndDependencies(Package package) { var dependencies = new List<Package> { package }; Parallel.ForEach(package.Dependencies, dependency => { try { if (dependency != null && PackagesInFeeds.Any(n => n.Value.Any(m => m.CanonicalName == dependency.CanonicalName))) { var subdependencies = IdentifyPackageAndDependencies((Package) dependency); lock (_L2) { dependencies.AddRange(subdependencies); } } } catch { } }); return dependencies.Distinct(); }
public bool IsPackageInFeed(Package package, string feedLocation) { return PackagesInFeeds.ContainsKey(feedLocation) && PackagesInFeeds[feedLocation].Contains(package); }
/// <summary> /// Sets package states. (blocked, locked, wanted) /// </summary> public void SetPackageState(Package package, string state) { ContinueTask(Task.Factory.StartNew(() => { switch (state) { case "Blocked": _pkm.SetGeneralPackageInformation(50, package.CanonicalName, "state", package.IsBlocked ? null : PackageState.Blocked.ToString()); RefreshPackage(package); break; case "Wanted": _pkm.SetPackageWanted(package.CanonicalName, !package.IsWanted); RefreshPackage(package); break; } })); }
public bool RemoveMark(Package package, Mark mark) { if (_marks.ContainsKey(package) && _marks[package].Contains(mark)) { _marks[package].Remove(mark); if (!_marks[package].Any()) { _marks.Remove(package); } return true; } return false; }
private static bool? DetermineCheckState(Package package, Project project, string config, string filename) { var packageReferenceFile = new PackageReferenceFile(project.GetDirectory() + "/coapp.packages.config"); foreach (var p in packageReferenceFile.GetPackageReferences().Where(p => p.CanonicalName.Name == package.CanonicalName.Name && p.CanonicalName.Flavor == package.CanonicalName.Flavor && p.CanonicalName.Architecture == package.CanonicalName.Architecture)) { if (filename == null) return true; if (config == null && p.Libraries.Any(l => l.Name == filename)) return true; if (p.Libraries.Any(l => l.ConfigurationName == config && l.Name == filename)) return true; } return false; }
private void CopyFileToDestination(string filename, string targetFilename, Package pkg) { RepositoryContainer[targetFilename].Lock(blob => { blob.CopyFromFile(filename); }); if (pkg.CanonicalName.Matches(CanonicalName.CoAppItself)) { RepositoryContainer["coapp.msi"].Lock(blob => { blob.CopyFromFile(filename); }); } if (pkg.CanonicalName.Matches(CanonicalName.CoAppDevtools)) { RepositoryContainer["coapp.devtools.msi"].Lock(blob => { blob.CopyFromFile(filename); }); } }
public Task<Package> GetPackageDetails(Package package) { return EPM.GetPackageDetails(package); }
private void RefreshPackage(Package package) { var newPackage = GetPackage(package.CanonicalName); foreach (var list in PackagesInFeeds.Select(n => n.Value)) { list.Remove(package); list.Add(newPackage); } PackagesViewModel.ReplacePackage(package, newPackage); }
public IEnumerable<Package> IdentifyDependencies(Package package) { return IdentifyPackageAndDependencies(package).Except(new[] { package }); }
public bool IsPackageHighestInstalled(Package package) { return package.NewerPackages.Any() ? package.NewerPackages.Any(m => m.IsInstalled && m.Version == package.NewerPackages.Max(k => k.Version)) : package.IsInstalled; }
public Task<IEnumerable<Package>> IdentifyPackageAndDependenciesToInstall(Package package, bool withUpgrade = false, bool ignoreThisPackage = true, bool getDetails = true) { return EPM.IdentifyPackageAndDependenciesToInstall(new[] {package}, withUpgrade).ContinueAlways(t => { t. RethrowWhenFaulted (); if ( ignoreThisPackage) { return t . Result . Where (p => p != package); } return t . Result; }) .ContinueAlways(t => getDetails ? GetPackages(t.Result) : t.Result); }
public IEnumerable<Package> IdentifyOwnDependencies(Package package) { var dependencies = new List<Package>(); Parallel.ForEach(package.Dependencies, dependency => { try { if (dependency != null && PackagesInFeeds.Any(n => n.Value.Any(m => m.CanonicalName == dependency.CanonicalName))) { lock (_L2) { dependencies.Add((Package)dependency); } } } catch { } }); return dependencies.Where(n => n != null).Distinct(); }
private void TweetPackage(Uri location, Package pkg) { if (_tweeter != null) { // pkg.Name Bitly.Shorten(location.AbsoluteUri).ContinueWith( (x) => { var name = "[{0}-{1}-{2}]".format(pkg.Name, pkg.Version, pkg.Architecture); var summary = pkg.PackageDetails.SummaryDescription; var l1 = 138 - (name.Length + x.Result.Length); if (summary.Length > l1) { summary = summary.Substring(0, l1 - 1) + "\u2026"; } var text = "{0} {1} {2}".format(name, summary, x.Result); Logger.Message("Tweet: {0}", text); _tweeter.Tweet(text); }); } }
public Task<Package> GetPackageDetails(Package package) { return Task.Factory.StartNew(() => package); }
public SolutionViewModel(Package package) { _solutionNode = SolutionWalker.Walk(package); }
public void AddMark(Package package, Mark mark) { if (_marks.ContainsKey(package)) { _marks[package].Add(mark); } else { _marks.Add(package, new List<Mark> { mark }); } }