/// <summary>
/// Reads the associations.
/// </summary>
private void ReadAssociations()
{
foreach (XmlNode assocNode in _xdoc.SelectNodes("/XMI/XMI.content/UML:Model/UML:Namespace.ownedElement/UML:Association/UML:Association.connection", _nsManager))
{
XmlNodeList assocEndNodes = assocNode.SelectNodes("UML:AssociationEnd", _nsManager);
string typeName;
bool isPrimitive;
bool classExists;
XmlNode node2 = assocEndNodes[0].SelectSingleNode("UML:AssociationEnd.participant/UML:Class", _nsManager);
string id = node2.Attributes["xmi.idref"].Value;
GetTypeInfo(id, out typeName, out isPrimitive);
ClassNameInfo nameHelper = new ClassNameInfo(_initialNamespace, typeName);
Entity source = (Entity)_layer.AddTypeIfNotExists(nameHelper, false, out classExists);
Debug.Assert(isPrimitive == false && classExists == true);
XmlNode multiplicityNode = assocEndNodes[0].SelectSingleNode("UML:AssociationEnd.multiplicity/UML:Multiplicity/UML:Multiplicity.range/UML:MultiplicityRange", _nsManager);
Multiplicity sourceMultiplicity = GetMultiplicityFromValue(multiplicityNode.Attributes["lower"].Value, multiplicityNode.Attributes["upper"].Value);
node2 = assocEndNodes[1].SelectSingleNode("UML:AssociationEnd.participant/UML:Class", _nsManager);
id = node2.Attributes["xmi.idref"].Value;
GetTypeInfo(id, out typeName, out isPrimitive);
Entity target = (Entity)_layer.AddTypeIfNotExists(nameHelper, false, out classExists);
Debug.Assert(isPrimitive == false && classExists == true);
multiplicityNode = assocEndNodes[1].SelectSingleNode("UML:AssociationEnd.multiplicity/UML:Multiplicity/UML:Multiplicity.range/UML:MultiplicityRange", _nsManager);
Multiplicity targetMultiplicity = GetMultiplicityFromValue(multiplicityNode.Attributes["lower"].Value, multiplicityNode.Attributes["upper"].Value);
Association assoc = source.AddAssociationTo(target);
assoc.SourceMultiplicity = sourceMultiplicity;
assoc.TargetMultiplicity = targetMultiplicity;
}
}
/// <summary>
/// Reads the generalizations.
/// </summary>
private void ReadGeneralizations()
{
foreach (XmlNode node in _xdoc.SelectNodes("/XMI/XMI.content/UML:Model/UML:Namespace.ownedElement/UML:Generalization", _nsManager))
{
string typeName;
bool isPrimitive;
bool classExists;
XmlNode node2 = node.SelectSingleNode("UML:Generalization.parent/UML:Class", _nsManager);
string id = node2.Attributes["xmi.idref"].Value;
GetTypeInfo(id, out typeName, out isPrimitive);
ClassNameInfo nameHelper = new ClassNameInfo(_initialNamespace, typeName);
Entity parent = (Entity)_layer.AddTypeIfNotExists(nameHelper, false, out classExists);
Debug.Assert(isPrimitive == false && classExists == true);
node2 = node.SelectSingleNode("UML:Generalization.child/UML:Class", _nsManager);
id = node2.Attributes["xmi.idref"].Value;
GetTypeInfo(id, out typeName, out isPrimitive);
nameHelper = new ClassNameInfo(_initialNamespace, typeName);
Entity child = (Entity)_layer.AddTypeIfNotExists(nameHelper, false, out classExists);
Debug.Assert(isPrimitive == false && classExists == true);
child.BaseType = parent.Name;
}
}
/// <summary>
/// Recherche d'un modèle par son nom
/// </summary>
/// <param name="fullName">The full name.</param>
/// <returns></returns>
private DataType FindModelClassByName(string fullName)
{
ClassNameInfo nameHelper = new ClassNameInfo(_initialNamespace, fullName);
// On recherche d'abord dans le modèle courant
DataType clazz = _layer.FindType(nameHelper.FullName);
if (clazz == null)
{
// Puis dans les les systèmes référencés
foreach (ExternalComponent sys in _layer.Component.Model.ExternalComponents)
{
CandleModel model = sys.ReferencedModel;
if (model != null && model.DataLayer != null)
{
clazz = model.DataLayer.FindType(nameHelper.FullName);
if (clazz != null)
{
break;
}
}
}
}
return(clazz);
}
/// <summary>
/// Creates the model.
/// </summary>
/// <param name="node">The node.</param>
/// <returns></returns>
private Entity CreateModel(XmlNode node)
{
string typeName = node.Attributes["name"].Value;
bool classExists;
ClassNameInfo nameHelper = new ClassNameInfo(_initialNamespace, typeName);
Entity model = (Entity)_layer.AddTypeIfNotExists(nameHelper, false, out classExists);
model.Properties.Clear();
return(model);
}
/// <summary>
/// Création d'un modèle de type classe
/// </summary>
/// <param name="clazz">Type clr de la classe</param>
/// <param name="createEnum">if set to <c>true</c> [create enum].</param>
/// <returns></returns>
private DataType CreateModel(Type clazz, bool createEnum)
{
bool classExists;
ClassNameInfo nameHelper = new ClassNameInfo(_initialNamespace, clazz.FullName);
DataType model = _layer.AddTypeIfNotExists(nameHelper.Namespace, clazz.Name, createEnum, out classExists);
CustomAttributeReflector c = new CustomAttributeReflector(clazz);
if (c.MoveTo(typeof(XmlRootAttribute)))
{
model.XmlName = c.GetPropertyValue <string>("ElementName");
_layer.XmlNamespace = c.GetPropertyValue <string>("Namespace");
}
return(model);
}
/// <summary>
/// Résolution du nom du fichier en remplacçant les mots-clés par leurs valeurs courantes.
/// </summary>
/// <param name="element">Element concerné par la génération</param>
/// <param name="filePattern">Pattern du nom de fichier</param>
/// <returns>Chaine résolue</returns>
/// <remarks>
/// Pattern dans le nom du fichier
/// '~' : indique de mettre le fichier tel quel à la racine
/// [codeFolder]|[code] : Répertoire de code (racine ou app_code)
/// [namespace]|[nspc] : namespace hierarchie
/// [strategyName]|[sn] : Nom de la strategie
/// ex : [codeFolder]/[namespace]/xxx.cs
/// </remarks>
/// <exception cref="Exception">Erreur de syntaxe dans le pattern</exception>
private string ResolvePattern(ICustomizableElement element, string filePattern)
{
// Pour que le replace marche dans tous les cas, on va d'abord parcourir la chaine
// pour mettre tous les mot-clés en minuscules sans toucher aux autres caractères.
char[] buffer = filePattern.ToCharArray();
bool inKeyword = false;
for (int i = 0; i < buffer.Length; i++)
{
char ch = buffer[i];
if (ch == ']')
{
if (!inKeyword)
{
throw new Exception(
String.Format("Syntax error in the generated file pattern '{1}' for element {0}",
element.Name, filePattern));
}
inKeyword = false;
}
else if (ch == '[')
{
if (inKeyword)
{
throw new Exception(
String.Format("Syntax error in the generated file pattern '{1}' for element {0}",
element.Name, filePattern));
}
inKeyword = true;
}
else if (inKeyword)
{
buffer[i] = Char.ToLower(ch);
}
}
if (inKeyword)
{
throw new Exception(
String.Format("Syntax error in the generated file pattern '{1}' for element {0}", element.Name,
filePattern));
}
// Remplacement des mots-clés
string tmpFileName = new String(buffer);
tmpFileName = tmpFileName.Replace("[code]", "[codefolder]");
tmpFileName = tmpFileName.Replace("[sn]", "[strategyname]");
tmpFileName = tmpFileName.Replace("[nspc]", "[namespace]");
tmpFileName = tmpFileName.Replace("[codefolder]", Context.RelativeProjectCodeFolder);
tmpFileName = tmpFileName.Replace("[strategyname]", DisplayName);
if (tmpFileName.Contains("[namespace]"))
{
// Arborescence correspondant au namespace
string ns = String.Empty;
if (element != null)
{
ClassNameInfo cni = new ClassNameInfo(element.FullName);
ns = cni.Namespace.Replace('.', Path.DirectorySeparatorChar);
}
tmpFileName = tmpFileName.Replace("[namespace]", ns);
}
return(tmpFileName);
}
/// <summary>
/// Alerts listeners that a property for an element has changed.
/// </summary>
/// <param name="e">Provides data for the ElementPropertyChanged event.</param>
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)
{
#region Condition
if (e.ModelElement.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.IsSerializing ||
e.ModelElement.Store.InUndoRedoOrRollback)
{
return;
}
#endregion
#region Traitement
if (e.DomainProperty.Id == NamedElement.NameDomainPropertyId)
{
string name = ((NamedElement)e.ModelElement).Name;
if (string.IsNullOrEmpty(name))
{
return;
}
if (e.ModelElement is DataType)
{
DataType type = (DataType)e.ModelElement;
ClassNameInfo cni = new ClassNameInfo(type.Package.Name, (string)e.OldValue);
string oldName = cni.FullName;
type.XmlName = name;
// Mise à jour de tous les types dans les opérations
foreach (SoftwareLayer layer in type.Package.Layer.Component.Layers)
{
if (layer is InterfaceLayer)
{
foreach (ServiceContract port in ((InterfaceLayer)layer).ServiceContracts)
{
foreach (Operation op in port.Operations)
{
if (op.Type == oldName)
{
op.Type = name;
}
foreach (Argument arg in op.Arguments)
{
if (arg.Type == oldName)
{
arg.Type = name;
}
}
}
}
}
}
}
//if( e.ModelElement is DataLayer )
//{
// ( (DataLayer)e.ModelElement ).XmlNamespace = name;
//}
if (e.ModelElement is Property)
{
((Property)e.ModelElement).XmlName = name;
}
}
#endregion
}
/// <summary>
/// Récupération des classes d'une assembly
/// </summary>
/// <param name="fullPath">The full path.</param>
/// <param name="selectedClasses">The selected classes.</param>
public void AddAssembly(string fullPath, IList selectedClasses)
{
using (AssemblyResolver resolver = new AssemblyResolver(fullPath))
{
using (Transaction transaction = _layer.Store.TransactionManager.BeginTransaction("Import models"))
{
transaction.Context.ContextInfo.Add("ReverseInProgress", true);
DataLayer modelsLayer = _layer.SoftwareComponent.DataLayer;
// 1er passage : Création des modéles
foreach (Type clazz in selectedClasses)
{
ServiceContract port = new ServiceContract(_layer.Store);
port.Name = clazz.Name;
port.RootName = clazz.Name;
_layer.ServiceContracts.Add(port);
foreach (MethodInfo method in clazz.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
Operation op = new Operation(port.Store);
port.Operations.Add(op);
op.Name = method.Name;
string typeName = GetTypeElement(method, method.ReturnType);
op.Type = typeName;
op.IsCollection = IsListe(method.ReturnType);
if (!Utils.StringStartsWith(op.Type, "System.") && !Utils.StringStartsWith(op.Type, "Microsoft."))
{
if (typeName != null)
{
bool exists;
ClassNameInfo cni = new ClassNameInfo(typeName);
Entity target = (Entity)modelsLayer.AddTypeIfNotExists(cni.Namespace, cni.ClassName, false, out exists);
if (!exists)
{
CreateEntity(target, method.ReturnType);
}
op.Type = target.Name;
}
}
// TODO a revoir
if (op.Type == "System.Void")
{
op.Type = "void";
}
foreach (ParameterInfo parm in method.GetParameters())
{
Argument arg = new Argument(port.Store);
arg.Name = parm.Name;
typeName = GetTypeElement(parm, parm.ParameterType);
arg.Type = typeName;
if (!Utils.StringStartsWith(arg.Type, "System.") && !Utils.StringStartsWith(arg.Type, "Microsoft."))
{
if (typeName != null)
{
ClassNameInfo cni = new ClassNameInfo(typeName);
bool exists;
Entity target = (Entity)modelsLayer.AddTypeIfNotExists(cni.Namespace, cni.ClassName, false, out exists);
if (!exists)
{
CreateEntity(target, parm.ParameterType);
}
arg.Type = target.Name;
}
}
// TODO a revoir
if (arg.Type == "System.Void")
{
arg.Type = "void";
}
arg.IsCollection = IsListe(parm.ParameterType);
arg.Direction = parm.IsOut ? ArgumentDirection.Out : ArgumentDirection.In;
op.Arguments.Add(arg);
}
}
}
transaction.Commit();
}
}
}
