/// <summary>
/// Called when [deactivated].
/// </summary>
/// <param name="finish">if set to <c>true</c> [finish].</param>
/// <returns></returns>
public override bool OnDeactivated(bool finish)
{
Wizard.SetUserData(_strategiesKey, _initialStrategy);
string template = SelectedModel;
if (template != null)
{
string temp = Path.GetTempFileName();
try
{
if (
RepositoryManager.Instance.GetFileFromRepository(RepositoryCategory.Configuration, template,
temp))
{
ModelLoader loader = ModelLoader.GetLoader(temp, false);
if (loader != null && loader.Model != null)
{
Wizard.SetUserData(_strategiesKey, loader.Model.StrategyTemplate);
}
}
}
finally
{
Utils.DeleteFile(temp);
}
}
return(base.OnDeactivated(finish));
}
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>
/// 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>
/// Gets all dependencies.
/// </summary>
/// <returns></returns>
public static List <DependencyGraphVisitor.RelationShip> GetAllDependencies()
{
List <CandleModel> models = new List <CandleModel>();
foreach (ComponentModelMetadata md in RepositoryManager.Instance.ModelsMetadata.Metadatas)
{
ModelLoader loader = ModelLoader.GetLoader(md);
if (loader != null && loader.Model != null)
{
models.Add(loader.Model);
}
}
return(GetDependencies(models.ToArray()));
}
/// <summary>
/// Création de l'arbre d'héritage
/// </summary>
/// <returns></returns>
private void CreateInheritanceTree()
{
// C'est la racine
_classInheritanceRootNode = new ClassInheritanceNode(null, false);
// On commence par charger les modèles référencés
foreach (ExternalComponent sys in _modelsLayer.Component.Model.ExternalComponents)
{
ModelLoader proxy = ModelLoader.GetLoader(sys);
if (proxy != null && proxy.DataLayer != null)
{
CreateInheritanceTreeFromModel(proxy.DataLayer, _classInheritanceRootNode, true);
}
}
// Puis le modèle en cours
CreateInheritanceTreeFromModel(_modelsLayer, _classInheritanceRootNode, false);
}
/// <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();
}
}
}
}
/// <summary>
/// Execute the command
/// </summary>
public void Exec()
{
if (_model == null)
{
ModelLoader loader = ModelLoader.GetLoader(_fileName, true);
if (loader != null)
{
_model = loader.Model;
}
}
if (!String.IsNullOrEmpty(_model.Path) && _model.Version != null && !String.IsNullOrEmpty(_model.Name))
{
RepositoryManager.Instance.ModelsMetadata.PublishModel(_model, _fileName, true);
}
else
{
ServiceLocator.Instance.IDEHelper.ShowMessage("The path, version and name properties must be provided to publish the model");
}
}
/// <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>
/// 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>
/// 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();
}
}
}