public static void AddTargetsFileToOldProjects(VCProject vcProject) { string projectFilePath = vcProject.ProjectFile; ProjectRootElement projectRootElement = ProjectRootElement.Open(projectFilePath); ICollection <ProjectImportElement> imports = projectRootElement.Imports; ProjectPropertyGroupElement userMacrosPropertyGroup = projectRootElement.PropertyGroups.Where(g => g.Label.Equals("UserMacros")).FirstOrDefault(); ProjectImportElement userFileImport = imports.Where(i => i.Project.Equals("$(VCTargetsPath)\\Microsoft.Cpp.targets")).FirstOrDefault(); if (userMacrosPropertyGroup != null && !userMacrosPropertyGroup.NextSibling.Equals(userFileImport)) { projectRootElement.RemoveChild(userFileImport); projectRootElement.InsertAfterChild(userFileImport, userMacrosPropertyGroup); //delete all occurences of PLCnCLIIncludes and PLCnCLIMacros -> saved in .users file now IEnumerable <ProjectPropertyElement> elementsToDelete = projectRootElement.PropertyGroups .Where(g => g.Label.Equals("Configuration")) .SelectMany(g => g.Properties .Where(p => p.Name.Equals("PLCnCLIMacros") || p.Name.Equals("PLCnCLIIncludes"))); elementsToDelete.ToList().ForEach(e => e.Parent.RemoveChild(e)); MessageBox.Show("The project file needs to be updated outside of the environment. Please choose 'Reload all...' in the next dialog.", "Project update needed", MessageBoxButton.OK, MessageBoxImage.Exclamation); projectRootElement.Save(); } }
public static void AddImportStatement(this MsBuildProject buildProject, string targetsPath, ProjectImportLocation location) { // adds an <Import> element to this project file if it doesn't already exist. if (buildProject.Xml.Imports == null || buildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase))) { ProjectImportElement pie = buildProject.Xml.AddImport(targetsPath); pie.Condition = "Exists('" + targetsPath + "')"; if (location == ProjectImportLocation.Top) { // There's no public constructor to create a ProjectImportElement directly. // So we have to cheat by adding Import at the end, then remove it and insert at the beginning pie.Parent.RemoveChild(pie); buildProject.Xml.InsertBeforeChild(pie, buildProject.Xml.FirstChild); } else { // the import might get added into an ImportGroup. In this case, // we remove it from the ImportGroup and add it at the end of the // project. if (pie.Parent.GetType() == typeof(ProjectImportGroupElement)) { pie.Parent.RemoveChild(pie); buildProject.Xml.AppendChild(pie); } } NuGet.MSBuildProjectUtility.AddEnsureImportedTarget(buildProject, targetsPath); buildProject.ReevaluateIfNecessary(); } }
static ProjectImportElement AddImportAtTop(ProjectRootElement projectRoot, string importedProjectFile) { ProjectImportElement import = projectRoot.CreateImportElement(importedProjectFile); projectRoot.InsertBeforeChild(import, projectRoot.FirstChild); return(import); }
IEnumerable <ProjectElement> Import(ProjectImportElement import) { string dir = ProjectCollection.GetEvaluationTimeThisFileDirectory(() => FullPath); // FIXME: use appropriate logger (but cannot be instantiated here...?) string path = ProjectCollection.FindFileInSeveralExtensionsPath(ref extensions_path_override, ExpandString, import.Project, TextWriter.Null.WriteLine); path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path); if (ProjectCollection.OngoingImports.Contains(path)) { switch (load_settings) { case ProjectLoadSettings.RejectCircularImports: throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} (resolved as \"{1}\") is already on \"importing\" stack", import.Project, path)); } return(new ProjectElement [0]); // do not import circular references } ProjectCollection.OngoingImports.Push(path); try { using (var reader = XmlReader.Create(path)) { var root = ProjectRootElement.Create(reader, ProjectCollection); raw_imports.Add(new ResolvedImport(import, root, true)); return(this.EvaluatePropertiesAndImportsAndChooses(root.Children).ToArray()); } } finally { ProjectCollection.OngoingImports.Pop(); } }
IEnumerable <ProjectElement> Import(ProjectImportElement import) { string dir = ProjectCollection.GetEvaluationTimeThisFileDirectory(() => FullPath); string path = WindowsCompatibilityExtensions.FindMatchingPath(ExpandString(import.Project)); path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path); if (ProjectCollection.OngoingImports.Contains(path)) { switch (load_settings) { case ProjectLoadSettings.RejectCircularImports: throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} (resolved as \"{1}\") is already on \"importing\" stack", import.Project, path)); } return(new ProjectElement [0]); // do not import circular references } ProjectCollection.OngoingImports.Push(path); try { using (var reader = XmlReader.Create(path)) { var root = ProjectRootElement.Create(reader, ProjectCollection); raw_imports.Add(new ResolvedImport(import, root, true)); return(this.EvaluatePropertiesAndImports(root.Children).ToArray()); } } finally { ProjectCollection.OngoingImports.Pop(); } }
protected ImportElement GetImportElement(ProjectImportElement element) { return((element == null) ? default : new ImportElement(element) { parentProject = this }); }
public void SdkReferenceIsCorrect_CreatedFromOnDiskProject_SdkAttributeSet() { using (TestEnvironment testEnvironment = TestEnvironment.Create()) { TransientTestFile projectFile = testEnvironment.CreateFile( "test.proj", @" <Project> <Import Project=""Sdk.props"" Sdk=""My.Sdk"" /> </Project>"); ProjectRootElement rootElement = ProjectRootElement.Open(projectFile.Path); ProjectImportElement importElement = rootElement.Imports.First(); importElement.SdkReference.Name.ShouldBe("My.Sdk"); importElement.SdkReference.Version.ShouldBeNull(); importElement.SdkReference.MinimumVersion.ShouldBeNull(); SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.Sdk = "My.Sdk"); SetPropertyAndExpectProjectXmlChangedEventToFire(rootElement, () => importElement.Version = "1.2.0", "Set Import Version 1.2.0"); SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.Version = "1.2.0"); importElement.SdkReference.Name.ShouldBe("My.Sdk"); importElement.SdkReference.Version.ShouldBe("1.2.0"); importElement.SdkReference.MinimumVersion.ShouldBeNull(); SetPropertyAndExpectProjectXmlChangedEventToFire(rootElement, () => importElement.MinimumVersion = "1.0.0", "Set Import Minimum Version 1.0.0"); SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.MinimumVersion = "1.0.0"); importElement.SdkReference.Name.ShouldBe("My.Sdk"); importElement.SdkReference.Version.ShouldBe("1.2.0"); importElement.SdkReference.MinimumVersion.ShouldBe("1.0.0"); } }
private static void AddImports(ProjectRootElement root) { root.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets"); ProjectImportElement import = root.AddImport("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props"); import.Condition = "Exists('$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props')"; }
public void SettingConditionDirties() { string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); ProjectRootElement importProject = ProjectRootElement.Create(); importProject.AddProperty("p", "v1"); importProject.Save(file); string content = String.Format ( @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <Import Project='{0}'/> </Project>", file ); Project project = new Project(XmlReader.Create(new StringReader(content))); ProjectImportElement import = Helpers.GetFirst(project.Xml.Imports); import.Condition = "false"; Assert.Equal("v1", project.GetPropertyValue("p")); project.ReevaluateIfNecessary(); Assert.Equal(String.Empty, project.GetPropertyValue("p")); } finally { File.Delete(file); } }
IEnumerable <ProjectElement> Import(ProjectImportElement import) { string dir = projects.GetEvaluationTimeThisFileDirectory(() => FullPath); string path = WindowsCompatibilityExtensions.NormalizeFilePath(ExpandString(import.Project)); path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path); if (projects.OngoingImports.Contains(path)) { throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} is already on \"importing\" stack", path)); } projects.OngoingImports.Push(path); try { using (var reader = XmlReader.Create(path)) { var root = ProjectRootElement.Create(reader, projects); if (DefaultTargets.Count == 0) { DefaultTargets.AddRange(GetDefaultTargets(root)); } raw_imports.Add(new ResolvedImport(import, root, true)); return(this.EvaluatePropertiesAndImports(root.Children).ToArray()); } } finally { projects.OngoingImports.Pop(); } }
public static void SetProperty(Microsoft.Build.Evaluation.Project project, String label, String name, String value) { ProjectPropertyGroupElement group = project.Xml.PropertyGroups.FirstOrDefault(g => g.Label.Equals(label)); if (group == null) { // // Create our property group after the main language targets are imported so we can use the properties // defined in this files. // ProjectImportElement import = project.Xml.Imports.FirstOrDefault( p => (p.Project.IndexOf("Microsoft.Cpp.targets") != -1 || p.Project.IndexOf("IceBuilder.CSharp.props") != -1)); if (import != null) { group = project.Xml.CreatePropertyGroupElement(); project.Xml.InsertAfterChild(group, import); } else { group = project.Xml.CreatePropertyGroupElement(); } group.Label = label; } ProjectPropertyElement property = group.Properties.FirstOrDefault(p => p.Name.Equals(name)); if (property != null) { property.Value = value; } else { group.AddProperty(name, value); } }
/// <summary> /// Add an unresolved regular-style import (i.e. condition is false). /// </summary> /// <param name="import"> /// The declaring import element. /// </param> void AddUnresolvedImport(ProjectImportElement import) { if (import == null) { throw new ArgumentNullException(nameof(import)); } Position importStart = import.Location.ToNative(); XmlLocation importLocation = _projectXmlLocator.Inspect(importStart); if (importLocation == null) { return; } XSElement importElement; if (!importLocation.IsElement(out importElement)) { return; } Add( new MSBuildUnresolvedImport(import, importElement) ); }
/// <summary> /// Initializes a new instance of the <see cref="ResolvedImport"/> struct. /// </summary> internal ResolvedImport(Project project, ProjectImportElement importingElement, ProjectRootElement importedProject) { ErrorUtilities.VerifyThrowInternalNull(importingElement, "parent"); ErrorUtilities.VerifyThrowInternalNull(importedProject, "child"); _importingElement = importingElement; _importedProject = importedProject; _isImported = !ReferenceEquals(project.Xml, importingElement.ContainingProject); }
/// <param name="element"></param> public ImportElement(ProjectImportElement element) : this() { parentElement = element ?? throw new ArgumentNullException(nameof(element)); project = element.Project; condition = element.Condition; label = element.Label; }
/// <summary> /// Add MSBuild Import to the Artifactory project /// </summary> private void AddImportToProj() { var p = Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.GetLoadedProjects(_project.FullName).ElementAt(0); string targetsPath = @"$(solutionDir)\.artifactory\Deploy.targets"; ProjectImportElement import = p.Xml.AddImport(targetsPath); import.Condition = "Exists('" + targetsPath + "')"; _project.Save(); }
/// <summary> /// Initializes a new instance of the <see cref="ResolvedImport"/> struct. /// </summary> internal ResolvedImport(ProjectImportElement importingElement, ProjectRootElement importedProject, int versionEvaluated, SdkResult sdkResult, bool isImported) { ErrorUtilities.VerifyThrowInternalNull(importedProject, "child"); ImportingElement = importingElement; ImportedProject = importedProject; SdkResult = sdkResult; VersionEvaluated = versionEvaluated; IsImported = isImported; }
public static void RemoveImport(this MSBuildBasedProject project, string importedProjectFile) { lock (project.SyncRoot) { ProjectImportElement import = project.FindImport(importedProjectFile); if (import != null) { import.Parent.RemoveChild(import); } } }
/// <summary> /// Initializes a new instance of the <see cref="ResolvedImport"/> struct. /// </summary> internal ResolvedImport(Project project, ProjectImportElement importingElement, ProjectRootElement importedProject, int versionEvaluated, SdkResult sdkResult) { ErrorUtilities.VerifyThrowInternalNull(importedProject, "child"); ImportingElement = importingElement; ImportedProject = importedProject; SdkResult = sdkResult; VersionEvaluated = versionEvaluated; IsImported = importingElement != null && !ReferenceEquals(project.Xml, importingElement.ContainingProject); }
public void Merge_MSBuildProjectHasOneImportAndSharpDevelopProjectHasNoImports_MissingImportAddedToSharpDevelopProject() { AddImportToMSBuildProject("MyImport.targets"); Merge(); ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.FirstOrDefault(); Assert.AreEqual("MyImport.targets", import.Project); Assert.AreEqual(1, sharpDevelopProject.MSBuildProjectFile.Imports.Count); }
private static bool UpdateImport(Microsoft.Build.Evaluation.Project project, String oldValue, String newValue) { ProjectImportElement import = project.Xml.Imports.FirstOrDefault(p => p.Project.Equals(oldValue)); if (import != null) { import.Project = newValue; import.Condition = String.Format("Exists('{0}')", newValue); return(true); } return(false); }
public void Merge_MSBuildProjectHasTwoImportsAndSharpDevelopProjectHasOneImportWhichMatchesOneInMSBuildProject_DifferentImportAddedToSharpDevelopProject() { AddImportToMSBuildProject("MyImport.targets"); AddImportToMSBuildProject("Different.targets"); AddImportToSharpDevelopProject("MyImport.targets"); Merge(); ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.LastOrDefault(); Assert.AreEqual("Different.targets", import.Project); Assert.AreEqual(2, sharpDevelopProject.MSBuildProjectFile.Imports.Count); }
private static bool AddImportAfter(Microsoft.Build.Evaluation.Project project, string import, ProjectElement after) { if (!HasImport(project, import)) { ProjectImportElement props = project.Xml.CreateImportElement(import); props.Condition = string.Format("Exists('{0}')", import); project.Xml.InsertAfterChild(props, after); return(true); } return(false); }
private static ProjectRootElement CreateBasicProjectStructure() { var pre = ProjectRootElement.Create(toolsVersion: "12.0").AddChildren( ProjectPropertyGroupElement.Create().AddChildren( ProjectPropertyElement.Create(name: "TargetFrameworkIdentifier", value: ".NETFramework"), ProjectPropertyElement.Create(name: "TargetFrameworkVersion", value: "v4.5")), ProjectItemGroupElement.Create().AddChildren( ProjectItemElement.Create(itemType: "Compile", include: "a.cs"), ProjectItemElement.Create(itemType: "Compile", include: "b.cs")), ProjectImportElement.Create(project: "$(MSBuildExtensionsPath32)Microsoft.CSharp.targets")); return(pre); }
public void Merge_MSBuildProjectHasOneImportAndSharpDevelopProjectHasTwoImportsOneWhichIsDifferent_DifferentImportRemovedFromSharpDevelopProject() { AddImportToMSBuildProject("MyImport.targets"); AddImportToSharpDevelopProject("MyImport.targets"); AddImportToSharpDevelopProject("Different.targets"); Merge(); ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.FirstOrDefault(); Assert.AreEqual("MyImport.targets", import.Project); Assert.AreEqual(1, sharpDevelopProject.MSBuildProjectFile.Imports.Count); }
private static bool UpdateImport(Microsoft.Build.Evaluation.Project project, string oldValue, string newValue) { ProjectImportElement import = project.Xml.Imports.FirstOrDefault( p => p.Project.Equals(oldValue, StringComparison.CurrentCultureIgnoreCase)); if (import != null) { DTEUtil.EnsureFileIsCheckout(project.FullPath); import.Project = newValue; import.Condition = string.Format("Exists('{0}')", newValue); return(true); } return(false); }
private ProjectRootElement ValidateProject(LockFile lockFile, Action <GenerateLockedPackageReferencesFile> modifier, out MockBuildEngine buildEngine) { buildEngine = new MockBuildEngine(); GenerateLockedPackageReferencesFile task = new GenerateLockedPackageReferencesFile { BuildEngine = buildEngine, ProjectAssetsFile = GetAssetsFilePath(lockFile), }; modifier?.Invoke(task); task.TryCreateProject(out ProjectRootElement project).ShouldBeTrue(); ProjectPropertyGroupElement propertyGroupElement = project.PropertyGroups.ShouldHaveSingleItem(); ProjectPropertyElement propertyElement = propertyGroupElement.Properties.FirstOrDefault(i => i.Name.Equals("NuGetDeterministicPropsWasImported")); propertyElement.ShouldNotBeNull(); propertyElement.Value.ShouldBe("true"); HashSet <string> excludes = new HashSet <string>(task.PackagesToExclude == null ? Enumerable.Empty <string>() : task.PackagesToExclude.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase); foreach (TargetFrameworkInformation targetFramework in lockFile.PackageSpec.TargetFrameworks) { if (!task.ExcludeImplicitReferences && targetFramework.Dependencies.Any(i => !excludes.Contains(i.Name) && i.AutoReferenced)) { ProjectPropertyElement disableImplicitFrameworkReferencesPropertyElement = lockFile.PackageSpec.TargetFrameworks.Count > 1 ? project.Properties.FirstOrDefault(i => i.Name.Equals("DisableImplicitFrameworkReferences") && i.Condition.Contains($"'{targetFramework.FrameworkName.GetShortFolderName()}'")) : project.Properties.FirstOrDefault(i => i.Name.Equals("DisableImplicitFrameworkReferences") && i.Condition.Equals(String.Empty)); disableImplicitFrameworkReferencesPropertyElement.ShouldNotBeNull(); } } ProjectElement secondElement = project.Children.Skip(1).FirstOrDefault(); ProjectImportElement beforeImportElement = secondElement.ShouldBeOfType <ProjectImportElement>(); beforeImportElement.Project.ShouldBe("Before.$(MSBuildThisFile)"); beforeImportElement.Condition.ShouldBe("Exists('Before.$(MSBuildThisFile)')"); ProjectElement lastElement = project.Children.LastOrDefault(); ProjectImportElement afterImportElement = lastElement.ShouldBeOfType <ProjectImportElement>(); afterImportElement.Project.ShouldBe("After.$(MSBuildThisFile)"); afterImportElement.Condition.ShouldBe("Exists('After.$(MSBuildThisFile)')"); return(project); }
public override void Run() { Log.LogMessage("Generating module build package imports"); ProjectRootElement propsProject = ProjectRootElement.Create(PropsFile); ProjectRootElement targetsProject = ProjectRootElement.Create(TargetsFile); ProjectPropertyGroupElement propertyGroup = propsProject.AddPropertyGroup(); foreach (BuildPackageInfo buildPackageInfo in ModulePaths.Select(BuildPackageInfo.FromModulePath).Where(i => i != null)) { if (buildPackageInfo.PropsPath == null && buildPackageInfo.TargetsPath == null) { Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is not a standard NuGet build package."); continue; } // If this is a cbt module do not auto import props or targets. if (File.Exists(Path.Combine(Path.GetDirectoryName(buildPackageInfo.PropsPath ?? buildPackageInfo.TargetsPath), "module.config"))) { Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is a CBT Module."); continue; } ProjectPropertyElement enableProperty = propertyGroup.AddProperty(buildPackageInfo.EnablePropertyName, "false"); enableProperty.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == '' "; ProjectPropertyElement runProperty = propertyGroup.AddProperty(buildPackageInfo.RunPropertyName, "true"); runProperty.Condition = $" '$({buildPackageInfo.RunPropertyName})' == '' "; if (File.Exists(buildPackageInfo.PropsPath)) { ProjectImportElement import = propsProject.AddImport(buildPackageInfo.PropsPath); import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' "; } if (File.Exists(buildPackageInfo.TargetsPath)) { ProjectImportElement import = targetsProject.AddImport(buildPackageInfo.TargetsPath); import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' "; } Log.LogMessage($" Generated imports for '{buildPackageInfo.Id}'."); } propsProject.Save(); targetsProject.Save(); }
private static void InitializeLegacyProjectImports(ProjectRootElement root) { ProjectElement firstChild = root.FirstChild; ProjectElement lastChild = root.LastChild; ProjectImportElement commonImport = root.CreateImportElement("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props"); commonImport.Condition = "Exists('$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props')"; ProjectImportElement csharpImport = root.CreateImportElement("$(MSBuildToolsPath)\\Microsoft.CSharp.targets"); root.InsertBeforeChild(commonImport, firstChild); root.InsertAfterChild(csharpImport, lastChild); }
public void SetProjectInvalidEmpty() { string content = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <Import Project='i1.proj' /> </Project> "; ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(content))); ProjectImportElement import = (ProjectImportElement)Helpers.GetFirst(project.Children); import.Project = String.Empty; }
public static bool AddIceBuilderToProject(Microsoft.Build.Evaluation.Project project) { bool modified = false; if (project != null) { if (IsCppProject(project)) { if (!HasImport(project, IceCppPropsPath)) { ProjectImportElement iceBuilderProps = project.Xml.CreateImportElement(IceCppPropsPath); ProjectImportElement vcProps = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.Cpp.props") != -1); project.Xml.InsertAfterChild(iceBuilderProps, vcProps); modified = true; } if (!HasImport(project, IceCppTargetsPath)) { ProjectImportElement iceBuilderTargets = project.Xml.CreateImportElement(IceCppTargetsPath); ProjectImportElement vcTargets = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.Cpp.targets") != -1); project.Xml.InsertAfterChild(iceBuilderTargets, vcTargets); modified = true; } } else if (IsCSharpProject(project)) { if (!HasImport(project, IceCSharpPropsPath)) { ProjectImportElement iceBuilderProps = project.Xml.CreateImportElement(IceCSharpPropsPath); ProjectImportElement vcProps = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.CSharp.targets") != -1); project.Xml.InsertAfterChild(iceBuilderProps, vcProps); modified = true; } if (!HasImport(project, IceCSharpTargetsPath)) { ProjectImportElement iceBuilderTargets = project.Xml.CreateImportElement(IceCSharpTargetsPath); ProjectImportElement vcTargets = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("IceBuilder.CSharp.props") != -1); project.Xml.InsertAfterChild(iceBuilderTargets, vcTargets); modified = true; } if (!HasProjectFlavor(project, IceBuilderProjectFlavorGUID)) { AddProjectFlavorIfNotExists(project, IceBuilderProjectFlavorGUID); } } } return(modified); }