/// <summary>
/// Vérification si un type existe et le crée le cas échéant (y compris les packages)
/// </summary>
/// <param name="newTypeName">Nom complet du type</param>
/// <returns>Une instance du type</returns>
public DataType EnsureTypeExists(string newTypeName)
{
if (String.IsNullOrEmpty(newTypeName))
{
return(null);
}
// le test suivant ne peut pas être null car son appel va générer la création
// de la couche modèles si elle n'existe pas. C'est bien ce que l'on veut
if (DataLayer == null)
{
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
if (ide != null)
{
ide.ShowMessage(String.Format("Can't create user type '{0}' because the models layer does not exist.", newTypeName));
}
throw new DataLayerNotDefinedException();
}
if (!IsDataLayerExists)
{
return(null);
}
if (this.Store.TransactionManager.CurrentTransaction.Context.ContextInfo.ContainsKey("ReverseInProgress"))
{
return(null);
}
DataType newDefinedTypeModel = null;
DataLayer modelsLayer = DataLayer;
using (Transaction transaction = this.Store.TransactionManager.BeginTransaction("Add class to dataLayer"))
{
transaction.Context.ContextInfo.Add("Generated", true);
string typeName = newTypeName;
ClassNameInfo cnh = new ClassNameInfo(typeName);
// Si il n'y a pas de namespace, on force le namespace par défaut.
if (String.IsNullOrEmpty(cnh.Namespace))
{
// Si il y a plusieurs packages, on va lui demander d'en sélectionner un
if (modelsLayer.Packages.Count > 1)
{
NamespacesSelectorDialog dlg = new NamespacesSelectorDialog(modelsLayer.Packages);
if (dlg.ShowDialog() == DialogResult.Cancel)
{
return(null);
}
cnh.Namespace = dlg.SelectedNamespace;
}
else
{
cnh.Namespace = modelsLayer.DefaultPackage.Name;
}
}
// Recherche si le type existe dans un des packages
newDefinedTypeModel = modelsLayer.FindType(cnh.Namespace, cnh.ClassName);
if (newDefinedTypeModel == null)
{
bool classExists;
newDefinedTypeModel = modelsLayer.AddTypeIfNotExists(cnh, false, out classExists);
}
transaction.Commit();
}
return(newDefinedTypeModel);
}
/// <summary>
/// Generates the specified service provider.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="modelFileName">Name of the model file.</param>
/// <param name="selectedElement">The selected element.</param>
public static void Generate(IServiceProvider serviceProvider, string modelFileName, ICustomizableElement selectedElement)
{
if (modelFileName == null)
{
throw new ArgumentNullException("modelFileName");
}
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
Generator.s_serviceProvider = serviceProvider;
try
{
// Sauvegarde de tous les documents
ServiceLocator.Instance.ShellHelper.Solution.DTE.Documents.SaveAll();
CandleModel model = CandleModel.GetModelFromCurrentSolution(modelFileName);
// Chargement du modèle
//ModelLoader loader = ModelLoader.GetLoader(modelFileName, false);
//if (loader == null || loader.Model == null)
//{
// if (logger != null)
// logger.Write("Generator", "unable to load the model", LogType.Error);
// return;
//}
//CandleModel model = loader.Model;
if (model.Component == null)
{
if (logger != null)
{
logger.Write("Generator", "model contains no software component.", LogType.Error);
}
return;
}
if (StrategyManager.GetInstance(model.Store).GetStrategies(null, true).Count == 0)
{
if (logger != null)
{
logger.Write("Generator", "No strategies configured.", LogType.Error);
}
return;
}
// CandleModel model = loader.Model;
s_context = new GenerationContext(model, modelFileName, selectedElement != null ? selectedElement.Id : Guid.Empty);
GenerationPass generationPassesSelected = GenerationPass.CodeGeneration | GenerationPass.MetaModelUpdate;
try
{
// Demande des stratégies à executer
if (selectedElement != null)
{
RunningStrategiesForm dlg = new RunningStrategiesForm(selectedElement.StrategiesOwner);
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
s_context.SelectedStrategies = dlg.SelectedStrategies;
generationPassesSelected = dlg.SelectedGenerationPasses;
}
if (logger != null)
{
logger.BeginProcess(true, true);
}
// Préparation de l'IDE
ide.SetWaitCursor();
ide.DisplayProgress("Generate...", 1, 3);
Microsoft.VisualStudio.Modeling.Validation.ValidationContext vc = new Microsoft.VisualStudio.Modeling.Validation.ValidationContext(Microsoft.VisualStudio.Modeling.Validation.ValidationCategories.Save, model);
if (vc.CurrentViolations.Count > 0)
{
if (ide != null)
{
if (ide.ShowMessageBox("There is validation errors, continue generate ?", "Generation", MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
}
}
// Au cas ou cette passe a été forcé dans la boite de dialogue
if ((generationPassesSelected & GenerationPass.ElementAdded) == GenerationPass.ElementAdded)
{
if (logger != null)
{
logger.BeginStep("Code Generation for the ElementAdded event", LogType.Info);
}
s_context.GenerationPass = GenerationPass.ElementAdded;
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Update metamodel"))
{
model.Component.GenerateCode(s_context);
transaction.Commit();
}
if (logger != null)
{
logger.EndStep();
}
}
// Mise à jour du méta modèle
if ((generationPassesSelected & GenerationPass.MetaModelUpdate) == GenerationPass.MetaModelUpdate)
{
if (logger != null)
{
logger.BeginStep("1) Meta Model Update", LogType.Info);
}
s_context.GenerationPass = GenerationPass.MetaModelUpdate;
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Update metamodel"))
{
// On ne veut pas que les wizards soient appelés
model.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo[StrategyManager.IgnoreStrategyWizards] = true;
model.Component.GenerateCode(s_context);
if (transaction.HasPendingChanges)
{
transaction.Commit();
}
}
if (logger != null)
{
logger.EndStep();
}
}
if (logger != null)
{
logger.BeginStep("1) Check references", LogType.Info);
}
// Vérification des dépendances
ReferencesHelper.CheckReferences(true, vc, new ConfigurationMode(), ReferenceScope.Compilation, model);
if (logger != null)
{
logger.EndStep();
}
ide.DisplayProgress("Generate...", 2, 3);
// Génération de code
if ((generationPassesSelected & GenerationPass.CodeGeneration) == GenerationPass.CodeGeneration)
{
if (logger != null)
{
logger.BeginStep("2) Code Generation", LogType.Info);
}
s_context.GenerationPass = GenerationPass.CodeGeneration;
model.Component.GenerateCode(s_context);
if (logger != null)
{
logger.EndStep();
}
}
}
finally
{
Mapper.Instance.Save();
}
//if (logger != null)
// logger.BeginStep("Generation epilogue", LogType.Debug);
//if (logger != null)
// logger.EndStep();
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Generator", "Generator", ex);
}
}
finally
{
// On s'assure de faire disparaitre la progress bar
ide.DisplayProgress("", 2, 0);
if (logger != null)
{
logger.EndProcess();
}
if (ide != null)
{
ide.ShowErrorList();
}
}
}
/// <summary>
/// Sélection d'un modèle
/// </summary>
/// <param name="component">The component.</param>
/// <param name="metaData">The meta data.</param>
/// <returns></returns>
bool IModelsMetadata.SelectModel(ExternalComponent component, out ComponentModelMetadata metaData)
{
metaData = null;
// Ici on veut saisir le fichier décrivant le système
ComponentType?ct = null;
if (component.MetaData != null)
{
ct = component.MetaData.ComponentType;
}
RepositoryTreeForm wizard = new RepositoryTreeForm(true, ct);
if (wizard.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
// On doit le créer
if (wizard.SelectedItem == null)
{
//
// Création d'un composant externe
//
if (component.Name == String.Empty)
{
PromptBox pb = new PromptBox("Name of the new component");
if (pb.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return(false);
}
// Vérification des doublons.
if (_metadatas.NameExists(pb.Value))
{
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowMessage("This model already exists in this model.");
}
return(false);
}
component.Name = pb.Value;
}
// Création d'un modèle vide dans un répertoire temporaire
string relativeModelFileName = component.Name + ModelConstants.FileNameExtension;
string fn = Utils.GetTemporaryFileName(relativeModelFileName);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
// Persistence du modèle
CandleModel model = ModelLoader.CreateModel(component.Name, component.Version);
component.ModelMoniker = model.Id;
SerializationResult result = new SerializationResult();
CandleSerializationHelper.Instance.SaveModel(result, model, fn);
// Et ouverture du modèle
ServiceLocator.Instance.ShellHelper.Solution.DTE.ItemOperations.OpenFile(fn, EnvDTE.Constants.vsViewKindDesigner);
}
else // Sinon affectation
{
metaData = wizard.SelectedItem;
ExternalComponent externalComponent = component.Model.FindExternalComponent(metaData.Id);
if (externalComponent != null)
{
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowMessage("This model already exists in this model.");
}
return(false);
}
metaData.UpdateComponent(component);
}
return(true); // On ne passe pas dans le rollback
}
return(false);
}
/// <summary>
/// Copie du modèle dans le repository local et mise à jour du repository local
/// avec les modèles des références externes du modèle et des artifacts
/// </summary>
/// <remarks>
/// Cet événement se produit lors de la sauvegarde du modèle
/// </remarks>
/// <param name="model">Modèle à copier</param>
/// <param name="fileName">Path du fichier contenant le modèle</param>
private void PublishLocally(CandleModel model, string fileName)
{
Debug.Assert(model != null);
Debug.Assert(fileName != null);
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.BeginProcess(false, true);
logger.BeginStep("Local publication", LogType.Info);
}
try
{
IRepositoryProvider localProvider = RepositoryManager.Instance.GetLocalProvider();
Debug.Assert(localProvider != null);
string sourceFolder = Path.GetDirectoryName(fileName);
string folder = Path.GetDirectoryName(model.MetaData.GetFileName(PathKind.Absolute));
Utils.RemoveDirectory(folder);
// D'abord le modele.
try
{
fileName = localProvider.PublishModel(model, fileName, fileName);
if (logger != null)
{
logger.Write("Local publication", "Publish model " + Path.GetFileName(fileName), LogType.Info);
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Local publication", "Publish model " + Path.GetFileName(fileName), ex);
}
}
// Puis les diagrammes
foreach (string diagramFile in Directory.GetFiles(sourceFolder, String.Format("{0}*.diagram", Path.GetFileName(fileName))))
{
try
{
localProvider.PublishModel(model, diagramFile, diagramFile);
if (logger != null)
{
logger.Write("Local publication", "Publish diagram file " + Path.GetFileName(diagramFile), LogType.Info);
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Local publication", "Publish diagram file " + Path.GetFileName(diagramFile), ex);
}
}
}
ReferencesCollection references = DSLFactory.Candle.SystemModel.Dependencies.ReferencesHelper.GetReferences(new ConfigurationMode(), ReferenceScope.Publish, sourceFolder, model);
//if (model.SoftwareComponent != null)
//{
// DateTime lastModified = File.GetLastWriteTime(fileName);
// foreach (string referenceFileName in references)
// {
// if (File.Exists(referenceFileName) && lastModified < File.GetLastWriteTime(referenceFileName))
// {
// upToDate = false;
// break;
// }
// }
//}
// Ensuite les binaires et les artifacts
foreach (string referenceFileName in references)
{
try
{
localProvider.PublishModel(model, referenceFileName, referenceFileName);
if (logger != null)
{
logger.Write("Local publication", "Publish file " + Path.GetFileName(referenceFileName), LogType.Info);
}
// Il y a peut-être des fichiers additionnels
string additionalFileName = Path.ChangeExtension(referenceFileName, ".xml");
if (File.Exists(additionalFileName))
{
localProvider.PublishModel(model, additionalFileName, additionalFileName);
}
additionalFileName = Path.ChangeExtension(referenceFileName, ".pdb");
if (File.Exists(additionalFileName))
{
localProvider.PublishModel(model, additionalFileName, additionalFileName);
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Local publication", "Publish file " + Path.GetFileName(referenceFileName), ex);
}
}
}
// On n'oublie pas de mettre à jour les metadata
ComponentModelMetadata data = model.MetaData;
Metadatas.Update(data, fileName);
}
finally
{
//if (!upToDate)
// logger.Write("Local publication", "Some files are more recents than the models", LogType.Warning);
if (logger != null)
{
logger.EndStep();
logger.EndProcess();
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowErrorList();
}
}
}
}
/// <summary>
/// Publication d'un modele
/// </summary>
/// <param name="model">Modèle à publier</param>
/// <param name="fileName">Fichier initial contenant le modèle</param>
/// <param name="promptWarning">Indique si il faut demander une confirmation à l'utilisateur</param>
/// <remarks>
/// Tout est mis dans un fichier compréssé.
/// </remarks>
public void PublishModel(CandleModel model, string fileName, bool promptWarning)
{
// La publication copie tous les artifacts dans le repository local puis le contenu de ce repository
// est ensuite publié sur le serveur distant.
// On publie tjs sur le serveur principal.
// TODO voir si on ne peut pas publier sur le serveur d'origine du modèle (metadata.ServerUrl) ????
IRepositoryProvider wsRepository = RepositoryManager.Instance.GetMainRemoteProvider();
PublishModelForm form = null;
if (promptWarning)
{
IDialogService service = ServiceLocator.Instance.GetService <IDialogService>();
if (service != null)
{
form = service.CreatePublishModelForm(wsRepository != null);
if (form.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
}
}
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.BeginProcess(false, true);
}
try
{
// Sauvegarde
ServiceLocator.Instance.ShellHelper.Solution.DTE.Documents.SaveAll();
Generator.NotifyPublishEvents(model, fileName, PublishEventType.BeforeLocal);
// On copie d'abord en local
PublishLocally(model, fileName);
// Certaines strategies peuvent effectuer des actions lors de la publication
Generator.NotifyPublishEvents(model, fileName, PublishEventType.AfterLocal);
bool publishOnServer = true;
if (form == null || !form.PublishOnServer)
{
if (logger != null)
{
logger.Write("Custom strategy publishing actions", String.Format("Model {0} published locally.", Path.GetFileName(fileName)), LogType.Info);
}
publishOnServer = false;
}
if (publishOnServer)
{
Generator.NotifyPublishEvents(model, fileName, PublishEventType.BeforeServer);
// Publication du repository local
PublishLocalModel(model);
Generator.NotifyPublishEvents(model, fileName, PublishEventType.AfterServer);
}
// Increment du numero de version du serveur
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Increment model number"))
{
model.Version++;
transaction.Commit();
}
// On sauvegarde la modif
ServiceLocator.Instance.ShellHelper.Solution.DTE.Documents.SaveAll();
Generator.NotifyPublishEvents(model, fileName, PublishEventType.EndPublish);
}
catch
{
Generator.NotifyPublishEvents(model, fileName, PublishEventType.PublishFailed);
if (logger != null)
{
logger.Write("PublishModel", "Model publication stopped", LogType.Error);
}
}
finally
{
if (logger != null)
{
logger.EndProcess();
}
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowErrorList();
}
}
}
/// <summary>
/// Création d'une dépendance avec une assembly importée
/// </summary>
/// <param name="asm">The asm.</param>
internal void InsertDependencies(Assembly asm)
{
// Gestion des dépendances
List <AssemblyName> referencedAssemblies = GetAssemblyListToCreate(asm);
if (referencedAssemblies.Count == 0)
{
return;
}
// On va demander de faire le mapping entre l'assembly et les modèles
// Fenetre permettant de trouver le lien entre une assembly et son modèle
ReferencedAssembliesForm form = new ReferencedAssembliesForm(this, referencedAssemblies.ToArray());
if (form.ShowDialog() == DialogResult.OK)
{
// Création des composants externes
List <ExternalComponent> externalComponents = new List <ExternalComponent>();
foreach (ComponentMetadataMap map in form.SelectedAssemblyBindings)
{
if (!map.AlreadyExists)
{
externalComponents.Add(map.CreateComponent(Component.Model));
}
}
// Puis création des relations avec eux
foreach (ExternalComponent externalComponent in externalComponents)
{
// Pour l'instant, on ne crée des références qu'avec des composants binaires
if (externalComponent == null || externalComponent.MetaData == null ||
externalComponent.MetaData.ComponentType != ComponentType.Library)
{
continue;
}
if (externalComponent.Ports.Count == 1)
{
if (ExternalServiceReference.GetLink(this, externalComponent.Ports[0]) == null)
{
ExternalServiceReference esr =
new ExternalServiceReference(this, externalComponent.Ports[0]);
esr.Scope = ReferenceScope.Runtime;
}
}
else if (externalComponent.Ports.Count > 1)
{
string assemblyName = asm.GetName().Name;
foreach (ExternalPublicPort port in externalComponent.Ports)
{
if (Utils.StringCompareEquals(port.Name, assemblyName) ||
Utils.StringCompareEquals(port.Parent.Name, assemblyName))
{
if (ExternalServiceReference.GetLink(this, port) == null)
{
ExternalServiceReference esr = new ExternalServiceReference(this, port);
esr.Scope = ReferenceScope.Runtime;
}
break;
}
}
}
else
{
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
ide.LogError(false, String.Format("Can not create relationship between {0} and {1}", this.Name, externalComponent.Name), 0, 0, "Import");
}
}
}
}
