static void FindProjectInternal(ProjectItems items, List<Project> projectList)
{
if (items == null)
{
return;
}
foreach (ProjectItem item in items)
{
Project project;
if (item.SubProject != null)
{
project = item.SubProject;
}
else
{
project = item.Object as Project;
}
if (project != null)
{
if (ProjectKind.IsSupportedProjectKind(project.Kind))
{
projectList.Add(project);
}
FindProjectInternal(project.ProjectItems, projectList);
}
}
}
private void CheckThatTTOutputIsNotUnderSCC(DTE service, Project project, ProjectItems projectItems)
{
foreach (ProjectItem childItem in projectItems)
{
if (childItem.Name.EndsWith(".tt"))
{
//ok, tt-File found, check, if the child is under source control
if (childItem.ProjectItems.Count > 0)
{
foreach (ProjectItem ttOutputItem in childItem.ProjectItems)
{
string itemname = Helpers.GetFullPathOfProjectItem(ttOutputItem); // ttOutputHelpers.GetFullPathOfProjectItem(item);
if(service.SourceControl.IsItemUnderSCC(itemname))
{
Helpers.LogMessage(service, this, "Warning: File " + itemname + " should not be under source control");
if (MessageBox.Show("Warning: File " + itemname + " should not be under source control. " + Environment.NewLine + Environment.NewLine + "Exclude file from source control?", "Warning", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
Helpers.ExcludeItemFromSCC(service, project, ttOutputItem);
solved++;
}
else
{
ignored++;
}
}
}
}
}
CheckThatTTOutputIsNotUnderSCC(service, project, childItem.ProjectItems);
}
}
private static IEnumerable<Project> GetAllProjects(ProjectItems projectItems)
{
if(projectItems == null)
yield break;
foreach(var projectItem in projectItems.Cast<ProjectItem>())
{
if(projectItem.SubProject != null)
{
yield return projectItem.SubProject;
foreach(var project in GetAllProjects(projectItem.SubProject))
{
yield return project;
}
}
else
{
foreach(var project in GetAllProjects(projectItem.ProjectItems))
{
yield return project;
}
}
}
}
private static void CopyProjectItems(ProjectItems sourceItems, ProjectItems targetItems)
{
foreach (ProjectItem projectItem in sourceItems)
{
ProjectItem tempItem = null;
try
{
tempItem = targetItems.Item(projectItem.Name);
}
catch (ArgumentException)
{
if (projectItem.Kind == "{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}")
{
if (projectItem.Name != "Properties")
{
tempItem = targetItems.AddFolder(projectItem.Name);
}
}
else if (projectItem.Name != "packages.config")
{
tempItem = targetItems.AddFromFile(projectItem.Properties.Item("LocalPath").Value as string);
}
}
if (tempItem != null)
{
CopyProjectItems(projectItem.ProjectItems, tempItem.ProjectItems);
}
}
}
static void FindProjectInternal(ProjectItems items, List<Project> projectList)
{
if (items == null)
{
return;
}
foreach (ProjectItem item in items)
{
try
{
var project = item.SubProject;
if (project == null)
{
project = item.Object as Project;
}
if (project != null)
{
if (ProjectKind.IsSupportedProjectKind(project.Kind))
{
projectList.Add(project);
}
FindProjectInternal(project.ProjectItems, projectList);
}
}
catch (NotImplementedException)
{
}
catch (NullReferenceException)
{
}
}
}
public IEnumerable<ProjectItem> GetAllProjectItemsRecursive(ProjectItems projectItems)
{
foreach (ProjectItem projectItem in projectItems)
{
if (projectItem == null)
{
continue;
}
if (projectItem.ProjectItems != null)
{
foreach (ProjectItem subItem in GetAllProjectItemsRecursive(projectItem.ProjectItems))
{
// INFO: We only want real files, not folders etc.
// http://msdn.microsoft.com/en-us/library/z4bcch80%28v=vs.80%29.aspx
if (subItem.Kind == "{6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}")
{
yield return subItem;
}
}
}
// INFO: We only want real files, not folders etc.
// http://msdn.microsoft.com/en-us/library/z4bcch80%28v=vs.80%29.aspx
if (projectItem.Kind == "{6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}")
{
yield return projectItem;
}
}
}
private static void DrillDownInProjectItems(ProjectItems projectItems, Review review, ProcessProjectItemScanResult psr, out bool found)
{
found = false;
ProjectItems projItems;
ProjectItem projectItem = projectItems.Parent as ProjectItem;
//Check if the parent itself matches before searching for the parent's children.
if (projectItem.Name == review.File)
{
psr.Invoke(projectItem, review);
found = true;
return;
}
foreach (ProjectItem projItem in projectItems)
{
projItems = projItem.ProjectItems;
if ((projItems != null
&& (projItems.Count > 0)))
{
// recurse to get to the bottom of the tree
DrillDownInProjectItems(projItems, review, psr, out found);
if (found)
{
return;
}
}
else if (projItem.Name == review.File && projItem.ContainingProject.Name == review.Project)
{
// call back to the user function delegated to
// handle a single project item
psr.Invoke(projItem, review);
found = true;
return;
}
}
}
private static ProjectItem CheckProjectItemsRecursive(ProjectItems projectItems, string path)
{
foreach (ProjectItem projectItem in projectItems)
{
if (projectItem.ProjectItems != null && projectItem.ProjectItems.Count > 0)
{
var x = CheckProjectItemsRecursive(projectItem.ProjectItems, path);
if (x != null)
{
return x;
}
}
for (short i = 1; i <= projectItem.FileCount; i++)
{
try
{
var filename = projectItem.FileNames[i];
if (filename != null)
{
if (filename.ToLower() == path)
{
return projectItem;
}
}
}
catch(Exception ex)
{
}
}
}
return null;
}
private static void AddFiles(Project project, ProjectItems items, Document currentDoc)
{
foreach (ProjectItem subItem in items)
{
if (currentDoc == subItem)
continue;
if (subItem.Kind == PhysicalFolderKind || subItem.Kind == VirtualFolderKind)
AddFiles (project, subItem.ProjectItems, currentDoc);
else if (subItem.Kind == PhysicalFileKind)
{
if (subItem.Name.EndsWith (".cs")) // HACK: Gotta be a better way to know if it's C#.
{
for (short i = 0; i < subItem.FileCount; i++)
{
string path = subItem.FileNames[i];
if (path == currentDoc.FullName)
continue;
project.Sources.Add (Either<FileInfo, string>.A (new FileInfo (path)));
}
}
}
}
}
private List<string> FilesFromProjectItems(ProjectItems projectItems, string path)
{
if (projectItems == null)
return null;
List<string> result = new List<string>();
foreach (ProjectItem item in projectItems)
{
if (item.Kind == ProjectItemKind.PhysicalFile)
{
if (item.Name.EndsWith(".js", StringComparison.InvariantCultureIgnoreCase) == true)
{
result.Add(item.FileNames[0]);
}
}
else if (item.Kind == ProjectItemKind.PhysicalFolder || item.Kind == ProjectItemKind.VirtualFolder)
{
List<string> files = FilesFromProjectItems(item.ProjectItems, path + "\\" + item.Name );
result.AddRange(files);
}
}
return result;
}
/// <summary>
/// Generate a list of all files included in the Visual Studio solutions.
/// </summary>
/// <param name="projectName"></param>
/// <param name="projectItems"></param>
/// <param name="fileDetails"></param>
private void CreateFileList(string projectName, ProjectItems projectItems, ref List<FileDetails> fileDetails)
{
foreach (ProjectItem projItem in projectItems)
{
if (projItem.ProjectItems != null && projItem.ProjectItems.Count > 0)
{
// This is a sub project...
CreateFileList(projectName, projItem.ProjectItems, ref fileDetails);
}
if (projItem.Kind == Constants.vsProjectItemKindPhysicalFile)
{
string entirePathAndFile = projItem.Properties.Item("FullPath").Value as string;
string fileName = Path.GetFileName(entirePathAndFile);
string path = Path.GetDirectoryName(entirePathAndFile);
FileDetails details = new FileDetails();
details.FileName = fileName;
details.Path = path;
details.Project = projectName;
fileDetails.Add(details);
}
}
}
/// <summary>
/// Find the first project item with the given filename.
/// </summary>
/// <param name="projectItems">
/// The list of project items to inspect recursively.
/// </param>
/// <param name="filename">
/// The name of the project item to find.
/// </param>
/// <param name="recurse">
/// Whether to recurse into project items. Optional, true by default.
/// </param>
/// <returns>
/// Returns the first project item with the given filename.
/// </returns>
public static ProjectItem FindProjectItem(ProjectItems projectItems, string filename, bool recurse = true)
{
if (projectItems == null)
{
return null;
}
foreach (ProjectItem item in projectItems)
{
if (string.Equals(item.Name, filename, StringComparison.OrdinalIgnoreCase))
{
return item;
}
else if (recurse && item.ProjectItems != null)
{
var subItem = ProjectUtilities.FindProjectItem(item.ProjectItems, filename);
if (subItem != null)
{
return subItem;
}
}
}
return null;
}
static IEnumerable<ProjectItem> AllProjectItemsRecursive(ProjectItems projectItems)
{
if (projectItems == null)
yield break;
foreach (ProjectItem projectItem in projectItems)
{
if (projectItem.IsFolder() && projectItem.ProjectItems != null)
{
foreach (var folderProjectItem in AllProjectItemsRecursive(projectItem.ProjectItems))
{
yield return folderProjectItem;
}
}
else if (projectItem.IsSolutionFolder())
{
foreach (var solutionProjectItem in AllProjectItemsRecursive(projectItem.SubProject.ProjectItems))
{
yield return solutionProjectItem;
}
}
else
{
yield return projectItem;
}
}
}
public static ProjectItem FindProjectItem(ProjectItems items, string file)
{
var atom = file.Substring(0, file.IndexOf("\\") + 1);
foreach (ProjectItem item in items)
{
if (atom.StartsWith(item.Name))
{
// then step in
var ritem = FindProjectItem(item.ProjectItems, file.Substring(file.IndexOf("\\") + 1));
if (ritem != null)
return ritem;
}
if (Regex.IsMatch(item.Name, file))
return item;
if (item.ProjectItems.Count > 0)
{
ProjectItem ritem = FindProjectItem(item.ProjectItems, file.Substring(file.IndexOf("\\") + 1));
if (ritem != null)
return ritem;
}
}
return null;
}
/// <summary>
/// Lookup the license header file within the given projectItems.
/// </summary>
/// <param name="projectItems"></param>
/// <returns>A dictionary, which contains the extensions and the corresponding lines</returns>
public static IDictionary<string, string[]> GetHeader (ProjectItems projectItems)
{
//Check for License-file within this level
var headerFile = GetLicenseHeaderDefinitions (projectItems);
if (!string.IsNullOrEmpty (headerFile))
return LoadLicenseHeaderDefinition (headerFile); //Found a License header file on this level
return null;
}
public ProjectItem AddDefinitionFileToOneProject (string fileName, ProjectItems projectItems)
{
var licenseHeaderDefinitionFileName = OpenFileDialogForExistingFile(fileName);
if (licenseHeaderDefinitionFileName == string.Empty) return null;
return AddFileToProject(projectItems, licenseHeaderDefinitionFileName);
}
private CodeElement FindType(ProjectItems projectItems, string typename)
{
var tokens = typename.Split('.');
var path =new Queue<string>(tokens.ToList());
while ( path.Count>0)
{
var itemName = path.Dequeue();
var found = false;
Debug.WriteLine("Searching for " + itemName );
if (projectItems == null) break;
foreach (ProjectItem projectItem in projectItems)
{
Debug.WriteLine("Checking " + projectItem.Name );
if (projectItem.Name.Equals(itemName, StringComparison.CurrentCultureIgnoreCase))
{
Debug.WriteLine("Found the project Item!!!");
found = true;
if (projectItem.ProjectItems != null && projectItem.ProjectItems.Count > 0)
{
Debug.WriteLine("Searching children");
// search the children of this projectitem
var foundHere = FindType(projectItem.ProjectItems, string.Join(".", path.ToArray()));
if (foundHere != null)
{
Debug.WriteLine("Found in children of " + projectItem.Name );
return foundHere;
}
Debug.WriteLine("Continuing looking");
break;
}
}
else
{
var theType = FindType(projectItem, typename);
if (theType != null)
{
Debug.WriteLine("Found it!!!!" + theType.FullName );
return theType;
}
}
}
if (!found)
{
Debug.WriteLine("Didnt find this token" + itemName );
break;
}
}
return null;
}
private void Generate(ProjectItems items)
{
if (items == null) return;
foreach (ProjectItem item in items)
{
Generate(item);
}
}
//private static void DoVcProject
private static void DoProjectItems(
ProjectItems projectItems
)
{
foreach (ProjectItem projectItem in projectItems)
{
DoProjectItem(projectItem);
}
}
internal static IEnumerable<ProjectItem> EnumerateCSharpFiles(ProjectItems list)
{
foreach (ProjectItem item in EnumerateItems(list))
{
if (item.Name.EndsWith(".cs"))
{
yield return item;
}
}
}
private static List<ProjectItem>Get(ProjectItems projectItems)
{
var items = new List<ProjectItem>();
foreach (var projectItem in projectItems.Cast<ProjectItem>())
{
items.Add(projectItem);
items.AddRange(Get(projectItem.ProjectItems));
}
return items;
}
private void CopyFolder(DTE dte, string sourceFolder, string destFolder, ProjectItems parentProjectItems)
{
//first copy all files
string[] files = Directory.GetFiles(sourceFolder);
foreach (string file in files)
{
string name = Path.GetFileName(file);
string dest = Path.Combine(destFolder, name);
if (File.Exists(dest))
{
//if (MessageBox.Show("Project file " + name + " already exists. Overwrite?", "Overwrite file", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
//Helpers.WriteToOutputWindow(dte, "Warning: File " + dest + " replaced.", false);
File.Copy(file, dest, true);
}
}
else
{
File.Copy(file, dest, true);
}
try
{ //add file to project items
ProjectItem addItem = AddFromFile(parentProjectItems, dest);
addItem.Properties.Item("BuildAction").Value = 2;
}
catch (Exception)
{ //file already existed
}
}
//second create the directories in the project if they are not there
string[] sourcefolders = Directory.GetDirectories(sourceFolder);
foreach (string sourcefolder in sourcefolders)
{
string name = Path.GetFileName(sourcefolder);
string dest = Path.Combine(destFolder, name);
//create folder in the project if it not exists
ProjectItem projectFolder = null;
try
{
projectFolder = GetProjectItemByName(parentProjectItems, name);
}
catch (Exception)
{
}
if (projectFolder == null)
{
projectFolder = parentProjectItems.AddFolder(name, EnvDTE.Constants.vsProjectItemKindPhysicalFolder);
}
CopyFolder(dte, sourcefolder, dest, projectFolder.ProjectItems);
}
}
private ProjectItem GetProjectItemByName(ProjectItems pitems, string name)
{
foreach (ProjectItem pitem in pitems)
{
if (pitem.Name.ToUpper() == name.ToUpper())
{
return pitem;
}
}
throw new Exception("ProjectItem " + name + " not found");
}
public static ProjectItem GetProjectItemByName(ProjectItems pitems, string name)
{
foreach (ProjectItem pitem in pitems)
{
if (pitem.Name.ToUpper() == name.ToUpper())
{
return pitem;
}
}
return null;
}
IList<Page> IVisualStudioService.GetPages(ProjectItems projectItems)
{
List<Page> pages = new List<Page>();
foreach (ProjectItem item in projectItems)
{
pages.AddRange(GetPages(item));
}
return pages;
}
protected void WalkProjectItems( ProjectComponent project, ProjectItems itemList )
{
if( itemList != null )
{
foreach( ProjectItem item in itemList )
{
VisitProject( project, item );
WalkProjectItems( project, item.ProjectItems ); // Get children.
}
}
}
/// <summary>
/// Finds any item called "app.config" or "web.config" in the given list of project items and performs the given action for each.
/// </summary>
public virtual void FindConfigFiles(ProjectItems items, Action<ProjectItem> action)
{
DebugCheck.NotNull(items);
DebugCheck.NotNull(action);
foreach (ProjectItem projectItem in items)
{
if (projectItem.IsConfig())
{
action(projectItem);
}
}
}
/// <summary>
/// Finds any item called "app.config" or "web.config" in the given list of project items and performs the given action for each.
/// </summary>
public virtual void FindConfigFiles(ProjectItems items, Action<ProjectItem> action)
{
Contract.Requires(items != null);
Contract.Requires(action != null);
foreach (ProjectItem projectItem in items)
{
if (projectItem.IsConfig())
{
action(projectItem);
}
}
}
public static void AddItem(string ttInclude, string vsVersion, string netVersion, string ttIncludeName, string templatesFolder, HashSet<string> existingTTIncludes, ProjectItems templatesProjectItems)
{
var m = Regex.Match(ttInclude, @".(NET\d+).");
if (!m.Success || m.Groups[1].Value == netVersion)
{
const string x64Key = @"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows";
if (ttIncludeName.EndsWith(".x64"))
{
try
{
if (Registry.LocalMachine.OpenSubKey(x64Key) == null)
{
return;
}
ttIncludeName = ttIncludeName.Substring(0, ttIncludeName.Length - 4);
}
catch
{
return;
}
}
else if (ttIncludeName.EndsWith(".x86"))
{
try
{
if (Registry.LocalMachine.OpenSubKey(x64Key) != null)
{
return;
}
}
catch
{
}
ttIncludeName = ttIncludeName.Substring(0, ttIncludeName.Length - 4);
}
var ttIncludeCopy = Path.Combine(templatesFolder, ttIncludeName);
if (!existingTTIncludes.Contains(ttIncludeName))
{
templatesProjectItems.AddFromFile(ttIncludeCopy);
}
if (ttIncludeName.Contains("." + vsVersion + "." + netVersion + "."))
{
ttIncludeCopy = ttIncludeCopy.Substring(0, ttIncludeCopy.Length - 10) + ".merge.tt";
ttIncludeName = Path.GetFileName(ttIncludeCopy);
if (!existingTTIncludes.Contains(ttIncludeName))
{
templatesProjectItems.AddFromFile(ttIncludeCopy);
}
}
}
}
/// <summary>
/// add all the item from the project that match one of the file includes
/// </summary>
private void AddNuSpecFilesCSharpVisualBasic(ProjectItems items, PackageInformation packageInfo, ProjectInformation projectInformation)
{
//-----get all the include able item here
foreach (ProjectItem item in items)
{
//-----check if the item contains an item type property
string itemType = ExtensionUtil.GetPropertyValue<string>(item.Properties, projectInformation.ItemType, null);
if (!string.IsNullOrEmpty(itemType))
{
object itemOutput = ExtensionUtil.GetPropertyValue<object>(item.Properties, projectInformation.ItemOutput, -1);
if (itemOutput != null && itemOutput.ToString() != "0")
{
string itemFullPath = ExtensionUtil.GetPropertyValue<string>(item.Properties, "FullPath", null);
if (!string.IsNullOrEmpty(itemFullPath))
{
try
{
string itemRelativePath = itemFullPath.Remove(0, Path.GetDirectoryName(packageInfo.ProjectFullName).Length + 1).Replace("\\", "/");
if (!itemRelativePath.Contains("/"))
itemRelativePath = string.Format("/{0}", itemRelativePath);
LoggingManager.Instance.Logger.Debug(string.Format("checking item [{0}] for a possible fit", itemRelativePath));
FileInclude fileInclude = packageInfo.ProjectOptions.NuGetOptions.NuSpecOptions.Files.FileIncludes.FirstOrDefault(x =>
{
string wildcard = string.Format("{0}/{1}", string.IsNullOrEmpty(x.Folder) ? "*" : x.Folder.Replace("\\", "/"), string.IsNullOrEmpty(x.Name) ? "*" : x.Name.Replace("\\", "/"));
LoggingManager.Instance.Logger.Debug(string.Format("checking file include [{0}]", wildcard));
return StringUtil.MatchesWildcard(itemRelativePath, wildcard);
});
if (fileInclude != null)
{
packageInfo.NuSpecPackage.Files.Add(new Xml.NuGet.NuSpec.File() { Source = itemFullPath, Target = fileInclude.Target });
LoggingManager.Instance.Logger.Debug(string.Format("added file [{0}] under [{1}]", itemFullPath, fileInclude.Target));
}
else
{
LoggingManager.Instance.Logger.Info(string.Format("could not add file [{0}] because no fitting file include was found", itemFullPath));
}
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is ThreadInterruptedException)
throw;
LoggingManager.Instance.Logger.Error(string.Format("error occured while adding the item [{0}]", itemFullPath), ex);
}
}
}
}
//-----check sub items if any
AddNuSpecFilesCSharpVisualBasic(item.ProjectItems, packageInfo, projectInformation);
}
}
public static ProjectItem FindFolder(this ProjectItems items, string folderName)
{
var item = items.FindItem(folderName, StringComparer.OrdinalIgnoreCase);
return(item.IsFolder() ? item : null);
}
protected override void AddFileToContainer(string fullPath, ProjectItems container)
{
// You can't add files to an Azure project
}
public void CreateLibraryFileFromProject(string fileName)
{
string file = ProjectItems.LoadFile("eWolfPodcasterCore.RawData.PodcastList.xml");
File.WriteAllText(fileName, file);
}
static IEnumerable <ProjectItem> Items(ProjectItems ProjectItems)
{
return(ProjectItems.Cast <ProjectItem>().SelectMany(Items));
}
private static IEnumerable <string> EnumerateProjectItems(ProjectItems projectItems)
{
return(projectItems.Cast <ProjectItem>().SelectMany(p => EnumerateProjectItems(p)));
}
private ProjectItem GetOrCreateParentItem(string filePath)
{
if (string.IsNullOrEmpty(filePath))
{
return(templateProjectItem);
}
string projectDirectory = Path.GetDirectoryName(templateProjectItem.ContainingProject.FullName);
string fileDirectory = Path.GetDirectoryName(filePath);
if (fileDirectory.ToLower() == projectDirectory.ToLower())
{
return(templateProjectItem);
}
ProjectItem result = templateProjectItem;
string relativeFilePath = fileDirectory.Substring(projectDirectory.Length + 1);
Queue <string> pathParts = new Queue <string>(relativeFilePath.Split('\\'));
ProjectItems currentItemList = templateProjectItem.ContainingProject.ProjectItems;
while (pathParts.Any())
{
bool found = false;
string pathPart = pathParts.Dequeue();
for (int index = 1; index <= currentItemList.Count; ++index)
{
ProjectItem item = currentItemList.Item(index);
if (item.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFolder && item.Name == pathPart)
{
if (!pathParts.Any())
{
result = item;
}
else
{
currentItemList = item.ProjectItems;
}
found = true;
break;
}
}
if (!found)
{
ProjectItem newItem = currentItemList.AddFolder(pathPart);
if (!pathParts.Any())
{
result = newItem;
}
else
{
currentItemList = newItem.ProjectItems;
}
}
}
return(result);
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void MenuItemCallback(DestinationType destination)
{
string message = string.Format(CultureInfo.CurrentCulture, "Inside {0}.MenuItemCallback()", this.GetType().FullName);
ProjectItems rootItems = null;
switch (destination)
{
case DestinationType.Solution:
{
}
break;
case DestinationType.SolutionFolder:
case DestinationType.Project:
{
// figure out if a project or project-folder was clicked
try
{
IntPtr hierarchyPointer, selectionContainerPointer;
Object selectedObject = null;
IVsMultiItemSelect multiItemSelect;
uint projectItemId;
IVsMonitorSelection monitorSelection =
(IVsMonitorSelection)Package.GetGlobalService(
typeof(SVsShellMonitorSelection));
monitorSelection.GetCurrentSelection(out hierarchyPointer,
out projectItemId,
out multiItemSelect,
out selectionContainerPointer);
IVsHierarchy selectedHierarchy = Marshal.GetTypedObjectForIUnknown(
hierarchyPointer,
typeof(IVsHierarchy)) as IVsHierarchy;
if (selectedHierarchy != null)
{
ErrorHandler.ThrowOnFailure(selectedHierarchy.GetProperty(
projectItemId,
(int)__VSHPROPID.VSHPROPID_ExtObject,
out selectedObject));
}
dynamic dyn = selectedObject;
rootItems = (ProjectItems)(dyn.ProjectItems);
}
catch (Exception)
{
// what the heck was clicked ???
}
}
break;
}
string basePath;
switch (destination)
{
default:
case DestinationType.Solution:
case DestinationType.SolutionFolder:
{
Solution2 sol2 = (Solution2)dte.Solution;
basePath = Path.GetDirectoryName(sol2.FullName);
}
break;
case DestinationType.Project:
{
basePath = Path.GetDirectoryName(rootItems.ContainingProject.FullName);
}
break;
}
try
{
DirectoryInfo folder = GetFolder(basePath, destination);
if (folder == null)
{
return;
}
const string folderKindVirtual = @"{6BB5F8F0-4483-11D3-8BCF-00C04F8EC28C}";
const string folderKindPhysical = @"{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}";
string folderKind = folderKindVirtual;
bool isSolutionFolder = false;
switch (destination)
{
case DestinationType.Solution:
{
Solution2 solution = (Solution2)dte.Solution;
rootItems = solution.AddSolutionFolder(folder.Name).ProjectItems;
isSolutionFolder = true;
}
break;
case DestinationType.SolutionFolder:
{
var solutionFolder = (SolutionFolder)((Project)rootItems.Parent).Object;
rootItems = solutionFolder.AddSolutionFolder(folder.Name).ProjectItems;
isSolutionFolder = true;
}
break;
case DestinationType.Project:
{
if (rootItems != null)
{
try
{
// try virtual folder first (C/C++ projects)
rootItems = rootItems.AddFolder(folder.Name, folderKind).ProjectItems;
}
catch (Exception)
{
// try physical folder (.net language projects)
folderKind = folderKindPhysical;
rootItems = rootItems.AddFolder(folder.Name, folderKind).ProjectItems;
}
}
}
break;
}
IncludeFiles(folder, rootItems, isSolutionFolder, folderKind, folder.Name);
}
catch (Exception ex)
{
dte.StatusBar.Text = $"Error while Creating Folders: {ex.Message}";
}
}
private static bool ContainsItem(string itemName, ProjectItems items)
{
return(items.Cast <ProjectItem>().Any(item => item.Name == itemName));
}
/// <summary>
/// Get the list of all supported projects in the current solution. This method
/// recursively iterates through all projects.
/// </summary>
public static IEnumerable <Project> GetAllProjects(this Solution solution)
{
if (solution == null || !solution.IsOpen)
{
yield break;
}
var projects = new Stack <Project>();
foreach (Project project in solution.Projects)
{
if (!project.IsExplicitlyUnsupported())
{
projects.Push(project);
}
}
while (projects.Any())
{
Project project = projects.Pop();
if (project.IsSupported())
{
yield return(project);
}
else if (project.IsExplicitlyUnsupported())
{
// do not drill down further if this project is explicitly unsupported, e.g. LightSwitch projects
continue;
}
ProjectItems projectItems = null;
try
{
// bug 1138: Oracle Database Project doesn't implement the ProjectItems property
projectItems = project.ProjectItems;
}
catch (NotImplementedException)
{
continue;
}
// ProjectItems property can be null if the project is unloaded
if (projectItems != null)
{
foreach (ProjectItem projectItem in projectItems)
{
try
{
if (projectItem.SubProject != null)
{
projects.Push(projectItem.SubProject);
}
}
catch (NotImplementedException)
{
// Some project system don't implement the SubProject property,
// just ignore those
continue;
}
}
}
}
}
public override void Execute()
{
if (string.IsNullOrEmpty(Content))
{
return;
}
DTE dte = base.GetService <DTE>(true);
string fileWithContent = "";
string testcontent = Content.Trim(new char[] { ' ', '\t', '\n', '\r' });
if ((testcontent == "") || (testcontent == "dummy"))
{
//no content, check for sourcefile
if (SourceFileName == null)
{
return;
}
if (SourceFileName == "")
{
return;
}
fileWithContent = this.SourceFileName;
string templateBasePath = GetTemplateBasePath();
if (!Path.IsPathRooted(fileWithContent))
{
fileWithContent = Path.Combine(templateBasePath, fileWithContent);
fileWithContent = new FileInfo(fileWithContent).FullName;
}
}
else
{
fileWithContent = Path.GetTempFileName();
using (StreamWriter writer = new StreamWriter(fileWithContent, false))
{
writer.Write(content);
writer.Close();
}
}
if ((TargetFileName == null) || (TargetFileName == ""))
{
if (File.Exists(fileWithContent))
{
TargetFileName = Path.GetFileName(fileWithContent);
}
}
Project projectByName = Helpers.GetProjectByName(dte, projectName);
if (projectByName != null)
{
ProjectItems whereToAdd = projectByName.ProjectItems;
//check if item exists
ProjectItem existingFile = null;
try
{
existingFile = Helpers.GetProjectItemByName(whereToAdd, TargetFileName);
}
catch (Exception)
{
}
if (existingFile != null && !Overwrite)
{
Helpers.LogMessage(dte, this, "File " + TargetFileName + " exists and will not be overwritten");
return;
}
//if targetfilename ends with .tt, we remove any file with the same start
if (TargetFileName.EndsWith(".tt"))
{
//is there any file with the same name, but different extension
foreach (ProjectItem pitem in whereToAdd)
{
if (Path.GetFileNameWithoutExtension(pitem.Name.ToUpper()) == Path.GetFileNameWithoutExtension(TargetFileName.ToUpper()))
{
string deletedFilepath = Helpers.GetFullPathOfProjectItem(pitem); //pHelpers.GetFullPathOfProjectItem(item);
//delete the file
pitem.Remove();
File.Delete(deletedFilepath);
break;
}
}
}
ProjectItem _ProjectItem = Helpers.AddFromTemplate(whereToAdd, fileWithContent, this.TargetFileName);
}
else
{
//do nothing if project is not found
//throw new Exception("Project with name " + projectName + " not found in solution");
}
}
protected virtual void AddFileToContainer(string fullPath, string folderPath, ProjectItems container)
{
container.AddFromFileCopy(fullPath);
}
public static void AddNewItem(string templateName, string name, string extension, string destinationPath)
{
var project = GetActiveProject();
if (project != null)
{
DTE dte = VsAppShell.Current.GetGlobalService <DTE>();
var solution = (Solution2)dte.Solution;
// Construct name of the compressed template
var compressedTemplateName = Path.ChangeExtension(templateName, "zip");
var templatePath = Path.Combine(GetProjectItemTemplatesFolder(), compressedTemplateName);
// We will be extracting template contents into a temp folder
var uncompressedTemplateFolder = Path.Combine(Path.GetTempPath(), templateName);
var uncompressedTemplateName = Path.ChangeExtension(compressedTemplateName, "vstemplate");
var tempTemplateFile = Path.Combine(uncompressedTemplateFolder, uncompressedTemplateName);
// Extract template files overwriting any existing ones
using (ZipArchive zip = ZipFile.OpenRead(templatePath)) {
foreach (ZipArchiveEntry entry in zip.Entries)
{
if (!Directory.Exists(uncompressedTemplateFolder))
{
Directory.CreateDirectory(uncompressedTemplateFolder);
}
string destFilePath = Path.Combine(uncompressedTemplateFolder, entry.FullName);
if (!string.IsNullOrEmpty(entry.Name))
{
entry.ExtractToFile(destFilePath, true);
}
else
{
Directory.CreateDirectory(Path.GetDirectoryName(destFilePath));
}
}
// Given path to the project or a folder in it, generate unique file name
var fileName = GetUniqueFileName(destinationPath, name, extension);
// Locate folder in the project
var projectFolder = Path.GetDirectoryName(project.FullName);
if (destinationPath.StartsWith(projectFolder, StringComparison.OrdinalIgnoreCase))
{
ProjectItems projectItems = project.ProjectItems;
if (destinationPath.Length > projectFolder.Length)
{
var relativePath = destinationPath.Substring(projectFolder.Length + 1);
// Go into folders and find project item to insert the file in
while (relativePath.Length > 0)
{
int index = relativePath.IndexOf('\\');
string folder;
if (index >= 0)
{
folder = relativePath.Substring(0, index);
relativePath = relativePath.Substring(index + 1);
}
else
{
folder = relativePath;
relativePath = string.Empty;
}
try {
var item = projectItems.Item(folder);
projectItems = item.ProjectItems;
} catch (COMException) {
return;
}
}
}
projectItems?.AddFromTemplate(tempTemplateFile, Path.GetFileName(fileName));
}
}
}
}
///-------------------------------------------------------------------------------------------------------------
/// <summary>
/// Gets a VshierarchyItem for the designer file if possible.
/// Will create new file if specified and not existing.
/// </summary>
///-------------------------------------------------------------------------------------------------------------
protected virtual VsHierarchyItem GetDesignerItem(VsHierarchyItem itemCode, bool create)
{
VsHierarchyItem itemDesigner = null;
if (itemCode != null)
{
// Calculate codebehind and designer file paths
string codeBehindFile = itemCode.FullPath();
string designerFile = null;
if (_isPartialClassDisabled)
{
designerFile = codeBehindFile;
}
else if (!string.IsNullOrEmpty(codeBehindFile))
{
designerFile = codeBehindFile.Insert(codeBehindFile.LastIndexOf("."), ".designer");
}
// Try to locate existing designer file
if (!string.IsNullOrEmpty(designerFile))
{
itemDesigner = VsHierarchyItem.CreateFromMoniker(designerFile, _hierarchy);
if (itemDesigner != null)
{
return(itemDesigner);
}
}
// Create empty designer file if requested
if (create && !string.IsNullOrEmpty(designerFile))
{
ProjectItem projectItemCode = itemCode.ProjectItem();
if (projectItemCode != null)
{
ProjectItems projectItems = projectItemCode.Collection;
if (projectItems != null)
{
try
{
using (StreamWriter sw = File.CreateText(designerFile))
{
sw.WriteLine(" ");
}
projectItems.AddFromFileCopy(designerFile);
}
catch
{
}
itemDesigner = VsHierarchyItem.CreateFromMoniker(designerFile, _hierarchy);
if (itemDesigner != null)
{
return(itemDesigner);
}
}
}
}
}
return(itemDesigner);
}
/// <summary>
/// Lookup the license header file within the given projectItems.
/// </summary>
/// <param name="projectItems"></param>
/// <returns>A dictionary, which contains the extensions and the corresponding lines</returns>
public static IDictionary <string, string[]> SearchItemsDirectlyGetHeaderDefinition(ProjectItems projectItems)
{
// Check for License-file within this level
var headerFileName = SearchItemsDirectlyGetHeaderDefinitionFileName(projectItems);
if (!string.IsNullOrEmpty(headerFileName))
{
return(LoadHeaderDefinition(headerFileName)); // Found a License header file on this level
}
return(null);
}
private async Task DeleteProjectItemAsync(Project project, string deleteFileName)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
ProjectItems prjItems = project.ProjectItems;
ProjectItem deleteItem = prjItems.OfType <ProjectItem>()
.Where(c =>
{
ThreadHelper.ThrowIfNotOnUIThread();
return(c.Name.ToLower() == deleteFileName.ToLower());
})
.FirstOrDefault();
#pragma warning disable VSTHRD109 // 使用非同步方法時請切換而非判斷提示
ThreadHelper.ThrowIfNotOnUIThread();
#pragma warning restore VSTHRD109 // 使用非同步方法時請切換而非判斷提示
try
{
deleteItem.Remove();
}
catch (Exception ex) { }
if (deleteItem != null)
{
var deletePhysicalName = deleteItem.Properties.Item("FullPath");
string fullPath = deletePhysicalName.Value.ToString();
try
{
string deletePath = Path.GetDirectoryName(fullPath);
try
{
File.Delete(fullPath);
}
catch { }
//真的移除掉該實體檔案
switch (deleteFileName.ToLower())
{
case "web.config":
File.Delete(Path.Combine(deletePath, "Web.Debug.config"));
File.Delete(Path.Combine(deletePath, "Web.Release.config"));
break;
case "global.asax":
File.Delete(Path.Combine(deletePath, "global.asax.cs"));
break;
case "app_start":
File.Delete(Path.Combine(deletePath, "RouteConfig.cs"));
File.Delete(Path.Combine(deletePath, "WebApiConfig.cs"));
Directory.Delete(deletePath);
break;
case "properties":
File.Delete(Path.Combine(deletePath, "AssemblyInfo.cs"));
break;
case "views":
File.Delete(Path.Combine(deletePath, "web.config"));
break;
}
}
catch (Exception ex) { }
}
}
private string[] GetFilesFromHierarchy(string filename, string[] additionalBuffers)
{
int itemid;
IVsHierarchy hier = ShellDocumentManager.GetHierarchyForFile(serviceProvider, filename, out itemid);
if (itemid != __VSITEMID.VSITEMID_NIL && hier != null)
{
object o;
hier.GetProperty(itemid, __VSHPROPID.VSHPROPID_ExtObject, out o);
ProjectItem projectItem = o as ProjectItem;
if (projectItem != null)
{
ArrayList items = new ArrayList();
if (DoesFileNeedCheckout(filename))
{
items.Add(filename);
}
if (projectItem.ProjectItems != null)
{
foreach (ProjectItem childItem in projectItem.ProjectItems)
{
if (DoesFileNeedCheckout(childItem.get_FileNames(0)))
{
items.Add(childItem.get_FileNames(0));
}
}
}
/* asurt 100273
* after much trauma, we're going to not do this anymore...
*
* // also add the project above it
* //
* if (projectItem.ContainingProject != null) {
* string containingFileName = projectItem.ContainingProject.FileName;
*
* try {
* if (containingFileName != null && containingFileName.Length > 0 && System.IO.File.Exists(containingFileName)) {
* if (DoesFileNeedCheckout(containingFileName))
* items.Add(containingFileName);
* }
* }
* catch {
* }
* }
*/
// if needed add the LicX file to the list of files to be checked out.
//
if (additionalBuffers != null && additionalBuffers.Length > 0 && projectItem.ContainingProject != null)
{
foreach (string bufferName in additionalBuffers)
{
ProjectItems pitems = projectItem.ContainingProject.ProjectItems;
foreach (ProjectItem item in pitems)
{
System.IO.FileInfo fi = new System.IO.FileInfo(item.get_FileNames(0));
if ((String.Compare(bufferName, fi.Name, true, CultureInfo.InvariantCulture) == 0) || (String.Compare(bufferName, fi.FullName, true, CultureInfo.InvariantCulture) == 0))
{
items.Add(fi.FullName);
}
}
}
}
string[] fileItems = new string[items.Count];
items.CopyTo(fileItems, 0);
return(fileItems);
}
}
return(new string[] { filename });
}
/// <summary>
/// Finds the assembly information project item.
/// </summary>
/// <param name="items">The items.</param>
/// <returns></returns>
private ProjectItem FindAssemblyInfoProjectItem(ProjectItems items)
{
ThreadHelper.ThrowIfNotOnUIThread();
return(FindProjectItem(items, "assemblyinfo"));
}
private static bool RemoveDeletedItems(string extractedFolder, ProjectItems projectItems, string projectFolder)
{
bool itemChanged = false;
//Handle file & folder deletes
foreach (ProjectItem projectItem in projectItems)
{
string name = projectItem.FileNames[0];
if (string.IsNullOrEmpty(name))
{
continue;
}
if (CrmDeveloperExtensions2.Core.StringFormatting.FormatProjectKind(projectItem.Kind) == VSConstants.GUID_ItemType_PhysicalFile.ToString())
{
name = Path.GetFileName(name);
// Do not delete the mapping file
if (name == CrmDeveloperExtensions2.Core.ExtensionConstants.SolutionPackagerMapFile)
{
continue;
}
// Do not delete the config file
if (name == CrmDeveloperExtensions2.Core.Resources.Resource.ConfigFileName)
{
continue;
}
if (File.Exists(Path.Combine(extractedFolder, name)))
{
continue;
}
projectItem.Delete();
itemChanged = true;
}
if (CrmDeveloperExtensions2.Core.StringFormatting.FormatProjectKind(projectItem.Kind) == VSConstants.GUID_ItemType_PhysicalFolder.ToString())
{
name = new DirectoryInfo(name).Name;
if (name == projectFolder || name == "Properties")
{
continue;
}
if (!Directory.Exists(Path.Combine(extractedFolder, name)))
{
projectItem.Delete();
itemChanged = true;
}
else
{
if (projectItem.ProjectItems.Count <= 0)
{
continue;
}
bool subItemChanged = RemoveDeletedItems(Path.Combine(extractedFolder, name),
projectItem.ProjectItems, projectFolder);
if (subItemChanged)
{
itemChanged = true;
}
}
}
}
return(itemChanged);
}
/// <summary>
/// Checks if the project contains the specified
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
public bool ContainsFile(string filename)
{
return(ProjectItems.Any(p => p.Filename == filename));
}
private void InitTestprojectStructure()
{
//mock exist file *.cs with name equal to name method
mainMethodFileProjectItem = Substitute.For <ProjectItem>();
mainMethodFileProjectItem.Name.Returns("TestMethodName.cs");
methodWrapperFileProjectItem = Substitute.For <ProjectItem>();
methodWrapperFileProjectItem.Name.Returns("TestMethodNameWrapper.cs");
methodTestsFileProjectItem = Substitute.For <ProjectItem>();
methodTestsFileProjectItem.Name.Returns("TestMethodNameTests.cs");
List <ProjectItem> methodFiles = new List <ProjectItem>()
{
mainMethodFileProjectItem, methodWrapperFileProjectItem, methodTestsFileProjectItem
};
ProjectItems specialMethodFolderProjectItems = Substitute.For <ProjectItems>();
specialMethodFolderProjectItems.GetEnumerator().Returns(methodFiles.GetEnumerator());
specialMethodFolderProjectItems.Item("TestMethodName.cs").Returns(mainMethodFileProjectItem);
specialMethodFolderProjectItems.Item("TestMethodNameWrapper.cs").Returns(methodWrapperFileProjectItem);
specialMethodFolderProjectItems.Item("TestMethodNameTests.cs").Returns(methodTestsFileProjectItem);
//mock folder with method
specialMethodFolder = Substitute.For <ProjectItem>();
specialMethodFolder.Name.Returns("TestMethodName");
specialMethodFolder.ProjectItems.Returns(specialMethodFolderProjectItems);
List <ProjectItem> methodFolders = new List <ProjectItem>()
{
specialMethodFolder
};
ProjectItems serverMethodsFolderItems = Substitute.For <ProjectItems>();
serverMethodsFolderItems.GetEnumerator().Returns(methodFolders.GetEnumerator());
serverMethodsFolderItems.Item("TestMethodName").Returns(specialMethodFolder);
//mock main methods folder "ServerMethods"
ProjectItem serverMethodsFolderProjectItem = Substitute.For <ProjectItem>();
serverMethodsFolderProjectItem.Name.Returns("ServerMethods");
serverMethodsFolderProjectItem.ProjectItems.Returns(serverMethodsFolderItems);
List <ProjectItem> projectFolders = new List <ProjectItem>()
{
serverMethodsFolderProjectItem
};
ProjectItems projectItems = Substitute.For <ProjectItems>();
projectItems.Item("ServerMethods").Returns(serverMethodsFolderProjectItem);
projectItems.GetEnumerator().Returns(projectFolders.GetEnumerator());
Project project = Substitute.For <Project>();
project.UniqueName.Returns("ProjectName");
project.ProjectItems.Returns(projectItems);
DTE2 dte2 = Substitute.For <DTE2>();
dte2.ActiveSolutionProjects.Returns(new Project[] { project });
this.serviceProvider.GetService(Arg.Any <Type>()).Returns(dte2);
}
public static bool TryGetFolder(this ProjectItems projectItems, string name, out ProjectItem projectItem)
{
projectItem = GetProjectItem(projectItems, name, _folderKinds);
return(projectItem != null);
}
/// <summary>
/// Generates the specified Source File in the received Project with the options
/// provided and gets the Namespace ready to add code in it.
/// </summary>
/// <param name="targetProject">Project where the Source File is going to be placed.</param>
/// <param name="targetProjectFolder">Project folder where the source file is going to be placed.
/// Null indicates to place the source file as child of targetProject.</param>
/// <param name="sourceFileName">Source File name to use.</param>
/// <param name="sourceFileHeaderComment">Source File Header Comment (optional).</param>
/// <param name="sourceNamespace">Namespace used in the Source File.</param>
/// <param name="isServiceReady">Specifies if it is Service-Ready (serialization is going to be used).</param>
/// <param name="sourceFileItem">(out parameter) Source File ProjectItem.</param>
/// <returns></returns>
public static CodeNamespace GenerateSourceAndGetNamespace(Project targetProject, ProjectItem targetProjectFolder,
string sourceFileName, string sourceFileHeaderComment, string sourceNamespace,
bool isServiceReady, out ProjectItem sourceFileItem)
{
// Validate source file name
if (sourceFileName.EndsWith(Resources.CSharpFileExtension) == false)
{
sourceFileName += Resources.CSharpFileExtension;
}
// Validate source file header comment
if (string.IsNullOrWhiteSpace(sourceFileHeaderComment) == false)
{
if (sourceFileHeaderComment.IndexOf("*/") >= 0)
{
throw new ApplicationException(Resources.Error_HeaderCommentInvalidChars);
}
}
// ProjectItems collection where to place the source file
ProjectItems projectItems = targetProject.ProjectItems;
if (targetProjectFolder != null)
{
// Place inside received project folder
projectItems = targetProjectFolder.ProjectItems;
}
// Properties collection of the target
EnvDTE.Properties targetProperties = targetProject.Properties;
if (targetProjectFolder != null)
{
targetProperties = targetProjectFolder.Properties;
}
// Source file
sourceFileItem = null;
#region If source file exists in the target, clear it and get the reference
foreach (ProjectItem projItem in projectItems)
{
string projItemFileName = projItem.Properties.Item(Resources.ProjectItem_FileName).Value.ToString();
if (sourceFileName.ToLower() == projItemFileName.ToLower())
{
// Source file already exists
sourceFileItem = projItem;
if (sourceFileItem.FileCodeModel.CodeElements != null &&
sourceFileItem.FileCodeModel.CodeElements.Count > 0)
{
// Clear source file
CodeElement firstElement = sourceFileItem.FileCodeModel.CodeElements.Item(1);
CodeElement lastElement = sourceFileItem.FileCodeModel.CodeElements.Item(
sourceFileItem.FileCodeModel.CodeElements.Count);
EditPoint startPoint = firstElement.StartPoint.CreateEditPoint();
EditPoint endPoint = lastElement.EndPoint.CreateEditPoint();
while (startPoint.AtStartOfDocument != true)
{
startPoint.LineUp();
}
while (endPoint.AtEndOfDocument != true)
{
endPoint.LineDown();
}
startPoint.Delete(endPoint);
}
break;
}
}
#endregion
#region If source file NOT exists in the target, create it and get the reference
if (sourceFileItem == null)
{
// New source file, get target path
string targetPath = targetProperties.Item(Resources.Properties_LocalPath).Value.ToString();
// Check if the new source file already exists in the file system (and it is not added to the solution)
if (File.Exists(targetPath + sourceFileName))
{
// Rename the existent source file
string backupSourceFileName = (sourceFileName + Resources.BackupFileExtension);
File.Move((targetPath + sourceFileName), (targetPath + backupSourceFileName));
// Add warning
VisualStudioHelper.AddToErrorList(TaskErrorCategory.Warning,
string.Format(Resources.Warning_SourceFileAlreadyExists, sourceFileName, backupSourceFileName),
targetProject, sourceFileName, null, null);
}
// Add source file to target
sourceFileItem = projectItems.AddFromTemplate(TemplateClass.FilePath, sourceFileName);
}
#endregion
#region Generate imports
var importList = new List <SourceCodeImport>();
importList.Add(new SourceCodeImport(Resources.NamespaceSystem));
importList.Add(new SourceCodeImport(Resources.NamespaceSystemCollectionsGeneric));
importList.Add(new SourceCodeImport(Resources.NamespaceSystemText));
if (isServiceReady)
{
importList.Add(new SourceCodeImport(Resources.NamespaceSystemRuntimeSerialization));
}
importList = importList.OrderBy(d => d.ImportNamespace).ToList();
#endregion Generate imports
// Add imports to the source code
VisualStudioHelper.AddImportsToSourceCode(ref sourceFileItem, importList);
// Get Source file code start
EditPoint objEditPoint = sourceFileItem.FileCodeModel.CodeElements.Item(1).StartPoint.CreateEditPoint();
objEditPoint.StartOfDocument();
// Add header comment
if (string.IsNullOrWhiteSpace(sourceFileHeaderComment) == false)
{
sourceFileHeaderComment = (Environment.NewLine + sourceFileHeaderComment + Environment.NewLine);
objEditPoint.Insert(
string.Format(Resources.CSharpCommentMultiline, sourceFileHeaderComment) +
Environment.NewLine);
}
// Add EntitiesToDTOs signature
string timestamp = DateTime.Now.ToString("yyyy/MM/dd - HH:mm:ss");
objEditPoint.Insert(string.Format(Resources.EntitiesToDTOsSignature, AssemblyHelper.Version, timestamp));
objEditPoint.Insert(Environment.NewLine);
// Add blank line before source file namespace
objEditPoint.EndOfDocument();
objEditPoint.Insert(Environment.NewLine);
// Add namespace
CodeNamespace objNamespace = sourceFileItem.FileCodeModel
.AddNamespace(sourceNamespace, AppConstants.PLACE_AT_THE_END);
return(objNamespace);
}
/// <summary>
/// Gets the available assemblies & classes of which unit test items can be created against.
/// </summary>
/// <param name="referencedProjects">The solution projects which are referenced by the unit test project.</param>
/// <returns>List of ComboboxItems containing the project assembly & class info.</returns>
private static List <ComboBoxItem> GetSourceProjectItems(ICollection <string> referencedProjects)
{
List <ComboBoxItem> classItems = new List <ComboBoxItem>();
var dte = Package.GetGlobalService(typeof(DTE)) as DTE;
if (dte == null)
{
return(classItems);
}
Projects projects = dte.Solution.Projects;
ComboBoxItem itemEmpty = new ComboBoxItem {
Content = string.Empty, Tag = string.Empty
};
classItems.Add(itemEmpty);
foreach (Project project in projects)
{
if (!referencedProjects.Contains(project.Name))
{
continue;
}
string assemblyName = project.Properties.Item("AssemblyName").Value.ToString();
ProjectItems activeProjectItems = project.ProjectItems;
if (activeProjectItems.Count <= 0)
{
continue;
}
foreach (ProjectItem projectItem in activeProjectItems)
{
if (!projectItem.FileNames[0].EndsWith((".cs")))
{
continue;
}
foreach (CodeElement element in projectItem.FileCodeModel.CodeElements)
{
if (element.Kind != vsCMElement.vsCMElementNamespace)
{
continue;
}
foreach (CodeElement childElement in element.Children)
{
if (childElement.Kind != vsCMElement.vsCMElementClass)
{
continue;
}
ComboBoxItem item = new ComboBoxItem {
Content = childElement.FullName, Tag = assemblyName
};
classItems.Add(item);
}
}
}
}
return(classItems);
}
/// <summary>
/// Walks qualified project items and processes all of their qualified items.
/// </summary>
private void ProcessProjectItems(List <FileModel> model, ProcessorFlags flags, CodeModelFilterFlags filter, LanguageSettings languageSet,
ProjectItems projectItems, bool isWebProject, ref bool isRoot, ProjectItem parentItem, string parentName)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Parent item is applicable or meant to be used for actual files only, i.e. file combos like .cs and .designer.cs, etc.
if (parentItem != null)
{
if ((string.Compare(parentItem.Kind, Constants.vsProjectItemKindPhysicalFile, StringComparison.OrdinalIgnoreCase) != 0) &&
(string.Compare(parentItem.Kind, Constants.vsProjectItemKindSolutionItems, StringComparison.OrdinalIgnoreCase) != 0))
{
parentItem = null;
}
}
var parentSubType = FileSubType.None;
var parentSubTypeSet = false;
if (!string.IsNullOrEmpty(parentName) && !parentName.EndsWith("\\", StringComparison.OrdinalIgnoreCase))
{
parentName = parentName + "\\";
}
// Save the current language and determine the new current language
if (isWebProject)
{
var webLanguageSet = GetWebFolderLanguage(isRoot, projectItems);
// Fallback scenario - use default project language so that non-code files can be resolved
if (webLanguageSet?.Type != LanguageType.Unknown)
{
languageSet = webLanguageSet; // language should be restored for other items once we walk up the stack
}
}
// Root processing is finished after language is checked for the root project items
isRoot = false;
var projectName = string.Empty;
foreach (ProjectItem projectItem in projectItems)
{
// Skip project references as they can't contribute any files
var isReferences = projectItem.Object is VSLangProj.References;
var isReference = projectItem.Object is VSLangProj.Reference;
if (isReferences || isReference)
{
continue;
}
// LightSwitch type projects with virtual references node workaround
if (!string.IsNullOrEmpty(projectItem.Name) &&
projectItem.Name.Equals(REFERENCES_NODE, StringComparison.OrdinalIgnoreCase) &&
(string.Compare(projectItem.Kind, Constants.vsProjectItemKindVirtualFolder, StringComparison.OrdinalIgnoreCase) == 0))
{
continue;
}
if ((string.Compare(projectItem.Kind, Constants.vsProjectItemKindPhysicalFile, StringComparison.OrdinalIgnoreCase) == 0) ||
(string.Compare(projectItem.Kind, Constants.vsProjectItemKindSolutionItems, StringComparison.OrdinalIgnoreCase) == 0))
{
if (!parentSubTypeSet)
{
parentSubTypeSet = true;
if (parentItem != null)
{
parentSubType = _fileTypeResolver.GetSubType(parentItem, languageSet, isWebProject);
}
}
var itemSubType = _fileTypeResolver.GetSubType(projectItem, languageSet, isWebProject);
// Check if this is a code file
var add = !flags.HasFlag(ProcessorFlags.IncludeCodeFilesOnly) || _fileTypeResolver.IsCodeSubType(itemSubType);
// Check for .Designer file
if (add &&
!flags.HasFlag(ProcessorFlags.IncludeDesignerFiles) &&
_fileTypeResolver.IsDesignerItem(projectItem, itemSubType, languageSet, isWebProject))
{
add = false;
}
// Used to collect skipped files here as well... something to keep an eye out out for
if (add)
{
var fileName = projectItem.get_FileNames(1);
if (string.IsNullOrEmpty(fileName))
{
add = false;
}
if (add)
{
// Try getting a misc/simple subtype for unknown and solution projects
if ((languageSet?.Type == LanguageType.Unknown) && (itemSubType == FileSubType.None))
{
itemSubType = _fileTypeResolver.GetExtensionSubType(projectItem, languageSet, isWebProject);
}
if (string.IsNullOrEmpty(projectName))
{
projectName = projectItem.ContainingProject?.Name;
}
var itemModel = new FileModel
{
ProjectItem = projectItem,
FileName = projectItem.Name,
ParentProjectItem = parentItem,
ParentName = parentName,
ParentSubType = parentSubType,
ItemSubType = itemSubType,
FileNameWithPath = fileName,
ProjectName = projectName
};
if (flags.HasFlag(ProcessorFlags.IncludeFileCodeModel))
{
var members = _fileProcessor.GetMembers(projectItem, flags, filter);
if (members != null)
{
itemModel.Members.AddRange(members);
}
}
model.Add(itemModel);
}
}
ProjectItems currentProjectItems = projectItem.ProjectItems;
if ((currentProjectItems != null) && (currentProjectItems.Count > 0))
{
ProcessProjectItems(
model, flags, filter, languageSet,
currentProjectItems, false, ref isRoot, projectItem, parentName);
}
}
else
{
if ((string.Compare(projectItem.Kind, Constants.vsProjectItemKindPhysicalFolder, StringComparison.OrdinalIgnoreCase) == 0) ||
(string.Compare(projectItem.Kind, Constants.vsProjectItemKindVirtualFolder, StringComparison.OrdinalIgnoreCase) == 0))
{
ProjectItems currentProjectItems = projectItem.ProjectItems;
if ((currentProjectItems != null) && (currentProjectItems.Count > 0))
{
ProcessProjectItems(
model, flags, filter, languageSet,
currentProjectItems, isWebProject, ref isRoot, projectItem, parentName + projectItem.Name);
}
}
}
} // foreach (projectItem)
}
private static bool RemoveDeletedItems(string extractedFolder, ProjectItems projectItems)
{
bool itemChanged = false;
//Handle file & folder deletes
foreach (ProjectItem projectItem in projectItems)
{
string name = projectItem.FileNames[0];
switch (projectItem.Kind.ToUpper())
{
case "{6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}":
name = Path.GetFileName(name);
// Do not delete the mapping file
if (name == "mapping.xml")
{
continue;
}
// Do not delete the config file
if (name == "CRMDeveloperExtensions.config")
{
continue;
}
if (File.Exists(extractedFolder + "\\" + name))
{
continue;
}
projectItem.Delete();
itemChanged = true;
break;
case "{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}":
name = new DirectoryInfo(name).Name;
if (name == "_Solutions")
{
continue;
}
if (!Directory.Exists(extractedFolder + "\\" + name))
{
projectItem.Delete();
itemChanged = true;
}
else
{
if (projectItem.ProjectItems.Count <= 0)
{
continue;
}
bool subItemChanged = RemoveDeletedItems(extractedFolder + "\\" + name,
projectItem.ProjectItems);
if (subItemChanged)
{
itemChanged = true;
}
}
break;
}
}
return(itemChanged);
}
public static ProjectItem BuildDteProjectItem(IEnumerable <Type> fromClassTypes, string projectItemName, ProjectItems subProjectItems = null)
{
var namespaceName = fromClassTypes
.Select(t => t.Namespace)
.Distinct()
.Single();
var classes = fromClassTypes
.Select(BuildDteClass)
.ToList();
var moqFileCodeModel = new Mock <FileCodeModel>();
var moqProjectItem = new Mock <ProjectItem>();
var moqProjCodeElements = new Mock <CodeElements>();
var moqMembers = new Mock <CodeElements>();
moqMembers.Setup(x => x.GetEnumerator()).Returns(() => classes.GetEnumerator());
var moqCodeNamespace = new Mock <CodeNamespace>();
moqCodeNamespace.SetupGet(x => x.Members).Returns(moqMembers.Object);
moqCodeNamespace.SetupGet(x => x.Name).Returns(namespaceName);
moqProjCodeElements.Setup(x => x.GetEnumerator()).Returns(() => new[] { moqCodeNamespace.Object }.GetEnumerator());
moqFileCodeModel.SetupGet(x => x.CodeElements).Returns(moqProjCodeElements.Object);
moqProjectItem.SetupProperty(x => x.Name, projectItemName);
moqProjectItem.SetupGet(x => x.FileCodeModel).Returns(moqFileCodeModel.Object);
moqProjectItem.SetupGet(x => x.ProjectItems).Returns(subProjectItems);
return(moqProjectItem.Object);
}
/// <include file='doc\InstallerDesign.uex' path='docs/doc[@for="InstallerDesign.GetProjectInstallerDocument"]/*' />
/// <devdoc>
/// Gets the document that contains the installers for the project.
/// </devdoc>
public static IDesignerHost GetProjectInstallerDocument(IComponent component)
{
ProjectItem currentProjItem = (ProjectItem)component.Site.GetService(typeof(ProjectItem));
if (currentProjItem == null)
{
throw new Exception(SR.GetString(SR.InstallerDesign_CouldntGetService));
}
Project project = currentProjItem.ContainingProject;
ProjectItems projItems = project.ProjectItems;
ProjectItem installationClass = null;
string projectKind = project.Kind;
string projectInstallerItemName = null;
string projectInstallerTemplateName = null;
if (new Guid(projectKind).Equals(CSharpProjectGuid))
{
// c# has a special name for the installer wizard
projectInstallerTemplateName = "\\NewInstaller.vsz";
}
else
{
// all other project types will have the same name
projectInstallerTemplateName = "\\Installer.vsz";
}
int fileCount = currentProjItem.FileCount;
if (fileCount == 0)
{
throw new Exception(SR.GetString(SR.InstallerDesign_NoProjectFilename));
}
string extension = Path.GetExtension(currentProjItem.get_FileNames(0));
projectInstallerItemName = "ProjectInstaller" + extension;
try {
installationClass = projItems.Item(projectInstallerItemName);
}
catch (Exception) {
// if file isn't in the project, we'll get an ArgumentException.
}
// If we could't find an existing ProjectInstaller.xx, we'll try to add
// one from the template.
if (installationClass == null)
{
string templateFileName = GetItemTemplatesDir(projectKind) + projectInstallerTemplateName;
try {
// AddFromTemplate will try to copy the template file into ProjectInstaller.xx.
// If ProjectInstaller.xx already exists, it will bring up a dialog that says:
// A file with the name 'C:\myproject\ProjectInstaller.xx'
// already exists. Do you want to replace it?
// If you answer yes, you're good to go. The existing file will be overwritten
// with the template. If you answer no, AddFromTemplate will throw a COMException
// with hresult = 0x80070050 (file already exists).
installationClass = projItems.AddFromTemplate(templateFileName, projectInstallerItemName);
}
catch (COMException e) {
// if the errorcode is HRESULT_FROM_WIN32(ERROR_FILE_EXISTS) (which is 0x80070050)
// then ProjectInstaller.xx exists and the user does not want to overwrite it.
// We could try to use the existing file, but that might cause more problems then
// want to get into. Just inform the user that we can't add the installer.
if (e.ErrorCode == unchecked ((int)0x80070050))
{
throw new Exception(SR.GetString(SR.InstallerDesign_UnableToAddProjectInstaller));
}
else
{
// unexpected -> bubble up
throw;
}
}
catch (FileNotFoundException) {
// The template was not found. This probably means that the current project type
// doesn't provide a template for installers. Nothing to do but report the error.
throw new FileNotFoundException(SR.GetString(SR.InstallerDesign_CoulndtFindTemplate), templateFileName);
}
}
try {
installationClass.Properties.Item("SubType").Value = "Component";
Window window = installationClass.Open(vsViewKindDesigner);
window.Visible = true;
IDesignerHost host = (IDesignerHost)window.Object;
// make sure the project has a reference to System.Configuration.Install.dll.
// This is done as a side-effect of calling GetType.
host.GetType(typeof(ComponentInstaller).FullName);
return(host);
} catch (Exception e) {
throw new Exception(SR.GetString(SR.InstallerDesign_CouldntShowProjectInstaller), e);
}
}
public static Project BuildDteProject(IEnumerable <Type> fromClassTypes, string projectName, ProjectItems subProjectItems = null)
{
var moqProject = new Mock <Project>();
var moqProjectItems = new Mock <ProjectItems>();
moqProject.SetupGet(x => x.ProjectItems).Returns(moqProjectItems.Object);
var byNamespace = fromClassTypes
.GroupBy(x => x.Namespace)
.ToDictionary(
g => g.Key,
g => g.ToList()
);
var projectItems = new List <ProjectItem>();
foreach (string namespaceName in byNamespace.Keys)
{
var projectItem = BuildDteProjectItem(byNamespace[namespaceName], projectName, subProjectItems);
projectItems.Add(projectItem);
}
moqProjectItems.Setup(x => x.GetEnumerator()).Returns(() => projectItems.GetEnumerator());
return(moqProject.Object);
}
private bool ProcessDownloadedSolution(DirectoryInfo extractedFolder, string baseFolder, ProjectItems projectItems)
{
bool itemChanged = false;
//Handle file adds
foreach (FileInfo file in extractedFolder.GetFiles())
{
if (File.Exists(baseFolder + "\\" + file.Name))
{
if (FileEquals(baseFolder + "\\" + file.Name, file.FullName))
{
continue;
}
}
File.Copy(file.FullName, baseFolder + "\\" + file.Name, true);
projectItems.AddFromFile(baseFolder + "\\" + file.Name);
itemChanged = true;
}
//Handle folder adds
foreach (DirectoryInfo folder in extractedFolder.GetDirectories())
{
if (!Directory.Exists(baseFolder + "\\" + folder.Name))
{
Directory.CreateDirectory(baseFolder + "\\" + folder.Name);
}
var newProjectItems = projectItems;
bool subItemChanged = ProcessDownloadedSolution(folder, baseFolder + "\\" + folder.Name, newProjectItems);
if (subItemChanged)
{
itemChanged = true;
}
}
return(itemChanged);
}
internal static ProjectItem GetItemByFullFileName(ProjectItems items, string fullFileNameOfItemToGet)
{
return(GetItemByFullFileName(items, fullFileNameOfItemToGet, false));
}
