/// <summary>
/// Récupération d'un modèle dans un répertoire temporaire pour visualisation
/// </summary>
/// <param name="metaData"></param>
/// <returns></returns>
public string CopyModelInTemporaryFolder(ComponentModelMetadata metaData)
{
if (metaData == null)
{
return(null);
}
// Si le modéle n'existe pas dans le repository local, on le récupère dans un répertoire
// temporaire pour ne pas polluer le répertoire local.
string basePath = Utils.GetTemporaryFolder();
string targetFileName = Path.Combine(basePath, metaData.GetFileName(PathKind.Relative));
if (!metaData.ExistsLocally)
{
if (!GetModelInFolder(basePath, metaData))
{
ServiceLocator.Instance.IDEHelper.ShowError("Model file name does not exist.");
return(null);
}
}
else
{
// Si le modèle est présent en local, on le copie pour le rendre read-only
Utils.CopyDirectory(Path.GetDirectoryName(metaData.GetFileName(PathKind.Absolute)), Path.GetDirectoryName(targetFileName));
}
// Récupération du modèle dans un fichier temporaire pour pouvoir l'éditer
if (File.Exists(targetFileName))
{
File.SetAttributes(targetFileName, FileAttributes.ReadOnly);
return(targetFileName);
}
return(null);
}
/// <summary>
/// Publication du modèle sur le serveur
/// </summary>
/// <param name="model"></param>
public void PublishLocalModel(CandleModel model)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.BeginProcess(false, true);
logger.BeginStep("Publish on remote server", LogType.Info);
}
try
{
// On récupère ses métadonnées
ComponentModelMetadata data = model.MetaData;
if (data != null)
{
//if( !data.IsLastVersion())
//{
// if (System.Windows.Forms.MessageBox.Show("You want to publish an older version than the server. Do you want to continue ?", "Warning", System.Windows.Forms.MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.Cancel)
// return;
//}
ModelLoader.Save(model, data.GetFileName(PathKind.Absolute));
// On prend tout ce qu'il y a dans le repository local (==> Il faut que la publication locale
// se fasse obligatoirement chaque fois avant )
string[] fileNames = System.IO.Directory.GetFiles(System.IO.Path.GetDirectoryName(data.GetFileName(PathKind.Absolute)));
PublishZip(model, new List <string>(fileNames), ZipFileName);
// Mise à jour des métadatas
Metadatas.SetMetadataPublished(data, model);
if (logger != null)
{
logger.Write("Publish on remote server", "Published on remote server ", LogType.Info);
}
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Publish on remote server ", "Publish on remote server", ex);
}
}
finally
{
if (logger != null)
{
logger.EndStep();
logger.EndProcess();
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowErrorList();
}
}
}
}
/// <summary>
/// Indique qu'un modèle vient d'être publié
/// </summary>
/// <param name="data">The data.</param>
/// <param name="model">The model.</param>
internal void SetMetadataPublished(ComponentModelMetadata data, CandleModel model)
{
data.ServerVersion = data.LocalVersion = model.Version.Revision;
MetadataChangedEventArg e = new MetadataChangedEventArg(data);
OnMetadataChanged(e);
}
/// <summary>
/// Fusion avec un les metadatas existantes
/// </summary>
/// <param name="origin">Indique l'origine de la metadata à fusionner</param>
/// <param name="metadata">Metadata à fusionner</param>
public void Merge(RepositoryLocation origin, ComponentModelMetadata metadata)
{
Debug.Assert(_models != null);
List <ComponentModelMetadata> list = new List <ComponentModelMetadata>();
list.Add(metadata);
Merge(origin, list);
}
/// <summary>
/// Indique qu'un modèle a été chargé en local
/// </summary>
/// <param name="metaData">The meta data.</param>
internal void SetMetadataLoaded(ComponentModelMetadata metaData)
{
metaData.Location = RepositoryLocation.Local;
metaData.LocalVersion = metaData.ServerVersion;
MetadataChangedEventArg e = new MetadataChangedEventArg(metaData);
OnMetadataChanged(e);
}
/// <summary>
/// Lecture des metadonnées d'un modéle
/// </summary>
/// <param name="fileName">Chemin absolu du fichier contenant le modèle</param>
/// <returns>Ne renvoit jamais null</returns>
internal static ComponentModelMetadata RetrieveMetadata(string fileName)
{
ComponentModelMetadata item = new ComponentModelMetadata();
UpdateMetadata(item, fileName);
item.LocalVersion = -1;
item.ServerVersion = item._version.Revision;
return(item);
}
/// <summary>
/// Comparaison de 2 metadata
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj == null || !(obj is ComponentModelMetadata))
{
return(false);
}
ComponentModelMetadata other = obj as ComponentModelMetadata;
return(_id == other._id && _version.Equals(other._version));
}
/// <summary>
/// Suppression d'un modele en local
/// </summary>
/// <param name="data"></param>
public void RemoveModelInLocalRepository(ComponentModelMetadata data)
{
if (data == null)
{
return;
}
Metadatas.RemoveLocal(data);
//Suppression physique du répertoire local
Utils.RemoveDirectory(System.IO.Path.GetDirectoryName(data.GetFileName(PathKind.Absolute)));
}
/// <summary>
/// Chargement du modèle en local
/// </summary>
/// <param name="metaData"></param>
public bool GetModelInLocalRepository(ComponentModelMetadata metaData)
{
if (metaData == null)
{
return(false);
}
if (GetModelInFolder(RepositoryManager.GetFolderPath(RepositoryCategory.Models), metaData))
{
Metadatas.SetMetadataLoaded(metaData);
return(true);
}
return(false);
}
/// <summary>
/// Mise à jour à partir d'un modèle local
/// </summary>
/// <param name="data">The data.</param>
/// <param name="fileName">Name of the file.</param>
internal void Update(ComponentModelMetadata data, string fileName)
{
if (data != null)
{
ComponentModelMetadata.UpdateMetadata(data, fileName);
}
else
{
data = ComponentModelMetadata.RetrieveMetadata(fileName);
Merge(RepositoryLocation.Local, data);
data = Find(data.Id, data.Version);
}
MetadataChangedEventArg e = new MetadataChangedEventArg(data);
OnMetadataChanged(e);
}
/// <summary>
/// Suppression de la liste
/// </summary>
/// <param name="metadata">The metadata.</param>
public void RemoveLocal(ComponentModelMetadata metadata)
{
// Si le modèle existe sur le serveur, on met à jour les metadata sans les supprimer
if (metadata.ExistsOnServer)
{
metadata.Location = RepositoryLocation.Server;
metadata.Version.Revision = metadata.ServerVersion;
metadata.LocalVersion = -1;
}
else
{
// Si il n'existe pas sur le serveur, il n'y a pas de raison de le garder
GetMetadatas().Remove(metadata);
}
MetadataChangedEventArg e = new MetadataChangedEventArg(metadata);
OnMetadataChanged(e);
}
/// <summary>
/// Récupére un modèle dans un répertoire
/// </summary>
/// <param name="basePath">The base path.</param>
/// <param name="metaData">The meta data.</param>
/// <returns></returns>
private static bool GetModelInFolder(string basePath, ComponentModelMetadata metaData)
{
// Si le modèle est plus récent en local, on demande à le récupérer
// Non si l'utilisateur veut la dernière version, il doit faire un getlastversion
//if (metaData.IsLastVersion())
//{
// using (ModelSynchronizationForm confirm = new ModelSynchronizationForm(metaData))
// {
// if (confirm.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
// return null;
// if (confirm.ServerVersionSelected)
// RepositoryManager.Instance.ModelsMetadata.GetModelInLocalRepository(metaData);
// }
//}
IRepositoryProvider wsProvider = RepositoryManager.Instance.GetRemoteProvider(metaData.ServerUrl);
if (wsProvider != null)
{
// Récupération et extraction du modele
string zipFilePath = metaData.GetFileName(PathKind.Relative);
zipFilePath = Path.Combine(Path.GetDirectoryName(zipFilePath), ZipFileName);
RepositoryFile rfi = new RepositoryFile(Path.Combine(basePath, zipFilePath), RepositoryCategory.Models, zipFilePath);
// Extraction
string fullPath = rfi.LocalPhysicalPath;
string folder = Path.GetDirectoryName(fullPath);
// Si il existe en local (si il a bien été récupéré, on le décompresse)
if (File.Exists(fullPath))
{
RepositoryZipFile zipFile = new RepositoryZipFile(fullPath, false);
zipFile.ExtractAll(folder);
return(true);
}
}
return(false);
}
/// <summary>
/// Fusion entre les metadata locales et distantes
/// </summary>
/// <param name="origin">The origin.</param>
/// <param name="list">Liste des metadata à fusionner avec celles existantes</param>
public void Merge(RepositoryLocation origin, List <ComponentModelMetadata> list)
{
if (list == null)
{
return;
}
// Parcours des metadatas à fusionner
foreach (ComponentModelMetadata item in list)
{
// Recherche parmi celle existante (on n'utilise pas la méthode FindWithPartialVersion car celle-ci appele
// GetMetadata qui utilise Merge en interne). On se base sur la liste des modèles actuelles
ComponentModelMetadata cmm =
_models.Find(
delegate(ComponentModelMetadata m) { return(m.Id == item.Id && item.Version.Equals(m.Version, 3)); }
);
// Il n'existe pas dèja
if (cmm == null)
{
// On le rajoute
_models.Add(item);
// On met à jour les n° de version en partant du principe que un metadata
// à sa version serveur initialisé par défaut.
if (origin == RepositoryLocation.Server)
{
item.Location = RepositoryLocation.Server;
// On garde la version serveur et on indique qu'il n'y a rien en local
item.LocalVersion = -1; // Rien en local
}
else
{
// On est en local. On prend la version serveur initialisé pour mettre à jour la version locale
item.LocalVersion = item.ServerVersion;
// Et on indique qu'il n'y a rien sur le serveur
item.ServerVersion = -1;
}
}
else // Fusion
{
// On met à jour un metadata qui vient du serveur
if (origin == RepositoryLocation.Server)
{
// Le référentiel ne retourne que des informations considérées comme locales
// donc on met à jour l'information serveur maintenant.
// Les infos du serveur priment
cmm.Path = item.Path;
cmm.Name = item.Name;
if (!String.IsNullOrEmpty(item.Description))
{
cmm.Description = item.Description;
}
cmm.ModelFileName = item.ModelFileName;
cmm.ServerUrl = item.ServerUrl;
if (!String.IsNullOrEmpty(item.TestBaseAddress))
{
cmm.TestBaseAddress = item.TestBaseAddress;
}
if (!String.IsNullOrEmpty(item.DocUrl))
{
cmm.DocUrl = item.DocUrl;
}
cmm.ServerVersion = item.ServerVersion;
}
else // On est en local
{
cmm.ModelFileName = item.ModelFileName;
cmm.LocalVersion = item.ServerVersion; // Initialisation de la version locale
cmm.Location = RepositoryLocation.Local;
}
}
}
}
/// <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>
/// Initializes a new instance of the <see cref="RepositoryPropertiesForm"/> class.
/// </summary>
/// <param name="metadata">The metadata.</param>
public RepositoryPropertiesForm(ComponentModelMetadata metadata)
{
_metadata = metadata;
InitializeComponent();
}
/// <summary>
/// Mise à jour des métadata à partir du modèle
/// </summary>
/// <param name="item">Metadata à mettre à jour</param>
/// <param name="fileName">Fichier contenant le modèle</param>
internal static void UpdateMetadata(ComponentModelMetadata item, string fileName)
{
item.ModelFileName = System.IO.Path.GetFileName(fileName);
ModelLoader loader = null;
try
{
// Chargement du modèle pour récupèrer les metadata
ModelLoader.ClearCache(fileName);
loader = ModelLoader.GetLoader(fileName, true);
item.Id = loader.Model.Id;
item.Version = loader.Model.Version ?? new VersionInfo();
item.Name = loader.Model.Name;
item.Path = loader.Model.Path;
item.DocUrl = loader.Model.Url ?? String.Empty;
item.TestBaseAddress = loader.Model.BaseAddress ?? String.Empty;
item.Description = loader.Model.Comment ?? String.Empty;
item.ComponentType = loader.Model.ComponentType;
item.Location = RepositoryLocation.Local; // Toujours
//item.ServerVersion = item.version.Revision;
item.Visibility = loader.Model.Visibility;
//item.LocalVersion = -1;
}
catch (Exception ex)
{
try
{
// On essaye de déduire le n° de version à partir du nom de fichier.
// Idem pour l'id
string v = System.IO.Path.GetDirectoryName(fileName);
string[] parts = v.Split(System.IO.Path.DirectorySeparatorChar);
if (parts.Length > 2)
{
item.Version = VersionInfo.TryParse(parts[parts.Length - 1]);
item.Id = new Guid(parts[parts.Length - 2]);
}
}
catch
{
item.Id = Guid.NewGuid();
item.Version = new VersionInfo();
}
item.DocUrl = String.Empty;
if (ModelLoader.LastSerializationResult != null && ModelLoader.LastSerializationResult.Failed)
{
StringBuilder sb = new StringBuilder(ex.Message);
foreach (SerializationMessage msg in ModelLoader.LastSerializationResult)
{
sb.AppendLine(String.Format("{0} at {1},{2}", msg.Message, msg.Line, msg.Column));
}
item.Description = sb.ToString();
}
else
{
item.Description = ex.Message;
}
item.ServerVersion = -1;
item.Location = RepositoryLocation.Local; // Toujours
item.Name = String.Format("Loading error : {0}", System.IO.Path.GetFileNameWithoutExtension(fileName));
item.Path = "????";
item.Visibility = Visibility.Public;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataChangedEventArg"/> class.
/// </summary>
/// <param name="metadata">The metadata.</param>
public MetadataChangedEventArg(ComponentModelMetadata metadata)
{
this.metadata = metadata;
}
/// <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();
}
}
}
}