/// <summary>
/// Recherche du template de génération
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns></returns>
public string GetProjectTemplate(SoftwareLayer layer)
{
// Le template de la couche est prioritaire
if (!string.IsNullOrEmpty(layer.Template))
{
return(layer.Template);
}
// Puis on cherche dans les autres stratégies
foreach (StrategyBase strategy in layer.GetStrategies(true))
{
if (strategy is IStrategyProvidesProjectTemplates && strategy != this)
{
string projectTemplate = ((IStrategyProvidesProjectTemplates)strategy).GetProjectTemplate(layer);
if (!String.IsNullOrEmpty(projectTemplate))
{
return(projectTemplate);
}
}
}
// Puis celui de la stratégie courante
if (!String.IsNullOrEmpty(ProjectTemplate))
{
return(ProjectTemplate);
}
// Valeur par défaut
if (layer is Layer && ((Layer)layer).HostingContext == HostingContext.Web)
{
return(StrategyManager.GetInstance(layer.Store).TargetLanguage.DefaultWebLibraryTemplateName);
}
return(StrategyManager.GetInstance(layer.Store).TargetLanguage.DefaultLibraryTemplateName);
}
/// <summary>
/// Récupére la liste des stratégies applicables et actives sur un modéle
/// </summary>
/// <param name="strategiesOwner">The strategies owner.</param>
/// <param name="element">Elément concerné ou null pour tous</param>
/// <returns></returns>
internal static List <StrategyBase> GetStrategies(CandleElement strategiesOwner, ICustomizableElement element)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
List <StrategyBase> strategies = new List <StrategyBase>();
if (strategiesOwner == null)
{
return(strategies);
}
if (element != null && logger != null)
{
logger.BeginStep(String.Concat("Get enabled strategies for element ", element.Name, " (id=", element.Id, ")"), LogType.Debug);
}
foreach (StrategyBase strategy in StrategyManager.GetInstance(strategiesOwner.Store).GetStrategies(strategiesOwner, true))
{
if (strategy.IsEnabled)
{
strategies.Add(strategy);
}
else
if (element != null && logger != null)
{
logger.Write("GetStrategies", String.Concat("Strategy ", strategy.StrategyId, " ignored because it is disabled"), LogType.Debug);
}
}
if (element != null && logger != null)
{
logger.EndStep();
}
return(strategies);
}
/// <summary>
/// Initializes a new instance of the <see cref="RunningStrategiesForm"/> class.
/// </summary>
/// <param name="element">The element.</param>
public RunningStrategiesForm(CandleElement element)
{
InitializeComponent();
btnOK.Enabled = false;
chkPass.Items.Clear();
chkPass.Items.Add(GenerationPass.MetaModelUpdate, true);
chkPass.Items.Add(GenerationPass.CodeGeneration, true);
chkPass.Items.Add(GenerationPass.ElementAdded, false);
lstStrategies.Items.Clear();
if (element != null)
{
foreach (
StrategyBase strategy in StrategyManager.GetInstance(element.Store).GetStrategies(element, true))
{
ListViewItem item = new ListViewItem(strategy.DisplayName);
item.SubItems.Add(strategy.Description);
item.Checked = true;
item.Tag = strategy;
lstStrategies.Items.Add(item);
btnOK.Enabled = true;
}
}
}
/// <summary>
/// Handles the Click event of the btnGo control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void btnGo_Click(object sender, EventArgs e)
{
try
{
if (txtUrl.Text.Length == 0)
{
_manifests = StrategyManager.GetAvailableManifests();
}
else
{
ManifestCollection tmp = new ManifestCollection();
tmp.AddRange(RepositoryManager.GetExternalManifests(txtUrl.Text));
foreach (StrategyManifest mf in tmp)
{
mf.PackageName = String.Format("{0}@{1}", mf.PackageName, txtUrl.Text);
}
_manifests = tmp;
}
if (rbTree.Checked)
{
PopulateTreeView();
}
else
{
PopulateListView();
}
}
catch (Exception ex)
{
ServiceLocator.Instance.IDEHelper.ShowError(
String.Format("Unable to retrieve strategies from {0} - {1}", txtUrl.Text, ex.Message));
}
}
/// <summary>
/// Gets the properties.
/// </summary>
/// <param name="attributes">The attributes.</param>
/// <returns></returns>
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
PropertyDescriptorCollection properties = base.GetProperties(attributes);
// Recherche dans les stratégies associés à ce modèle
if (ModelElement is ICustomizableElement && !ModelElement.IsDeleted)
{
foreach (
StrategyBase strategy in
StrategyManager.GetStrategies(((ICustomizableElement)ModelElement).StrategiesOwner, null))
// On prend toutes les stratégies
{
try
{
foreach (PropertyDescriptor prop in strategy.GetCustomProperties(ModelElement))
{
properties.Add(prop);
}
}
catch
{
}
}
}
return(properties);
}
/// <summary>
/// Affichage du source correspondant à un élément. Si plusieurs fichiers
/// correspondent, une fenètre de sélection est affichée
/// </summary>
/// <param name="elementId">ID de l'élément</param>
/// <param name="className">Nom de la classe ou null</param>
/// <param name="operationName">Nom de la méthode ou null</param>
public void ShowCode(Guid elementId, string className, string operationName)
{
try
{
// Recherche des fichiers générés
List <string> files1 = GetFiles(elementId, false);
List <string> files2 = GetFiles(elementId, true);
string fileName = null;
if (files1.Count == 0 && files2.Count == 0)
{
// On essaye de chercher le fichier dans la solution
fileName =
String.Concat(className, StrategyManager.GetInstance(_model.Store).TargetLanguage.Extension);
ProjectItem item = ServiceLocator.Instance.ShellHelper.FindProjectItemByFileName(null, fileName);
if (item == null)
{
return; // Aucun
}
fileName = item.get_FileNames(1);
}
else if (files1.Count == 1 && files2.Count == 0)
{
fileName = files1[0];
}
else if (files1.Count == 0 && files2.Count == 1)
{
fileName = files2[0];
}
else
{
// Il y en a plusieurs, on affiche une fenètre de sélection
SelectFile dlg = new SelectFile(files1, files2);
if (dlg.ShowDialog() == DialogResult.OK)
{
fileName = dlg.SelectedFile;
}
}
if (fileName != null)
{
ServiceLocator.Instance.ShellHelper.TryToShow(fileName, className, operationName);
}
}
catch (Exception ex)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.WriteError("Show code", "Unable to show code for " + className, ex);
}
}
}
/// <summary>
/// Chargement des stratégies disponibles sous forme d'arbre organisé
/// par StrategyPath
/// </summary>
/// <param name="strategiesOwner">The strategies owner.</param>
/// <param name="selectedStrategy">The selected strategy.</param>
private void PopulateListView(CandleElement strategiesOwner, StrategyBase selectedStrategy)
{
this._strategiesOwner = strategiesOwner != null ? strategiesOwner.StrategiesOwner : null;
Dictionary <string, ListViewGroup> groups = new Dictionary <string, ListViewGroup>();
// Evite l'evenement OnItemChecked
_initialize = true;
lvStrategies.Items.Clear();
//
// Lecture de toutes les strategies disponibles
//
foreach (StrategyBase strategy in StrategyManager.GetInstance(_store).GetStrategies(strategiesOwner, false))
{
// Création du noeud de la stratégie
ListViewItem item = new ListViewItem(strategy.DisplayName);
//
// Recherche si les strategies possédent des attributs de description
//
string strategyGroup = "Standard";
foreach (
StrategyAttribute customAttribute in
strategy.GetType().GetCustomAttributes(typeof(StrategyAttribute), false))
{
if (!String.IsNullOrEmpty(customAttribute.Description))
{
strategy.Description = customAttribute.Description;
}
if (!String.IsNullOrEmpty(customAttribute.StrategyGroup))
{
strategyGroup = customAttribute.StrategyGroup;
strategy.StrategyGroup = strategyGroup;
}
}
item.Group = FindGroup(groups, strategyGroup);
item.Tag = strategy;
item.Checked = strategy.IsEnabled;
lvStrategies.Items.Add(item);
item.Selected = selectedStrategy != null && selectedStrategy == strategy;
}
_initialize = false;
ListViewGroup[] temp = new ListViewGroup[groups.Values.Count];
groups.Values.CopyTo(temp, 0);
//Array.Sort(temp);
lvStrategies.Groups.AddRange(temp);
}
/// <summary>
/// Suppression d'une stratégie
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void btnRemove_Click(object sender, EventArgs e)
{
StrategyBase strategy = SelectedStrategy;
if (strategy != null && ServiceLocator.Instance.IDEHelper.Confirm())
{
StrategyManager.GetInstance(_store).RemoveStrategy(_strategiesOwner, strategy);
propGrid.SelectedObject = null;
Populate(_strategiesOwner, null);
OnStrategyRemoved(
new StrategyRemovedEventArgs(strategy, StrategyManager.GetStrategyOwnerName(_strategiesOwner)));
}
}
/// <summary>
/// Ajout d'une stratégie
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void btnAdd_Click(object sender, EventArgs e)
{
SelectStrategyDialog dlg = new SelectStrategyDialog();
if (dlg.ShowDialog() == DialogResult.OK)
{
foreach (StrategyManifest manifest in dlg.SelectedStrategies)
{
// On ne rajoute la stratégie que si elle n'y est pas dèjà
StrategyBase strategy = StrategyManager.GetInstance(_store).AddStrategy(_strategiesOwner, manifest);
if (strategy != null)
{
Populate(_strategiesOwner, strategy);
}
}
}
}
/// <summary>
/// Bouton OK. Vérification qu'il n'y ait pas de doublons dans les ID et que ceux ci soient valides.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void btnOK_Click(object sender, EventArgs e)
{
foreach (StrategiesListControl ctrl in specificStrategies)
{
if (!ctrl.CommitChanges())
{
return;
}
}
if (globalsStrategies.CommitChanges())
{
// TODO verif doublons entre les deux tabpages.
RemoveStrategiesCode();
StrategyManager.GetInstance(_store).Save(_store);
DialogResult = DialogResult.OK;
}
}
/// <summary>
/// Création du fichier dans le projet
/// </summary>
/// <param name="prj">Projet contenant le fichier</param>
/// <param name="element">Elément concerné ou null</param>
/// <param name="fileName">Nom du fichier ou null (default: element.Name)</param>
/// <returns>Chemin complet du fichier</returns>
protected string CreateOutputFileName(Project prj, ICustomizableElement element, string fileName)
{
if (String.IsNullOrEmpty(fileName))
{
fileName = element.Name;
}
if (!Path.HasExtension(fileName))
{
fileName =
String.Format("{0}{1}", fileName,
StrategyManager.GetInstance(_currentElement.Store).TargetLanguage.Extension);
}
// On le prend tel quel
string tmpFileName = fileName;
if (tmpFileName.Length > 0 && tmpFileName[0] == '~')
{
tmpFileName = tmpFileName.Substring(1);
}
else
{
// Si il n'y a que le nom du fichier, on prend le pattern par défaut
if (Path.GetFileName(tmpFileName) == tmpFileName)
{
string pattern = DefaultGeneratedFilePathPattern;
if (String.IsNullOrEmpty(pattern))
{
pattern =
StrategyManager.GetInstance(_currentElement.Store).NamingStrategy.
DefaultGeneratedCodeFilePattern;
}
tmpFileName = String.Format(pattern, tmpFileName);
}
}
tmpFileName = ResolvePattern(element, tmpFileName);
// Suppression du '/' de debut
if (tmpFileName.Length > 1 &&
(tmpFileName[0] == Path.AltDirectorySeparatorChar || tmpFileName[0] == Path.DirectorySeparatorChar))
{
tmpFileName = tmpFileName.Substring(1);
}
string pathName = tmpFileName.Replace('/', '\\');
if (pathName.Length > 0 && pathName[0] == '\\')
{
pathName = pathName.Substring(1);
}
// Permet de surcharger
pathName = CreateRelativeOutputFileName(element, pathName);
Debug.Assert(pathName.Length > 0 && pathName[0] != '\\', "the file name must be relatif");
Debug.Assert(Path.HasExtension(pathName), "file name must have an extension");
Debug.Assert(pathName.IndexOf('{') < 0, "incorrect file name");
Context.RelativeGeneratedFileName = pathName;
return(Context.ProjectFolder != null?Path.Combine(Context.ProjectFolder, pathName) : pathName);
}
/// <summary>
/// Génération du mapping des propriétés
/// </summary>
/// <param name="level"></param>
/// <param name="root"></param>
/// <param name="componentName"></param>
private void GenerateMappingProperties(int level, Entity clazz, string componentName)
{
this.WriteLineWithIndent(level, "<!-- Properties -->");
foreach (DSLFactory.Candle.SystemModel.Property prop in clazz.Properties)
{
if (prop.IsPrimaryKey || prop.IsForeignKey)
{
continue;
}
string typeName = prop.Type;
DataType refType = _inheritanceTree.FindEntityByName(prop.Type);
if (refType != null)
{
typeName = refType.AssemblyQualifiedName;
}
else
{
// C'est peut-être une énumération
refType = clazz.DataLayer.FindType(prop.Type) as Enumeration;
if (refType != null)
{
typeName = refType.FullName;
}
}
string columnName = prop.ColumnName;
if (string.IsNullOrEmpty(columnName))
{
columnName = StrategyManager.GetInstance(clazz.Store).NamingStrategy.CreateSQLColumnName(componentName, prop.Name);
}
// Propriété simple
IList <string> types = ClrTypeParser.GetModelNamesFromClrType(prop.Type);
if (types == null || types.Count == 0 || refType is Enumeration)
{
this.WriteLineWithIndent(level, String.Format("<property name=\"{0}\" column=\"{1}\" type=\"{2}\"/>", prop.Name, columnName, typeName));
}
else
{
// Component
this.WriteLineWithIndent(level, String.Format("<component name=\"{0}\" class=\"{1}\" >", prop.Name, typeName));
Entity entity = refType as Entity;
if (entity != null)
{
GenerateMappingProperties(level + 1, entity, columnName);
// Propriétés des classes de bases
while (entity.SuperClass != null)
{
entity = entity.SuperClass;
GenerateMappingProperties(level + 1, entity, columnName);
}
}
this.WriteLineWithIndent(level, "</component>");
}
}
IList <Association> list = Association.GetLinksToTargets(clazz);
foreach (Association association in list)
{
if (association.SourceMultiplicity == Multiplicity.OneMany || association.SourceMultiplicity == Multiplicity.ZeroMany)
{
string lazy = NHibernateStrategy.AssociationLazyLoadingProperty.GetValue(association).ToString().ToLower();
this.WriteLine("");
this.WriteLineWithIndent(level, "<!-- Relation 0..* -->");
this.WriteLineWithIndent(level, "<bag ");
this.WriteLineWithIndent(level, String.Format(" name=\"{0}\" inverse=\"true\" lazy=\"{1}\" >", association.SourceRoleName, lazy));
this.WriteLineWithIndent(level, String.Format(" <key column=\"{0}\"/>", association.SourceRoleName));
this.WriteLineWithIndent(level, String.Format(" <one-to-many class=\"{0}\" />", association.Target.AssemblyQualifiedName));
this.WriteLineWithIndent(level, "</bag>");
}
else if (association.SourceMultiplicity != Multiplicity.NotApplicable)
{
string insert = NHibernateStrategy.AssociationInsertProperty.GetValue(association).ToString().ToLower();
string update = NHibernateStrategy.AssociationUpdateProperty.GetValue(association).ToString().ToLower();
string outerJoin = NHibernateStrategy.AssociationOuterJoinProperty.GetValue(association).ToString().ToLower();
this.WriteLineWithIndent(level, String.Format("<many-to-one name=\"{0}\" class=\"{1}\" insert=\"{2}\" update=\"{3}\" outer-join=\"{4}\">", association.SourceRoleName, association.Target.AssemblyQualifiedName, insert, update, outerJoin));
foreach (ForeignKey fk in association.ForeignKeys)
{
WriteColumn(level + 1, "<column name=\"{0}\"/>", fk.Column);
}
this.WriteLineWithIndent(level, "</many-to-one>");
}
}
list = Association.GetLinksToSources(clazz);
foreach (Association association in list)
{
if (association.TargetMultiplicity != Multiplicity.NotApplicable && !String.IsNullOrEmpty(association.TargetRoleName))
{
string lazy = NHibernateStrategy.AssociationLazyLoadingProperty.GetValue(association).ToString().ToLower();
this.WriteLine("");
this.WriteLineWithIndent(level, "<!-- Relation 0..* -->");
this.WriteLineWithIndent(level, "<bag ");
this.WriteLineWithIndent(level, String.Format(" name=\"{0}\" inverse=\"true\" lazy=\"{1}\" >", association.TargetRoleName, lazy));
if (association.ForeignKeys.Count == 1)
{
WriteColumn(level + 1, "<key column=\"{0}\"/>", association.ForeignKeys[0].Column);
}
else
{
this.WriteLineWithIndent(level + 1, "<key>");
foreach (ForeignKey fk in association.ForeignKeys)
{
WriteColumn(level + 2, "<column name=\"{0}\"/>", fk.Column);
}
this.WriteLineWithIndent(level + 1, "</key>");
}
this.WriteLineWithIndent(level + 1, String.Format("<one-to-many class=\"{0}\" />", association.Source.AssemblyQualifiedName));
this.WriteLineWithIndent(level, "</bag>");
}
}
}
/// <summary>
/// Génération du mapping d'une classe
/// </summary>
/// <param name="root">Classe sur lequel s'effectue le mapping</param>
/// <param name="level">Niveau d'indentation dans le fichier de sortie</param>
private void GenerateClassMapping(ClassInheritanceNode root, int level, int discriminator)
{
if (root.IsExternal)
{
return;
}
// Si cette classe n'est pas persistable, on ne fait rien y compris sur ses sous classes
bool isPersistable = NHibernateStrategy.EntityIsPersistableProperty.GetValue(root.clazz);
if (isPersistable == false)
{
return;
}
string endTag = "</class>";
if (level == 1)
{
bool isRootClass = root.childs.Count > 0;
string tableName = root.clazz.TableName;
if (String.IsNullOrEmpty(tableName))
{
tableName = root.clazz.Name;
}
string schema = root.clazz.TableOwner;
if (!String.IsNullOrEmpty(schema))
{
schema = String.Format("schema=\"{0}\"", schema);
}
this.WriteLine("");
string comment = String.Format("<!-- Mapping de la classe {0} -->", root.clazz.Name);
string asterix = new string('*', comment.Length - 9);
this.WriteLineWithIndent(0, String.Format("<!-- {0} -->", asterix));
this.WriteLineWithIndent(0, comment);
this.WriteLineWithIndent(0, String.Format("<!-- {0} -->", asterix));
this.WriteLineWithIndent(0, String.Format("<class name=\"{0}\" table=\"{1}\" {2}>", root.clazz.AssemblyQualifiedName, tableName, (isRootClass ? " discriminator-value=\"0\"" : "")));
// Identifiant
if (root.clazz.PrimaryKeys.Count == 0)
{
this.WriteLineWithIndent(1, "<id><generator/></id>");
}
else if (root.clazz.PrimaryKeys.Count == 1)
{
Property prop = root.clazz.PrimaryKeys[0];
string columnName = prop.ColumnName;
if (string.IsNullOrEmpty(columnName))
{
columnName = StrategyManager.GetInstance(root.clazz.Store).NamingStrategy.CreateSQLColumnName(root.clazz.Name, prop.Name);
}
this.WriteLineWithIndent(1, String.Format("<id name=\"{0}\" column=\"{1}\">", prop.Name, columnName));
GeneratorInfo gi = NHibernateStrategy.EntityIdGeneratorProperty.GetValue(root.clazz);
if (gi != null)
{
this.WriteLineWithIndent(2, String.Format("<generator class=\"{0}\">", gi.Name));
foreach (GeneratorInfo.GeneratorParm parm in gi.Parms)
{
this.WriteLineWithIndent(3, String.Format("<param name=\"{0}\">{1}</param>", parm.Name, parm.Value));
}
this.WriteLineWithIndent(2, "</generator>");
}
this.WriteLineWithIndent(1, "</id>");
}
else // Count > 1
{
this.WriteLineWithIndent(1, String.Format("<composite-id name=\"Key\" class=\"{0}+PrimaryKey,{1}\">", root.clazz.FullName, root.clazz.DataLayer.AssemblyName));
foreach (Property property in root.clazz.PrimaryKeys)
{
string columnName = property.ColumnName;
if (string.IsNullOrEmpty(columnName))
{
columnName = StrategyManager.GetInstance(root.clazz.Store).NamingStrategy.CreateSQLColumnName(root.clazz.Name, property.Name);
}
this.WriteLineWithIndent(2, String.Format("<key-property name=\"{0}\" column=\"{1}\"/>", property.Name, columnName));
}
this.WriteLineWithIndent(1, "</composite-id>");
}
if (isRootClass)
{
this.WriteLineWithIndent(1, "<!-- Mapping utilise la stratégie de mapping filtré -->");
this.WriteLineWithIndent(1, "<discriminator column=\"DiscriminatorValue\" type=\"Int16\" force=\"true\"/>");
}
}
else
{
endTag = "</subclass>";
this.WriteLine("");
string comment = String.Format("<!-- sub-class mapping : {0} -->", root.clazz.Name);
string asterix = new string('*', comment.Length - 9);
this.WriteLineWithIndent(0, String.Format("<!-- {0} -->", asterix));
this.WriteLineWithIndent(0, comment);
this.WriteLineWithIndent(0, String.Format("<!-- {0} -->", asterix));
this.WriteLineWithIndent(level, String.Format("<subclass name=\"{0}\" discriminator-value=\"{1}\" >", root.clazz.AssemblyQualifiedName, (1 << (discriminator - 1))));
}
// Génération des propriétés de la classe
GenerateMappingProperties(level, root.clazz, null);
// Génération des sous classes
foreach (ClassInheritanceNode childNode in root.childs)
{
GenerateClassMapping(childNode, level + 1, discriminator);
discriminator++;
}
// Fermeture du tag
this.WriteLineWithIndent(level - 1, endTag);
}
/// <summary>
/// Chargement
/// </summary>
/// <param name="store">The store.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns></returns>
public static StrategyManager Load(Store store, string fileName)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (String.IsNullOrEmpty(fileName))
{
return(null);
}
StrategyManager sm = null;
try
{
using (StreamReader reader = new StreamReader(fileName))
{
// Désérialization de la description
XmlSerializer serializer = new XmlSerializer(typeof(StrategyManager));
sm = (StrategyManager)serializer.Deserialize(reader);
// Lecture et chargement des types
List <Type> types = new List <Type>();
foreach (StrategyTypeReference str in sm.StrategyTypes)
{
InternalPackage package = sm.GetPackage(str.PackageName);
if (package != null)
{
Type type = package.GetStrategyType(str.StrategyTypeName);
if (type != null)
{
types.Add(type);
}
}
}
// D'abord chargement de la stratégie de nommage
if (sm.NamingStrategyNode != null)
{
using (XmlNodeReader nr = new XmlNodeReader(sm.NamingStrategyNode))
{
serializer = new XmlSerializer(typeof(BaseNamingStrategy), types.ToArray());
sm._namingStrategy = (INamingStrategy)serializer.Deserialize(nr);
}
}
// Chargement des strategies
if (sm.StrategiesNode != null)
{
using (XmlNodeReader nr = new XmlNodeReader(sm.StrategiesNode))
{
serializer = new XmlSerializer(typeof(StrategyCollection), types.ToArray());
sm._strategies = (StrategyCollection)serializer.Deserialize(nr);
}
foreach (StrategyBase strategy in sm._strategies)
{
try
{
strategy.OnLoading(sm, new EventArgs());
StrategyPackage package = sm.GetPackage(strategy.PackageName) as StrategyPackage;
if (package != null)
{
strategy.StrategyFolder = package.PackageFolder;
}
}
catch (Exception ex)
{
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
if (ide != null)
{
ide.ShowMessageBox("Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, "Error", System.Windows.Forms.MessageBoxButtons.OK);
ide.LogError(false, "Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, 0, 0, "StrategyManager");
}
}
}
}
}
}
catch (Exception ex)
{
string text = ex.Message;
XmlException xex = ex as XmlException;
StringBuilder sb = new StringBuilder(ex.Message);
if (xex != null)
{
sb.AppendFormat(" line={0}, column={1}", xex.LineNumber, xex.LinePosition);
}
Exception iex = ex.InnerException;
while (iex != null)
{
sb.Append(" - ");
sb.Append(iex.Message);
iex = iex.InnerException;
}
text = sb.ToString();
if (logger != null)
{
logger.WriteError("StrategyManager", String.Format("Loading error {0}", text), ex);
}
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
if (ide != null)
{
ide.ShowMessage("Error when reading the strategies file (see error in the task list). A new empty file will be initialized. The current strategies file will be saved with a .bak extension");
}
try
{
// Sauvegarde du fichier en erreur
if (File.Exists(fileName))
{
Utils.CopyFile(fileName, fileName + ".bak");
}
}
catch { }
}
if (sm == null)
{
// Génération d'un fichier par défaut
sm = new StrategyManager();
sm.FileName = fileName;
sm.Save(store);
}
else
{
sm.FileName = fileName;
}
return(sm);
}
/// <summary>
/// Initialisation de la liste des stratégies à partir de celles disponibles sur le
/// repository central + les stratégies internes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SelectStrategyDialog_Load(object sender, EventArgs e)
{
_manifests = StrategyManager.GetAvailableManifests();
PopulateListView();
}
/// <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);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="StrategiesForm"/> class.
/// </summary>
/// <param name="component">The component.</param>
/// <param name="model">The model.</param>
public StrategiesForm(SoftwareComponent component, CandleElement model)
{
InitializeComponent();
if (component != null)
{
_store = component.Store;
}
else
{
_store = model.Store;
}
specificStrategies = new List <StrategiesListControl>();
globalsStrategies = new StrategiesListControl();
namingStrategy = new NamingStrategyControl();
languageConfig = new LanguageConfigurationControl();
globalsStrategies.Dock = DockStyle.Fill;
globalsStrategies.Name = "globalsStrategies";
globalsStrategies.TabIndex = 1;
namingStrategy.Dock = DockStyle.Fill;
namingStrategy.Name = "namingStrategy";
namingStrategy.TabIndex = 1;
languageConfig.Dock = DockStyle.Fill;
languageConfig.Name = "languageConfig";
languageConfig.TabIndex = 1;
tabStrategies.TabPages.Clear();
// Création des onglets (une par couche + une globale + une pour la stratégie de nommage)
// L'onglet courant est sélectionné
// D'abord le global
globalsStrategies.Initialize(_store, null);
tabGlobals.Controls.Add(globalsStrategies);
tabStrategies.TabPages.Add(tabGlobals);
// Puis un par couche
int index = 1;
foreach (SoftwareLayer layer in component.Layers)
{
StrategiesListControl specificStrategy = new StrategiesListControl();
specificStrategy.Dock = DockStyle.Fill;
specificStrategy.Name = String.Format("specificStrategies{0}", index);
specificStrategy.TabIndex = 0;
specificStrategy.Initialize(_store, layer);
specificStrategy.StrategyRemoved += Strategies_StrategyRemoved;
TabPage tabSpecific = new TabPage();
tabStrategies.TabPages.Add(tabSpecific);
tabSpecific.Location = new Point(4, 22);
tabSpecific.Name = String.Format("tabSpecific{0}", index);
tabSpecific.Padding = new Padding(3);
tabSpecific.Size = new Size(741, 348);
tabSpecific.TabIndex = index;
tabSpecific.UseVisualStyleBackColor = true;
tabSpecific.Text = layer.Name;
if (layer == model.StrategiesOwner)
{
tabSpecific.Text += "*";
tabStrategies.SelectedTab = tabSpecific;
}
tabSpecific.Controls.Add(specificStrategy);
}
// Stratégie de nommage
namingStrategy.Initialize(StrategyManager.GetInstance(_store).NamingStrategy);
tabNaming.Controls.Add(namingStrategy);
tabStrategies.TabPages.Add(tabNaming);
// Et le language
languageConfig.Initialize(StrategyManager.GetInstance(_store).TargetLanguage);
tabLanguage.Controls.Add(languageConfig);
tabStrategies.TabPages.Add(tabLanguage);
globalsStrategies.StrategyRemoved += new EventHandler <StrategyRemovedEventArgs>(Strategies_StrategyRemoved);
}
/// <summary>
/// Initialisation de la liste des stratégies
/// </summary>
/// <param name="strategiesOwner">The strategies owner.</param>
/// <param name="selectedStrategy">The selected strategy.</param>
private void PopulateTreeView(CandleElement strategiesOwner, StrategyBase selectedStrategy)
{
this._strategiesOwner = strategiesOwner != null ? strategiesOwner.StrategiesOwner : null;
_initialize = true;
tvStrategies.Nodes.Clear();
// Remplissage à partir des stratégies liées au modèle
TreeNode selectedNode = null;
foreach (StrategyBase strategy in StrategyManager.GetInstance(_store).GetStrategies(strategiesOwner, false))
{
TreeNodeCollection nodes = tvStrategies.Nodes;
// Insertion dans l'arbre en tenant compte du path
if (!String.IsNullOrEmpty(strategy.StrategyPath))
{
string[] pathParts = strategy.StrategyPath.Split('/');
// Création ou recherche de l'arborescence liée au path
foreach (string part in pathParts)
{
// Recherche du noeud parent pour chaque part
bool bFind = false;
foreach (TreeNode node in nodes)
{
if (Utils.StringCompareEquals(node.Text, part))
{
nodes = node.Nodes;
bFind = true;
break;
}
}
// Si pas trouvé, on le crèe
if (!bFind)
{
TreeNode parent = new TreeNode(part);
nodes.Add(parent);
nodes = parent.Nodes;
parent.Expand();
}
}
}
// Création du noeud de la stratégie
TreeNode tmpNode = new TreeNode(strategy.DisplayName);
tmpNode.Tag = strategy;
nodes.Add(tmpNode);
tmpNode.Checked = strategy.IsEnabled;
if (selectedStrategy != null && selectedStrategy.StrategyId == strategy.StrategyId)
{
selectedNode = tmpNode;
}
}
if (selectedNode != null)
{
tvStrategies.SelectedNode = selectedNode;
}
_initialize = false;
}
