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