Show list of view templates in Add MVC View dialog.

src/AddIns/BackendBindings/AspNet.Mvc/Project/AspNet.Mvc.csproj

@@ -115,6 +115,7 @@
     <Compile Include="Src\MvcTextTemplateTypeFolderName.cs" />
     <Compile Include="Src\MvcViewFileName.cs" />
     <Compile Include="Src\MvcViewFileGenerator.cs" />
+    <Compile Include="Src\MvcViewTextTemplate.cs" />
     <Compile Include="Src\MvcViewTextTemplateFileName.cs" />
     <Compile Include="Src\MvcViewTypeViewModel.cs" />
     <Compile Include="Src\MvcVirtualPath.cs" />

src/AddIns/BackendBindings/AspNet.Mvc/Project/Src/AddMvcViewToProjectView.xaml

@@ -97,6 +97,19 @@
 				Text="{Binding Path=ModelClassName, UpdateSourceTrigger=PropertyChanged}"
 				SelectedItem="{Binding Path=SelectedModelClass}"/>
 			
+			<Label
+				Grid.Row="5"
+				IsEnabled="{Binding Path=IsStronglyTypedView}"
+				Content="Template:"/>
+			<ComboBox
+				Grid.Row="5"
+				Grid.Column="1"
+				Margin="0, 2, 0, 0"
+				IsEnabled="{Binding Path=IsStronglyTypedView}"
+				ItemsSource="{Binding Path=ViewTemplates}"
+				ItemTemplate="{StaticResource ViewEngineTemplate}"
+				SelectedItem="{Binding Path=SelectedViewTemplate}"/>
+			
 			<Label
 				Grid.Row="6"
 				Margin="0, 20, 0, 0"

src/AddIns/BackendBindings/AspNet.Mvc/Project/Src/AddMvcViewToProjectViewModel.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.IO;
+using System.Linq;
 using System.Windows.Input;
 
 namespace ICSharpCode.AspNet.Mvc
@@ -13,6 +14,7 @@ namespace ICSharpCode.AspNet.Mvc
 	{
 		IMvcViewFileGenerator viewGenerator;
 		ISelectedMvcFolder selectedViewFolder;
+		IMvcTextTemplateRepository textTemplateRepository;
 		MvcViewFileName viewFileName = new MvcViewFileName();
 		bool closed;
 		List<MvcViewEngineViewModel> viewEngines;
@@ -22,22 +24,26 @@ namespace ICSharpCode.AspNet.Mvc
 		bool isSelectMasterPageViewOpen;
 		MvcProjectFile selectedMasterPage;
 		string masterPageFile = String.Empty;
-		
+		List<MvcViewTextTemplate> viewTemplates;
+		MvcViewTextTemplate selectedViewTemplate;
 		MvcModelClassViewModelsForSelectedFolder modelClassesForSelectedFolder;
 		
 		public AddMvcViewToProjectViewModel(ISelectedMvcFolder selectedViewFolder)
 			: this(
 				selectedViewFolder,
-				new MvcViewFileGenerator())
+				new MvcViewFileGenerator(),
+				new MvcTextTemplateRepository())
 		{
 		}
 		
 		public AddMvcViewToProjectViewModel(
 			ISelectedMvcFolder selectedViewFolder,
-			IMvcViewFileGenerator viewGenerator)
+			IMvcViewFileGenerator viewGenerator,
+			IMvcTextTemplateRepository textTemplateRepository)
 		{
 			this.selectedViewFolder = selectedViewFolder;
 			this.viewGenerator = viewGenerator;
+			this.textTemplateRepository = textTemplateRepository;
 			this.viewFileName.Folder = selectedViewFolder.Path;
 			this.ModelClassName = String.Empty;
 			this.PrimaryContentPlaceHolderId = "Main";
@@ -138,10 +144,38 @@ namespace ICSharpCode.AspNet.Mvc
 			IsRazorViewEngineSelected = selectedViewEngine.TemplateType.IsRazor();
 			
 			SetDefaultMasterPage();
+			AddViewTemplates();
 			
 			OnPropertyChanged(viewModel => viewModel.IsAspxViewEngineSelected);
 			OnPropertyChanged(viewModel => viewModel.IsRazorViewEngineSelected);
 			OnPropertyChanged(viewModel => viewModel.MasterPageFile);
+			OnPropertyChanged(viewModel => viewModel.ViewTemplates);
+		}
+		
+		void AddViewTemplates()
+		{
+			viewTemplates = GetViewTemplates();
+		}
+		
+		List<MvcViewTextTemplate> GetViewTemplates()
+		{
+			var templateCriteria = new MvcTextTemplateCriteria() {
+				TemplateLanguage = GetTemplateLanguage(),
+				TemplateType = selectedViewEngine.TemplateType
+			};
+			return textTemplateRepository
+				.GetMvcViewTextTemplates(templateCriteria)
+				.OrderBy(t => t.Name)
+				.ToList();
+		}
+		
+		public IEnumerable<MvcViewTextTemplate> ViewTemplates {
+			get { return viewTemplates; }
+		}
+		
+		public MvcViewTextTemplate SelectedViewTemplate {
+			get { return selectedViewTemplate; }
+			set { selectedViewTemplate = value; }
 		}
 		
 		public bool IsRazorViewEngineSelected { get; private set; }

src/AddIns/BackendBindings/AspNet.Mvc/Project/Src/IMvcTextTemplateRepository.cs

@@ -9,5 +9,6 @@ namespace ICSharpCode.AspNet.Mvc
 	public interface IMvcTextTemplateRepository
 	{
 		IEnumerable<MvcControllerTextTemplate> GetMvcControllerTextTemplates(MvcTextTemplateCriteria templateCriteria);
+		IEnumerable<MvcViewTextTemplate> GetMvcViewTextTemplates(MvcTextTemplateCriteria templateCriteria);
 	}
 }

src/AddIns/BackendBindings/AspNet.Mvc/Project/Src/MvcTextTemplateRepository.cs

@@ -12,9 +12,11 @@ namespace ICSharpCode.AspNet.Mvc
 	public class MvcTextTemplateRepository : IMvcTextTemplateRepository
 	{
 		string textTemplatesRootDirectory;
+		IFileSystem fileSystem;
 		
 		public MvcTextTemplateRepository(string mvcAddInPath, IFileSystem fileSystem)
 		{
+			this.fileSystem = fileSystem;
 			GetTextTemplatesRootDirectory(mvcAddInPath);
 		}
 		
@@ -81,5 +83,29 @@ namespace ICSharpCode.AspNet.Mvc
 				AddActionMethods = true
 			};
 		}
+		
+		public IEnumerable<MvcViewTextTemplate> GetMvcViewTextTemplates(MvcTextTemplateCriteria templateCriteria)
+		{
+			foreach (string templateFileName in GetMvcViewTemplateFileNamesInFolder(templateCriteria)) {
+				yield return new MvcViewTextTemplate(templateFileName);
+			}
+		}
+		
+		IEnumerable<string> GetMvcViewTemplateFileNamesInFolder(MvcTextTemplateCriteria templateCriteria)
+		{
+			string templatePath = GetMvcViewTemplatePath(templateCriteria);
+			return fileSystem.GetFiles(templatePath, "*.tt");
+		}
+		
+		string GetMvcViewTemplatePath(MvcTextTemplateCriteria templateCriteria)
+		{
+			var emptyViewTemplateCriteria = new MvcTextTemplateCriteria() {
+				TemplateLanguage = templateCriteria.TemplateLanguage,
+				TemplateName = "Empty",
+				TemplateType = templateCriteria.TemplateType
+			};
+			string emptyViewTemplateFileName = GetMvcViewTextTemplateFileName(emptyViewTemplateCriteria);
+			return Path.GetDirectoryName(emptyViewTemplateFileName);
+		}
 	}
 }

src/AddIns/BackendBindings/AspNet.Mvc/Project/Src/MvcViewTextTemplate.cs

@@ -0,0 +1,25 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.AspNet.Mvc
+{
+	public class MvcViewTextTemplate
+	{
+		public MvcViewTextTemplate()
+			: this(String.Empty)
+		{
+		}
+		
+		public MvcViewTextTemplate(string fileName)
+		{
+			this.Name = Path.GetFileNameWithoutExtension(fileName);
+			this.FileName = fileName;
+		}
+		
+		public string Name { get; set; }
+		public string FileName { get; set; }
+	}
+}

src/AddIns/BackendBindings/AspNet.Mvc/Test/AspNet.Mvc.Tests.csproj

@@ -71,6 +71,7 @@
     <Compile Include="Helpers\MvcControllerTextTemplateCollectionAssert.cs" />
     <Compile Include="Helpers\MvcProjectFileAssert.cs" />
     <Compile Include="Helpers\MvcProjectFileCollectionAssert.cs" />
+    <Compile Include="Helpers\MvcViewTextTemplateCollectionAssert.cs" />
     <Compile Include="Helpers\TestableAddMvcControllerToProjectCommand.cs" />
     <Compile Include="Helpers\TestableAddMvcViewToProjectCommand.cs" />
     <Compile Include="Helpers\TestableProject.cs" />

src/AddIns/BackendBindings/AspNet.Mvc/Test/Helpers/FakeMvcTextTemplateRepository.cs

@@ -17,5 +17,14 @@ namespace AspNet.Mvc.Tests.Helpers
 			TemplateCriteriaPassedToGetMvcControllerTextTemplates = templateCriteria;
 			return ControllerTextTemplates;
 		}
+		
+		public List<MvcViewTextTemplate> ViewTextTemplates = new List<MvcViewTextTemplate>();
+		public MvcTextTemplateCriteria TemplateCriteriaPassedToGetMvcViewTextTemplates;
+		
+		public IEnumerable<MvcViewTextTemplate> GetMvcViewTextTemplates(MvcTextTemplateCriteria templateCriteria)
+		{
+			TemplateCriteriaPassedToGetMvcViewTextTemplates = templateCriteria;
+			return ViewTextTemplates;
+		}
 	}
 }

src/AddIns/BackendBindings/AspNet.Mvc/Test/Helpers/MvcViewTextTemplateCollectionAssert.cs

@@ -0,0 +1,38 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.AspNet.Mvc;
+using NUnit.Framework;
+
+namespace AspNet.Mvc.Tests.Helpers
+{
+	public static class MvcViewTextTemplateCollectionAssert
+	{
+		public static void AreEqual(IEnumerable<MvcViewTextTemplate> expected, IEnumerable<MvcViewTextTemplate> actual)
+		{
+			List<string> expectedAsStrings = ConvertToStrings(expected);
+			List<string> actualAsStrings = ConvertToStrings(actual);
+			
+			CollectionAssert.AreEqual(expectedAsStrings, actualAsStrings);
+		}
+		
+		static List<string> ConvertToStrings(IEnumerable<MvcViewTextTemplate> templates)
+		{
+			var templatesAsStrings = new List<string>();
+			foreach (MvcViewTextTemplate template in templates) {
+				string templateAsString = ConvertToString(template);
+				templatesAsStrings.Add(templateAsString);
+			}
+			return templatesAsStrings;
+		}
+		
+		static string ConvertToString(MvcViewTextTemplate template)
+		{
+			return String.Format(
+				"Name: {0}, FileName: {1}",
+				template.Name, template.FileName);
+		}
+	}
+}

src/AddIns/BackendBindings/AspNet.Mvc/Test/Src/AddMvcViewToProjectViewModelTests.cs

@@ -20,6 +20,7 @@ namespace AspNet.Mvc.Tests
 		FakeSelectedMvcFolder fakeSelectedMvcViewFolder;
 		List<string> propertyChangedEvents;
 		FakeMvcProject fakeProject;
+		FakeMvcTextTemplateRepository fakeTextTemplateRepository;
 		
 		void CreateViewModel()
 		{
@@ -28,15 +29,35 @@ namespace AspNet.Mvc.Tests
 		}
 		
 		void CreateViewModelWithViewFolderPath(string path)
+		{
+			fakeTextTemplateRepository = new FakeMvcTextTemplateRepository();
+			CreateViewModelWithViewFolderPath(path, fakeTextTemplateRepository);
+		}
+		
+		void CreateViewModelWithViewFolderPath(
+			string path,
+			FakeMvcTextTemplateRepository fakeTextTemplateRepository)
+		{
+			CreateViewModelWithViewFolderPath(
+				path,
+				fakeTextTemplateRepository,
+				MvcTextTemplateLanguage.CSharp);
+		}
+		
+		void CreateViewModelWithViewFolderPath(
+			string path,
+			FakeMvcTextTemplateRepository fakeTextTemplateRepository,
+			MvcTextTemplateLanguage templateLanguage)
 		{
 			fakeSelectedMvcViewFolder = new FakeSelectedMvcFolder();
 			fakeSelectedMvcViewFolder.Path = path;
-			fakeSelectedMvcViewFolder.SetCSharpAsTemplateLanguage();
+			fakeSelectedMvcViewFolder.TemplateLanguage = templateLanguage;
 			fakeProject = fakeSelectedMvcViewFolder.FakeMvcProject;
 			fakeViewGenerator = new FakeMvcViewFileGenerator();
 			viewModel = new AddMvcViewToProjectViewModel(
 				fakeSelectedMvcViewFolder,
-				fakeViewGenerator);
+				fakeViewGenerator,
+				fakeTextTemplateRepository);
 		}
 		
 		void MonitorPropertyChangedEvents()
@@ -992,5 +1013,122 @@ namespace AspNet.Mvc.Tests
 			
 			Assert.AreEqual(expectedFiles, files);
 		}
+		
+		[Test]
+		public void ViewTemplates_CSharpProjectAndOneTemplateInRepository_ReturnsOneViewTemplate()
+		{
+			fakeTextTemplateRepository = new FakeMvcTextTemplateRepository();
+			var expectedTemplate = new MvcViewTextTemplate(@"d:\templates\Empty.tt");
+			fakeTextTemplateRepository.ViewTextTemplates.Add(expectedTemplate);
+			CreateViewModelWithViewFolderPath(@"d:\myproject\views", fakeTextTemplateRepository);
+			
+			IEnumerable<MvcViewTextTemplate> templates = viewModel.ViewTemplates;
+			
+			var expectedTemplates = new MvcViewTextTemplate[] {
+				expectedTemplate
+			};
+			
+			MvcViewTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
+		}
+		
+		[Test]
+		public void ViewTemplates_CSharpProject_CSharpViewTemplatesRetrievedFromTemplateRepository()
+		{
+			CreateViewModel();
+			
+			IEnumerable<MvcViewTextTemplate> templates = viewModel.ViewTemplates;
+			MvcTextTemplateCriteria templateCriteria = fakeTextTemplateRepository.TemplateCriteriaPassedToGetMvcViewTextTemplates;
+			
+			Assert.AreEqual(MvcTextTemplateLanguage.CSharp, templateCriteria.TemplateLanguage);
+			Assert.AreEqual(MvcTextTemplateType.Aspx, templateCriteria.TemplateType);
+		}
+		
+		[Test]
+		public void ViewTemplates_VisualBasicProject_VisualBasicTemplatesRetrievedFromTemplateRepository()
+		{
+			fakeTextTemplateRepository = new FakeMvcTextTemplateRepository();
+			var expectedTemplate = new MvcViewTextTemplate(@"d:\templates\Empty.tt");
+			fakeTextTemplateRepository.ViewTextTemplates.Add(expectedTemplate);
+			CreateViewModelWithViewFolderPath(
+				@"d:\myproject\views",
+				fakeTextTemplateRepository,
+				MvcTextTemplateLanguage.VisualBasic);
+			
+			IEnumerable<MvcViewTextTemplate> templates = viewModel.ViewTemplates;
+			MvcTextTemplateCriteria templateCriteria = fakeTextTemplateRepository.TemplateCriteriaPassedToGetMvcViewTextTemplates;
+			
+			Assert.AreEqual(MvcTextTemplateLanguage.VisualBasic, templateCriteria.TemplateLanguage);
+		}
+		
+		[Test]
+		public void ViewTemplates_CSharpProjectAndTwoTemplatesInRepository_ReturnsTwoViewTemplatesSortedByName()
+		{
+			fakeTextTemplateRepository = new FakeMvcTextTemplateRepository();
+			
+			var templateB = new MvcViewTextTemplate(@"d:\templates\B.tt");
+			fakeTextTemplateRepository.ViewTextTemplates.Add(templateB);
+			
+			var templateA = new MvcViewTextTemplate(@"d:\templates\A.tt");
+			fakeTextTemplateRepository.ViewTextTemplates.Add(templateA);
+			
+			CreateViewModelWithViewFolderPath(@"d:\myproject\views", fakeTextTemplateRepository);
+			
+			IEnumerable<MvcViewTextTemplate> templates = viewModel.ViewTemplates;
+			
+			var expectedTemplates = new MvcViewTextTemplate[] {
+				templateA,
+				templateB
+			};
+			
+			MvcViewTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
+		}
+		
+		[Test]
+		public void ViewTemplates_CSharpProjectAndRazorViewEngineSelected_ViewTemplatesUpdatedFromRepository()
+		{
+			CreateViewModel();
+			List<MvcViewTextTemplate> templates = viewModel.ViewTemplates.ToList();
+			
+			var expectedTemplate = new MvcViewTextTemplate(@"d:\templates\Empty.tt");
+			fakeTextTemplateRepository.ViewTextTemplates.Add(expectedTemplate);
+			
+			SelectRazorViewEngine();
+			
+			templates = viewModel.ViewTemplates.ToList();
+			
+			var expectedTemplates = new MvcViewTextTemplate[] {
+				expectedTemplate
+			};
+			
+			MvcViewTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
+		}
+		
+		[Test]
+		public void ViewTemplates_VisualBasicProjectAndRazorViewEngineSelected_RazorViewTemplatesReadFromRepository()
+		{
+			CreateViewModel();
+			List<MvcViewTextTemplate> templates = viewModel.ViewTemplates.ToList();
+			
+			VisualBasicProjectSelected();
+			SelectRazorViewEngine();
+			
+			templates = viewModel.ViewTemplates.ToList();
+			MvcTextTemplateCriteria templateCriteria = fakeTextTemplateRepository.TemplateCriteriaPassedToGetMvcViewTextTemplates;
+			
+			Assert.AreEqual(MvcTextTemplateType.Razor, templateCriteria.TemplateType);
+			Assert.AreEqual(MvcTextTemplateLanguage.VisualBasic, templateCriteria.TemplateLanguage);
+		}
+		
+		[Test]
+		public void SelectedViewEngine_RazorViewEngineSelected_ViewTemplatesPropertyChangedEventIsFired()
+		{
+			CreateViewModel();
+			MonitorPropertyChangedEvents();
+			SelectRazorViewEngine();
+			
+			bool fired = propertyChangedEvents.Contains("ViewTemplates");
+			
+			Assert.IsTrue(fired);
+		}
 	}
 }

src/AddIns/BackendBindings/AspNet.Mvc/Test/Src/MvcTextTemplateRepositoryTests.cs

@@ -22,15 +22,15 @@ namespace AspNet.Mvc.Tests
 			repository = new MvcTextTemplateRepository(mvcAddInPath, fakeFileSystem);
 		}
 		
-		void AddCSharpAspxTemplateToFolder(string path, string fileName)
+		void AddTextTemplateToFolder(string path, string fileName)
 		{
 			string[] fileNames = new string[] {
 				fileName
 			};
-			AddCSharpAspxTemplatesToFolder(path, fileNames);
+			AddTextTemplatesToFolder(path, fileNames);
 		}
 		
-		void AddCSharpAspxTemplatesToFolder(string path, string[] fileNames)
+		void AddTextTemplatesToFolder(string path, string[] fileNames)
 		{
 			fakeFileSystem.AddFakeFiles(path, "*.tt", fileNames);
 		}
@@ -202,5 +202,68 @@ namespace AspNet.Mvc.Tests
 			
 			MvcControllerTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
 		}
+		
+		[Test]
+		public void GetMvcViewTextTemplates_CSharpAspxTemplatesRequestedAndOneViewTemplateInFolder_ReturnsOneViewTextTemplate()
+		{
+			CreateRepositoryWithAspNetMvcAddInDirectory(@"C:\SD\AddIns\AspNet.Mvc");
+			string templateFolder = 
+				@"C:\SD\AddIns\AspNet.Mvc\ItemTemplates\CSharp\CodeTemplates\AddView\AspxCSharp";
+			string existingTemplateFileName = 
+				@"C:\SD\AddIns\AspNet.Mvc\ItemTemplates\CSharp\CodeTemplates\AddView\AspxCSharp\Empty.tt";
+			AddTextTemplateToFolder(templateFolder, existingTemplateFileName);
+			
+			var templateCriteria = new MvcTextTemplateCriteria() {
+				TemplateLanguage = MvcTextTemplateLanguage.CSharp,
+				TemplateType = MvcTextTemplateType.Aspx
+			};
+			
+			List<MvcViewTextTemplate> templates = repository.GetMvcViewTextTemplates(templateCriteria).ToList();
+			
+			var expectedTemplate = new MvcViewTextTemplate() {
+				Name = "Empty",
+				FileName = existingTemplateFileName
+			};
+			var expectedTemplates = new MvcViewTextTemplate[] {
+				expectedTemplate
+			};
+			
+			MvcViewTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
+		}
+		
+		[Test]
+		public void GetMvcViewTextTemplates_CSharpRazorTemplatesRequestedAndTwoViewTemplatesInFolder_ReturnsTwoViewTextTemplates()
+		{
+			CreateRepositoryWithAspNetMvcAddInDirectory(@"C:\SD\AddIns\AspNet.Mvc");
+			string templateFolder = 
+				@"C:\SD\AddIns\AspNet.Mvc\ItemTemplates\CSharp\CodeTemplates\AddView\CSHTML";
+			string[] templateFileNames = new string[] {
+				@"C:\SD\AddIns\AspNet.Mvc\ItemTemplates\CSharp\CodeTemplates\AddView\CSHTML\B.tt",
+				@"C:\SD\AddIns\AspNet.Mvc\ItemTemplates\CSharp\CodeTemplates\AddView\CSHTML\A.tt"
+			};
+			AddTextTemplatesToFolder(templateFolder, templateFileNames);
+			
+			var templateCriteria = new MvcTextTemplateCriteria() {
+				TemplateLanguage = MvcTextTemplateLanguage.CSharp,
+				TemplateType = MvcTextTemplateType.Razor
+			};
+			
+			List<MvcViewTextTemplate> templates = repository.GetMvcViewTextTemplates(templateCriteria).ToList();
+			
+			var expectedTemplate1 = new MvcViewTextTemplate() {
+				Name = "B",
+				FileName = templateFileNames[0]
+			};
+			var expectedTemplate2 = new MvcViewTextTemplate() {
+				Name = "A",
+				FileName = templateFileNames[1]
+			};
+			var expectedTemplates = new MvcViewTextTemplate[] {
+				expectedTemplate1,
+				expectedTemplate2
+			};
+			
+			MvcViewTextTemplateCollectionAssert.AreEqual(expectedTemplates, templates);
+		}
 	}
 }