Exemplo n.º 1
0
        /// <summary>
        /// Publication d'un modele en tant que template
        /// </summary>
        /// <param name="modelFileName"></param>
        /// <param name="remoteName"></param>
        /// <param name="strategiesFileName"></param>
        /// <param name="remoteStrategiesFileName"></param>
        /// <remarks>
        /// Tout est mis dans un fichier compréssé.
        /// </remarks>
        public void PublishModelAsTemplate(string modelFileName, string remoteName, string strategiesFileName, string remoteStrategiesFileName)
        {
            ILogger             logger             = ServiceLocator.Instance.GetService <ILogger>();
            IRepositoryProvider repositoryProvider = RepositoryManager.Instance.GetMainRemoteProvider();

            // On peut publier en local ou à distance
            PublishModelForm form    = null;
            IDialogService   service = ServiceLocator.Instance.GetService <IDialogService>();

            if (service != null)
            {
                form = service.CreatePublishModelForm(repositoryProvider != null);
                if (form.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
                {
                    return;
                }
            }

            // Choix du provider de publication
            if (form == null || !form.PublishOnServer)
            {
                repositoryProvider = RepositoryManager.Instance.GetLocalProvider();
            }

            if (logger != null)
            {
                logger.BeginProcess(false, true);
                logger.BeginStep("Publish as template", LogType.Info);
            }

            try
            {
                // Le fichier des strategies
                if (!String.IsNullOrEmpty(remoteStrategiesFileName))
                {
                    remoteStrategiesFileName = Path.GetFileName(remoteStrategiesFileName);
                    if (repositoryProvider != null)
                    {
                        repositoryProvider.PublishFile(strategiesFileName, RepositoryCategory.Configuration, String.Format("Strategies/{0}{1}", remoteStrategiesFileName, StrategyManager.DefaultStrategiesFileNameExtension));
                    }
                }

                // Le modèle
                if (remoteName != null)
                {
                    remoteName = Path.GetFileName(remoteName);

                    // Le fichier modèle
                    string tempFile = Path.GetTempFileName();
                    try
                    {
                        File.Copy(modelFileName, tempFile, true);
                        ModelLoader loader = ModelLoader.GetLoader(tempFile, false);
                        using (Transaction transaction = loader.Model.Store.TransactionManager.BeginTransaction("set properties"))
                        {
                            // Modification du nom pour qu'on puisse le remplacer lors de l'initialisation (voir LayerNameChangeRule)
                            loader.Model.Component.Namespace = "?";
                            loader.Model.Component.Name      = "?";
                            loader.Model.Name = String.Empty;

                            loader.Model.StrategyTemplate = Path.GetFileName(remoteStrategiesFileName);

                            foreach (SoftwareLayer layer in loader.Model.SoftwareComponent.Layers)
                            {
                                layer.Namespace = "?";
                            }

                            // Le fichier stratégie associé
                            if (!String.IsNullOrEmpty(remoteStrategiesFileName))
                            {
                                loader.Model.StrategyTemplate = Path.GetFileNameWithoutExtension(remoteStrategiesFileName);
                            }

                            transaction.Commit();
                        }

                        loader.Save(tempFile);

                        if (repositoryProvider != null)
                        {
                            repositoryProvider.PublishFile(tempFile, RepositoryCategory.Configuration, String.Format("Models/{0}{1}", remoteName, ModelConstants.FileNameExtension));
                        }
                    }
                    finally
                    {
                        File.Delete(tempFile);
                    }

                    // Liste des diagrammes dans le repository local
                    string diagramFilter = String.Format("{0}.diagram", Path.GetFileName(modelFileName));
                    foreach (string diagramFile in Directory.GetFiles(Path.GetDirectoryName(modelFileName), diagramFilter))
                    {
                        if (repositoryProvider != null)
                        {
                            repositoryProvider.PublishFile(diagramFile, RepositoryCategory.Configuration, String.Format("Models/{0}{1}{2}", remoteName, ModelConstants.FileNameExtension, ".diagram"));
                        }
                    }
                }

                if (logger != null)
                {
                    logger.Write("Publish template", "published", LogType.Info);
                }
            }
            catch (Exception ex)
            {
                if (logger != null)
                {
                    logger.WriteError("Publish template", "Publish template", ex);
                }
            }
            finally
            {
                if (logger != null)
                {
                    logger.EndStep();
                    logger.EndProcess();
                }
            }
        }
Exemplo n.º 2
0
        /// <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();
                }
            }
        }