/// <summary>
/// A la fin de la publication, on met à jour les fichiers des infos de l'assemblie avec le
/// n° de version du modèle.
/// </summary>
/// <param name="model"></param>
/// <param name="modelFileName"></param>
void IStrategyPublishEvents.OnPublicationEnded(CandleModel model, string modelFileName)
{
if (!String.IsNullOrEmpty(T4Template))
{
if (model.SoftwareComponent != null)
{
// Création du fichier AssemblyInfo
foreach (AbstractLayer layer in model.SoftwareComponent.Layers)
{
if (layer is SoftwareLayer)
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
// Recherche du projet associé
Project prj = shell.FindProjectByName(((SoftwareLayer)layer).VSProjectName);
if (prj != null)
{
Context.Project = prj;
CallT4Template(prj, T4Template, layer, _outputFileName);
}
}
}
}
}
}
}
/// <summary>
/// Gets a value indicating whether this <see cref="ICommand"/> is visible.
/// </summary>
/// <returns></returns>
/// <value><c>true</c> if visible; otherwise, <c>false</c>.</value>
public bool Visible()
{
IShellHelper sh = ServiceLocator.Instance.GetService <IShellHelper>();
if (String.IsNullOrEmpty(_fileName))
{
return(false);
}
if (sh != null)
{
// On ne peut pas publier un modèle qui n'est pas le modèle courant
// sauf si c'est un composant binaire (pour permettre la mise à jour)
if (_model != null && _model.BinaryComponent != null)
{
return(true);
}
// Vérif si c'est le modèle associé à la solution courante
string currentModel = sh.GetSolutionAssociatedModelName();
if (currentModel != null && !Utils.StringCompareEquals(_fileName, currentModel))
{
return(false);
}
}
return(true);
}
protected void ValidateProject(ValidationContext context)
{
if (Type != ArtifactType.Project)
{
return;
}
string msg = "Assembly name is not valid for the artifact {0} in the layer {1}.";
bool isValid = false;
try
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
isValid = shell.FindProjectByAssemblyName(InitialFileName) != null;
}
}
catch (Exception ex)
{
msg = ex.Message;
}
if (!isValid)
{
AbstractLayer layer = LayerHasArtifacts.GetLayer(this);
string layerName = layer != null ? layer.Name : "???";
context.LogError(
String.Format(msg, FileName, layerName),
"ERRART1", // Unique error number
this);
}
}
/// <summary>
/// Génération du fichier de config à partir des fichiers de l'utilisateur
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="project">The project.</param>
/// <param name="projectFolder">The project folder.</param>
/// <param name="forceGeneration">if set to <c>true</c> [force generation].</param>
/// <returns></returns>
private string GenerateConfigurationFile(Layer layer, Project project, string projectFolder,
bool forceGeneration)
{
if (project == null)
{
return(null);
}
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
// Vérification si le répertoire de config existe
string configFolderPath = Path.Combine(projectFolder, ConfigFolderName);
// On s'assure de son intègration dans la solution
Directory.CreateDirectory(configFolderPath);
ProjectItem folder = shell.AddFolderToProject(project.ProjectItems, ConfigFolderName);
// Création des fichiers à personnaliser
// D'abord le fichier correspondant au mode courant.
ConfigurationMode mode = new ConfigurationMode(project);
string currentFileName = CreateCustomConfigurationFile(mode.CurrentMode, configFolderPath, folder);
// Puis le fichier commun
string commonFileName = CreateCustomConfigurationFile("Common", configFolderPath, folder);
if (forceGeneration || File.GetLastWriteTime(commonFileName) > _lastGenerationTime ||
File.GetLastWriteTime(currentFileName) > _lastGenerationTime)
{
// Fichier généré
string generatedFileName = CalculateApplicationConfigurationFileName(layer);
if (generatedFileName == null)
{
return(configFolderPath);
}
if (project != null && shell != null)
{
// Création d'un fichier xml correspondant à la fusion du fichier commun et
// du fichier correspondant au contexte courant (debug, release...)
// Merge
XmlMerger merger = new XmlMerger();
XmlDocument customDocument = merger.MergeXml(currentFileName, commonFileName);
// Puis merge avec les config du modèle
XmlDocument resultDocument = MergeDeclaredConfigurations(customDocument, layer.Component);
// Sauvegarde
string generatedFilePath = Path.Combine(projectFolder, generatedFileName);
Directory.CreateDirectory(Path.GetDirectoryName(generatedFilePath));
shell.EnsureCheckout(generatedFilePath);
resultDocument.Save(generatedFilePath);
shell.AddFileToProject(project, generatedFilePath);
}
}
return(configFolderPath);
}
/// <summary>
/// Sets the current mode from visual studio context.
/// </summary>
private void SetCurrentModeFromVisualStudioContext()
{
IShellHelper shell = ServiceLocator.Instance.ShellHelper;
if (shell != null && shell.Solution != null && shell.Solution.SolutionBuild != null && shell.Solution.SolutionBuild.ActiveConfiguration != null)
{
_currentMode = shell.Solution.SolutionBuild.ActiveConfiguration.Name;
}
}
/// <summary>
/// Execute the command
/// </summary>
public void Exec()
{
IShellHelper shell = ServiceLocator.Instance.ShellHelper;
if (shell != null)
{
shell.Navigate(_metadata.DocUrl);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SafeStreamWriter"/> class.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="append">if set to <c>true</c> [append].</param>
/// <param name="encoding">The encoding.</param>
public SafeStreamWriter(string path, bool append, Encoding encoding)
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
shell.EnsureCheckout(path);
}
_writer = new StreamWriter(path, append, encoding);
}
/// <summary>
/// Initializes a new instance of the <see cref="SafeStreamWriter"/> class.
/// </summary>
/// <param name="fileName">Name of the file.</param>
public SafeStreamWriter(string fileName)
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
shell.EnsureCheckout(fileName);
}
_writer = new StreamWriter(fileName);
}
/// <summary>
/// Creates the custom configuration file.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="configFolderPath">The config folder path.</param>
/// <param name="folder">The folder.</param>
/// <returns></returns>
private string CreateCustomConfigurationFile(string name, string configFolderPath, ProjectItem folder)
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
// Calcule le nom du fichier personnalisable
string customFileName = String.Concat(name, ".config");
string customFilePath = Path.Combine(configFolderPath, customFileName);
XmlDocument xdoc = new XmlDocument();
// Ajout si n'existe pas
if (!File.Exists(customFilePath))
{
// On regarde si il n'existe pas un template
bool fileCreated = false;
string templateFileName = String.Format(_templateFormatName, name);
RepositoryFile rf =
new RepositoryFile(RepositoryCategory.T4Templates, Path.Combine("ConfigFiles", templateFileName));
try
{
if (rf.Exists())
{
xdoc.Load(rf.LocalPhysicalPath);
fileCreated = true;
}
}
catch
{
}
// Si on est pas arrivé à en créer un à partir d'un template, on en crée un vide.
if (!fileCreated)
{
xdoc.LoadXml(@"<?xml version=""1.0"" encoding=""utf-8"" ?><configuration/>");
}
xdoc.Save(customFilePath);
shell.AddFileToFolder(folder, customFilePath);
}
else
{
xdoc.Load(customFilePath);
}
return(customFilePath);
}
/// <summary>
/// Génération des fichiers de stratégies
/// </summary>
/// <remarks>
/// </remarks>
public void Execute()
{
// Pour éviter de boucler, on ne regénére pas si la dernière génération s'est faite dans les dernières 2 sec
TimeSpan ts = DateTime.Now - _lastGenerationTime;
if (ts.TotalSeconds <= 2)
{
return;
}
IShellHelper shell = ServiceLocator.Instance.ShellHelper;
// vérification si la stratégie s'applique sur l'élément courant
if (Context.GenerationPass != GenerationPass.CodeGeneration || shell == null)
{
return;
}
if (!(CurrentElement is Layer && ((Layer)CurrentElement).LayerPackage.IsHigherLevel()))
{
return;
}
try
{
_generating = true;
string configFolderPath =
GenerateConfigurationFile(CurrentElement as Layer, Context.Project, Context.ProjectFolder, true);
// Puis on s'abonne aux events de modif
if (configFolderPath != null)
{
AdviseFileEvents(configFolderPath);
}
}
catch (Exception ex)
{
LogError(ex);
}
finally
{
_lastGenerationTime = DateTime.Now;
_generating = false;
}
}
/// <summary>
/// Vérification si la commande peut s'activer
/// </summary>
/// <returns></returns>
/// <value><c>true</c> if visible; otherwise, <c>false</c>.</value>
public bool Visible()
{
// Fichier null
if (String.IsNullOrEmpty(_fileName))
{
return(false);
}
// Est on bien sur le modèle de la solution ?
IShellHelper sh = ServiceLocator.Instance.GetService <IShellHelper>();
if (sh != null)
{
string currentModel = sh.GetSolutionAssociatedModelName();
if (currentModel != null && !Utils.StringCompareEquals(_fileName, currentModel))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Recherche le modèle associé à la solution courante
/// </summary>
/// <returns></returns>
/// <remarks>
/// Le modèle associé est contenu dans un fichier portant le même nom que la solution
/// </remarks>
public static CandleModel GetModelFromCurrentSolution()
{
try
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell == null)
{
return(null);
}
// On cherche d'abord si le nom est enregistré dans la solution
string candleModelPath = shell.GetSolutionAssociatedModelName();
if (candleModelPath == null)
{
// Si pas trouvé, on le déduit à partir du nom de la solution
string solutionName = (string)shell.Solution.Properties.Item("Name").Value;
candleModelPath =
System.IO.Path.Combine(shell.SolutionFolder,
String.Concat(solutionName, ModelConstants.FileNameExtension));
}
// Recherche dans la RDT
CandleModel model = GetModelFromCurrentSolution(candleModelPath);
// Si tjs null, on essaye de le charger directement
if (model == null)
{
ModelLoader loader = ModelLoader.GetLoader(candleModelPath, true);
if (loader != null)
{
model = loader.Model;
}
}
return(model);
}
catch
{
}
return(null);
}
/// <summary>
/// Accepts the artifact.
/// </summary>
/// <param name="artifact">The artifact.</param>
private void AcceptArtifact(Artifact artifact)
{
if (artifact.Type == ArtifactType.Content && _scope == ReferenceScope.Compilation)
{
return;
}
if ((artifact.Scope & _scope) != _scope)
{
return;
}
#if DEBUG
if (_scope == ReferenceScope.Publish)
{
if (artifact.Type == ArtifactType.AssemblyInGac && !_initialModelIsInSolution)
{
throw new Exception("cas incorrect");
}
if (IsExternalModel && _scope != ReferenceScope.Runtime)
{
throw new Exception("cas incorrect");
}
}
#endif
// Assemblie dans le GAC, on le prend tel quel
if (artifact.Type == ArtifactType.AssemblyInGac)
{
if (_scope == ReferenceScope.Compilation)
{
_references.Add(artifact.FileName);
}
return;
}
// Une assemblie du framework sélectionné, on résoud son chemin
if (artifact.Type == ArtifactType.DotNetFramework)
{
if (_scope == ReferenceScope.Compilation)
{
CandleModel model = global::DSLFactory.Candle.SystemModel.CandleModel.GetInstance(artifact.Store);
_references.Add(
DSLFactory.Candle.SystemModel.Utilities.DotNetFrameworkHelper.ResolvePath(model,
artifact.FileName));
}
return;
}
//if (artifact.Type == ArtifactType.Assembly)
//{
// //if( parent != null )
// references.Add(Path.Combine(LocalPath, artifact.FileName));
// //else
// // References.Add( Path.Combine( LatestPath, artifact.FileName ) );
// return;
//}
// Référence de type projet
if (artifact.Type == ArtifactType.Project)
{
// Si on est dans le projet courant, on recherche le nom de l'assembly
if (!IsExternalModel && _initialModelIsInSolution)
{
if (_scope == ReferenceScope.Compilation)
{
_references.Add(artifact.FileName);
}
else
{
// Nom de l'assembly du projet
IShellHelper shell = ServiceLocator.Instance.ShellHelper;
if (shell != null)
{
EnvDTE.Project project = shell.FindProjectByName(artifact.FileName);
if (project != null)
{
string outputPath =
(string)
project.ConfigurationManager.ActiveConfiguration.Properties.Item("OutputPath").Value;
string assemblyName = (string)project.Properties.Item("OutputFileName").Value;
_references.Add(
Path.Combine(Path.GetDirectoryName(project.FullName),
String.Concat(outputPath, assemblyName)));
}
}
}
}
else // On est dans un modèle qui ne correspond pas au projet courant
{
if (_scope == ReferenceScope.Runtime)
{
string fileName = Path.Combine(CurrentModelPath, artifact.InitialFileName);
_references.Add(fileName);
}
}
return;
}
// Si on est dans le modèle courant
if (_initialModelIsInSolution && !IsExternalModel)
{
string fileName = Path.Combine(_projectPath.Peek(), artifact.FileName);
if (!File.Exists(fileName))
{
Utils.CopyFile(artifact.InitialFileName, fileName);
}
if (!File.Exists(fileName))
{
fileName = Path.Combine(SolutionFolder, artifact.FileName);
}
_references.Add(fileName);
}
else
{
_references.Add(Path.Combine(_projectPath.Peek(), artifact.FileName));
}
}
/// <summary>
/// Récupère les stratégies du modèle courant.
/// </summary>
/// <param name="store"></param>
/// <remarks>
/// Si un autre modèle est ouvert dans la solution, on retourne un manager ne contenant aucune strategie.
/// </remarks>
/// <returns></returns>
public static IStrategyManager GetInstance(Store store)
{
// Modèle correspondant au store
CandleModel model = CandleModel.GetInstance(store);
if (model == null) // On a pas trouvé le modèle, on retourne un strategyManager vide
{
return(new StrategyManager());
}
// Si on a dèja chargé les stratégies, on les retourne
if (s_currentModelId != Guid.Empty && s_currentModelId == model.Id)
{
return(s_currentStrategyManager);
}
// Est ce que c'est le modèle courant
CandleModel currentModel = CandleModel.GetModelFromCurrentSolution();
if (currentModel == null || currentModel.Id != model.Id)
{
return(new StrategyManager());
}
// Sinon on va créer les stratégies
SuspendWatcher(false);
// Flag indiquant si on peut persister les stratégies ou seulement les initialiser.
// On ne peut pas persister si on est dans le cas d'une initialisation du modèle puisqu'on ne connait pas
// encore le nom du modèle
bool canPersist = true;
string strategyFileName = null;
try
{
// Création d'un nouveau fichier de strategies ayant le même nom que le modèle mais avec
// l'extension .strategies
string modelFileName = model.FileName;
// Dans le cas d'une création d'un modèle, on ne peut pas récupérer le filepath du modèle car
// il n'y a pas encore de vue active. Dans ce cas, on essaye de le déduire.
if (modelFileName == null)
{
string name = model.Name;
// On est dans le cas d'une initialisation de modèle, on ne va crèer le fichier des stratégies tout de suite
// on attend que le modèle soit initialisé
if (name.Contains("?"))
{
canPersist = false;
strategyFileName = Path.GetTempFileName(); // Fichier temporaire pour récupèrer les stratégies pré-initialisées
Utils.DeleteFile(strategyFileName); // Obligé car GetTempFileName crée le fichier
}
else
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
string tmp = Path.GetFileNameWithoutExtension(shell.GetSolutionAssociatedModelName());
if (!String.IsNullOrEmpty(tmp))
{
name = tmp;
}
else
{
tmp = shell.Solution.FullName;
if (!String.IsNullOrEmpty(tmp))
{
name = Path.GetFileNameWithoutExtension(tmp);
}
}
}
strategyFileName = String.Concat(Path.Combine(ServiceLocator.Instance.ShellHelper.SolutionFolder, name), DefaultStrategiesFileNameExtension);
}
}
else
{
strategyFileName = Path.ChangeExtension(modelFileName, DefaultStrategiesFileNameExtension);
}
// Initialisation du fichier de stratégies à partir d'un modèle
if (!String.IsNullOrEmpty(model.StrategyTemplate))
{
EnsureStrategiesFileExists(strategyFileName, model.StrategyTemplate, canPersist);
}
StrategyManager manager = null;
if (File.Exists(strategyFileName))
{
manager = Load(store, strategyFileName);
}
else
{
manager = new StrategyManager();
}
if (canPersist)
{
manager.FileName = strategyFileName;
// Cache pour éviter de le relire
s_currentModelId = model.Id;
s_currentStrategyManager = manager;
}
return(manager);
}
finally
{
SuspendWatcher(true);
// Suppression du fichier temporaire
if (!canPersist)
{
Utils.DeleteFile(strategyFileName);
}
}
}
public ChipsetThermometer(IShellHelper shellHelper, string name)
{
_shellHelper = shellHelper;
Name = name;
}
public SensorFactory(IShellHelper shellHelper)
{
_shellHelper = shellHelper;
}
public DS18B20Thermometer(IShellHelper shellHelper, SensorSettings settings)
{
_shellHelper = shellHelper;
_deviceId = settings.DeviceId;
Name = settings.Name;
}
/// <summary>
/// Called when [after save].
/// </summary>
/// <param name="docCookie">The doc cookie.</param>
/// <returns></returns>
int IVsRunningDocTableEvents.OnAfterSave(uint docCookie)
{
if (_generating)
{
return(VSConstants.S_OK);
}
// Pour éviter de boucler, on ne regénére pas si la dernière génération s'est faite dans les dernières 2 sec
TimeSpan ts = DateTime.Now - _lastGenerationTime;
if (ts.TotalSeconds <= 2)
{
return(VSConstants.S_OK);
}
IVsRunningDocumentTable rdtEvents = GetService <IVsRunningDocumentTable>(typeof(SVsRunningDocumentTable));
uint pgrfRDTFlags;
uint pdwReadLocks;
uint pdwEditLocks;
string filePath;
IVsHierarchy ppHier;
IntPtr ppunkDocData;
uint itemId;
if (
rdtEvents.GetDocumentInfo(docCookie, out pgrfRDTFlags, out pdwReadLocks, out pdwEditLocks, out filePath,
out ppHier, out itemId, out ppunkDocData) == VSConstants.S_OK &&
filePath != null)
{
string folderPath = Path.GetDirectoryName(filePath).ToLower();
if (!_configFolders.Contains(folderPath) || Path.GetExtension(filePath).ToLower() != ".config")
{
return(VSConstants.S_OK);
}
try
{
_generating = true;
// TODO recherche le modele à partir d'autre chose que la RDT car il faut que ça marche
// même si le modèle n'a pas été ouvert.
IShellHelper shell = GetService <IShellHelper>();
if (shell != null)
{
CandleModel model = CandleModel.GetModelFromCurrentSolution();
if (model != null && model.SoftwareComponent != null)
{
foreach (LayerPackage lp in model.SoftwareComponent.LayerPackages)
{
if (lp.IsHigherLevel())
{
foreach (Layer layer in lp.Layers)
{
Project project = shell.FindProjectByName(layer.VSProjectName);
if (project != null)
{
string projectFolder = Path.GetDirectoryName(project.FileName);
GenerateConfigurationFile(layer, project, projectFolder, false);
}
}
break;
}
}
}
}
}
catch (Exception)
{
return(VSConstants.S_FALSE);
}
finally
{
_lastGenerationTime = DateTime.Now;
_generating = false;
}
}
return(VSConstants.S_OK);
}
