private ProjectItem TravAllItems(string tag)
        {
            tag = tag.Trim().TrimEnd('\\');

            var stack = new Stack <ProjectItem>();

            foreach (var item in ProjectItems.OfType <ProjectItem>())
            {
                var itemTag = item.Tag as string;
                if (string.Equals(itemTag?.Trim().TrimEnd('\\'), tag, StringComparison.OrdinalIgnoreCase))
                {
                    return(item);
                }

                stack.Push(item);
            }

            while (stack.Count > 0)
            {
                var parentItem = stack.Pop();
                foreach (var item in parentItem.Children.OfType <ProjectItem>())
                {
                    var itemTag = item.Tag as string;
                    if (string.Equals(itemTag?.Trim().TrimEnd('\\'), tag, StringComparison.OrdinalIgnoreCase))
                    {
                        return(item);
                    }

                    stack.Push(item);
                }
            }

            return(null);
        }
        /// <summary>
        /// 指定のアイテム一覧に含まれる全てのアイテムを取得します。
        /// </summary>
        /// <remarks>
        /// フォルダ、ファイルを指定できます。
        /// ファイルの中にネストされているアイテムも取得します。
        /// </remarks>
        private IEnumerable <ProjectItem> GetProjectItems(ProjectItems items, Func <string, bool> filter)
        {
            return(items
                   .OfType <ProjectItem>()
                   .Recursive(x =>
            {
                var innerItems = x.ProjectItems;
                if (innerItems != null)
                {
                    if (filter(x.Name))
                    {
                        return innerItems.OfType <ProjectItem>();
                    }
                }
                else
                {
                    var subProject = x.SubProject;
                    if (subProject != null)
                    {
                        // MEMO : フォルダの場合
                        return GetProjectItems(subProject, filter);
                    }
                }

                return Enumerable.Empty <ProjectItem>();
            }));
        }
Example #3
0
        private void AddProjectFolder(string name, NewItemTarget target)
        {
            // Make sure the directory exists before we add it to the project. Don't
            // use `PackageUtilities.EnsureOutputPath()` because it can silently fail.
            Directory.CreateDirectory(Path.Combine(target.Directory, name));

            // We can't just add the final directory to the project because that will
            // only add the final segment rather than adding each segment in the path.
            // Split the name into segments and add each folder individually.
            ProjectItems items           = target.ProjectItem?.ProjectItems ?? target.Project.ProjectItems;
            string       parentDirectory = target.Directory;

            foreach (string segment in SplitPath(name))
            {
                parentDirectory = Path.Combine(parentDirectory, segment);

                // Look for an existing folder in case it's already in the project.
                ProjectItem folder = items
                                     .OfType <ProjectItem>()
                                     .Where(item => segment.Equals(item.Name, StringComparison.OrdinalIgnoreCase))
                                     .Where(item => item.IsKind(Constants.vsProjectItemKindPhysicalFolder, Constants.vsProjectItemKindVirtualFolder))
                                     .FirstOrDefault();

                if (folder == null)
                {
                    folder = items.AddFromDirectory(parentDirectory);
                }

                items = folder.ProjectItems;
            }
        }
Example #4
0
        public static ProjectItems GetOrCreateFolder(ProjectItems projectItems, string viewModelLocation)
        {
            var path = viewModelLocation.Split('/', '\\').Where(p => !String.IsNullOrEmpty(p)).ToList();

            for (var i = 0; i < path.Count; i++)
            {
                var projectItem = projectItems.OfType <ProjectItem>().FirstOrDefault(p => p.Name == path[i]);
                if (projectItem == null)
                {
                    try
                    {
                        projectItem = projectItems.AddFolder(path[i]);
                    }
                    catch
                    {
                        throw new Exception($"Could not add a folder '{path[i]}' in the project!");
                    }
                }
                else if (projectItem.Kind != ProjectItemKindPhysicalFolder)
                {
                    throw new Exception($"The location of the viewmodel is not valid! Path '{path[i]}'.");
                }
                projectItems = projectItem.ProjectItems;
            }
            return(projectItems);
        }
Example #5
0
 public static ProjectItem FindItem(
     this ProjectItems items,
     string itemName,
     StringComparer comparer
     ) =>
 items
 .OfType <ProjectItem>()
 .FirstOrDefault(p => comparer.Compare(p.Name, itemName) == 0);
Example #6
0
        ///// <summary>
        ///// Ensuures that a project of a given name exists in the solution
        ///// </summary>
        ///// <param name="store">Model from which to look for</param>
        ///// <param name="relativePath">Relative path where to create the new project if necessary (ending in the project name with .csproj)</param>
        ///// <param name="sourcePath">Source path of the template of the project</param>
        ///// <param name="updateAssemblyNameAndNamespace">Should we update the assembly name and namespace of the new project.</param>
        ///// <remarks>
        ///// Suppose you want to create add a new project named "MyProject.csproj" from a template (vs vsTemplate located in a sub folder of the location of the extension,
        ///// and you want to have similar namespaces:
        ///// <code>
        /////    StoreHostingProject.EnsureNamedProjectExistsInDslSolution(dsl.Store, "MyProject.csproj"
        /////                                          , Path.Combine(Path.GetDirectoryName(typeof(ATypeInMyExtension).Assembly.Location), @"Templates\MyProject\MyTemplate.vstemplate")
        /////                                          , true
        /////                                          );
        ///// </code>
        ///// </remarks>
        //public static void EnsureNamedProjectExistsInDslSolution(Store store, string relativePath, string sourcePath, bool updateAssemblyNameAndNamespace)
        //{
        //    // Verify that the relative path ends with csproj
        //    if (Path.GetExtension(relativePath) != ".csproj")
        //    {
        //        throw new ArgumentException("relativePath should be relative path of the .csproj file to create with respect to the solution, hence ending in .csproj", "relativePath");
        //    }

        //    Project project = Store2DTE.GetProjectForStore(store);
        //    Solution solution = project.DTE.Solution;
        //    Project newProject = solution.Projects.OfType<Project>().FirstOrDefault(p => p.UniqueName == relativePath);
        //    if (newProject != null)
        //    {
        //        return;
        //    }

        //    string projectDirectory = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(project.FullName)), Path.GetFileNameWithoutExtension(relativePath));
        //    string projectPath = Path.Combine(projectDirectory, Path.GetFileName(relativePath));
        //    string projectSimpleName = Path.GetFileNameWithoutExtension(relativePath);

        //    // The project exist but is not in the solution: let's just add it.
        //    if (File.Exists(projectPath))
        //    {
        //        solution.AddFromFile(projectPath, false);
        //    }

        //    // The project does not exist: create it from a template
        //    else
        //    {
        //        newProject = project.DTE.Solution.AddFromTemplate(sourcePath, projectDirectory, Path.GetFileName(relativePath), false);

        //        // Well known workaround for C# and VB projects, AddFromTemplate returns null
        //        newProject = solution.Projects.OfType<Project>().FirstOrDefault(p => p.Name == projectSimpleName);

        //        // Update the assembly name and namespace if necessary
        //        if (updateAssemblyNameAndNamespace)
        //        {
        //            newProject.Properties.Item("AssemblyName").Value = project.Properties.Item("AssemblyName").Value.ToString().Replace("." + project.Name, "." + projectSimpleName);
        //            newProject.Properties.Item("DefaultNamespace").Value = project.Properties.Item("DefaultNamespace").Value.ToString() + "." + projectSimpleName;
        //        }

        //    }
        //}
        #endregion

        #region Adding a file or a link to a file
        /// <summary>
        /// Ensures that a file is present in the project
        /// </summary>
        /// <param name="store">Store containing a model</param>
        /// <param name="relativePath">relative path where the file should be located</param>
        /// <param name="sourcePath">Path of the file to copy if not already present in the solution</param>
        /// <example>
        /// if you have a file Adapter.tt, added to the VSIX, of type Content, and copied if newer, in a folder Temmplates of the extension project, you can add
        /// it to the GeneratedCode folder of the DSL by the following code:
        /// <code>
        ///    StoreHostingProject.EnsureFileInProject(dsl.Store, @"GeneratedCode\Adapter.tt",
        ///                                            Path.Combine(Path.GetDirectoryName(typeof(MyExtensionAuthoring).Assembly.Location), @"Templates\Adapter.tt"));
        /// </code>
        /// </example>
        public static void EnsureFileCopiedInDslProject(Store store, string relativePath, string sourcePath)
        {
            Contract.Requires(store != null);
            Contract.Requires(relativePath != null);
            Contract.Requires(sourcePath != null);

            Project project = Store2DTE.GetProjectForStore(store);

            string[] pathSegments = relativePath.Split('\\');

            ProjectItems parent = project.ProjectItems;

            // Find the folder (or create it if necessary)
            for (int i = 0; i < pathSegments.Length - 1; ++i)
            {
                ProjectItem folder = parent.OfType <ProjectItem>().FirstOrDefault(projectItem => projectItem.Name == pathSegments[i]);
                if (folder == null)
                {
                    folder = parent.AddFolder(pathSegments[i]);
                }

                parent = folder.ProjectItems;
            }

            // Find the file and create it if necessary
            ProjectItem file = parent.OfType <ProjectItem>().FirstOrDefault(projectItem => projectItem.Name == pathSegments[pathSegments.Length - 1]);

            if (file == null)
            {
                string fileDirectory = Path.Combine(Path.GetDirectoryName(project.FullName), Path.GetDirectoryName(relativePath));
                string filePath      = Path.Combine(fileDirectory, Path.GetFileName(relativePath));

                // Case where the file is already there, but not added to the project
                if (File.Exists(filePath))
                {
                    parent.AddFromFile(filePath);
                }
                else
                {
                    parent.AddFromFileCopy(sourcePath);
                }
            }
        }
        private IEnumerable <ProjectItem> GetAllItems(ProjectItems projectItems)
        {
            if (projectItems == null)
            {
                return(SpecializedCollections.EmptyEnumerable <ProjectItem>());
            }

            var items = projectItems.OfType <ProjectItem>();

            return(items.Concat(items.SelectMany(i => GetAllItems(i.ProjectItems))));
        }
Example #8
0
        /// <summary>
        /// Ensures a link on a file is created in a project
        /// </summary>
        /// <param name="store">Store containing a model</param>
        /// <param name="uniqueProjectName">Unique project name of the project to which to add a link a a file</param>
        /// <param name="relativePathOfFileToCreate">Relative path to the link to create in the project described by <paramref name="relativePathOfFileToCreate"/></param>
        /// <param name="originalFileToLink">Path to the original file to link</param>
        public static void EnsureFileLinkInProject(Store store, string uniqueProjectName, string relativePathOfFileToCreate, string originalFileToLink)
        {
            Contract.Requires(store != null);
            Contract.Requires(relativePathOfFileToCreate != null);
            Contract.Requires(originalFileToLink != null);

            Project project = Store2DTE.GetProjectForStore(store);

            if (!string.IsNullOrWhiteSpace(uniqueProjectName))
            {
                project = project.DTE.Solution.Projects.OfType <Project>().FirstOrDefault(p => p.UniqueName == uniqueProjectName);
            }
            if (project == null)
            {
                return;
            }

            string[] pathSegments = relativePathOfFileToCreate.Split('\\');

            ProjectItems parent = project.ProjectItems;

            // Find the folder (or create it if necessary)
            for (int i = 0; i < pathSegments.Length - 1; ++i)
            {
                ProjectItem folder = parent.OfType <ProjectItem>().FirstOrDefault(projectItem => projectItem.Name == pathSegments[i]);
                if (folder == null)
                {
                    folder = parent.AddFolder(pathSegments[i]);
                }

                parent = folder.ProjectItems;
            }

            // Find the file and create a link on the originalFileToLink it if necessary
            ProjectItem file = parent.OfType <ProjectItem>().FirstOrDefault(projectItem => projectItem.Name == pathSegments[pathSegments.Length - 1]);

            if (file == null)
            {
                parent.AddFromFile(Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.FullName), originalFileToLink)));
            }
        }
Example #9
0
        /// <summary>
        /// Find a project item using a path-like address in the project folder hierarchy
        /// </summary>
        /// <param name="topItems">Top level items in the project</param>
        /// <param name="itemPath">path to the required project item</param>
        /// <returns>the project item</returns>
        public static ProjectItem FindItemByPath(ProjectItems topItems, string itemPath)
        {
            ProjectItem item = topItems.OfType <ProjectItem>().FirstOrDefault(pi => pi.Name == itemPath.UpTo("/"));

            if (!itemPath.Contains("/"))
            {
                return(item);
            }
            else
            {
                return(FindItemByPath(item.ProjectItems, itemPath.After("/")));
            }
        }
        private static ProjectItem GetNestedProjectItem(ProjectItems items, string fileName)
        {
            ProjectItem currentItem = null;

            string[] pathParts = fileName.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string part in pathParts)
            {
                currentItem = items.OfType <ProjectItem>().FirstOrDefault(i => string.Equals(i.Name, part, StringComparison.OrdinalIgnoreCase));
                if (currentItem == null)
                {
                    return(null);
                }
                items = currentItem.ProjectItems;
            }
            return(currentItem);
        }
Example #11
0
 private static IEnumerable <ProjectItem> GetAllProjectItems(ProjectItems projectItems)
 {
     foreach (var item in projectItems.OfType <ProjectItem>())
     {
         if (item.ProjectItems.Count > 0)
         {
             foreach (var subItem in GetAllProjectItems(item.ProjectItems))
             {
                 yield return(subItem);
             }
         }
         else
         {
             yield return(item);
         }
     }
 }
Example #12
0
        private IEnumerable<string> GetFiles(ProjectItems projectItems)
        {
            if (projectItems == null)
            {
                return new string[0];
            }

            List<string> files = new List<string>();

            foreach (var projectItem in projectItems.OfType<ProjectItem>())
            {
                for (short i = 0; i < projectItem.FileCount; i++)
                {
                    files.Add(GetFileName(projectItem, i));
                }

                files.AddRange(GetFiles(projectItem.ProjectItems));
            }

            return files;
        }
Example #13
0
 /// <summary>
 /// Find a project item using a path-like address in the project folder hierarchy
 /// </summary>
 /// <param name="topItems">Top level items in the project</param>
 /// <param name="itemPath">path to the required project item</param>
 /// <returns>the project item</returns>
 public static ProjectItem FindItemByPath(ProjectItems topItems, string itemPath)
 {
     ProjectItem item = topItems.OfType<ProjectItem>().FirstOrDefault(pi => pi.Name == itemPath.UpTo("/"));
     if (!itemPath.Contains("/"))
         return item;
     else
         return FindItemByPath(item.ProjectItems, itemPath.After("/"));
 }
Example #14
0
        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) { }
            }
        }
Example #15
0
 List <DTE.ProjectItem> GetAllChildItems(ProjectItems projectItems)
 {
     return(projectItems.OfType <DTE.ProjectItem>().ToList());
 }
Example #16
0
 DTE.ProjectItem GetFirstChildItem(ProjectItems projectItems)
 {
     return(projectItems.OfType <DTE.ProjectItem>().FirstOrDefault());
 }
Example #17
0
 DTE.ProjectItem GetChildItem(ProjectItems projectItems, string name)
 {
     return(projectItems
            .OfType <DTE.ProjectItem>()
            .SingleOrDefault(item => item.Name == name));
 }