/// <summary>
/// Nom du template du projet
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns></returns>
/// <remarks>
/// Le template est soit un template standard de VS, soit un template fournit dans la stratégie.
/// </remarks>
public string GetProjectTemplate(SoftwareLayer layer)
{
string template = MapPath(_projectTemplate);
if (File.Exists(template))
{
// Template fournit avec la stratégie.
// On le décompresse dans un dossier temporaire
string folder = Utils.GetTemporaryFolder();
// On extrait le ichier de template (.vstemplate)
RepositoryZipFile zipFile = new RepositoryZipFile(template);
zipFile.ExtractAll(folder);
List <string> files = Utils.SearchFile(folder, "*.vstemplate");
// Si on le trouve, c'est bon
if (files.Count > 0)
{
return(files[0]); // On supprimera le répertoire temporaire aprés
}
// On a rien trouvé
Utils.RemoveDirectory(folder);
}
return(template);
}
/// <summary>
/// Updates the vs project.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="layer">The layer.</param>
private static void UpdateVsProject(string oldValue, SoftwareLayer layer)
{
if (layer.VSProjectName == oldValue || String.IsNullOrEmpty(layer.VSProjectName))
{
layer.VSProjectName = layer.Name;
}
}
/// <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>
/// Adds the full name assembly.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="extension">The extension.</param>
private void AddFullNameAssembly(SoftwareLayer layer, string extension)
{
string assemblyName = String.Concat(layer.AssemblyName, extension);
// Si on prend les références à partir d'un modèle d'une solution et qu'on est
// dans ce modèle (count==1) alors on résoud les chemins à partir du répertoire binaire
if (!IsExternalModel && _initialModelIsInSolution)
{
EnvDTE.Project project = ServiceLocator.Instance.ShellHelper.FindProjectByName(layer.VSProjectName);
if (project != null)
{
string binaryProjectPath = Path.Combine(_projectPath.Peek(), "bin");
if (!(project.Object is VsWebSite.VSWebSite))
{
string outputPath =
(string)
project.ConfigurationManager.ActiveConfiguration.Properties.Item("OutputPath").Value;
binaryProjectPath = Path.Combine(_projectPath.Peek(), outputPath);
}
_references.Add(Path.Combine(binaryProjectPath, assemblyName));
}
}
// Sinon on prend direct dans le repository
else
{
_references.Add(Path.Combine(CurrentModelPath, assemblyName));
}
}
/// <summary>
/// Prise en compte d'une référence sur un SoftwareLayer
/// </summary>
/// <param name="layer">The layer.</param>
private void AcceptSoftwareLayer(SoftwareLayer layer)
{
if (_scope == ReferenceScope.Compilation)
{
if (layer is Layer && ((Layer)layer).InterfaceLayer != null)
{
return;
}
if (!IsExternalModel && _initialModelIsInSolution)
{
// Pour une compilation, si il n'y a pas d'interface et qu'on est dans le modèle initial, on
// se contente de prendre le nom du projet
_references.Add(layer.VSProjectName);
return;
}
}
string extension = ".dll";
if (_initialModelIsInSolution)
{
extension = StrategyManager.GetInstance(layer.Store).GetAssemblyExtension(layer);
}
AddFullNameAssembly(layer, extension);
}
/// <summary>
/// Mise à jour des noms du package et de la couche d'interface
/// </summary>
/// <param name="slayer">The slayer.</param>
private static void UpdateInterfaceAndLayerPackageName(SoftwareLayer slayer)
{
Layer layer = slayer as Layer;
if (layer == null)
{
return;
}
LayerPackage package = layer.LayerPackage;
if (String.IsNullOrEmpty(package.Name) && package.Name != "?")
{
package.Name = StrategyManager.GetInstance(layer.Store).NamingStrategy.GetLayerName(layer);
}
if (package.InterfaceLayer != null)
{
if (String.IsNullOrEmpty(package.InterfaceLayer.Name))
{
package.InterfaceLayer.Name =
StrategyManager.GetInstance(layer.Store).NamingStrategy.CreateLayerName(package,
package.InterfaceLayer,
layer.Name);
}
}
}
public string GetProjectTemplate(SoftwareLayer layer)
{
if (layer is Layer && ((Layer)layer).HostingContext == HostingContext.Web)
{
return(@"web\csharp\EmptyWeb");
}
return(null);
}
public string GetAssemblyExtension(SoftwareLayer layer)
{
if (layer is Layer && ((Layer)layer).HostingContext == HostingContext.Web)
{
return(".dll");
}
return(null);
}
/// <summary>
/// Extension de l'assembly générée
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public virtual string GetAssemblyExtension(SoftwareLayer layer)
{
return
(layer != null && layer is PresentationLayer &&
((PresentationLayer)layer).HostingContext == HostingContext.Standalone
? ".exe"
: ".dll");
}
/// <summary>
/// Creates the name of the project folder.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="packageLayerName">Name of the package layer.</param>
/// <returns></returns>
public virtual string CreateProjectFolderName(SoftwareLayer layer, string packageLayerName)
{
if (packageLayerName == null)
{
packageLayerName = layer.Name;
}
LayerNamingRule rule = FindRule(layer);
return(string.Format(rule.ProjectFolderFormatString, packageLayerName, layer.VSProjectName, layer.Component.Namespace, rule.DefaultName));
}
/// <summary>
/// Traverses the specified layer.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="Scope">The scope.</param>
/// <param name="mode">The mode.</param>
public void Traverse(SoftwareLayer layer, ReferenceScope Scope, ConfigurationMode mode)
{
// Stocke les éléments traités pour éviter les doublons
List <Guid> guids = new List <Guid>();
if (layer is InterfaceLayer)
{
foreach (ServiceContract contract in ((InterfaceLayer)layer).ServiceContracts)
{
foreach (Implementation impl in Implementation.GetLinksToImplementations(contract))
{
if (mode.CheckConfigurationMode(impl.ConfigurationMode) &&
!guids.Contains(impl.ClassImplementation.Id))
{
_visitor.Accept(impl, impl.ClassImplementation);
guids.Add(impl.ClassImplementation.Id);
}
}
}
}
else if (layer is Layer)
{
foreach (ClassImplementation clazz in ((Layer)layer).Classes)
{
foreach (NamedElement service in clazz.ServicesUsed)
{
IList <ClassUsesOperations> externalServiceLinks =
ClassUsesOperations.GetLinksToServicesUsed(clazz);
foreach (ClassUsesOperations link in externalServiceLinks)
{
if (mode.CheckConfigurationMode(link.ConfigurationMode) && ((link.Scope & Scope) == Scope))
{
if (service is ExternalServiceContract)
{
_visitor.Accept(link, (ExternalServiceContract)service);
}
else if (service is ServiceContract)
{
_visitor.Accept(link, (ServiceContract)service);
}
else if (service is ClassImplementation)
{
_visitor.Accept(link, (ClassImplementation)service);
}
else
{
throw new Exception("Type not implemented");
}
guids.Add(service.Id);
}
}
}
}
}
}
/// <summary>
/// Creates the name of the assembly.
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns></returns>
public virtual string CreateAssemblyName(SoftwareLayer layer)
{
LayerNamingRule rule = FindRule(layer);
string fmt = rule.AssemblyFormatString;
if ((layer is PresentationLayer || layer is UIWorkflowLayer) && ((Layer)layer).HostingContext == HostingContext.Standalone)
{
fmt = "{4}";
}
return(string.Format(fmt, layer.VSProjectName, layer.Namespace, layer.Name, layer.Component.Model.Name, layer.Component.Name));
}
/// <summary>
/// Nom par défaut d'une couche
/// </summary>
/// <param name="layerPackage">The layer package.</param>
/// <param name="element">Type de la couche</param>
/// <param name="associatedName">Name of the associated.</param>
/// <returns></returns>
public virtual string CreateLayerName(LayerPackage layerPackage, SoftwareLayer element, string associatedName)
{
string typeName = element.GetType().Name;
LayerNamingRule rule = FindRule(element);
if (associatedName == null)
{
associatedName = rule.DefaultName;
}
return(string.Format(rule.FormatString, rule.DefaultName, element.Component.Name, element.Namespace, layerPackage != null ? layerPackage.Name : String.Empty, associatedName));
}
/// <summary>
/// Finds the rule.
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns></returns>
protected LayerNamingRule FindRule(SoftwareLayer layer)
{
string layerTypeName = layer.GetType().Name;
LayerNamingRule rule = _layersNamingRules.Find(delegate(LayerNamingRule r) { return(Utils.StringCompareEquals(r.LayerType, layerTypeName)); });
// Si n'existe pas, on en crée une par défaut
if (rule == null)
{
rule = new LayerNamingRule();
rule.LayerType = layerTypeName;
rule.AssemblyFormatString = "{2}";
rule.ProjectFolderFormatString = DefaultProjectFolderFormat;
rule.FormatString = "{0}";
rule.ElementFormatString = "{0}";
rule.DefaultName = layer.GetType().Name;
// Regles par défaut
if (layer is DataLayer)
{
rule.DefaultName = "InfoLayer";
rule.ElementFormatString = "{0}Info";
}
else if (layer is InterfaceLayer)
{
rule.DefaultName = "Interfaces";
rule.ElementFormatString = "I{0}";
rule.FormatString = "I{4}";
}
else if (layer is DataAccessLayer)
{
rule.DefaultName = "DAO";
rule.ElementFormatString = "{0}DAO";
}
else if (layer is BusinessLayer)
{
rule.DefaultName = "Services";
rule.ElementFormatString = "{0}BLL";
}
else if (layer is PresentationLayer)
{
rule.DefaultName = "UILayer";
rule.ElementFormatString = "{0}";
}
else
{
rule.DefaultName = "UILayer";
rule.ElementFormatString = "{0}";
}
_layersNamingRules.Add(rule);
}
return(rule);
}
/// <summary>
/// Updates the namespace.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="layer">The layer.</param>
private static void UpdateNamespace(string oldValue, SoftwareLayer layer)
{
string oldNamespace =
StrategyManager.GetInstance(layer.Store).NamingStrategy.CreateNamespace(layer.Component.Namespace,
oldValue, layer);
if (oldNamespace == layer.Namespace || String.IsNullOrEmpty(layer.Namespace))
{
layer.Namespace =
StrategyManager.GetInstance(layer.Store).NamingStrategy.CreateNamespace(layer.Component.Namespace,
layer.Name, layer);
}
}
/// <summary>
/// Génération du projet correspondant à cette couche
/// </summary>
/// <param name="elem">The elem.</param>
public virtual void GenerateVSProject(ICustomizableElement elem)
{
_layer = elem as SoftwareLayer;
if (_layer == null)
{
return;
}
Project project = null;
if (Context.CanGenerate(_layer.Id))
{
// Nom du dossier qui contient le projet
string folderName = _layer.GetProjectFolderName();
// Template du projet
string templateName = GetProjectTemplate(_layer);
// Création du projet si il n'existe pas
project = ServiceLocator.Instance.ShellHelper.CreateVSProject(folderName, _layer.VSProjectName, templateName);
if (project != null)
{
ServiceLocator.Instance.ShellHelper.SetProperty(project, "DefaultNamespace", _layer.Namespace);
ServiceLocator.Instance.ShellHelper.SetProperty(project, "AssemblyName", _layer.AssemblyName);
// Ajout des références
ServiceLocator.Instance.ShellHelper.AddProjectReferencesToProject(project,
ReferencesHelper.GetReferences(
Context.Mode,
ReferenceScope.Compilation,
ServiceLocator.Instance.
ShellHelper.SolutionFolder,
_layer));
if (_layer is Layer && ((Layer)_layer).StartupProject)
{
ServiceLocator.Instance.ShellHelper.Solution.SolutionBuild.StartupProjects = project.UniqueName;
}
}
}
else
{
// Si il y avait un élément sélectionné pour la génération, il faut quand même
// initialisé le projet concerné
project = GetProject();
}
// ShellHelper.SetProjectProperty( project, ConfigurationMode.All, "OutputPath", ResolveRepositoryPath( DSLFactory.Candle.SystemModel.Repository.RepositoryManager.LATEST ) );
Context.Project = project;
}
/// <summary>
/// Creates the name of the element.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="initialName">The initial name.</param>
/// <returns></returns>
public virtual string CreateElementName(SoftwareLayer layer, string initialName)
{
if (layer == null)
{
return(initialName);
}
if (initialName == null)
{
initialName = String.Empty;
}
LayerNamingRule rule = FindRule(layer);
return(string.Format(rule.ElementFormatString, ToPascalCasing(initialName), layer.Name));
}
/// <summary>
/// Creates the layer.
/// </summary>
/// <param name="component">The component.</param>
/// <param name="package">The package.</param>
/// <returns></returns>
public SoftwareLayer CreateLayer(SoftwareComponent component, LayerPackage package)
{
SoftwareLayer layer = null;
if (rbPres.Checked)
{
layer = new PresentationLayer(component.Store);
}
else if (rbUI.Checked)
{
layer = new UIWorkflowLayer(component.Store);
}
else if (rbDAL.Checked)
{
layer = new DataAccessLayer(component.Store);
}
else if (rbBLL.Checked)
{
layer = new BusinessLayer(component.Store);
}
else if (rbModels.Checked)
{
layer = new DataLayer(component.Store);
}
else if (rbInterface.Checked)
{
layer = new InterfaceLayer(component.Store);
((InterfaceLayer)layer).Level = (short)(package.Level + 1);
package.InterfaceLayer = (InterfaceLayer)layer;
}
Layer tmp = layer as Layer;
if (tmp != null)
{
package = component.LayerPackages.Find(delegate(LayerPackage p) { return(p.Level == tmp.Level); });
if (package == null)
{
package = new LayerPackage(component.Store);
package.Level = tmp.Level;
component.LayerPackages.Add(package);
}
package.Layers.Add(tmp);
}
component.Layers.Add(layer);
return(layer);
}
/// <summary>
/// Gets the assembly extension.
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns></returns>
public string GetAssemblyExtension(SoftwareLayer layer)
{
IList <StrategyBase> strategies = layer.GetStrategies(true);
// D'abord exécution des stratégies générant les projets
foreach (StrategyBase strategy in strategies)
{
if (strategy is IStrategyProvidesProjectTemplates)
{
string ext = ((IStrategyProvidesProjectTemplates)strategy).GetAssemblyExtension(layer);
if (!String.IsNullOrEmpty(ext))
{
return(ext);
}
}
}
return(".dll"); // defaut
}
/// <summary>
/// Imports the specified obj.
/// </summary>
/// <param name="obj">The obj.</param>
/// <param name="component">The component.</param>
/// <param name="package">The package.</param>
public static void Import(object obj, SoftwareComponent component, LayerPackage package)
{
MemoryStream ms = obj as MemoryStream;
if (ms != null)
{
string projectInfo = String.Empty;
String data = Encoding.Unicode.GetString(ms.ToArray());
StringBuilder sb = new StringBuilder();
for (int ix = 0; ix < data.Length; ix++)
{
char ch = data[ix];
if (ch == 0)
{
if (sb.Length > 2)
{
projectInfo = sb.ToString();
}
if (sb.Length != 0)
{
sb = new StringBuilder();
}
continue;
}
sb.Append(ch);
}
string[] infos = projectInfo.Split('|');
//// Comprend rien à la codification des noms de projet.
////
//// Si contient un ., on prend le nom avant le / sinon c'est un site web, on
//// prend le nom complet
//string projectName = infos[1];
//if (projectName.IndexOf('.') > 0)
//{
// int pos = projectName.LastIndexOf('\\');
// projectName = projectName.Substring(0, pos);
//}
Project prj = ServiceLocator.Instance.ShellHelper.FindProjectByName(infos[1]);
if (prj != null)
{
using (Transaction transaction = component.Store.TransactionManager.BeginTransaction("Import layer"))
{
ImportProjectWizard wizard = new ImportProjectWizard();
if (wizard.ShowDialog() == DialogResult.OK)
{
SoftwareLayer layer = wizard.CreateLayer(component, package);
string name = prj.Name;
string[] parts = name.Split('\\');
if (parts.Length > 1)
{
name = parts[parts.Length - 2];
}
layer.Name = name;
layer.VSProjectName = name;
// Récupération des propriétés
for (int i = 0; i < prj.Properties.Count; i++)
{
EnvDTE.Property prop = prj.Properties.Item(i + 1);
if (prop.Name == "RootNamespace")
{
layer.Namespace = prop.Value as string;
}
else if (prop.Name == "OutputFileName")
{
layer.AssemblyName = System.IO.Path.GetFileNameWithoutExtension(prop.Value as string);
}
}
}
transaction.Commit();
}
}
}
}
/// <summary>
/// Imports the operations.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="port">The port.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns>true if the import is ok</returns>
public bool ImportOperations(SoftwareLayer layer, TypeWithOperations port, string fileName)
{
FileCodeModel fcm = ServiceLocator.Instance.ShellHelper.GetFileCodeModel(fileName);
if (fcm == null)
{
return(false);
}
foreach (CodeElement cn in fcm.CodeElements)
{
if (cn is CodeNamespace)
{
foreach (CodeElement ci in ((CodeNamespace)cn).Members)
{
if ((ci is CodeInterface || ci is CodeClass) && layer is InterfaceLayer)
{
CodeElements members;
string comment;
if (ci is CodeInterface)
{
comment = ((CodeInterface)ci).DocComment;
members = ((CodeInterface)ci).Members;
}
else
{
comment = ((CodeClass)ci).DocComment;
members = ((CodeClass)ci).Members;
}
if (port == null)
{
port = new ServiceContract(layer.Store);
port.Name = ci.Name;
port.RootName = ci.Name;
port.Comment = NormalizeComment(comment);
((InterfaceLayer)layer).ServiceContracts.Add((ServiceContract)port);
}
RetrieveOperations(port, members, false);
}
else if (ci is CodeClass && layer is Layer)
{
CodeClass cc = ci as CodeClass;
ClassImplementation clazz = port as ClassImplementation;
//if (cc.Access == vsCMAccess.vsCMAccessPublic)
{
if (clazz == null)
{
clazz = new ClassImplementation(layer.Store);
clazz.Name = ci.Name;
clazz.RootName = ci.Name;
clazz.Comment = NormalizeComment(cc.DocComment);
((Layer)layer).Classes.Add(clazz);
}
InterfaceLayer iLayer = clazz.Layer.LayerPackage.InterfaceLayer;
// Si il y a plusieurs interfaces, on ne fait rien car on ne sait pas laquelle prendre
if (iLayer != null && cc.ImplementedInterfaces.Count == 1)
{
ServiceContract contract = clazz.Contract;
if (contract == null)
{
string iName = cc.ImplementedInterfaces.Item(1).Name;
contract = iLayer.ServiceContracts.Find(delegate(ServiceContract c) { return(c.Name == iName); });
if (contract == null)
{
contract = new ServiceContract(layer.Store);
contract.Name = StrategyManager.GetInstance(clazz.Store).NamingStrategy.CreateElementName(iLayer, cc.Name);
contract.RootName = cc.Name;
contract.Comment = NormalizeComment(cc.DocComment);
iLayer.ServiceContracts.Add(contract);
RetrieveOperations(contract, cc.Members, true);
}
clazz.Contract = contract;
}
}
}
}
}
}
}
return(true);
}
/// <summary>
/// Creates the namespace.
/// </summary>
/// <param name="appNamespace">The app namespace.</param>
/// <param name="projectName">Name of the project.</param>
/// <param name="element">The element.</param>
/// <returns></returns>
public virtual string CreateNamespace(string appNamespace, string projectName, SoftwareLayer element)
{
return(string.Format("{0}.{1}", appNamespace, projectName));
}
/// <summary>
/// Extension de l'assembly générée
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public string GetAssemblyExtension(SoftwareLayer layer)
{
return(null); // AssemblyExtension;
}
/// <summary>
/// Alerts listeners that a property for an element has changed.
/// </summary>
/// <param name="e">Provides data for the ElementPropertyChanged event.</param>
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)
{
// Modifications possibles :
// - Name
// - AssemblyName
// - VSProject
// - Namespace
//
// Regles de dépendences
// Name -> layerPackage.Name & interface.Name & VSProject
// Namespace -> component.Namespace & layer.Name|layer.VSProject
// AssemblyName -> Name | Namespace |vsproject
int pos;
object flag;
// Cast on the element
SoftwareLayer layer = e.ModelElement as SoftwareLayer;
if (layer == null || layer.Store.InUndoRedoOrRollback)
{
return;
}
// Modification du nom
if (e.DomainProperty.Id == Layer.NameDomainPropertyId &&
!layer.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.IsSerializing)
{
// Le nom du project
UpdateVsProject((string)e.OldValue, layer);
// Le layer package si il n'est pas renseigné et
// la couche d'interface si elle n'est pas renseignée
UpdateInterfaceAndLayerPackageName(layer);
// Modif du namespace
UpdateNamespace((string)e.OldValue, layer);
return;
}
// Passe aussi dans le cas du modif du nom car celui ci modifie le vsproject
if (e.DomainProperty.Id == Layer.VSProjectNameDomainPropertyId &&
!layer.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.IsSerializing)
{
// Modif du namespace
UpdateNamespace((string)e.OldValue, layer);
UpdateAssemblyName(layer);
return;
}
// Le namespace
if (e.DomainProperty.Id == Layer.NamespaceDomainPropertyId)
{
string oldName = (string)e.OldValue;
if (
layer.Store.TransactionManager.CurrentTransaction.Context.ContextInfo.TryGetValue(
"InitializeComponentWizard", out flag))
{
oldName = "?"; // Force la mise à jour
}
if (layer.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.IsSerializing &&
oldName != "?")
{
return;
}
string newName = (string)e.NewValue;
// Modif du nom de l'assembly
if (newName != "?" && layer.Component != null &&
(layer.AssemblyName.StartsWith(oldName) || String.IsNullOrEmpty(layer.AssemblyName)))
{
UpdateAssemblyName(layer);
}
// Modification du namespace sur le modelsLayer
// --> Modif des namespaces des packages
if (layer is DataLayer)
{
DataLayer ml = layer as DataLayer;
foreach (Package package in ml.Packages)
{
if (oldName == "?")
{
pos = package.Name.LastIndexOf('.');
if (pos > 0)
{
package.Name = String.Concat(newName, package.Name.Substring(pos));
}
}
else if ((!String.IsNullOrEmpty(oldName) && package.Name.StartsWith(oldName)) ||
String.IsNullOrEmpty(package.Name))
{
package.Name = newName + package.Name.Substring(oldName.Length);
}
}
}
}
}
/// <summary>
/// Updates the name of the assembly.
/// </summary>
/// <param name="layer">The layer.</param>
private static void UpdateAssemblyName(SoftwareLayer layer)
{
layer.AssemblyName = StrategyManager.GetInstance(layer.Store).NamingStrategy.CreateAssemblyName(layer);
}
/// <summary>
/// Execution du wizard
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="DSLFactory.Candle.SystemModel.Strategies.StrategyElementElementAddedEventArgs"/> instance containing the event data.</param>
public void RunWizard(ModelElement sender, StrategyElementElementAddedEventArgs e)
{
CandleElement elem = e.ModelElement as CandleElement;
txtRootName.Text = elem.RootName;
if (elem is ServiceContract) // Ce cas est désactivé (voir selection du wizard)
{
_layer = ((ServiceContract)e.ModelElement).Layer;
txtName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_layer, elem.RootName);
}
else
{
_layer = ((ClassImplementation)e.ModelElement).Layer;
_iLayer = ((ClassImplementation)e.ModelElement).Layer.LayerPackage.InterfaceLayer;
txtName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_layer, elem.RootName);
if (_iLayer == null)
{
txtContractName.Visible = false;
}
else
{
txtContractName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_iLayer, txtName.Text);
}
}
if (elem is ServiceContract || ((ClassImplementation)elem).Layer.LayerPackage.InterfaceLayer == null)
{
lblContractName.Visible = false;
txtContractName.Visible = false;
txtContractName.Text = null;
}
lblHeader.Text = String.Format(lblHeader.Text, _layer.Name);
groupBox1.Text = _layer.Namespace;
if (!s_dontShow)
{
e.UserCancel = (ShowDialog() == DialogResult.Cancel);
if (e.UserCancel)
{
return;
}
s_dontShow = ckDontShow.Checked;
}
// Ici on force les noms des classes donc on ne veut pas que la régle basée sur la modification
// du RootName s'execute. On l'indique dans le contexte de la transaction
if (
!elem.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.ContainsKey(
"CustomizableElementChangeRule_Enabled"))
{
elem.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.Add(
"CustomizableElementChangeRule_Enabled", false);
}
elem.Name = txtName.Text;
using (Transaction transaction = elem.Store.TransactionManager.BeginTransaction("Set root name"))
{
// Force la transaction pour que la règle s'execute tout de suite et qu'on puisse
// forcer le nom ensuite
elem.RootName = txtRootName.Text;
transaction.Commit();
}
// Si c'est une classe, on essaye de créer son interface
ClassImplementation clazz = elem as ClassImplementation;
if (clazz != null && _iLayer != null && !String.IsNullOrEmpty(txtContractName.Text))
{
if (clazz.Contract == null)
{
// On regarde si l'interface n'existe pas
clazz.Contract =
_iLayer.ServiceContracts.Find(
delegate(ServiceContract c) { return(c.Name == txtContractName.Text); });
if (clazz.Contract == null)
{
clazz.Contract = new ServiceContract(clazz.Store);
clazz.Contract.RootName = txtRootName.Text;
clazz.Layer.LayerPackage.InterfaceLayer.ServiceContracts.Add(clazz.Contract);
UnplacedModelHelper.RegisterNewModel(clazz.Store, clazz.Contract);
// Si la classe courante utilise un seul contract, on le recopie
IList <ClassUsesOperations> links = ClassUsesOperations.GetLinksToServicesUsed(clazz);
if (links.Count == 1)
{
ServiceContract contract = links[0].TargetService as ServiceContract;
if (contract != null)
{
TypeWithOperations.CopyOperations(contract, clazz.Contract);
}
else
{
ExternalServiceContract externalContract =
links[0].TargetService as ExternalServiceContract;
if (externalContract != null)
{
TypeWithOperations.CopyOperations(externalContract.ReferencedServiceContract,
clazz.Contract);
}
}
}
}
}
using (Transaction transaction = elem.Store.TransactionManager.BeginTransaction("Set root name"))
{
// Force la transaction pour que la règle s'execute tout de suite et qu'on puisse
// forcer le nom ensuite
clazz.Contract.RootName = elem.RootName;
transaction.Commit();
}
if (clazz.Contract.Name != txtContractName.Text)
{
clazz.Contract.Name = txtContractName.Text;
}
}
e.CancelBubble = true;
}
