/// <summary>
/// Adds the non core plugin.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
internal void AddNonCorePlugin(
IProjectService projectService,
Plugin plugin,
string source,
string destination,
string extensionSource,
string extensionDestination)
{
TraceService.WriteLine("PluginsService::AddNonCorePlugin " + plugin.FriendlyName);
//// only do if destination file doesn't exist
if (this.fileSystem.File.Exists(destination) == false)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects);
}
//// only do if extensionDestination file doesn't exist
if (this.fileSystem.File.Exists(extensionDestination) == false)
{
projectService.AddReference(
"Lib",
extensionDestination,
extensionSource,
this.settingsService.IncludeLibFolderInProjects);
this.BuildSourceFile(projectService, extensionSource, extensionDestination, plugin.FriendlyName);
}
}
/// <summary>
/// Adds the plugin.
/// </summary>)
/// <param name="projectService">The project service.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="folderName">Name of the folder.</param>
/// <param name="extensionName">Name of the extension.</param>
internal void AddPlugin(
IProjectService projectService,
Plugin plugin,
string folderName,
string extensionName)
{
TraceService.WriteLine("PluginsService::AddPlugin " + plugin.FriendlyName);
string projectPath = projectService.GetProjectPath();
string source = plugin.Source;
string destination = string.Format(@"{0}\Lib\{1}", projectPath, plugin.FileName);
//// at this moment we only want ot do the core as this plugin might not be
//// supported in the ui project.
if (extensionName == Settings.Core)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects);
}
else if (extensionName == Settings.CoreTests)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects);
}
else
{
//// now if we are not the core project we need to add the platform specific assemblies
//// and the bootstrap item templates!
string extensionSource = this.GetExtensionSource(folderName, extensionName, source);
string extensionDestination = this.GetExtensionDestination(folderName, extensionName, destination);
if (this.fileSystem.File.Exists(extensionSource))
{
//// if the plugin is supported add in the core library.
this.AddNonCorePlugin(
projectService,
plugin,
source,
destination,
extensionSource,
extensionDestination);
}
}
}
/// <summary>
/// Processes the config.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
internal void ProcessConfig(
IVisualStudioService visualStudioService,
IProjectService projectService,
CodeConfig codeConfig)
{
TraceService.WriteLine("ServicesService::ProcessConfig");
if (codeConfig != null)
{
//// do we have any dependent plugins?
codeConfig.DependentPlugins.ForEach(x => this.AddDependantPlugin(visualStudioService, x));
string sourceDirectory = this.settingsService.MvvmCrossAssembliesPath;
//// don't need to add reference if we are going to use nuget.
if (this.settingsService.UseNugetForServices == false)
{
foreach (string reference in codeConfig.References)
{
projectService.AddReference(
"Lib",
projectService.GetProjectPath() + @"\Lib\" + reference,
sourceDirectory + @"\" + reference,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
//// if we want to add via nuget then generate the command.
if (this.settingsService.UseNugetForServices ||
codeConfig.NugetInstallationMandatory == "Y")
{
////this.nugetService.UpdateViaNuget(projectService, codeConfig);
}
//// apply any code dependencies
IEnumerable<string> messages = this.codeConfigService.ApplyCodeDependencies(
visualStudioService,
codeConfig);
this.Messages.AddRange(messages);
}
}
/// <summary>
/// Adds the core.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="codeConfig">The code config.</param>
/// <param name="addPluginFromLocalDisk">if set to <c>true</c> [add plugin from local disk].</param>
/// <param name="destination">The destination.</param>
/// <param name="source">The source.</param>
/// <returns>True or false.</returns>
internal bool AddCorePlugin(
IProjectService projectService,
Plugin plugin,
CodeConfig codeConfig,
bool addPluginFromLocalDisk,
string destination,
string source)
{
TraceService.WriteLine("PluginService::AddCorePlugin plugin=" + plugin.FriendlyName);
//// inform the user that we cant install from nuget.
if (this.codeConfigService.NugetRequestedAndNotSupported(codeConfig))
{
this.Messages.Add(
plugin.FriendlyName
+ " plugin does not support being installed via Nuget and has been installed from the local machine.");
}
//// don't need to add reference if we are going to use nuget.
if (addPluginFromLocalDisk)
{
//// only do if destination file doesn't exist
if (this.fileSystem.File.Exists(destination) == false)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
return true;
}
/// <summary>
/// Adds the non core plugin.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
/// <param name="addPluginFromLocalDisk">if set to <c>true</c> [add plugin from local disk].</param>
/// <returns>
/// True or false.
/// </returns>
public bool AddUIPlugin(
IProjectService projectService,
Plugin plugin,
string source,
string destination,
string extensionSource,
string extensionDestination,
bool addPluginFromLocalDisk)
{
TraceService.WriteLine("PluginService::AddUIPlugin plugin=" + plugin.FriendlyName);
bool added = false;
string[] projectNameParts = projectService.Name.Split('.');
//// we need to look for the ui specific config file,
Plugin uiPlugin = new Plugin
{
FriendlyName = plugin.FriendlyName + "." + projectNameParts[1]
};
CodeConfig codeConfig = this.codeConfigFactory.GetPluginConfig(uiPlugin);
this.codeConfigService.ProcessCodeConfig(
projectService,
codeConfig,
extensionSource,
extensionDestination);
//// only do if destination file doesn't exist
if (this.fileSystem.File.Exists(destination) == false)
{
if (addPluginFromLocalDisk)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
//// only do if extensionDestination file doesn't exist
if (this.fileSystem.File.Exists(extensionDestination) == false)
{
if (addPluginFromLocalDisk)
{
projectService.AddReference(
"Lib",
extensionDestination,
extensionSource,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
added = true;
this.RequestBootstrapFile(
projectService,
plugin);
}
return added;
}
/// <summary>
/// Processes the code config.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
/// <returns>The code config.</returns>
public CodeConfig ProcessCodeConfig(
IProjectService projectService,
string friendlyName,
string extensionSource,
string extensionDestination)
{
TraceService.WriteLine("CodeConfigService::ProcessCodeConfig " + friendlyName);
//// grab the code config if it exists and process it.
CodeConfig codeConfig = this.GetUICodeConfig(projectService, friendlyName);
if (codeConfig != null)
{
//// process it if we are using local disk copy.
if (this.UseLocalDiskCopy(codeConfig))
{
string sourceDirectory = this.fileSystem.Path.GetDirectoryName(extensionSource);
string destinationDirectory = this.fileSystem.Path.GetDirectoryName(extensionDestination);
if (codeConfig.References != null)
{
codeConfig.References.ForEach(
x => projectService.AddReference(
"Lib",
destinationDirectory + @"\" + x,
sourceDirectory + @"\" + x,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder));
}
}
}
return codeConfig;
}
/// <summary>
/// Processes the config.
/// </summary>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="projectService">The project service.</param>
/// <param name="configFile">The config file.</param>
internal void ProcessConfig(
IVisualStudioService visualStudioService,
IProjectService projectService,
string configFile)
{
TraceService.WriteLine("ServicesService::ProcessConfig");
CodeConfig codeConfig = this.codeConfigService.GetCodeConfigFromPath(configFile);
if (codeConfig != null)
{
//// do we have any dependent plugins?
if (codeConfig.DependentPlugins != null)
{
foreach (string dependentPlugin in codeConfig.DependentPlugins)
{
List<Plugin> plugins = new List<Plugin>();
string source = this.settingsService.InstalledDirectory + @"\Plugins\" + dependentPlugin;
//// append dll if its missing.
if (source.ToLower().EndsWith(".dll") == false)
{
source += ".dll";
}
FileInfo fileInfo = new FileInfo(source);
Plugin plugin = this.pluginTranslator.Translate(fileInfo);
plugins.Add(plugin);
this.pluginsService.AddPlugins(
visualStudioService,
plugins,
string.Empty,
false);
}
}
string sourceDirectory = this.settingsService.InstalledDirectory + @"\Plugins\Core";
//// don't need to add reference if we are going to use nuget.
if (this.settingsService.UseNugetForServices == false)
{
foreach (string reference in codeConfig.References)
{
projectService.AddReference(
"Lib",
projectService.GetProjectPath() + @"\Lib\" + reference,
sourceDirectory + @"\" + reference,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
//// if we want to add via nuget then generate the command.
if (this.settingsService.UseNugetForServices ||
codeConfig.NugetInstallationMandatory == "Y")
{
////this.nugetService.UpdateViaNuget(projectService, codeConfig);
}
//// apply any code dependencies
IEnumerable<string> messages = this.codeConfigService.ApplyCodeDependencies(
visualStudioService,
codeConfig);
this.Messages.AddRange(messages);
}
}
/// <summary>
/// Adds the non core plugin.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
/// <param name="addPluginFromLocalDisk">if set to <c>true</c> [add plugin from local disk].</param>
/// <returns>True or false.</returns>
public bool AddUIPlugin(
IProjectService projectService,
string friendlyName,
string source,
string destination,
string extensionSource,
string extensionDestination,
bool addPluginFromLocalDisk)
{
TraceService.WriteLine("PluginService::AddUIPlugin " + friendlyName);
bool added = false;
this.codeConfigService.ProcessCodeConfig(
projectService,
friendlyName,
extensionSource,
extensionDestination);
//// only do if destination file doesn't exist
if (this.fileSystem.File.Exists(destination) == false)
{
if (addPluginFromLocalDisk)
{
projectService.AddReference(
"Lib",
destination,
source,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
}
//// only do if extensionDestination file doesn't exist
if (this.fileSystem.File.Exists(extensionDestination) == false)
{
if (addPluginFromLocalDisk)
{
projectService.AddReference(
"Lib",
extensionDestination,
extensionSource,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder);
}
added = true;
this.RequestBootstrapFile(
projectService,
friendlyName);
}
return added;
}
/// <summary>
/// Processes the code config.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="codeConfig">The code config.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
public void ProcessCodeConfig(
IProjectService projectService,
CodeConfig codeConfig,
string extensionSource,
string extensionDestination)
{
TraceService.WriteLine("CodeConfigService::ProcessCodeConfig");
if (codeConfig != null)
{
//// process it if we are using local disk copy.
if (this.UseLocalDiskCopy(codeConfig))
{
string sourceDirectory = this.fileSystem.Path.GetDirectoryName(extensionSource);
string destinationDirectory = this.fileSystem.Path.GetDirectoryName(extensionDestination);
codeConfig.References.ForEach(
x => projectService.AddReference(
"Lib",
destinationDirectory + @"\" + x,
sourceDirectory + @"\" + x,
this.settingsService.IncludeLibFolderInProjects,
this.settingsService.CopyAssembliesToLibFolder));
}
}
}
/// <summary>
/// Adds the plugin.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="folderName">Name of the folder.</param>
/// <param name="extensionName">Name of the extension.</param>
/// <returns>True or false.</returns>
internal bool AddPlugin(
IProjectService projectService,
Plugin plugin,
string folderName,
string extensionName)
{
TraceService.WriteLine("PluginsService::AddPlugin " + plugin.FriendlyName);
bool added = false;
string projectPath = projectService.GetProjectPath();
string source = plugin.Source;
string destination = string.Format(@"{0}\Lib\{1}", projectPath, plugin.FileName);
//// at this moment we only want ot do the core as this plugin might not be
//// supported in the ui project.
if (extensionName == Settings.Core ||
extensionName == Settings.CoreTests)
{
//// dont need to add reference if we are going to use nuget.
if (this.SettingsService.UseNugetForPlugins == false)
{
projectService.AddReference(
"Lib",
destination,
source,
this.SettingsService.IncludeLibFolderInProjects);
}
added = true;
}
else
{
//// now if we are not the core project we need to add the platform specific assemblies
//// and the bootstrap item templates!
string extensionSource = this.GetExtensionSource(folderName, extensionName, source);
string extensionDestination = this.GetExtensionDestination(folderName, extensionName, destination);
if (this.FileSystem.File.Exists(extensionSource))
{
//// if the plugin is supported add in the core library.
added = this.AddNonCorePlugin(
projectService,
plugin.FriendlyName,
source,
destination,
extensionSource,
extensionDestination);
}
}
return added;
}
/// <summary>
/// Adds the non core plugin.
/// </summary>
/// <param name="projectService">The project service.</param>
/// <param name="friendlyName">Name of the friendly.</param>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="extensionSource">The extension source.</param>
/// <param name="extensionDestination">The extension destination.</param>
/// <returns>True or false.</returns>
internal bool AddNonCorePlugin(
IProjectService projectService,
string friendlyName,
string source,
string destination,
string extensionSource,
string extensionDestination)
{
TraceService.WriteLine("PluginsService::AddNonCorePlugin " + friendlyName);
bool added = false;
//// only do if destination file doesn't exist
if (this.FileSystem.File.Exists(destination) == false)
{
if (this.SettingsService.UseNugetForPlugins == false)
{
projectService.AddReference(
"Lib",
destination,
source,
this.SettingsService.IncludeLibFolderInProjects);
}
}
//// only do if extensionDestination file doesn't exist
if (this.FileSystem.File.Exists(extensionDestination) == false)
{
if (this.SettingsService.UseNugetForPlugins == false)
{
projectService.AddReference(
"Lib",
extensionDestination,
extensionSource,
this.SettingsService.IncludeLibFolderInProjects);
}
added = true;
this.BuildSourceFile(projectService, extensionSource, extensionDestination, friendlyName);
}
return added;
}
