/// <summary>
/// Liste de tous les types disponibles dans le modèle
/// </summary>
/// <param name="sourceLayer">Source à partir duquel on veut récupérer les types (null pour récupérer à partir du modelsLayer)</param>
/// <param name="includeExternalTypes">Indique si on doit inclure les types externes</param>
/// <returns></returns>
public IList <DataType> GetAllTypes(SoftwareLayer sourceLayer, bool includeExternalTypes)
{
List <DataType> types = new List <DataType>();
foreach (Package package in this.Packages)
{
foreach (DataType clazz in package.Types)
{
types.Add(clazz);
}
}
if (includeExternalTypes)
{
// Référence entre les couches modèles
List <Guid> models = new List <Guid>();
foreach (ExternalComponent sys in this.ReferencedExternalComponents)
{
CandleModel model = sys.ReferencedModel;
if (model != null && model.DataLayer != null)
{
models.Add(model.Id);
types.AddRange(model.DataLayer.AllTypes);
}
}
if (sourceLayer != null)
{
ExternalDataLayerVisitor visitor = new ExternalDataLayerVisitor(types, models);
ReferenceWalker walker = new ReferenceWalker(ReferenceScope.Compilation, new ConfigurationMode());
walker.Traverse(visitor, sourceLayer);
}
}
return(types);
}
/// <summary>
/// Initializes a new instance of the <see cref="GenerationContext"/> class.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="modelFileName">Name of the model file.</param>
/// <param name="selectedModel">The selected model.</param>
public GenerationContext(CandleModel model, string modelFileName, Guid selectedModel)
{
_model = model;
_modelFileName = modelFileName;
_selectedModel = selectedModel;
_mode = new ConfigurationMode();
}
/// <summary>
///
/// </summary>
/// <param name="fileName"></param>
/// <param name="isReload"></param>
/// <returns></returns>
protected override int LoadDocData(string fileName, bool isReload)
{
int result = base.LoadDocData(fileName, isReload);
// Initialisation des stratégies
CandleModel model = CandleModel.GetInstance(this.Store);
StrategyManager.GetInstance(this.Store);
// Execution du wizard d'initialisation (voir commentaire dans SoftwareComponentInsertRule
if (model != null && model.SoftwareComponent != null && model.Name == "?")
{
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Component initialization"))
{
DSLFactory.Candle.SystemModel.Rules.SoftwareComponentInsertRule.ShowComponentWizard(model.SoftwareComponent);
transaction.Commit();
}
}
Mapper.Instance.SetModel(model, fileName);
// Force la validation du modèle - NON Validation sur open
// model.ValidateReferences(new Microsoft.VisualStudio.Modeling.Validation.ValidationContext(Microsoft.VisualStudio.Modeling.Validation.ValidationCategories.Open, model));
Mapper.Instance.RegisterEvents();
return(result);
}
/// <summary>
/// Saves the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns></returns>
public static bool Save(CandleModel model, string fileName)
{
Microsoft.VisualStudio.Modeling.SerializationResult result =
new Microsoft.VisualStudio.Modeling.SerializationResult();
CandleSerializationHelper.Instance.SaveModel(result, model, fileName);
return(!result.Failed);
}
/// <summary>
/// TIPS Affectation d'un parent graphique diffèrent que le parent du modèle à un enfant
/// </summary>
/// <param name="childShape">The child shape.</param>
/// <returns>The parent shape for the child shape.</returns>
public override ShapeElement ChooseParentShape(ShapeElement childShape)
{
// Les layers apparaissent graphiquement dans un PackageLayer mais leur père reste
// le composant
if (childShape.ModelElement is Layer)
{
// Recherche du shape du layerPackage
LayerPackage package = ((Layer)childShape.ModelElement).LayerPackage;
if (package != null)
{
IList <PresentationElement> shapes = PresentationViewsSubject.GetPresentation(package);
if (shapes.Count > 0)
{
NodeShape parentShape = (NodeShape)shapes[0];
return(parentShape);
}
}
}
if (childShape.ModelElement is DataLayer)
{
CandleModel model = ((DataLayer)childShape.ModelElement).Component.Model;
if (model != null)
{
IList <PresentationElement> shapes = PresentationViewsSubject.GetPresentation(model);
if (shapes.Count > 0)
{
NodeShape parentShape = (NodeShape)shapes[0];
return(parentShape);
}
}
}
return(base.ChooseParentShape(childShape));
}
/// <summary>
/// Liste de tous les noms de types référencées dans le modèle y compris les externes
/// </summary>
public IList <string> GetAllTypeNames(bool isExternal)
{
List <string> list = new List <string>();
foreach (Package package in this.Packages)
{
foreach (DataType clazz in package.Types)
{
list.Add(isExternal ? clazz.FullName : clazz.Name);
}
}
// On va trier alphabétiquement par composants
// Tri intermédiaire sur le composant courant
list.Sort();
// Liste temporaire pour trier sur les composants externes
List <string> tmp = new List <string>();
foreach (ExternalComponent sys in this.ReferencedExternalComponents)
{
CandleModel model = sys.ReferencedModel;
if (model != null && model.DataLayer != null)
{
list.AddRange(model.DataLayer.GetAllTypeNames(true));
}
}
// Tri puis ajout
tmp.Sort();
list.AddRange(tmp);
return(list);
}
/// <summary>
/// Drop d'un modèle à partir du repository tree
/// </summary>
/// <param name="e">The diagram drag event arguments.</param>
public override void OnDragDrop(DiagramDragEventArgs e)
{
base.OnDragDrop(e);
if (e.Data.GetDataPresent(typeof(RepositoryTreeControl.RepositoryDataDragDrop)))
{
RepositoryTreeControl.RepositoryDataDragDrop data = (RepositoryTreeControl.RepositoryDataDragDrop)e.Data.GetData(typeof(RepositoryTreeControl.RepositoryDataDragDrop));
if (data != null && this.ModelElement is CandleModel)
{
CandleModel model = ((CandleModel)this.ModelElement);
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Drop a model"))
{
// On ne le met pas si il y est dèjà
if (model.Id == data.MetaData.Id)
{
ServiceLocator.Instance.IDEHelper.ShowMessage("You can not drag the current model.");
return;
}
if (model.FindExternalComponent(data.MetaData.Id) != null)
{
ServiceLocator.Instance.IDEHelper.ShowMessage("This model already exists in the designer.");
return;
}
ExternalComponent system = data.MetaData.CreateComponent(model);
transaction.Commit();
}
}
}
}
/// <summary>
/// Alerts listeners that an element has been added back to a model.
/// </summary>
protected override void OnResurrected()
{
base.OnResurrected();
CandleModel sys = CandleModel.GetInstance(Store);
sys.UnregisterExternalAssemblyPendingDelete(this);
}
// Lors de la création d'un element, on va afficher un wizard que l'utilisateur peut annuler.
// TIPS permet d'intercepter la création d'un enfant
/// <summary>
/// Execution d'un wizard lors de la création d'un élément
/// </summary>
/// <param name="element">The element.</param>
/// <param name="defaultWizard">The default wizard.</param>
/// <returns></returns>
public bool ExecuteWizard(ModelElement element, IStrategyWizard defaultWizard)
{
if (!(element is ICustomizableElement))
{
return(true);
}
try
{
StrategyElementElementAddedEventArgs e = new StrategyElementElementAddedEventArgs(element);
foreach (StrategyBase strategy in GetStrategies(false))
{
IStrategyAddElementInterceptor sa = strategy as IStrategyAddElementInterceptor;
if (sa == null)
{
continue;
}
IStrategyWizard wizard = sa.GetWizard(element);
if (wizard != null)
{
wizard.RunWizard(this, e);
if (e.UserCancel)
{
return(false);
}
if (e.CancelBubble)
{
break;
}
}
}
if (!e.CancelBubble && defaultWizard != null)
{
defaultWizard.RunWizard(this, e);
if (e.UserCancel)
{
return(false);
}
}
OnElementAdded(e);
Generator.GenerateWhenElementAdded(this.Store, CandleModel.GetInstance(this.Store), element as ICustomizableElement);
return(true);
}
catch (Exception ex)
{
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
if (ide != null)
{
ide.ShowMessage(ex.Message);
}
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentSig"/> struct.
/// </summary>
/// <param name="model">The model.</param>
public ComponentSig(CandleModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
Id = model.Id;
Version = model.Version;
}
/// <summary>
/// Gets the references.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public IEnumerable <ReferenceItem> GetReferences(ReferenceContext context)
{
CandleModel model = ReferencedModel;
if (model != null)
{
yield return(new ReferenceItem(this, model, ReferenceScope.Compilation, context.Ports, true));
}
}
/// <summary>
/// Saves the given file.
/// </summary>
protected override void Save(string fileName)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.BeginProcess(false, false);
}
try
{
// On ne peut pas sauver si on est dans le repository
if (Repository.RepositoryManager.IsFileInRepository(fileName))
{
if (System.Windows.Forms.MessageBox.Show("Warning, this model is in the local repository. Modify it can cause overriding with the main repository. Do you really want to save this model ?", "Warning", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
return;
}
}
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
// SCC
ServiceLocator.Instance.ShellHelper.EnsureCheckout(fileName + this.DiagramExtension);
base.Save(fileName);
// Rajout à la solution pour être sur de la prise en compte dans le SCC
ServiceLocator.Instance.ShellHelper.AddFileToSolution(fileName + this.DiagramExtension);
SaveDocData <DataLayer, DataLayerDiagram>(fileName, DataLayerDiagramExtension);
SaveDocData <UIWorkflowLayer, UIWorkflowLayerDiagram>(fileName, UILayerDiagramExtension);
CandleModel system = CandleModel.GetInstance(this.Store);
if (system == null)
{
return;
}
// Pas de copie dans le repository si il y a des erreurs
if (this.ValidationController.ErrorMessages.Count > 0)
{
// if( System.Windows.Forms.MessageBox.Show( "There is validation errors. Do you want to copy the model in the repository ?", "Warning", System.Windows.Forms.MessageBoxButtons.YesNo ) == System.Windows.Forms.DialogResult.No )
return;
}
}
finally
{
if (logger != null)
{
logger.EndProcess();
}
}
}
protected void OnStatusShowStrategies(object sender, EventArgs e)
{
MenuCommand cmd = sender as MenuCommand;
if (this.CurrentDocView.PrimarySelection != null)
{
ShowStrategiesCommand command = new ShowStrategiesCommand(CandleModel.GetInstance(this.CurrentCandleDocData.Store).SoftwareComponent, this.CurrentDocView.PrimarySelection, this.CurrentDocData.FileName);
cmd.Visible = command.Visible();
cmd.Enabled = command.Enabled;
return;
}
cmd.Enabled = cmd.Visible = false;
}
/// <summary>
/// Accepts the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
public bool Accept(ReferenceItem item)
{
if (item.Element is CandleModel)
{
CandleModel model = item.Element as CandleModel;
if (!_models.Contains(model.Id) && model.SoftwareComponent != null && model.SoftwareComponent.IsDataLayerExists)
{
_types.AddRange(model.DataLayer.GetAllTypes(null, true));
_models.Add(model.Id);
}
}
return(true);
}
/// <summary>
/// Constructeur privé. On ne peut instancier un loader qu'avec GetLoader (qui gére le cache)
/// </summary>
/// <param name="fileName"></param>
private ModelLoader(string fileName)
{
SetFileName(fileName);
Store store = CreateStore();
// Ouverture d'une transaction avec l'attribut IsSerializing à True
using (Transaction transaction = store.TransactionManager.BeginTransaction("Load model", true))
{
DisableAllRules(store);
transaction.Context.ContextInfo["InModelLoader"] = true;
// Chargement du modèle (Peut générer des exceptions)
_serializationResult = new SerializationResult();
_model = CandleSerializationHelper.Instance.LoadModel(_serializationResult, store, fileName, null, null);
transaction.Commit();
}
}
/// <summary>
/// Recherche le modèle associé à la solution courante
/// </summary>
/// <returns></returns>
/// <remarks>
/// Le modèle associé est contenu dans un fichier portant le même nom que la solution
/// </remarks>
public static CandleModel GetModelFromCurrentSolution()
{
try
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell == null)
{
return(null);
}
// On cherche d'abord si le nom est enregistré dans la solution
string candleModelPath = shell.GetSolutionAssociatedModelName();
if (candleModelPath == null)
{
// Si pas trouvé, on le déduit à partir du nom de la solution
string solutionName = (string)shell.Solution.Properties.Item("Name").Value;
candleModelPath =
System.IO.Path.Combine(shell.SolutionFolder,
String.Concat(solutionName, ModelConstants.FileNameExtension));
}
// Recherche dans la RDT
CandleModel model = GetModelFromCurrentSolution(candleModelPath);
// Si tjs null, on essaye de le charger directement
if (model == null)
{
ModelLoader loader = ModelLoader.GetLoader(candleModelPath, true);
if (loader != null)
{
model = loader.Model;
}
}
return(model);
}
catch
{
}
return(null);
}
/// <summary>
/// Création d'un modèle vide
/// </summary>
/// <param name="name">Nom du modéle</param>
/// <param name="version">The version.</param>
/// <returns></returns>
public static CandleModel CreateModel(string name, VersionInfo version)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (version == null)
{
throw new ArgumentNullException("version");
}
Store store = CreateStore();
using (Transaction transaction = store.TransactionManager.BeginTransaction("Create model", true))
{
CandleModel model = new CandleModel(store);
model.Name = name;
model.Version = version;
transaction.Commit();
return(model);
}
}
/// <summary>
/// Finds the type of the global.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public DataType FindGlobalType(string name)
{
DataType type = this.FindType(name);
if (type == null)
{
foreach (ExternalComponent sys in this.ReferencedExternalComponents)
{
CandleModel model = sys.ReferencedModel;
if (model == null || model.DataLayer == null)
{
return(null);
}
type = model.DataLayer.FindType(name);
if (type != null)
{
return(type);
}
}
}
return(type);
}
/// <summary>
/// Gets the references.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override IEnumerable <DSLFactory.Candle.SystemModel.Dependencies.ReferenceItem> GetReferences(DSLFactory.Candle.SystemModel.Dependencies.ReferenceContext context)
{
IList <DataLayerReferencesExternalComponent> list = DataLayerReferencesExternalComponent.GetLinksToReferencedExternalComponents(this);
foreach (DataLayerReferencesExternalComponent link in list)
{
if (context.Mode.CheckConfigurationMode(link.ConfigurationMode) && context.CheckScope(link.Scope))
{
CandleModel model = link.ReferencedExternalComponent.ReferencedModel;
if (model != null && model.DataLayer != null)
{
List <Guid> ports = new List <Guid>();
ports.Add(model.DataLayer.Id);
yield return(new DSLFactory.Candle.SystemModel.Dependencies.ReferenceItem(this, model.DataLayer, context.Scope, ports, true));
}
}
}
foreach (DSLFactory.Candle.SystemModel.Dependencies.ReferenceItem ri in base.GetReferences(context))
{
yield return(ri);
}
}
/// <summary>
/// Surcharge pour permettre de traiter les mises à jour de version du modèle
/// </summary>
/// <param name="serializationResult"></param>
/// <param name="partition"></param>
/// <param name="fileName"></param>
/// <param name="schemaResolver"></param>
/// <param name="validationController"></param>
/// <returns></returns>
public override CandleModel LoadModel(SerializationResult serializationResult, Partition partition, string fileName, ISchemaResolver schemaResolver, ValidationController validationController)
{
_loadingFailed = false;
CandleModel model = base.LoadModel(serializationResult, partition, fileName, schemaResolver, validationController);
if (_loadingFailed || model == null)
{
// Upgrade de version du modele
if (File.Exists(fileName))
{
string str = File.ReadAllText(fileName);
str = str.Replace("modelRoot", "componentModel");
str = str.Replace("<contracts>", "<ports>");
str = str.Replace("</contracts>", "</ports>");
str = str.Replace("externalBinaryComponent", "externalComponent");
str = str.Replace("externalSoftwareComponent>", "externalComponent>");
ServiceLocator.Instance.ShellHelper.EnsureCheckout(fileName);
File.WriteAllText(fileName, str);
model = base.LoadModel(serializationResult, partition, fileName, schemaResolver, validationController);
}
}
return(model);
}
protected void OnStatusImplement(object sender, EventArgs e)
{
MenuCommand cmd = sender as MenuCommand;
NodeShape shape = SingleSelection as NodeShape;
bool flag = shape != null && (shape.ModelElement is CandleElement) && CandleModel.GetInstance(shape.ModelElement.Store).SoftwareComponent != null;
cmd.Enabled = cmd.Visible = flag &&
StrategyManager.GetInstance(shape.ModelElement.Store).GetStrategies(((CandleElement)shape.ModelElement).StrategiesOwner, true).Count > 0;
}
protected void OnShowStrategies(object sender, EventArgs e)
{
ShowStrategiesCommand command = new ShowStrategiesCommand(CandleModel.GetInstance(this.CurrentCandleDocData.Store).SoftwareComponent, this.CurrentDocView.PrimarySelection, this.CurrentDocData.FileName);
command.Exec();
}
/// <summary>
/// Permet d'afficher les ports corresponds aux ports définis dans le modèle
/// </summary>
internal bool UpdateFromModel()
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
try
{
object flag;
if (Store.TransactionManager.InTransaction &&
Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.TryGetValue(
"InModelLoader", out flag))
{
return(false);
}
ComponentModelMetadata metaData = MetaData;
CandleModel model = ReferencedModel;
if (model == null || metaData == null) //|| metaData.Version.Equals(this.Version))
{
return(false);
}
// Création des ports externes
using (Transaction transaction = Store.TransactionManager.BeginTransaction("Populate external system"))
{
// Mise à jour du numèro de version
if (!metaData.Version.Equals(Version))
{
Version = metaData.Version;
}
List <Guid> portsId = new List <Guid>();
if (model.BinaryComponent != null)
{
foreach (DotNetAssembly asm in model.BinaryComponent.Assemblies)
{
if (asm.Visibility == Visibility.Private)
{
continue;
}
portsId.Add(asm.Id);
ExternalPublicPort publicPort =
Ports.Find(
delegate(ExternalPublicPort port) { return(port.ComponentPortMoniker == asm.Id); });
if (publicPort == null)
{
publicPort = new ExternalPublicPort(Store);
Ports.Add(publicPort);
}
publicPort.Name = asm.Name;
publicPort.ComponentPortMoniker = asm.Id;
publicPort.IsInGac = asm.IsInGac;
}
}
else if (model.SoftwareComponent != null)
{
if (model.IsLibrary)
{
foreach (TypeWithOperations pub in model.SoftwareComponent.PublicContracts)
{
portsId.Add(pub.Id);
ExternalPublicPort publicPort =
Ports.Find(
delegate(ExternalPublicPort port) { return(port.ComponentPortMoniker == pub.Id); });
if (publicPort == null)
{
publicPort = new ExternalPublicPort(Store);
Ports.Add(publicPort);
}
publicPort.Name = pub.Name;
publicPort.ComponentPortMoniker = pub.Id;
}
}
else
{
foreach (TypeWithOperations pub in model.SoftwareComponent.PublicContracts)
{
portsId.Add(pub.Id);
ExternalPublicPort publicPort =
Ports.Find(
delegate(ExternalPublicPort port) { return(port.ComponentPortMoniker == pub.Id); });
if (publicPort == null)
{
publicPort = new ExternalServiceContract(Store);
Ports.Add(publicPort);
}
publicPort.Name = pub.Name;
publicPort.ComponentPortMoniker = pub.Id;
}
}
}
RemoveUnusedPorts(portsId);
if (transaction.HasPendingChanges)
{
transaction.Commit();
return(true);
}
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Update from model", String.Format("Error in UpdateFromModel for {0}", Name), ex);
}
}
return(false);
}
