/// <summary>
/// Traverses the specified layer.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="Scope">The scope.</param>
/// <param name="mode">The mode.</param>
public void Traverse(SoftwareLayer layer, ReferenceScope Scope, ConfigurationMode mode)
{
// Stocke les éléments traités pour éviter les doublons
List <Guid> guids = new List <Guid>();
if (layer is InterfaceLayer)
{
foreach (ServiceContract contract in ((InterfaceLayer)layer).ServiceContracts)
{
foreach (Implementation impl in Implementation.GetLinksToImplementations(contract))
{
if (mode.CheckConfigurationMode(impl.ConfigurationMode) &&
!guids.Contains(impl.ClassImplementation.Id))
{
_visitor.Accept(impl, impl.ClassImplementation);
guids.Add(impl.ClassImplementation.Id);
}
}
}
}
else if (layer is Layer)
{
foreach (ClassImplementation clazz in ((Layer)layer).Classes)
{
foreach (NamedElement service in clazz.ServicesUsed)
{
IList <ClassUsesOperations> externalServiceLinks =
ClassUsesOperations.GetLinksToServicesUsed(clazz);
foreach (ClassUsesOperations link in externalServiceLinks)
{
if (mode.CheckConfigurationMode(link.ConfigurationMode) && ((link.Scope & Scope) == Scope))
{
if (service is ExternalServiceContract)
{
_visitor.Accept(link, (ExternalServiceContract)service);
}
else if (service is ServiceContract)
{
_visitor.Accept(link, (ServiceContract)service);
}
else if (service is ClassImplementation)
{
_visitor.Accept(link, (ClassImplementation)service);
}
else
{
throw new Exception("Type not implemented");
}
guids.Add(service.Id);
}
}
}
}
}
}
// Ajout de l'élément
/// <summary>
/// Alerts listeners that a rule has been used.
/// </summary>
/// <param name="e">An ElementAddedEventArgs that contains the event data.</param>
public override void ElementAdded(ElementAddedEventArgs e)
{
ClassUsesOperations link = e.ModelElement as ClassUsesOperations;
if (link == null)
{
return;
}
// Cette régle ne s'applique pas quand on charge le modèle
if (link.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.IsSerializing ||
link.Store.InUndoRedoOrRollback)
{
return;
}
// Mise à jour du nom du service
link.Name = link.TargetService.Name;
if (link.InternalTargetService != null)
{
link.Scope = ReferenceScope.Compilation | ReferenceScope.Publish | ReferenceScope.Runtime;
}
}
void IStrategyCodeInjector.OnGenerateFunction(CodeInjectionContext context, DSLFactory.Candle.SystemModel.CodeGeneration.CodeModel.CandleCodeFunction function)
{
// Service factory
if (context.CurrentElement is Layer)
{
// On part du principe que le template du servicelocator à généré une classe nommée ServiceLocator et
// une méthode par création d'instance dont le nom commence par CreateInstanceOfxxxxxx
if (function.Parent.Name == "ServiceLocatorBase" && function.Name.StartsWith("CreateInstanceOf"))
{
string currentName = function.Name.Substring("CreateInstanceOf".Length);
foreach (ClassImplementation clazz in ((Layer)context.CurrentElement).Classes)
{
foreach (ClassUsesOperations service in ClassUsesOperations.GetLinksToServicesUsed(clazz))
{
if (!context.GenerationContext.Mode.CheckConfigurationMode(service.ConfigurationMode) || service.TargetService is ExternalServiceContract)
{
continue;
}
ServiceContract contract = service.TargetService as ServiceContract;
if (contract == null)
{
continue;
}
foreach (Implementation impl in Implementation.GetLinksToImplementations(contract))
{
if (context.GenerationContext.Mode.CheckConfigurationMode(impl.ConfigurationMode) && impl.ClassImplementation.Name == currentName)
{
if (impl.ClassImplementation.Contract != null)
{
foreach (Operation op in impl.ClassImplementation.Contract.Operations)
{
if (CheckAllHandler(op, impl.ClassImplementation))
{
function.ReplaceBody(
@" string path = ConfigurationManager.AppSettings[key];
Type t = Assembly.Load(path).GetType(""" + impl.ClassImplementation.FullName + @""");
PropertyInfo p = typeof(Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjection).GetProperty(""DefaultPolicyInjector"", BindingFlags.Static | BindingFlags.NonPublic);
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjector pi = (Microsoft.Practices.EnterpriseLibrary.PolicyInjection.PolicyInjector)p.GetValue(null, null);
return (" + contract.FullName + ")pi.Create(t, typeof(" + contract.FullName + @"));
");
return;
}
}
}
}
}
}
}
}
}
// Attribut
if (context.CurrentElement is ClassImplementation)
{
ClassImplementation clazz = context.CurrentElement as ClassImplementation;
if (clazz.Name + "Base" == function.Parent.Name || clazz.Name == function.Parent.Name)
{
Operation op = function.FindOperationFromContract(clazz.Contract);
if (op != null)
{
// LogCallHandler
IPIABHandler handler = CheckHandler <LogCallHandler>(LogCallHandlerProperty, op, clazz);
if (handler != null && handler.Enabled)
{
handler.SetAttribute(context, function);
}
// CacheCallHandler
handler = CheckHandler <CacheCallHandler>(CacheCallHandlerProperty, op, clazz);
if (handler != null && handler.Enabled)
{
handler.SetAttribute(context, function);
}
// PerformanceCounterCallHandler
handler = CheckHandler <PerformanceCounterCallHandler>(PerformanceCounterCallHandlerProperty, op, clazz);
if (handler != null && handler.Enabled)
{
handler.SetAttribute(context, function);
}
}
}
}
}
/// <summary>
/// Execution du wizard
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="DSLFactory.Candle.SystemModel.Strategies.StrategyElementElementAddedEventArgs"/> instance containing the event data.</param>
public void RunWizard(ModelElement sender, StrategyElementElementAddedEventArgs e)
{
CandleElement elem = e.ModelElement as CandleElement;
txtRootName.Text = elem.RootName;
if (elem is ServiceContract) // Ce cas est désactivé (voir selection du wizard)
{
_layer = ((ServiceContract)e.ModelElement).Layer;
txtName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_layer, elem.RootName);
}
else
{
_layer = ((ClassImplementation)e.ModelElement).Layer;
_iLayer = ((ClassImplementation)e.ModelElement).Layer.LayerPackage.InterfaceLayer;
txtName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_layer, elem.RootName);
if (_iLayer == null)
{
txtContractName.Visible = false;
}
else
{
txtContractName.Text =
StrategyManager.GetInstance(_layer.Store).NamingStrategy.CreateElementName(_iLayer, txtName.Text);
}
}
if (elem is ServiceContract || ((ClassImplementation)elem).Layer.LayerPackage.InterfaceLayer == null)
{
lblContractName.Visible = false;
txtContractName.Visible = false;
txtContractName.Text = null;
}
lblHeader.Text = String.Format(lblHeader.Text, _layer.Name);
groupBox1.Text = _layer.Namespace;
if (!s_dontShow)
{
e.UserCancel = (ShowDialog() == DialogResult.Cancel);
if (e.UserCancel)
{
return;
}
s_dontShow = ckDontShow.Checked;
}
// Ici on force les noms des classes donc on ne veut pas que la régle basée sur la modification
// du RootName s'execute. On l'indique dans le contexte de la transaction
if (
!elem.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.ContainsKey(
"CustomizableElementChangeRule_Enabled"))
{
elem.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.Add(
"CustomizableElementChangeRule_Enabled", false);
}
elem.Name = txtName.Text;
using (Transaction transaction = elem.Store.TransactionManager.BeginTransaction("Set root name"))
{
// Force la transaction pour que la règle s'execute tout de suite et qu'on puisse
// forcer le nom ensuite
elem.RootName = txtRootName.Text;
transaction.Commit();
}
// Si c'est une classe, on essaye de créer son interface
ClassImplementation clazz = elem as ClassImplementation;
if (clazz != null && _iLayer != null && !String.IsNullOrEmpty(txtContractName.Text))
{
if (clazz.Contract == null)
{
// On regarde si l'interface n'existe pas
clazz.Contract =
_iLayer.ServiceContracts.Find(
delegate(ServiceContract c) { return(c.Name == txtContractName.Text); });
if (clazz.Contract == null)
{
clazz.Contract = new ServiceContract(clazz.Store);
clazz.Contract.RootName = txtRootName.Text;
clazz.Layer.LayerPackage.InterfaceLayer.ServiceContracts.Add(clazz.Contract);
UnplacedModelHelper.RegisterNewModel(clazz.Store, clazz.Contract);
// Si la classe courante utilise un seul contract, on le recopie
IList <ClassUsesOperations> links = ClassUsesOperations.GetLinksToServicesUsed(clazz);
if (links.Count == 1)
{
ServiceContract contract = links[0].TargetService as ServiceContract;
if (contract != null)
{
TypeWithOperations.CopyOperations(contract, clazz.Contract);
}
else
{
ExternalServiceContract externalContract =
links[0].TargetService as ExternalServiceContract;
if (externalContract != null)
{
TypeWithOperations.CopyOperations(externalContract.ReferencedServiceContract,
clazz.Contract);
}
}
}
}
}
using (Transaction transaction = elem.Store.TransactionManager.BeginTransaction("Set root name"))
{
// Force la transaction pour que la règle s'execute tout de suite et qu'on puisse
// forcer le nom ensuite
clazz.Contract.RootName = elem.RootName;
transaction.Commit();
}
if (clazz.Contract.Name != txtContractName.Text)
{
clazz.Contract.Name = txtContractName.Text;
}
}
e.CancelBubble = true;
}
