/// <summary> /// Translates the specified from. /// </summary> /// <param name="from">From.</param> /// <returns></returns> public CustomRenderers Translate(string from) { TraceService.WriteLine("CustomRenderers::Translate " + from); CustomRenderers customRenderers = new CustomRenderers(); try { XDocument doc = XDocument.Load(@from); if (doc.Root != null) { TraceService.WriteDebugLine(doc.Root.Value); customRenderers.HelpLink = this.GetHelpLink(doc.Root); customRenderers.Groups = this.GetGroups(doc.Root); } } catch (Exception exception) { TraceService.WriteError(exception); } return(customRenderers); }
/// <summary> /// Translates the specified from. /// </summary> /// <param name="from">The translation source..</param> /// <returns>A collection of Plugins.</returns> public Plugins Translate(string from) { try { XDocument doc = XDocument.Load(from); if (doc.Root != null) { TraceService.WriteDebugLine(doc.Root.Value); IEnumerable <XElement> elements = doc.Root.Elements("Plugin"); List <Plugin> items = elements.Select(element => this.translator.Translate(element)).ToList(); Plugins plugins = new Plugins { Items = items }; return(plugins); } return(null); } catch (Exception) { return(null); } }
/// <summary> /// Gets the project item. /// </summary> /// <param name="instance">The instance.</param> /// <param name="fileName">Name of the file.</param> /// <returns>The project item.</returns> public static ProjectItem GetProjectItem( this Project instance, string fileName) { TraceService.WriteDebugLine("ProjectExtensions::GetProjectItem project=" + instance.Name + " fileName=" + fileName); ProjectItem projectItem = instance.GetCSharpProjectItems().FirstOrDefault(x => x.Name.StartsWith(fileName)); //// try all the sub-folders! if (projectItem == null) { IEnumerable <ProjectItem> projectItems = instance.GetProjectItems(); foreach (ProjectItem item in projectItems) { if (item.Name.StartsWith(fileName)) { return(item); } IEnumerable <ProjectItem> subProjectItems = item.GetSubProjectItems(); foreach (ProjectItem subItem in subProjectItems .Where(subItem => subItem.Name.StartsWith(fileName))) { return(subItem); } } } return(projectItem); }
/// <summary> /// Processes the command. /// </summary> /// <param name="fileOperation">The file operation.</param> public void ProcessCommand(FileOperation fileOperation) { TraceService.WriteLine("FileOperationService::ProcessCommand"); TraceService.WriteDebugLine("Platform=" + fileOperation.PlatForm); TraceService.WriteDebugLine("CommandType=" + fileOperation.CommandType); TraceService.WriteDebugLine("Directory=" + fileOperation.Directory); TraceService.WriteDebugLine("File=" + fileOperation.File); TraceService.WriteDebugLine("From=" + fileOperation.From); TraceService.WriteDebugLine("To=" + fileOperation.To); IProjectService projectService = this.visualStudioService.GetProjectServiceBySuffix(fileOperation.PlatForm); if (projectService != null) { IEnumerable <IProjectItemService> fileItemServices = this.GetFileItems(fileOperation, projectService); foreach (IProjectItemService projectItemService in fileItemServices) { if (fileOperation.CommandType == "ReplaceText") { this.ReplaceText(fileOperation, projectService, projectItemService); } else if (fileOperation.CommandType == "Properties") { this.UpdateProperty(fileOperation, projectItemService); } } } else { TraceService.WriteLine("Platform " + fileOperation.PlatForm + " not found"); } }
/// <summary> /// Translates the specified from. /// </summary> /// <param name="from">Translate Source.</param> /// <returns>A Commands List.</returns> public CommandsList Translate(string @from) { TraceService.WriteLine("CommandsList::Translate " + @from); try { XDocument doc = XDocument.Load(from); if (doc.Root != null) { TraceService.WriteDebugLine(doc.Root.Value); return(new CommandsList { Commands = this.commandsTranslator.Translate(doc.Root), FileOperations = this.fileOperationsTranslator.Translate(doc.Root) }); } return(null); } catch (Exception) { return(null); } }
/// <summary> /// Gets the project references. /// </summary> /// <param name="instance">The instance.</param> /// <returns>The project references.</returns> public static IEnumerable <Reference> GetProjectReferences(this Project instance) { TraceService.WriteDebugLine("ProjectExtensions::GetProjectReferences project=" + instance.Name); VSProject project = instance.Object as VSProject; return(project?.References.Cast <Reference>()); }
/// <summary> /// Attempts to resolve a type. /// </summary> /// <typeparam name="TResolveType">Type to resolve</typeparam> /// <returns>Instance of type</returns> public TResolveType Resolve <TResolveType>() where TResolveType : class { TraceService.WriteDebugLine("ResolverService::Resolve type=" + typeof(TResolveType)); TinyIoCContainer container = TinyIoCContainer.Current; return(container.Resolve <TResolveType>()); }
/// <summary> /// Writes the debug message. /// </summary> /// <param name="message">The message.</param> protected void WriteDebugMessage(string message) { TraceService.WriteDebugLine(message); if (this.SettingsService.ExtendedLogging) { this.Messages.Add(message); } }
/// <summary> /// Updates the property. /// </summary> /// <param name="fileOperation">The file operation.</param> /// <param name="projectItemService">The project item service.</param> private void UpdateProperty( FileOperation fileOperation, IProjectItemService projectItemService) { if (projectItemService.ProjectItem != null) { projectItemService.ProjectItem.Properties.Item(fileOperation.From).Value = fileOperation.To; TraceService.WriteDebugLine("**Properties Updates**"); } }
/// <summary> /// Adds the project reference. /// </summary> /// <param name="instance">The instance.</param> /// <param name="referencedProject">The referenced project.</param> /// <returns>The reference.</returns> public static Reference AddProjectReference( this Project instance, Project referencedProject) { TraceService.WriteDebugLine("ProjectExtensions::AddProjectReference project=" + instance.Name + " referenced project=" + referencedProject.Name); VSProject project = (VSProject)instance.Object; return(project.References.AddProject(referencedProject)); }
/// <summary> /// Removes the reference. /// </summary> /// <param name="instance">The instance.</param> /// <param name="value">The value.</param> public static void RemoveReferences( this Project instance, string value) { TraceService.WriteDebugLine("ProjectExtensions::RemoveReference project=" + instance.Name); instance.GetProjectReferences() .Where(x => x.Name.Contains(value)) .ToList() .ForEach(y => y.Remove()); }
/// <summary> /// Gets the reference path. /// </summary> /// <param name="instance">The instance.</param> /// <param name="referenceName">Name of the reference.</param> /// <returns>The path of the reference.</returns> public static string GetReferencePath( this Project instance, string referenceName) { TraceService.WriteDebugLine("ProjectExtensions::GetReferencePath project=" + instance.Name); IEnumerable <Reference> references = instance.GetProjectReferences(); foreach (Reference reference in references .Where(reference => reference.Name == referenceName)) { return(reference.Path); } return(string.Empty); }
/// <summary> /// Gets the file items. /// </summary> /// <param name="fileOperation">The file operation.</param> /// <param name="projectService">The project service.</param> /// <returns>The files to have operations on.</returns> private IEnumerable <IProjectItemService> GetFileItems( FileOperation fileOperation, IProjectService projectService) { TraceService.WriteLine("FileOperationService::GetFileItems"); List <IProjectItemService> fileItemServices = new List <IProjectItemService>(); if (string.IsNullOrEmpty(fileOperation.Directory) == false) { IProjectItemService projectItemService = projectService.GetFolder(fileOperation.Directory); if (projectItemService != null) { if (string.IsNullOrEmpty(fileOperation.File) == false) { fileItemServices.Add(projectItemService.GetProjectItem(fileOperation.File)); } else { IEnumerable <IProjectItemService> projectItemServices = projectItemService.GetCSharpProjectItems(); foreach (IProjectItemService childProjectItemService in projectItemServices) { TraceService.WriteDebugLine("FileOperationService::GetFileItems File=" + childProjectItemService.Name); fileItemServices.Add(childProjectItemService); } } } else { TraceService.WriteDebugLine("Directory " + fileOperation.Directory + " not found"); } } else { fileItemServices.Add(projectService.GetProjectItem(fileOperation.File)); } TraceService.WriteDebugLine("FileOperationService::GetFileItems fileItemServicesCount=" + fileItemServices.Count); return(fileItemServices); }
/// <summary> /// Gets the folder. /// </summary> /// <param name="instance">The instance.</param> /// <param name="folderName">Name of the folder.</param> /// <returns>The folder.</returns> public static ProjectItem GetFolder( this Project instance, string folderName) { TraceService.WriteDebugLine("ProjectExtensions::GetFolder project=" + instance.Name + " folderName=" + folderName); try { List <ProjectItem> projectItems = instance.ProjectItems?.Cast <ProjectItem>().ToList(); return(projectItems?.Where(projectItem => projectItem.Kind == VSConstants.VsProjectItemKindPhysicalFolder) .FirstOrDefault(projectItem => projectItem.Name == folderName)); } catch (Exception exception) { TraceService.WriteError("exception=" + exception.Message); return(null); } }
/// <summary> /// Adds the project. /// </summary> /// <param name="path">The path.</param> /// <param name="projectInfo">The project info.</param> internal void TryToAddProject( string path, ProjectTemplateInfo projectInfo) { TraceService.WriteLine("ProjectsService::TryToAddProject project=" + projectInfo.Name); //// Project may actually already exist - if so just skip it! string projectPath = $@"{path}\{projectInfo.Name}\"; if (this.FileSystem.Directory.Exists(projectPath) == false) { TraceService.WriteDebugLine(projectInfo.Name + " " + projectPath + " added to the solution."); this.AddProject(projectInfo, projectPath); } else { TraceService.WriteError("Directory " + projectPath + " not empty"); } }
/// <summary> /// Replaces the text. /// </summary> /// <param name="fileOperation">The file operation.</param> /// <param name="projectService">The project service.</param> /// <param name="projectItemService">The project item service.</param> private void ReplaceText( FileOperation fileOperation, IProjectService projectService, IProjectItemService projectItemService) { if (projectService == null) { return; } if (projectItemService == null) { return; } string to = fileOperation.To.Replace("$rootnamespace$", projectService.Name); to = to.Replace("$CoreProject$", this.settingsService.CoreProjectSuffix.Substring(1)); to = to.Replace("$FormsProject$", this.settingsService.XamarinFormsProjectSuffix.Substring(1)); to = to.Replace("$iOSProject$", this.settingsService.iOSProjectSuffix.Substring(1)); to = to.Replace("$DroidProject$", this.settingsService.DroidProjectSuffix.Substring(1)); to = to.Replace("$WindosPhonedProject$", this.settingsService.WindowsPhoneProjectSuffix.Substring(1)); to = to.Replace("$WindosUniversalProject$", this.settingsService.WindowsUniversalProjectSuffix.Substring(1)); to = to.Replace("$WpfProject$", this.settingsService.WpfProjectSuffix.Substring(1)); string from = fileOperation.From; TraceService.WriteDebugLine("from=" + @from + " to" + to); if (@from != to) { projectItemService.ReplaceText(fileOperation.From, to); TraceService.WriteDebugLine("**Replaced**"); } else { TraceService.WriteDebugLine("No need to replace!"); } }
/// <summary> /// Translates the specified from. /// </summary> /// <param name="from">From.</param> /// <returns></returns> public IEnumerable <ProjectTemplateInfo> Translate(string from) { List <ProjectTemplateInfo> projectTemplateInfos = new List <ProjectTemplateInfo>(); try { XDocument doc = XDocument.Load(@from); if (doc.Root != null) { TraceService.WriteDebugLine(doc.Root.Value); IEnumerable <XElement> projectElements = doc.Root.Elements("Project"); projectTemplateInfos.AddRange(projectElements.Select(projectElement => this.translator.Translate(projectElement))); } } catch (Exception exception) { TraceService.WriteError("Failed to load project templates document=" + from + " exception=" + exception.StackTrace); } return(projectTemplateInfos); }
/// <summary> /// For when yous need to save some values that can't be directly bound to UI elements. /// Not called when moving previous (see WizardViewModel.MoveToNextStep). /// </summary> /// <returns> /// An object that may modify the route /// </returns> public override RouteModifier OnNext() { this.settingsService.SelectedMvvmCrossiOSViewType = this.SelectedMvvmCrossiOSViewType; TraceService.WriteDebugLine("ViewsViewModel::OnNext SelectedMvvmCrossiOSViewType=" + this.settingsService.SelectedMvvmCrossiOSViewType); return(base.OnNext()); }
/// <summary> /// Gets the c# project items. /// </summary> /// <param name="instance">The instance.</param> /// <returns>The project items.</returns> public static IEnumerable <ProjectItem> GetCSharpProjectItems(this Project instance) { TraceService.WriteDebugLine("ProjectExtensions::GetCSharpProjectItems project=" + instance.Name); return(instance.ProjectItems.Cast <ProjectItem>().Where(x => x.Name.EndsWith(".cs")).ToList()); }
/// <summary> /// Gets the project items. /// </summary> /// <param name="instance">The instance.</param> /// <returns>The project items.</returns> public static IEnumerable <ProjectItem> GetProjectItems(this Project instance) { TraceService.WriteDebugLine("ProjectExtensions::GetProjectItems project=" + instance.Name); return(instance.ProjectItems?.Cast <ProjectItem>().ToList()); }