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