/// <summary>
/// Handles the Click event of the properties control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void properties_Click(object sender, EventArgs e)
{
ComponentModelMetadata item = GetSelectedData();
RepositoryPropertiesForm dlg = new RepositoryPropertiesForm(item);
dlg.ShowDialog();
}
/// <summary>
/// Called when [model selected].
/// </summary>
/// <param name="repositoryItem">The repository item.</param>
private void OnModelSelected(ComponentModelMetadata repositoryItem)
{
if (ModelSelected != null)
{
ModelSelected(this, new ModelSelectedEventArgs(repositoryItem));
}
}
/// <summary>
/// Remplissage d'un noeud de l'arbre
/// </summary>
/// <param name="tvRoot">The tv root.</param>
/// <param name="data">The data.</param>
private static void PopulateNode(TreeNode tvRoot, ComponentModelMetadata data)
{
// Recherche de l'arborescence dans l'arbre actuel
string[] pathParts = data.Path.Split(DomainManager.PathSeparator);
TreeNode currentNode = tvRoot;
TreeNode tmpNode;
TreeNode[] tmp;
// Arborescence
foreach (string part in pathParts)
{
tmp = currentNode.Nodes.Find(part, false);
// Pas trouvé
if (tmp == null || tmp.Length == 0)
{
tmpNode = new TreeNode(part);
tmpNode.Name = part;
tmpNode.SelectedImageIndex = tmpNode.ImageIndex = 3;
currentNode.Nodes.Add(tmpNode);
}
else // trouvé
{
tmpNode = tmp[0];
}
currentNode = tmpNode;
}
// Ajout si nécessaire du nom de l'appli
tmp = currentNode.Nodes.Find(data.Name, false);
if (tmp == null || tmp.Length == 0)
{
tmpNode = new TreeNode(data.Name);
tmpNode.Name = data.Name;
tmpNode.SelectedImageIndex = tmpNode.ImageIndex = 3;
currentNode.Nodes.Add(tmpNode);
}
else
{
tmpNode = tmp[0];
}
currentNode = tmpNode;
// Puis ajout du noeud terminal : N° de version
tmp = currentNode.Nodes.Find(data.Version.ToString(3), false);
if (tmp == null || tmp.Length == 0)
{
tmpNode = new TreeNode();
currentNode.Nodes.Add(tmpNode);
}
else
{
tmpNode = tmp[0];
}
currentNode = tmpNode;
SetComponentNode(data, currentNode);
}
/// <summary>
/// Handles the NodeMouseDoubleClick event of the treeCtrl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Forms.TreeNodeMouseClickEventArgs"/> instance containing the event data.</param>
private static void treeCtrl_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Node.Tag != null && e.Node.Parent != null)
{
ComponentModelMetadata item = (ComponentModelMetadata)e.Node.Tag;
ExternalComponentShapeHelper.ShowModel(item);
}
}
/// <summary>
/// Handles the AfterSelect event of the treeCtrl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Forms.TreeViewEventArgs"/> instance containing the event data.</param>
private void treeCtrl_AfterSelect(object sender, TreeViewEventArgs e)
{
if (e.Node.Tag != null && e.Node.Parent != null)
{
ComponentModelMetadata item = (ComponentModelMetadata)e.Node.Tag;
OnModelSelected(item);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShowDocumentationCommand"/> class.
/// </summary>
/// <param name="obj">The obj.</param>
public ShowDocumentationCommand(object obj)
{
NodeShape shape = obj as NodeShape;
if (shape != null && shape.ModelElement is ExternalComponent)
{
_metadata = ((ExternalComponent)shape.ModelElement).MetaData;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentSig"/> struct.
/// </summary>
/// <param name="metadata">The metadata.</param>
public ComponentSig(ComponentModelMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
Id = metadata.Id;
Version = metadata.Version;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
StringBuilder sb = new StringBuilder();
ComponentModelMetadata metadata = CandleRepositoryController.Instance.GetMetadata(Request["id"], Request["version"]);
if (metadata != null)
{
ModelLoader loader = ModelLoader.GetLoader(metadata);
if (loader != null && loader.Model != null)
{
if (loader.Model.SoftwareComponent != null)
{
foreach (ServiceContract contract in loader.Model.SoftwareComponent.PublicContracts)
{
sb.AppendLine(@"<div class=""Contract"">");
// Nom du contrat
sb.AppendLine(String.Format(@"<div class=""ContractHeader"">{0}</div>", contract.FullName));
// Description
sb.AppendLine(String.Format(@"<div class=""ContractDescription"">{0}</div>", Server.HtmlEncode(contract.Comment)));
foreach (Operation op in contract.Operations)
{
// Operation
sb.AppendLine(@"<div class=""ContractOperation"">");
sb.AppendLine(String.Format(@"<div class=""ContractOperationHeader"">{0} {1}({2})</div>", Server.HtmlEncode(op.FullTypeName), op.Name, op.CreateParametersDefinition()));
sb.AppendLine(String.Format(@"<div class=""ContractOperationDesc"">{0}</div>", Server.HtmlEncode(op.Comment)));
// Arguments
sb.AppendLine(@"<div class=""ContractArguments"">");
sb.AppendLine(@"<div class=""ContractArgumentsHeader"">");
sb.AppendLine(@"<div class=""ContractArgumentsHeaderType"">Type</div>");
sb.AppendLine(@"<div class=""ContractArgumentsHeaderName"">Name</div>");
sb.AppendLine(@"<div class=""ContractArgumentsHeaderDesc"">Description</div>");
sb.AppendLine(@"</div>");
foreach (Argument arg in op.Arguments)
{
sb.AppendLine(@"<div class=""ContractArgumentItem"">");
sb.AppendLine(String.Format(@"<div class=""ContractArgumentItemType"">{0}</div>", Server.HtmlEncode(arg.FullTypeName)));
sb.AppendLine(String.Format(@"<div class=""ContractArgumentItemName"">{0}</div>", arg.Name));
sb.AppendLine(String.Format(@"<div class=""ContractArgumentItemDesc"">{0}</div>", Server.HtmlEncode(arg.Comment)));
sb.AppendLine("</div>");
}
sb.AppendLine(@"</div></div>");
}
}
}
}
}
lbCode.Text = sb.ToString();
}
}
/// <summary>
/// Affiche d'un modèle du repository
/// </summary>
/// <param name="metaData">The meta data.</param>
public static void ShowModel(ComponentModelMetadata metaData)
{
string targetFileName = RepositoryManager.Instance.ModelsMetadata.CopyModelInTemporaryFolder(metaData);
if (targetFileName != null)
{
ServiceLocator.Instance.ShellHelper.Solution.DTE.ItemOperations.OpenFile(targetFileName,
Constants.vsViewKindDesigner);
}
}
/// <summary>
/// Handles the Click event of the showDocumentation control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void showDocumentation_Click(object sender, EventArgs e)
{
ComponentModelMetadata item = GetSelectedData();
ShowDocumentationCommand cmd = new ShowDocumentationCommand(item);
if (cmd.Enabled)
{
cmd.Exec();
}
}
/// <summary>
/// Handles the Popup event of the menu control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void menu_Popup(object sender, EventArgs e)
{
ComponentModelMetadata item = GetSelectedData();
_propertiesMenuItem_.Visible = item != null;
_showDocumentationMenuItem.Visible = item != null;
_showDocumentationMenuItem.Enabled = item != null && !String.IsNullOrEmpty(item.DocUrl);
_getLastVersionMenuItem.Visible = item != null;
_publishMenuItem.Visible = _removeLocalMenuItem.Visible = item != null && item.Location == RepositoryLocation.Local;
}
/// <summary>
/// Chargement d'un modèle
/// </summary>
/// <param name="system"></param>
/// <returns></returns>
public static ModelLoader GetLoader(ExternalComponent system)
{
ComponentModelMetadata metaData = system.MetaData;
ModelLoader loader = GetLoader(metaData);
if (loader != null && loader.Model != null && loader.Model.SoftwareComponent != null)
{
loader.Model.SoftwareComponent.NamespaceResolver = new ExternalNamespaceProvider(system);
}
return(loader);
}
/// <summary>
/// Parcours d'un répertoire pour récupèrer les métadata des modèles
/// </summary>
/// <param name="directoryName">Name of the directory.</param>
/// <returns></returns>
private static List <ComponentModelMetadata> GetModelFromDirectory(string directoryName)
{
List <ComponentModelMetadata> items = new List <ComponentModelMetadata>();
foreach (string fileName in Utils.SearchFile(directoryName, ModelConstants.FilterExtension))
{
ComponentModelMetadata item = ComponentModelMetadata.RetrieveMetadata(fileName);
items.Add(item);
}
return(items);
}
/// <summary>
/// Handles the ItemDrag event of the treeCtrl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Forms.ItemDragEventArgs"/> instance containing the event data.</param>
private void treeCtrl_ItemDrag(object sender, ItemDragEventArgs e)
{
TreeNode node = e.Item as TreeNode;
if (node != null && node.Tag != null && node.Parent != null)
{
ComponentModelMetadata item = (ComponentModelMetadata)node.Tag;
RepositoryDataDragDrop data = new RepositoryDataDragDrop(item);
DoDragDrop(data, DragDropEffects.Copy);
}
}
/// <summary>
/// Handles the Click event of the getLastVersionMenuItem control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void getLastVersionMenuItem_Click(object sender, EventArgs e)
{
TreeNode node = _treeCtrl.SelectedNode;
ComponentModelMetadata metaData = GetSelectedData();
GetLastVersionCommand command = new GetLastVersionCommand(metaData, true);
command.Exec();
if (node != null)
{
node.EnsureVisible();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GetLastVersionCommand"/> class.
/// </summary>
/// <param name="metadata">The metadata.</param>
/// <param name="force">if set to <c>true</c> [force].</param>
public GetLastVersionCommand(ComponentModelMetadata metadata, bool force)
{
if (metadata != null)
{
this._force = force;
ModelLoader loader = ModelLoader.GetLoader(metadata);
if (loader != null)
{
_externalModel = loader.Model;
}
}
}
/// <summary>
/// Récupèration d'un fichier contenant un modèle
/// </summary>
/// <param name="metadata">Caractèristiques du modèle à charger</param>
/// <returns></returns>
public RepositoryServerItemStatus GetModel(ComponentModelMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
string url =
String.Format("{0}/services/DownloadFile.ashx?c={1}&p={2}", _baseUrl, RepositoryCategory.Models,
metadata.GetFileName(PathKind.Relative));
return(GetFile(url, metadata.GetFileName(PathKind.Absolute)));
}
protected void metadataRepeater_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
ComponentModelMetadata metadata = e.Item.DataItem as ComponentModelMetadata;
if (metadata == null)
{
return;
}
Label lbDomain = e.Item.FindControl("lbDomain") as Label;
Label lbDescription = e.Item.FindControl("lbDescription") as Label;
HyperLink link = e.Item.FindControl("lnkModel") as HyperLink;
link.NavigateUrl = String.Format("details.aspx?id={0}&version={1}", metadata.Id, metadata.Version);
Label lbName = e.Item.FindControl("lbName") as Label;
//LinkButton l = e.Item.FindControl("Option1") as LinkButton;
//l.CommandArgument = metadata.Id.ToString();
//l = e.Item.FindControl("Option2") as LinkButton;
//l.CommandArgument = metadata.Id.ToString();
//l = e.Item.FindControl("Option3") as LinkButton;
//l.CommandArgument = metadata.Id.ToString();
if (lastCategoryString != metadata.Path)
{
lbDomain.Text = metadata.Path.Replace('/', '>');
lastCategoryString = metadata.Path;
lastComponentName = null;
}
else
{
Panel p = e.Item.FindControl("pnlDomain") as Panel;
p.Visible = false;
lbDomain.Visible = false;
}
if (lastComponentName != metadata.Name)
{
lbName.Text = metadata.Name;
lastComponentName = metadata.Name;
}
else
{
lbName.Text = String.Empty;
}
link.Text = metadata.Version.ToString();
lbDescription.Text = metadata.Description;
}
/// <summary>
/// Publication
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void publish_Click(object sender, EventArgs e)
{
TreeNode node = _treeCtrl.SelectedNode;
ComponentModelMetadata item = GetSelectedData();
if (item != null)
{
ModelLoader loader = ModelLoader.GetLoader(item.GetFileName(PathKind.Absolute), true);
if (loader != null && loader.Model != null)
{
RepositoryManager.Instance.ModelsMetadata.PublishLocalModel(loader.Model);
if (node != null)
{
node.EnsureVisible();
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
ComponentModelMetadata metadata = CandleRepositoryController.Instance.GetMetadata(Request["id"], Request["version"]);
if (metadata != null)
{
if (!String.IsNullOrEmpty(metadata.DocUrl))
{
pnlDoc.Text = String.Format(@"<iframe scrolling=""auto"" src=""{0}""/>", metadata.DocUrl);
}
else
{
tabDoc.Visible = false;
}
lstArtifacts.DataSource = CandleRepositoryController.Instance.GetArtifacts(metadata);
lstArtifacts.DataBind();
}
}
//private void ShowFromTemporaryFolder(string physicalModelFileName, string relativeModelFileName)
//{
//}
/// <summary>
/// Tries to show.
/// </summary>
/// <param name="model">The model.</param>
public static void TryToShow(ExternalComponent model)
{
// Si le système n'est pas encore défini, on va demander à l'utilisateur d'en choisir un
// dans le référentiel ou d'en créer un nouveau.
ComponentModelMetadata metaData = model.MetaData;
if (metaData == null)
{
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Select model"))
{
if (RepositoryManager.Instance.ModelsMetadata.SelectModel(model, out metaData))
{
transaction.Commit();
}
}
return;
}
ShowModel(metaData);
}
//public List<RepositoryItem> GetAllVersionsForApplication(string path, string name)
//{
// DirectoryInfo di = new DirectoryInfo( Path.Combine( _modelPath, name) );
// if (di.Exists)
// {
// return GetModelFromDirectory(di.FullName);
// }
// else
// {
// di.Create();
// }
// return new List<RepositoryItem>();
//}
/// <summary>
/// Gets the model metadata.
/// </summary>
/// <param name="modelId">The model id.</param>
/// <param name="version">The version.</param>
/// <returns></returns>
public ComponentModelMetadata GetModelMetadata(Guid modelId, VersionInfo version)
{
if (modelId == Guid.Empty || version == null)
{
return(null);
}
string path = Path.Combine(_modelPath, Path.Combine(modelId.ToString(), version.ToString()));
// Recherche du modèle
if (Directory.Exists(path))
{
string[] fileName = Directory.GetFiles(path, ModelConstants.FilterExtension);
if (fileName.Length > 0)
{
return(ComponentModelMetadata.RetrieveMetadata(fileName[0]));
}
}
return(null);
}
/// <summary>
/// Initialisation du noeud terminal
/// </summary>
/// <param name="data">The data.</param>
/// <param name="tvNode">The tv node.</param>
private static void SetComponentNode(ComponentModelMetadata data, TreeNode tvNode)
{
tvNode.Name = data.Version.ToString(3);
tvNode.Text = String.Format("{0} ({1})", data.Version.ToString(), data.Location);
tvNode.SelectedImageIndex = tvNode.ImageIndex = data.IsLastVersion() ? 4 : 0;
if (!String.IsNullOrEmpty(data.Description))
{
if (data.Description.Length > 50)
{
tvNode.Text = String.Format("{0} - {1}...", tvNode.Text, data.Description.Substring(0, 50));
}
else
{
tvNode.Text += " - " + data.Description;
}
}
tvNode.Tag = data;
tvNode.ToolTipText = data.Description;
}
/// <summary>
/// Suppression locale
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void removeLocal_Click(object sender, EventArgs e)
{
TreeNode node = _treeCtrl.SelectedNode;
ComponentModelMetadata item = GetSelectedData();
if (item != null)
{
RepositoryManager.Instance.ModelsMetadata.RemoveModelInLocalRepository(item);
if (item.ExistsOnServer)
{
if (node != null)
{
node.EnsureVisible();
}
}
else
{
node.Remove();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShowPropertiesCommand"/> class.
/// </summary>
/// <param name="shape">The shape.</param>
public ShowPropertiesCommand(object shape)
{
if (shape == null)
{
return;
}
ExternalComponent ext = ((PresentationElement)shape).ModelElement as ExternalComponent;
if (ext != null)
{
_metadata = ext.MetaData;
return;
}
CandleModel model = ((PresentationElement)shape).ModelElement as CandleModel;
if (model != null)
{
_metadata = model.MetaData;
}
}
/// <summary>
/// Chargement du modèle (Récupèration sur le serveur si il n'est pas présent)
/// </summary>
/// <param name="metaData"></param>
/// <returns></returns>
public static ModelLoader GetLoader(ComponentModelMetadata metaData)
{
if (metaData == null)
{
return(null);
}
string fileName = metaData.GetFileName(PathKind.Absolute);
bool enableCache = true;
string tmpFileName = null;
// Si le modèle n'est pas présent en local, on le récupère dans un endroit temporaire pour pouvoir le charger en
// mémoire. Ceci est nécessaire car le chargement de ce modèle sert juste à vérifier si il est à jour sur le serveur
// pour pouvoir ensuite demander à l'utilisateur si il veut le charger. Si on le charge directement dans le repository
// local, on court-circuite le choix de l'utilisateur.
if (!File.Exists(fileName))
{
enableCache = false; // Pas de mis en cache pour un modèle temporaire
// On supprime le fichier temporaire sinon il posséde une date qui fait croire, lors de
// la récupération du modèle sur le serveur, que le fichier en local est plus récent.
fileName = tmpFileName = Path.GetTempFileName();
Utils.DeleteFile(fileName);
RepositoryManager.Instance.GetFileFromRepository(RepositoryCategory.Models,
metaData.GetFileName(PathKind.Relative), tmpFileName);
}
try
{
return(GetLoader(fileName, enableCache));
}
finally
{
// On nettoie le fichier temporaire
Utils.DeleteFile(tmpFileName);
}
}
/// <summary>
/// Liste des artifacts d'un modèle
/// </summary>
/// <param name="metadata"></param>
/// <returns></returns>
public List <string> GetArtifacts(ComponentModelMetadata metadata)
{
ComponentSig sig = new ComponentSig(metadata);
List <string> artifacts;
if (!_artifactsCache.TryGetValue(sig, out artifacts))
{
ModelLoader loader = ModelLoader.GetLoader(metadata);
if (loader != null && loader.Model != null)
{
ReferenceWalker walker = new ReferenceWalker(ReferenceScope.Publish, new ConfigurationMode("*"));
ReferenceVisitor visitor = new ReferenceVisitor(ReferenceScope.Publish);
walker.Traverse(visitor, loader.Model);
artifacts = new List <string>();
foreach (string artifactFileName in visitor.References)
{
artifacts.Add(Path.GetFileName(artifactFileName));
}
}
_artifactsCache.Add(sig, artifacts);
}
return(artifacts);
}
/// <summary>
/// Ajoute une référence sur un modèle externe.
/// </summary>
/// <param name="modelId">The model id.</param>
/// <param name="displayName">The display name.</param>
/// <param name="version">Version désirée ou null</param>
/// <returns></returns>
/// <remarks>
/// Si la référence existe dans le référentiel avec le bon numèro de version,
/// on rajoute la référence si le numéro de version n'est pas précisé ou n'est pas
/// présent dans le référentiel, on affiche la boite de dialogue de sélection
/// si ce n'est toujours pas bon, on rajoute la référence en tant que référence
/// classique statique.
/// </remarks>
protected ExternalComponent AddExternalModel(Guid modelId, string displayName, VersionInfo version)
{
ExternalComponent externalComponent = this.Component.Model.FindExternalComponent(modelId);
if (externalComponent != null)
{
return(externalComponent);
}
// Recherche le modèle dans le repository
ComponentModelMetadata metadata = RepositoryManager.Instance.ModelsMetadata.Metadatas.Find(modelId, version);
if (metadata != null)
{
// Ok on l'a trouvé
using (Transaction transaction = this.Store.TransactionManager.BeginTransaction("Add external component"))
{
externalComponent = metadata.CreateComponent(this.Component.Model);
transaction.Commit();
return(externalComponent);
}
}
else
{
// Pas trouvé
ReferencedAssembliesForm form = new ReferencedAssembliesForm(modelId, displayName, version, null);
if (form.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
if (form.SelectedAssemblyBindings.Count > 0)
{
return(form.SelectedAssemblyBindings[0].CreateComponent(this.Component.Model));
}
}
}
return(null);
}
/// <summary>
/// Execute the command
/// </summary>
public void Exec()
{
// Affiche la fenetre de dialogue permettant de choisir les assemblies
IAssemblySelectorDialog selector = ServiceLocator.Instance.GetService <IAssemblySelectorDialog>();
if (selector.ShowDialog(1)) // Une seule sélection possible
{
Assembly asm = selector.SelectedAssemblies[0];
using (Transaction transaction = _element.Store.TransactionManager.BeginTransaction("Update model version"))
{
// Mise à jour de la version du composant et son emplacement initial
// et création des nouvelles dépendances (les dépendances actuelles ne seront pas touchées
// mais il faudra s'assurer qu'elles soient bien à jour car la procédure ne vérifie que le nom
// et ignore la version)
_element.InitFromAssembly(asm, true /* creation des nouvelles dépendances*/);
transaction.Commit();
}
// Vérification si les assemblies existantes possédent la bonne version
foreach (AssemblyName assemblyName in asm.GetReferencedAssemblies())
{
// On ignore les assemblies systèmes
if (Utils.StringCompareEquals(assemblyName.Name, "mscorlib") ||
assemblyName.Name.StartsWith("System", StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
// On regarde si cette assembly existe déjà dans le modèle
DotNetAssembly eam = _element.Component.FindDotNetAssemblyModelFromAssembly(assemblyName);
if (eam != null)
{
if (!assemblyName.Version.Equals((Version)eam.Version))
{
using (Transaction transaction = _element.Store.TransactionManager.BeginTransaction("Update assembly version"))
{
eam.Version = new VersionInfo(assemblyName.Version);
transaction.Commit();
}
}
}
else
{
// Idem pour les composants externes
ExternalComponent esm = _element.Component.Model.FindExternalComponentByName(assemblyName.Name);
if (esm != null && esm.MetaData != null && esm.MetaData.ComponentType == ComponentType.Library)
{
if (!assemblyName.Version.Equals((Version)esm.Version))
{
// Recherche si il existe un modèle avec la bonne version
List <ComponentModelMetadata> versions = RepositoryManager.Instance.ModelsMetadata.Metadatas.GetAllVersions(esm.Id);
ComponentModelMetadata metadata = versions.Find(delegate(ComponentModelMetadata m) { return(assemblyName.Version.Equals(m.Version)); });
using (Transaction transaction = _element.Store.TransactionManager.BeginTransaction("Update model version"))
{
if (metadata != null)
{
// OK on met a jour
esm.Version = metadata.Version;
}
else // erreur On a pas trouvé de modéle
{
// Sauvegarde de la bonne version
esm.Version = new VersionInfo(assemblyName.Version);
// On force à null pour obliger l'utilisateur à sélectionner un
// modéle
esm.ModelMoniker = Guid.Empty;
}
transaction.Commit();
}
}
}
}
}
// Demande si il faut aussi mettre à jour le n° de version du composant
if (_element.Visibility == Visibility.Public)
{
if (MessageBox.Show(String.Format("Do you want to change the current version of the component from {0} to {1}",
_element.Component.Model.Version, _element.Version), "Component version change", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
using (Transaction transaction = _element.Store.TransactionManager.BeginTransaction("Update model version"))
{
_element.Component.Model.Version = _element.Version;
transaction.Commit();
}
}
}
}
}
public List <string> GetArtifacts(ComponentModelMetadata metadata)
{
return(_cache.GetArtifacts(metadata));
}
