/// <summary>
/// Updates the item templates.
/// </summary>
/// <returns>A list of required views.</returns>
public List<ItemTemplateInfo> GetRequiredItemTemplates()
{
const string ViewModelSuffix = "ViewModel";
string viewName = this.view.ViewModelName.Remove(this.view.ViewModelName.Length - ViewModelSuffix.Length) + "View.cs";
this.itemTemplateInfos.Clear();
//// first add thew view model
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffixes.Core,
FolderName = "ViewModels",
TemplateName = ItemTemplates.ViewModel,
FileName = this.view.ViewModelName,
};
this.itemTemplateInfos.Add(viewModelTemplateInfo);
foreach (ItemTemplateInfo itemTemplateInfo in this.view.RequiredTemplates)
{
itemTemplateInfo.FileName = viewName;
this.itemTemplateInfos.Add(itemTemplateInfo);
}
return this.itemTemplateInfos;
}
/// <summary>
/// Updates the item templates.
/// </summary>
/// <returns>A list of required views.</returns>
public IEnumerable<ItemTemplateInfo> GetRequiredItemTemplates()
{
const string ViewModelSuffix = "ViewModel";
string viewName = this.view.ViewModelName.Remove(this.view.ViewModelName.Length - ViewModelSuffix.Length) + "View.cs";
List<ItemTemplateInfo> itemTemplateInfos = new List<ItemTemplateInfo>();
//// first add the view model
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffixes.Core,
FolderName = "ViewModels",
TemplateName = ItemTemplates.ViewModel,
FileName = this.view.ViewModelName,
};
itemTemplateInfos.Add(viewModelTemplateInfo);
foreach (ItemTemplateInfo itemTemplateInfo in this.view.RequiredTemplates)
{
itemTemplateInfo.FileName = viewName;
itemTemplateInfos.Add(itemTemplateInfo);
}
//// do we require a Test ViewModel?
if (this.view.IncludeUnitTests)
{
viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffixes.CoreTests,
FolderName = "ViewModels",
TemplateName = ItemTemplates.TestViewModel,
FileName = "Test" + this.view.ViewModelName,
};
itemTemplateInfos.Add(viewModelTemplateInfo);
}
return itemTemplateInfos;
}
/// <summary>
/// Adds the converter.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="templatesPath">The templates path.</param>
/// <param name="messages">The messages.</param>
/// <param name="templateInfo">The template info.</param>
internal void AddConverter(
IProjectService projectService,
string templatesPath,
List<string> messages,
ItemTemplateInfo templateInfo)
{
TraceService.WriteLine("ConvertersService::AddConverters adding from template path " + templatesPath + " template=" + templateInfo.FileName);
string fileName = templateInfo.FriendlyName + ".cs";
projectService.AddToFolderFromTemplate("Converters", templateInfo.FileName, fileName, false);
IProjectItemService projectItemService = projectService.GetProjectItem(fileName);
//// if we find the project item replace the text in it.
if (projectItemService != null)
{
projectItemService.ReplacePattern("MvvmCross." + templateInfo.FriendlyName, projectService.Name);
projectItemService.Save();
}
messages.Add(@"Converters\" + fileName + " added to project " + projectService.Name + ".");
}
/// <summary>
/// Implements the test code snippet.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="itemTemplateInfo">The item template info.</param>
internal void ImplementTestCodeSnippet(
IVisualStudioService visualStudioService,
string viewModelName,
ItemTemplateInfo itemTemplateInfo)
{
CodeSnippet testCodeSnippet = this.codeSnippetFactory.GetServiceTestSnippet(itemTemplateInfo.FriendlyName);
IProjectItemService projectItemService = this.codeSnippetService.CreateUnitTests(
visualStudioService,
visualStudioService.CoreTestsProjectService,
testCodeSnippet,
viewModelName,
itemTemplateInfo.FriendlyName,
string.Empty);
projectItemService.FixUsingStatements();
}
/// <summary>
/// Implements the code snippet.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="coreProjectService">The core project service.</param>
/// <param name="projectItemService">The project item service.</param>
/// <param name="itemTemplateInfo">The item template info.</param>
/// <returns>The project Item service.</returns>
internal void ImplementCodeSnippet(
IVisualStudioService visualStudioService,
string viewModelName,
IProjectService coreProjectService,
IProjectItemService projectItemService,
ItemTemplateInfo itemTemplateInfo)
{
TraceService.WriteLine("ServicesService::CreateSnippet service=" + itemTemplateInfo.FriendlyName + " viewModelName=" + viewModelName);
CodeSnippet codeSnippet = this.codeSnippetFactory.GetServiceSnippet(itemTemplateInfo.FriendlyName);
if (codeSnippet != null)
{
projectItemService.ImplementCodeSnippet(
codeSnippet,
this.settingsService.FormatFunctionParameters);
this.Messages.Add(itemTemplateInfo.FriendlyName + " service code added to " + viewModelName + ".cs in project " + coreProjectService.Name + ".");
}
}
/// <summary>
/// Adds the service.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="templateInfo">The template info.</param>
/// <returns>True or false.</returns>
internal bool AddService(
IVisualStudioService visualStudioService,
IProjectService projectService,
ItemTemplateInfo templateInfo)
{
TraceService.WriteLine("ServicesService::AddServices");
//// put at the top of the stack!
if (this.settingsService.UseNugetForPlugins)
{
IEnumerable<string> messages = this.nugetService.GetInitNugetMessages(NinjaMessages.ServicesViaNuget);
this.Messages.AddRange(messages);
}
string fileName = templateInfo.FriendlyName + ".cs";
try
{
projectService.AddToFolderFromTemplate(templateInfo.FileName, fileName);
CodeConfig codeConfig = this.codeConfigFactory.GetServiceConfig(templateInfo.FriendlyName);
if (codeConfig != null)
{
this.ProcessConfig(
visualStudioService,
projectService,
codeConfig);
}
return true;
}
catch (Exception exception)
{
string message = "AddToFolderFromTemplate error:-" + exception.Message;
TraceService.WriteError(message);
this.messageBoxService.Show(
message,
"Ninja Code for MvvmCross - Add Service",
this.settingsService.BetaTesting,
Theme.Light,
this.settingsService.ThemeColor);
throw new NinjaCoderServiceException
{
NinjaMessage = "Ninja exception :-" + message,
FileName = templateInfo.FileName,
};
}
}
public void TestImplementTestCodeSnippet()
{
Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>();
ItemTemplateInfo itemTemplateInfo = new ItemTemplateInfo();
this.service.ImplementTestCodeSnippet(
mockVisualStudioService.Object,
"viewModelName",
itemTemplateInfo);
}
public void TestImplementCodeSnippet()
{
Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>();
Mock<IProjectService> mockProjectService = new Mock<IProjectService>();
mockVisualStudioService.SetupGet(x => x.CoreProjectService)
.Returns(mockProjectService.Object);
Mock<IProjectItemService> mockProjectItemService = new Mock<IProjectItemService>();
ItemTemplateInfo itemTemplateInfo = new ItemTemplateInfo();
this.mockCodeSnippetFactory
.Setup(x => x.GetServiceSnippet(
It.IsAny<string>()))
.Returns(new CodeSnippet());
service.ImplementCodeSnippet(
mockVisualStudioService.Object,
"viewModelName",
mockProjectService.Object,
mockProjectItemService.Object,
itemTemplateInfo);
mockProjectItemService
.Verify(x => x.ImplementCodeSnippet(
It.IsAny<CodeSnippet>(),
It.IsAny<bool>()));
}
public void TestAddService()
{
Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>();
Mock<IProjectService> mockProjectService = new Mock<IProjectService>();
mockVisualStudioService.SetupGet(x => x.CoreProjectService).Returns(mockProjectService.Object);
ItemTemplateInfo itemTemplateInfo = new ItemTemplateInfo();
service.AddService(
mockVisualStudioService.Object,
mockProjectService.Object,
itemTemplateInfo);
mockProjectService.Verify(x => x.AddToFolderFromTemplate(
It.IsAny<string>(),
It.IsAny<string>()));
this.mockCodeConfigFactory.Verify(x => x.GetServiceConfig(
It.IsAny<string>()));
}
/// <summary>
/// Creates the snippet.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="codeSnippetsPath">The code snippets path.</param>
/// <param name="createUnitTests">if set to <c>true</c> [create unit tests].</param>
/// <param name="coreProjectService">The core project service.</param>
/// <param name="projectItemService">The project item service.</param>
/// <param name="itemTemplateInfo">The item template info.</param>
/// <returns>The project Item service.</returns>
internal IProjectItemService CreateSnippet(
IVisualStudioService visualStudioService,
string viewModelName,
string codeSnippetsPath,
bool createUnitTests,
IProjectService coreProjectService,
IProjectItemService projectItemService,
ItemTemplateInfo itemTemplateInfo)
{
TraceService.WriteLine("ServicesService::CreateSnippet service=" + itemTemplateInfo.FriendlyName + " viewModelName=" + viewModelName);
string snippetPath = string.Format(@"{0}\Services.{1}.xml", codeSnippetsPath, itemTemplateInfo.FriendlyName);
IProjectItemService testProjectItemService = null;
CodeSnippet codeSnippet = this.snippetService.GetSnippet(snippetPath);
if (codeSnippet != null)
{
//// Do some variable substitution!!!!
if (this.settingsService.ReplaceVariablesInSnippets)
{
this.snippetService.ApplyGlobals(visualStudioService, codeSnippet);
}
projectItemService.ImplementCodeSnippet(codeSnippet, this.settingsService.FormatFunctionParameters);
this.Messages.Add(itemTemplateInfo.FriendlyName + " service code added to " + viewModelName + ".cs in project " + coreProjectService.Name + ".");
//// do we need to implement any unit tests?
if (createUnitTests)
{
string testSnippetPath = string.Format(@"{0}\Services.{1}.Tests.xml", codeSnippetsPath, itemTemplateInfo.FriendlyName);
IProjectItemService itemService = this.snippetService.CreateUnitTests(
visualStudioService,
visualStudioService.CoreTestsProjectService,
testSnippetPath,
viewModelName,
itemTemplateInfo.FriendlyName,
string.Empty);
//// if we actually create some units tests save the pointer to do
//// the sort and remove of the using statements later!
if (itemService != null)
{
testProjectItemService = itemService;
}
}
}
return testProjectItemService;
}
/// <summary>
/// Adds the service.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="templatesPath">The templates path.</param>
/// <param name="templateInfo">The template info.</param>
/// <returns>True or false.</returns>
internal bool AddService(
IVisualStudioService visualStudioService,
IProjectService projectService,
string templatesPath,
ItemTemplateInfo templateInfo)
{
TraceService.WriteLine("ServicesService::AddServices adding from template path " + templatesPath + " template=" + templateInfo.FileName);
//// put at the top of the stack!
if (this.settingsService.UseNugetForPlugins)
{
IEnumerable<string> messages = this.nugetService.GetInitNugetMessages(NinjaMessages.ServicesViaNuget);
this.Messages.AddRange(messages);
}
string fileName = templateInfo.FriendlyName + ".cs";
try
{
projectService.AddToFolderFromTemplate("Services", templateInfo.FileName, fileName, false);
string configFile = string.Format(@"{0}\Services\Config.{1}.xml", this.settingsService.ConfigPath, templateInfo.FriendlyName);
if (this.fileSystem.File.Exists(configFile))
{
this.ProcessConfig(
visualStudioService,
projectService,
configFile);
}
return true;
}
catch (Exception exception)
{
string message = "AddToFolderFromTemplate error:-" + exception.Message;
TraceService.WriteError(message);
this.messageBoxService.Show(message, "Ninja Code for MvvmCross - Add Service");
throw new NinjaCoderServiceException
{
NinjaMessage = "Ninja exception :-" + message,
FileName = templateInfo.FileName,
FolderName = templateInfo.FolderName
};
}
}
/// <summary>
/// Gets the required templates.
/// </summary>
/// <param name="view">The view.</param>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="requiredUIViews">The required UI views.</param>
/// <param name="unitTestsRequired">if set to <c>true</c> [unit tests required].</param>
/// <param name="overwriteCurrentFiles">if set to <c>true</c> [overwrite current files].</param>
/// <returns>
/// The required template.
/// </returns>
public IEnumerable<ItemTemplateInfo> GetRequiredViewModelAndViews(
View view,
string viewModelName,
IEnumerable<ItemTemplateInfo> requiredUIViews,
bool unitTestsRequired,
bool overwriteCurrentFiles)
{
TraceService.WriteLine("ViewModelAndViewsFactory::GetRequiredViewModelAndViews");
const string ViewModelSuffix = "ViewModel";
List<ItemTemplateInfo> itemTemplateInfos = new List<ItemTemplateInfo>();
//// first add the view model
if (view.Framework == FrameworkType.MvvmCross.GetDescription())
{
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffix.Core.GetDescription(),
TemplateName = this.GetViewModelTemplate(FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework), view.PageType),
FileName = viewModelName + ".cs"
};
itemTemplateInfos.Add(viewModelTemplateInfo);
string viewName = viewModelName.Remove(viewModelName.Length - ViewModelSuffix.Length) + "View.cs";
foreach (ItemTemplateInfo itemTemplateInfo in requiredUIViews)
{
itemTemplateInfo.TemplateName = this.GetViewTemplate(FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework),
itemTemplateInfo.ProjectSuffix,
view.PageType);
itemTemplateInfo.FileName = viewName;
itemTemplateInfos.Add(itemTemplateInfo);
}
}
else if (view.Framework == FrameworkType.XamarinForms.GetDescription())
{
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffix.Core.GetDescription(),
TemplateName = this.GetViewModelTemplate(FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework), view.PageType),
FileName = viewModelName + ".cs",
};
itemTemplateInfos.Add(viewModelTemplateInfo);
string viewName = viewModelName.Remove(viewModelName.Length - ViewModelSuffix.Length) + "View.cs";
ItemTemplateInfo viewTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffix.XamarinForms.GetDescription(),
TemplateName = this.GetViewTemplate(FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework),
string.Empty,
view.PageType),
FileName = viewName,
};
itemTemplateInfos.Add(viewTemplateInfo);
}
//// do we require a Test ViewModel?
if (unitTestsRequired)
{
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffix.CoreTests.GetDescription(),
TemplateName = this.GetTestViewModelTemplate(
FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework),
view.PageType),
FileName = "Test" + viewModelName + ".cs",
};
itemTemplateInfos.Add(viewModelTemplateInfo);
}
return itemTemplateInfos;
}
/// <summary>
/// Gets the MVVM cross view.
/// </summary>
/// <param name="itemTemplateInfo">The item template information.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="viewTemplateName">Name of the view template.</param>
/// <param name="viewName">Name of the view.</param>
/// <returns></returns>
public TextTemplateInfo GetMvvmCrossView(
ItemTemplateInfo itemTemplateInfo,
Dictionary<string, string> tokens,
string viewTemplateName,
string viewName)
{
TraceService.WriteLine("MvvmCrossViewFactory::GetMvvmCrossView viewTemplateName=" + viewTemplateName);
if (itemTemplateInfo.ProjectSuffix == this.SettingsService.iOSProjectSuffix)
{
return this.GetiOSMvvmCrossView(
itemTemplateInfo,
tokens,
viewTemplateName,
viewName);
}
TextTemplateInfo textTemplateInfo = new TextTemplateInfo
{
ProjectSuffix = itemTemplateInfo.ProjectSuffix,
ProjectFolder = "Views",
Tokens = tokens,
ShortTemplateName = viewTemplateName,
TemplateName = this.SettingsService.ItemTemplatesDirectory + "\\" + itemTemplateInfo.ProjectType + "\\" + viewTemplateName
};
TextTransformationRequest textTransformationRequest = new TextTransformationRequest
{
SourceFile = textTemplateInfo.TemplateName,
Parameters = textTemplateInfo.Tokens,
RemoveFileHeaders = this.SettingsService.RemoveDefaultFileHeaders,
RemoveXmlComments = this.SettingsService.RemoveDefaultComments,
RemoveThisPointer = this.SettingsService.RemoveThisPointer
};
TextTransformation textTransformation = this.GetTextTransformationService().Transform(textTransformationRequest);
textTemplateInfo.TextOutput = textTransformation.Output;
textTemplateInfo.FileName = viewName + "." + textTransformation.FileExtension;
if (itemTemplateInfo.ProjectSuffix == this.SettingsService.DroidProjectSuffix)
{
textTemplateInfo.FileOperations.Add(
this.GetCompileFileOperation(textTemplateInfo.ProjectSuffix, textTemplateInfo.FileName));
}
else
{
textTemplateInfo.FileOperations.Add(
this.GetPageFileOperation(textTemplateInfo.ProjectSuffix, textTemplateInfo.FileName));
}
return textTemplateInfo;
}
/// <summary>
/// Getis the os MVVM cross view.
/// </summary>
/// <param name="itemTemplateInfo">The item template information.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="viewTemplateName">Name of the view template.</param>
/// <param name="viewName">Name of the view.</param>
/// <returns>A TextTemplateInfo.</returns>
internal TextTemplateInfo GetiOSMvvmCrossView(
ItemTemplateInfo itemTemplateInfo,
Dictionary<string, string> tokens,
string viewTemplateName,
string viewName)
{
TraceService.WriteLine("MvvmCrossViewFactory::GetiOSMvvmCrossView viewTemplateName=" + viewTemplateName);
string folder = viewTemplateName.Replace("View.t4", string.Empty);
TraceService.WriteLine("folder=" + folder);
string subFolder = this.SettingsService.SelectedMvvmCrossiOSViewType;
TraceService.WriteLine("subFolder=" + subFolder);
folder = folder.Replace(subFolder, string.Empty);
TraceService.WriteLine("folder=" + folder);
string templateFolder = this.SettingsService.ItemTemplatesDirectory + "\\iOS\\" + folder + "\\" + subFolder + "\\";
string shortFolderName = folder + "\\" + subFolder + "\\";
TraceService.WriteLine("templateFolder=" + templateFolder);
TextTemplateInfo textTemplateInfo = new TextTemplateInfo
{
ProjectSuffix = this.SettingsService.iOSProjectSuffix,
ProjectFolder = "Views",
Tokens = tokens,
ShortTemplateName = shortFolderName + "View.t4",
TemplateName = templateFolder + "View.t4"
};
TextTransformationRequest textTransformationRequest = new TextTransformationRequest
{
SourceFile = textTemplateInfo.TemplateName,
Parameters = tokens,
RemoveFileHeaders = this.SettingsService.RemoveDefaultFileHeaders,
RemoveXmlComments = this.SettingsService.RemoveDefaultComments,
RemoveThisPointer = this.SettingsService.RemoveThisPointer
};
TextTransformation textTransformation = this.GetTextTransformationService().Transform(textTransformationRequest);
textTemplateInfo.TextOutput = textTransformation.Output;
textTemplateInfo.FileName = viewName + "." + textTransformation.FileExtension;
textTemplateInfo.FileOperations.Add(this.GetCompileFileOperation(
textTemplateInfo.ProjectSuffix,
textTemplateInfo.FileName));
//// now handle xib and story board options!
TraceService.WriteLine("SelectedMvvmCrossiOSViewType=" + this.SettingsService.SelectedMvvmCrossiOSViewType);
if (this.SettingsService.SelectedMvvmCrossiOSViewType == MvvmCrossViewType.StoryBoard.GetDescription() ||
this.SettingsService.SelectedMvvmCrossiOSViewType == MvvmCrossViewType.Xib.GetDescription())
{
viewTemplateName = this.SettingsService.SelectedMvvmCrossiOSViewType == MvvmCrossViewType.Xib.GetDescription() ? "ViewXib.t4" : "ViewStoryBoard.t4";
TraceService.WriteLine("Adding ChildTextTemplate ViewTemplateName=" + viewTemplateName);
TextTemplateInfo childTextTemplateInfo = new TextTemplateInfo
{
ProjectSuffix = itemTemplateInfo.ProjectSuffix,
ProjectFolder = "Views",
Tokens = tokens,
ShortTemplateName = shortFolderName + viewTemplateName,
TemplateName = templateFolder + viewTemplateName
};
TextTransformationRequest childTextTransformationRequest = new TextTransformationRequest
{
SourceFile = childTextTemplateInfo.TemplateName,
Parameters = tokens,
RemoveFileHeaders = this.SettingsService.RemoveDefaultFileHeaders,
RemoveXmlComments = this.SettingsService.RemoveDefaultComments,
RemoveThisPointer = this.SettingsService.RemoveThisPointer
};
textTransformation = this.GetTextTransformationService().Transform(childTextTransformationRequest);
childTextTemplateInfo.TextOutput = textTransformation.Output;
childTextTemplateInfo.FileName = viewName + "." + textTransformation.FileExtension;
textTemplateInfo.ChildItems.Add(childTextTemplateInfo);
//// add in designer file
viewTemplateName = "ViewDesigner.t4";
TraceService.WriteLine("Adding ChildTextTemplate ViewTemplateName=" + viewTemplateName);
childTextTemplateInfo = new TextTemplateInfo
{
ProjectSuffix = itemTemplateInfo.ProjectSuffix,
ProjectFolder = "Views",
Tokens = tokens,
ShortTemplateName = shortFolderName + viewTemplateName,
TemplateName = templateFolder + viewTemplateName
};
childTextTransformationRequest = new TextTransformationRequest
{
SourceFile = childTextTemplateInfo.TemplateName,
Parameters = tokens,
RemoveFileHeaders = this.SettingsService.RemoveDefaultFileHeaders,
RemoveXmlComments = this.SettingsService.RemoveDefaultComments,
RemoveThisPointer = this.SettingsService.RemoveThisPointer
};
textTransformation = this.GetTextTransformationService().Transform(childTextTransformationRequest);
childTextTemplateInfo.TextOutput = textTransformation.Output;
childTextTemplateInfo.FileName = viewName + ".designer." + textTransformation.FileExtension;
textTemplateInfo.ChildItems.Add(childTextTemplateInfo);
}
return textTemplateInfo;
}
/// <summary>
/// Gets the MVVM cross view.
/// </summary>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="itemTemplateInfo">The item template information.</param>
/// <param name="view">The view.</param>
/// <returns>A TextTemplateInfo.</returns>
public TextTemplateInfo GetMvvmCrossView(
string viewModelName,
ItemTemplateInfo itemTemplateInfo,
View view)
{
TraceService.WriteLine("MvvmCrossViewFactory::GetMvvmCrossView");
string viewName = viewModelName.Remove(viewModelName.Length - ViewModelSuffix.Length) + "View";
TraceService.WriteLine("viewName=" + viewName);
string viewTemplateName = this.GetViewTemplate(
FrameworkType.MvvmCross.GetValueFromDescription<FrameworkType>(view.Framework),
view.PageType);
TraceService.WriteLine("ViewTemplateName=" + viewTemplateName);
if (itemTemplateInfo.ProjectSuffix == this.SettingsService.iOSProjectSuffix)
{
viewTemplateName = this.SettingsService.SelectedMvvmCrossiOSViewType + viewTemplateName;
TraceService.WriteLine("iOS ViewTemplateName=" + viewTemplateName);
}
Dictionary<string, string> tokens = this.GetBaseDictionary(
viewName,
itemTemplateInfo.ProjectSuffix);
TextTemplateInfo textTemplateInfo = this.GetMvvmCrossView(
itemTemplateInfo,
tokens,
viewTemplateName,
viewName);
if (itemTemplateInfo.ProjectSuffix == this.SettingsService.WindowsPhoneProjectSuffix ||
itemTemplateInfo.ProjectSuffix == this.SettingsService.WpfProjectSuffix ||
itemTemplateInfo.ProjectSuffix == this.SettingsService.WindowsUniversalProjectSuffix)
{
TextTemplateInfo childTextTemplateInfo =
this.GetCodeBehindTextTemplateInfo(
itemTemplateInfo.ProjectSuffix,
viewName,
viewTemplateName,
tokens);
textTemplateInfo.ChildItems.Add(childTextTemplateInfo);
}
else if (itemTemplateInfo.ProjectSuffix == this.SettingsService.DroidProjectSuffix)
{
this.GetDroidMvvmCrossViewLayout(textTemplateInfo, tokens, viewName);
}
return textTemplateInfo;
}
/// <summary>
/// Adds the template.
/// </summary>
/// <param name="itemTemplateInfo">The item template info.</param>
public void AddTemplate(ItemTemplateInfo itemTemplateInfo)
{
this.mvxListView1.AddTemplate(itemTemplateInfo);
}
/// <summary>
/// Gets the required templates.
/// </summary>
/// <param name="viewModelName">Name of the view model.</param>
/// <param name="requiredUIViews">The required UI views.</param>
/// <param name="includeUnitTests">if set to <c>true</c> [include unit tests].</param>
/// <returns>The required template.</returns>
public IEnumerable<ItemTemplateInfo> GetRequiredViewModelAndViews(
string viewModelName,
IEnumerable<ItemTemplateInfo> requiredUIViews,
bool includeUnitTests)
{
const string ViewModelSuffix = "ViewModel";
List<ItemTemplateInfo> itemTemplateInfos = new List<ItemTemplateInfo>();
//// first add the view model
ItemTemplateInfo viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffixes.Core,
TemplateName = this.GetViewModelTemplate(),
FileName = viewModelName + ".cs",
};
itemTemplateInfos.Add(viewModelTemplateInfo);
string viewName = viewModelName.Remove(viewModelName.Length - ViewModelSuffix.Length) + "View.cs";
foreach (ItemTemplateInfo itemTemplateInfo in requiredUIViews)
{
itemTemplateInfo.TemplateName = this.GetViewTemplate(itemTemplateInfo.ProjectSuffix);
itemTemplateInfo.FileName = viewName;
itemTemplateInfos.Add(itemTemplateInfo);
}
//// do we require a Test ViewModel?
if (includeUnitTests)
{
viewModelTemplateInfo = new ItemTemplateInfo
{
ProjectSuffix = ProjectSuffixes.CoreTests,
TemplateName = this.GetTestViewModelTemplate(),
FileName = "Test" + viewModelName + ".cs",
};
itemTemplateInfos.Add(viewModelTemplateInfo);
}
return itemTemplateInfos;
}
