public void AddOrModifyReferenceInProjectFile(NugetReference referenceToCopy, Project project, VerifiedFolder packagesDirectory)
{
var srcNode = referenceToCopy.Project.GetReferenceNode(referenceToCopy.Package.ID)
?? throw new System.Exception("Unable to read source reference node for package " + referenceToCopy.Package.ID);
var xmlNode = project.GetReferenceNode(referenceToCopy.Package.ID);
if (xmlNode != null)
{
var copy = xmlNode.OwnerDocument.ImportNode(srcNode, true);
xmlNode.ParentNode.ReplaceChild(newChild: copy, oldChild: xmlNode);
project.SaveChanges();
}
else
{
var itemGroupNode = project.GetReferenceItemGroupNode();
var copy = itemGroupNode.OwnerDocument.ImportNode(srcNode, true);
itemGroupNode.AppendChild(copy);
}
var hintPathNode = project.GetReferenceHintPathNode(referenceToCopy.Package.ID);
if (hintPathNode != null)
{
hintPathNode.InnerText = CorrectPackagesPath(project.ProjectDirectory, packagesDirectory, hintPathNode.InnerText);
}
project.SaveChanges();
}
public void AddNugetReferenceToContext_Execute()
{
var templateName = "Test";
var projectName = "TestProject";
var destPath = Path.GetFullPath(@".\DestinationPath\Project");
var nugetReference = new NugetReference()
{
Project = Path.Combine(destPath, projectName),
PackageId = "TestPackage",
Version = "1.0.0",
};
GenContext.Current = new FakeContextProvider()
{
DestinationPath = destPath,
GenerationOutputPath = destPath,
};
var postAction = new FakeTemplateDefinedPostAction(
new Guid(AddNugetReferenceToContextPostAction.Id),
new Dictionary <string, string>()
{
{ "packageId", nugetReference.PackageId },
{ "version", nugetReference.Version },
{ "projectPath", projectName },
});
var mergePostAction = new AddNugetReferenceToContextPostAction(templateName, postAction, new Dictionary <string, string>(), destPath);
mergePostAction.Execute();
Assert.Equal(nugetReference, GenContext.Current.ProjectInfo.NugetReferences[0]);
}
public void AddNugetReference(NugetReference nugetReference)
{
var isCpsProject = IsCpsProject();
if (NugetReferenceExists(nugetReference, isCpsProject))
{
return;
}
XElement element = GetNugetReferenceXElement(nugetReference.PackageId, nugetReference.Version.ToString(), isCpsProject);
ApplyNs(element);
var firstPackageReference = _root.Descendants().FirstOrDefault(d => d.Name.LocalName == "PackageReference");
if (firstPackageReference != null)
{
firstPackageReference.AddBeforeSelf(element);
}
else
{
var itemsContainer = new XElement(_root.GetDefaultNamespace() + "ItemGroup");
itemsContainer.Add(element);
_root.Add(itemsContainer);
}
}
private void ExpandGraphNode(SolutionGraph graph, ProjectGraphNode node)
{
if (node.IsAlreadyExpanded)
{
return;
}
foreach (var projectRef in node.Project.ProjectReferences)
{
var projectRefNode = TryCreateGraphNode(graph, projectRef);
if (projectRefNode != null)
{
node.ProjectRequirements.Add(projectRefNode);
}
}
var nugetPackages = _nugetReferenceReader.TryReadPackagesConfig(node.Project.ProjectDirectory);
foreach (var fileReference in node.Project.FileReferences)
{
var nugetPackage = nugetPackages?.FindPackage(fileReference.Include.ID);
if (nugetPackage != null)
{
var nugetReference = new NugetReference(node.Project, nugetPackage, fileReference.GetFile(), fileReference.VersionFromPath ?? VersionWithSuffix.Empty());
node.NugetPackageRequirements.Add(nugetReference);
}
else
{
var reference = new ReferencedFile(node.Project, fileReference.GetFile(), fileReference.Include.Version);
node.FileRequirements.Add(reference);
}
}
}
private bool NugetReferenceExists(NugetReference nuget)
{
return(_root.Descendants().Any(
d => d.Attribute("id") != null &&
d.Attribute("id").Value.Equals(nuget.PackageId, StringComparison.OrdinalIgnoreCase) &&
d.Attribute("version") != null &&
d.Attribute("version").Value.Equals(nuget.PackageId, StringComparison.OrdinalIgnoreCase)));
}
public IReadOnlyList <NugetReference> FindNugetReferences()
{
List <NugetReference> refs = new List <NugetReference>();
var elements = mRoot.Children("ItemGroup").Children("PackageReference");
foreach (var element in elements)
{
string id = element.Attribute("Include");
string version = element.AttributeOrElement("Version");
string targetFramework = null;
XmlElement parent = element.ParentNode as XmlElement;
if (parent != null && parent.HasAttribute("Condition"))
{
//need to parse condition
string condition = parent.Attribute("Condition");
Match m = mConditionParser.Match(condition);
if (!m.Success)
{
throw new Exception("The condition of a property group that consists of a package reference is in incompatible format");
}
targetFramework = m.Groups[1].Value;
}
var reference = new NugetReference(id, targetFramework, version);
reference.IncludeAssets = element.AttributeOrElement("IncludeAssets");
reference.ExcludeAssets = element.AttributeOrElement("ExcludeAssets");
reference.PrivateAssets = element.AttributeOrElement("PrivateAsserts");
if (reference.PrivateAssets != null && (reference.PrivateAssets.Contains("all") || reference.PrivateAssets.Contains("runtime")))
{
continue;
}
if (reference.ExcludeAssets != null && (reference.ExcludeAssets.Contains("all") || reference.ExcludeAssets.Contains("runtime")))
{
continue;
}
if (reference.IncludeAssets != null && !(reference.IncludeAssets.Contains("all") || reference.IncludeAssets.Contains("runtime")))
{
continue;
}
refs.Add(reference);
}
return(refs);
}
private bool NugetReferenceExists(NugetReference nuget, bool isCpsProject)
{
if (isCpsProject)
{
return(_root.Descendants().Any(
d => d.Attribute("Include") != null &&
d.Attribute("Include").Value.Equals(nuget.PackageId, StringComparison.OrdinalIgnoreCase) &&
d.Attribute("Version") != null &&
d.Attribute("Version").Value.Equals(nuget.PackageId, StringComparison.OrdinalIgnoreCase)));
}
else
{
return(_root.Descendants().Any(
d => d.Attribute("Include") != null &&
d.Attribute("Include").Value.Equals(nuget.PackageId, StringComparison.OrdinalIgnoreCase) &&
d.Value == nuget.Version));
}
}
public void AddNugetReference(NugetReference nugetReference)
{
var isCpsProject = IsCpsProject();
if (NugetReferenceExists(nugetReference, isCpsProject))
{
return;
}
var itemsContainer = new XElement(_root.GetDefaultNamespace() + "ItemGroup");
XElement element = GetNugetReferenceXElement(nugetReference.PackageId, nugetReference.Version.ToString(), isCpsProject);
ApplyNs(element);
itemsContainer.Add(element);
_root.Add(itemsContainer);
}
public void AddNugetReference(NugetReference nugetReference)
{
if (NugetReferenceExists(nugetReference))
{
return;
}
XElement element = GetNugetReferenceXElement(nugetReference.PackageId, nugetReference.Version.ToString());
var firstPackageReference = _root.Descendants().FirstOrDefault(d => d.Name.LocalName == "package");
if (firstPackageReference != null)
{
firstPackageReference.AddBeforeSelf(element);
}
else
{
_root.Add(element);
}
}
public void AddNugetImport(NugetReference nugetReference)
{
if (NugetImportExists(nugetReference))
{
return;
}
XElement targetsElement = GetPackageImportXElement(nugetReference.PackageId, nugetReference.Version.ToString(), "targets");
ApplyNs(targetsElement);
var importGroup = _root.Descendants().FirstOrDefault(d => d.Name.LocalName == "ImportGroup" && d.FirstAttribute.Value == "ExtensionTargets");
if (importGroup != null)
{
importGroup.AddFirst(targetsElement);
}
XElement propsElement = GetPackageImportXElement(nugetReference.PackageId, nugetReference.Version.ToString(), "props");
ApplyNs(propsElement);
_root.AddFirst(propsElement);
}
public void AddOrModifyReferencePackagesConfig(NugetReference referenceToCopy, Project project)
{
var packagesConfig = _nugetReader.TryReadPackagesConfig(project.ProjectDirectory) ??
CreateNewPackagesConfig(project.ProjectDirectory);
var xmlNode = packagesConfig.GetPackageNode(referenceToCopy.Package.ID);
if (xmlNode == null)
{
var packagesNode = packagesConfig.GetPackagesNodes();
xmlNode = packagesNode.OwnerDocument.CreateElement("package");
packagesNode.AppendChild(xmlNode);
xmlNode.AddAttribute("id", referenceToCopy.Package.ID);
xmlNode.AddAttribute("version");
xmlNode.AddAttribute("targetFramework");
}
xmlNode.Attributes["version"].Value = referenceToCopy.Package.Version.ToString();
xmlNode.Attributes["targetFramework"].Value = project.DotNetVersion.ToPackagesConfigString();
packagesConfig.SaveChanges();
}
private bool NugetImportExists(NugetReference nuget)
{
return(_root.Descendants().Any(
d => d.Attribute("Project") != null &&
d.Attribute("Project").Value.Contains($"{nuget.PackageId}.{nuget.Version}")));
}
public void AddOrModifyNugetReference(NugetReference referenceToCopy, Project project, VerifiedFolder packagesDirectory)
{
AddOrModifyReferencePackagesConfig(referenceToCopy, project);
AddOrModifyReferenceInProjectFile(referenceToCopy, project, packagesDirectory);
}
public NugetReferenceNotInPackagesFolder(NugetReference reference, Project project)
{
NugetReference = reference;
Project = project;
}
public FileReferenceInsteadOfNugetReference(ProjectGraphNode projectNode, NugetReference missingReference)
: base(projectNode)
{
MissingReference = missingReference;
}
