/// <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; }