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