// dependencyProperty Name
// configurationPart Name
// foreignKey ?
/// <summary>
/// Merges the specified model.
/// </summary>
/// <param name="model">The model.</param>
public static void Merge(CandleModel model)
{
foreach (ModelElement elem in model.Store.ElementDirectory.AllElements)
{
if (elem is ShapeElement || elem is ElementLink)
{
continue;
}
DomainClassInfo ci = elem.GetDomainClass();
Debug.WriteLine(String.Format("Elem '{0}' id={1}", ci.Name, elem.Id));
foreach (DomainPropertyInfo p in ci.LocalDomainProperties)
{
Debug.WriteLine(String.Format(" property '{0}'={1}", p.Name, p.GetValue(elem)));
}
foreach (DomainRoleInfo role in ci.LocalDomainRolesPlayed)
{
foreach (ElementLink link in role.GetElementLinks(elem))
{
Debug.WriteLine(String.Format(" --> '{0}' id={1}", role.Name, link.Id));
foreach (DomainPropertyInfo p in link.GetDomainClass().LocalDomainProperties)
{
Debug.WriteLine(String.Format(" --> property '{0}'={1}", p.Name, p.GetValue(link)));
}
}
}
}
}
public Task <TrendDirection> CheckTrendAsync(string tradingPair, CandleModel currentCandle)
{
var candleSticksValue = _candleSticksIndicator.GetIndicatorValue(currentCandle);
if (_lastTrend == TrendDirection.Short)
{
if (candleSticksValue.CandleFormat == CandleFormat.BullishMarubozu)
{
_lastTrend = TrendDirection.Long;
return(Task.FromResult(_lastTrend));
}
}
if (_lastTrend == TrendDirection.Long)
{
if (currentCandle.ClosePrice >= _lastBuyPrice * (decimal)1.01 ||
candleSticksValue.CandleFormat == CandleFormat.BearishMarubozu)
{
_lastTrend = TrendDirection.Short;
}
else
{
return(Task.FromResult(TrendDirection.None));
}
}
return(Task.FromResult(TrendDirection.None));
}
/// <summary>
/// Shows the component wizard.
/// </summary>
/// <param name="component">The component.</param>
/// <remarks>
/// Ce traitement peut-être appelé soit lors de l'insertion d'un composant avec le designer soit à l'ouverture d'un modèle dont
/// le nom du composant est un '?' (cas du template). Dans ce dernier cas, on ne passe pas par une règle car une règle déclenchée
/// lors de l'ouverture du document ne notifie pas le designer des changements (car le designer ne s'aboone aux notifications qu'après
/// le chargement du doc.
/// </remarks>
public static void ShowComponentWizard(SoftwareComponent component)
{
if (component.Name != "?")
{
return;
}
component.Store.TransactionManager.CurrentTransaction.Context.ContextInfo["InitializeComponentWizard"] =
true;
// Wizard pour demander le namespace et la version
ApplicationNamespaceForm form = new ApplicationNamespaceForm(component);
if (form.ShowDialog() != DialogResult.OK)
{
throw new CanceledByUser();
}
// Demande du namespace
component.Namespace = form.Namespace;
component.Name = form.ApplicationName;
// Mise à jour de la définition du système
CandleModel def = component.Model;
if (def != null)
{
def.IsLibrary = form.IsLibrary;
def.Version = form.Version;
def.Comment = form.Description;
def.Url = form.URL;
def.Name = form.ApplicationName;
def.Path = form.DomainPath;
}
}
/// <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>
/// Traverses the specified visitor.
/// </summary>
/// <param name="visitor">The visitor.</param>
/// <param name="element">The element.</param>
public void Traverse(IReferenceVisitor visitor, ModelElement element)
{
if (visitor == null)
{
throw new ArgumentNullException("visitor");
}
if (element == null)
{
return;
}
_visitor = visitor;
// Il faut toujours commencer par un modèle pour initialiser le contexte
CandleModel model = null;
if (!(element is CandleModel))
{
model = CandleModel.GetInstance(element.Store);
visitor.Accept(new ReferenceItem(null, model, false)); // Initialisation du contexte
}
// Parcours de l'élément choisi
Traverse(new ReferenceItem(null, element, false));
if (model != null)
{
visitor.ExitElement(new ReferenceItem(null, model, false));
}
}
/// <summary>
/// Copie dans le repository local
/// </summary>
/// <param name="model">Le modèle à publier</param>
/// <param name="fileName">Chemin absolu du modèle à publier</param>
/// <param name="remoteName">Nom du fichier modèle dans le repository</param>
/// <returns></returns>
public string PublishModel(CandleModel model, string fileName, string remoteName)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
remoteName = Path.GetFileName(remoteName);
string targetFileName = model.MetaData.ResolvePath(remoteName, PathKind.Absolute);
// On ne copie que si c'est nécessaire
if (targetFileName != String.Empty && File.Exists(fileName) &&
!Utils.StringCompareEquals(targetFileName, fileName) &&
!Utils.FileDateEquals(targetFileName, fileName))
{
try
{
Utils.CopyFile(fileName, targetFileName);
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Repository", "Publish model", ex);
}
}
}
else if (logger != null)
{
logger.Write("Repository", "Skip copy of " + fileName + " (same version)", LogType.Info);
}
return(targetFileName);
}
public async Task SellAsync(CandleModel candle)
{
if (candle != null)
{
if (_userBalanceService.HasOpenOrder)
{
await _exchangeProvider.CancelOrderAsync(_tradingPair, _userBalanceService.OpenOrderNumber);
return;
}
var sellPrice = !_userBalanceService.EnableRealtimeTrading ? candle.ClosePrice : _exchangeProvider.GetTicker(_tradingPair).Result.HighestBid;
_userBalanceService.TradingCount++;
long orderNumber = 0;
if (_userBalanceService.EnableRealtimeTrading)
{
orderNumber = await _exchangeProvider.CreateOrderAsync(TradeType.Sell, _tradingPair, sellPrice, _userBalanceService.Rate);
_userBalanceService.HasOpenOrder = true;
await CheckOrderInvoked(orderNumber, TradeType.Sell);
}
var profit = _userBalanceService.GetProfit(sellPrice, candle.StartDateTime);
var msg = $"Sell crypto currency. Date: {candle.StartDateTime}; Price: ${sellPrice}; Rate: {_userBalanceService.Rate}; OrderNumber: {orderNumber}\n" +
$"Profit: ${profit.Profit}\n" +
$"Trading time in hours: {Math.Round(profit.TradingTimeInMinutes / 60.0, 2)}\n" +
"\n" +
_userBalanceService.TradingSummary();
Console.WriteLine(msg);
_emailService.SendEmail(string.Format(_cryptoTradingOptions.EmailSubject, _tradingPair), msg);
}
}
/// <summary>
/// Resolves the path.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns></returns>
public static string ResolvePath(CandleModel model, string assemblyName)
{
if (assemblyName.EndsWith(".dll", StringComparison.CurrentCultureIgnoreCase) == false)
{
assemblyName += ".dll";
}
string version = model.DotNetFrameworkVersion.ToString();
string folder = FindInFirstFramework(version);
if (folder != null)
{
return(Path.Combine(folder, assemblyName));
}
// Si pas trouvé, on recherche dans le répertoire apparu depuis la version 3
// "%ProgramFiles%\Reference Assemblies\Microsoft\Framework\v3.0
string[] parts = version.Split('.');
version = String.Join(".", parts, 0, 2);
folder =
Path.Combine(Environment.ExpandEnvironmentVariables("%ProgramFiles%"),
@"Reference Assemblies\Microsoft\Framework\v" + version);
// Bidouille pour le 3.0 car l'assembly peut exister dans le 2.0
string fileName = Path.Combine(folder, assemblyName);
if (version == "3.0" && File.Exists(fileName))
{
return(fileName);
}
return(Path.Combine(FindInFirstFramework("2.0.0.0"), assemblyName));
}
public Task <TrendDirection> CheckTrendAsync(string tradingPair, CandleModel currentCandle)
{
var rsiValue = _rsiIndicator.GetIndicatorValue(currentCandle).IndicatorValue;
Console.WriteLine($"Rsi value: {rsiValue}");
if (rsiValue < 30 && rsiValue > 0)
{
if (_lastTrend == TrendDirection.Long)
{
return(Task.FromResult(TrendDirection.None));
}
_lastTrend = TrendDirection.Long;
return(Task.FromResult(_lastTrend));
}
if (rsiValue > 70)
{
if (_lastTrend == TrendDirection.Short)
{
return(Task.FromResult(TrendDirection.None));
}
_lastTrend = TrendDirection.Short;
return(Task.FromResult(_lastTrend));
}
return(Task.FromResult(TrendDirection.None));
}
/// <summary>
/// Appelée pour chaque modèle
/// </summary>
/// <param name="model"></param>
/// <param name="isInitialModel"></param>
protected virtual void AcceptModel(CandleModel model, bool isInitialModel)
{
if (!_models.Contains(model))
{
_models.Add(model);
}
}
/// <summary>
/// Création du composant principal initialisé à partir d'une assembly
/// </summary>
/// <param name="model">The model.</param>
/// <param name="mainAssembly">The main assembly.</param>
/// <returns></returns>
private static BinaryComponent CreateComponent(CandleModel model, Assembly mainAssembly)
{
using (Transaction transaction = model.Store.TransactionManager.BeginTransaction("Init main component"))
{
// Création du composant
BinaryComponent component = new BinaryComponent(model.Store);
// Init avec les valeurs d'un assembly
if (mainAssembly != null)
{
if (string.IsNullOrEmpty(model.Name))
{
component.Name = component.Namespace = mainAssembly.GetName().Name;
int pos = component.Name.IndexOf('.');
if (pos > 0)
{
component.Name = component.Name.Substring(0, pos);
}
// Init du system
model.Name = component.Name;
}
else
{
component.Name = model.Name;
}
model.Version = new VersionInfo(mainAssembly.GetName().Version);
}
model.Component = component;
transaction.Commit();
return(component);
}
}
public Task <TrendDirection> CheckTrendAsync(string tradingPair, CandleModel currentCandle)
{
var mfiValue = _mfiIndicator.GetIndicatorValue(currentCandle).IndicatorValue;
Console.WriteLine($"Mfi indicator value: {mfiValue}");
if (mfiValue < 0)
{
return(Task.FromResult(TrendDirection.None));
}
if (mfiValue > 0 && mfiValue <= 20)
{
if (_lastTrend == TrendDirection.Short)
{
_lastTrend = TrendDirection.Long;
return(Task.FromResult(_lastTrend));
}
}
if (mfiValue >= 80)
{
if (_lastTrend == TrendDirection.Long)
{
_lastTrend = TrendDirection.Short;
return(Task.FromResult(_lastTrend));
}
}
return(Task.FromResult(TrendDirection.None));
}
/// <summary>
/// Execute the command
/// </summary>
public void Exec()
{
CandleModel system = _shape.ModelElement as CandleModel;
// Si la commande a été lancé sur le composant, on référence le modèle
if (system == null)
{
BinaryComponent component = _shape.ModelElement as BinaryComponent;
if (component != null)
{
system = component.Model;
}
}
// Peut etre à null si le composant n'est pas de type Binary
if (system != null)
{
// Affiche la fenetre de dialogue permettant de choisir les assemblies
IAssemblySelectorDialog selector = ServiceLocator.Instance.GetService <IAssemblySelectorDialog>();
if (selector.ShowDialog(0))
{
ImportAssemblies(system, selector.SelectedAssemblies);
// On arrange les shapes du composant
IList <PresentationElement> componentShapes = PresentationViewsSubject.GetPresentation(system.Component);
ArrangeShapesCommand cmd = new ArrangeShapesCommand((NodeShape)componentShapes[0]);
cmd.Exec();
}
}
}
internal void Execute(GenerationContext context, string outputFile)
{
writer = new SafeStreamWriter(outputFile, false);
try
{
this.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
this.WriteLine("<hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.0\">");
this.WriteLine("");
CandleModel model = context.Model;
if (model == null || !model.SoftwareComponent.IsDataLayerExists)
{
return;
}
_modelsLayer = model.SoftwareComponent.DataLayer;
_inheritanceTree = new ClassInheritanceTree(_modelsLayer);
foreach (ClassInheritanceNode childNode in _inheritanceTree.Root.childs)
{
GenerateClassMapping(childNode, 1, 1);
}
_inheritanceTree = null;
this.WriteLine("");
this.WriteLine("</hibernate-mapping>");
}
finally
{
writer.Close();
}
}
/// <summary>
/// A la fin de la publication, on met à jour les fichiers des infos de l'assemblie avec le
/// n° de version du modèle.
/// </summary>
/// <param name="model"></param>
/// <param name="modelFileName"></param>
void IStrategyPublishEvents.OnPublicationEnded(CandleModel model, string modelFileName)
{
if (!String.IsNullOrEmpty(T4Template))
{
if (model.SoftwareComponent != null)
{
// Création du fichier AssemblyInfo
foreach (AbstractLayer layer in model.SoftwareComponent.Layers)
{
if (layer is SoftwareLayer)
{
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
if (shell != null)
{
// Recherche du projet associé
Project prj = shell.FindProjectByName(((SoftwareLayer)layer).VSProjectName);
if (prj != null)
{
Context.Project = prj;
CallT4Template(prj, T4Template, layer, _outputFileName);
}
}
}
}
}
}
}
public async Task BuyAsync(CandleModel candle)
{
if (candle != null)
{
if (_userBalanceService.HasOpenOrder)
{
return;
}
var buyPrice = !_userBalanceService.EnableRealtimeTrading ? candle.ClosePrice : _exchangeProvider.GetTicker(_tradingPair).Result.LowestAsk;
_userBalanceService.SetBuyPrice(new CandleModel
{
ClosePrice = buyPrice,
StartDateTime = DateTime.UtcNow
});
if (_userBalanceService.EnableRealtimeTrading)
{
_userBalanceService.OpenOrderNumber = await _exchangeProvider.CreateOrderAsync(TradeType.Buy, _tradingPair, buyPrice, _userBalanceService.Rate);
_userBalanceService.HasOpenOrder = true;
await CheckOrderInvoked(_userBalanceService.OpenOrderNumber, TradeType.Buy);
}
var msg = $"Buy crypto currency. Date: {candle.StartDateTime}; Price: ${buyPrice}; Rate: {_userBalanceService.Rate}; OrderNumber: {_userBalanceService.OpenOrderNumber}\n";
Console.WriteLine(msg);
_emailService.SendEmail(string.Format(_cryptoTradingOptions.EmailSubject, _tradingPair), msg);
}
}
/// <summary>
/// Création d'un fichier zip et envoi sur le serveur
/// </summary>
/// <param name="systemDefinition"></param>
/// <param name="fileNames"></param>
/// <param name="remoteName"></param>
private static void PublishZip(CandleModel systemDefinition, List <string> fileNames, string remoteName)
{
IRepositoryProvider wsRepository = RepositoryManager.Instance.GetMainRemoteProvider();
if (wsRepository == null)
{
return;
}
string tempFile = Path.GetTempFileName();
try
{
RepositoryZipFile zipFile = new RepositoryZipFile(tempFile);
zipFile.ArchiveFiles(fileNames);
wsRepository.PublishModel(systemDefinition, tempFile, remoteName);
}
finally
{
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
}
}
/// <summary>
/// Publication du modèle sur le serveur
/// </summary>
/// <param name="model"></param>
public void PublishLocalModel(CandleModel model)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.BeginProcess(false, true);
logger.BeginStep("Publish on remote server", LogType.Info);
}
try
{
// On récupère ses métadonnées
ComponentModelMetadata data = model.MetaData;
if (data != null)
{
//if( !data.IsLastVersion())
//{
// if (System.Windows.Forms.MessageBox.Show("You want to publish an older version than the server. Do you want to continue ?", "Warning", System.Windows.Forms.MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.Cancel)
// return;
//}
ModelLoader.Save(model, data.GetFileName(PathKind.Absolute));
// On prend tout ce qu'il y a dans le repository local (==> Il faut que la publication locale
// se fasse obligatoirement chaque fois avant )
string[] fileNames = System.IO.Directory.GetFiles(System.IO.Path.GetDirectoryName(data.GetFileName(PathKind.Absolute)));
PublishZip(model, new List <string>(fileNames), ZipFileName);
// Mise à jour des métadatas
Metadatas.SetMetadataPublished(data, model);
if (logger != null)
{
logger.Write("Publish on remote server", "Published on remote server ", LogType.Info);
}
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Publish on remote server ", "Publish on remote server", ex);
}
}
finally
{
if (logger != null)
{
logger.EndStep();
logger.EndProcess();
IIDEHelper ide = ServiceLocator.Instance.IDEHelper;
if (ide != null)
{
ide.ShowErrorList();
}
}
}
}
/// <summary>
/// Indique qu'un modèle vient d'être publié
/// </summary>
/// <param name="data">The data.</param>
/// <param name="model">The model.</param>
internal void SetMetadataPublished(ComponentModelMetadata data, CandleModel model)
{
data.ServerVersion = data.LocalVersion = model.Version.Revision;
MetadataChangedEventArg e = new MetadataChangedEventArg(data);
OnMetadataChanged(e);
}
public Task BuyAsync(CandleModel candle)
{
_hasOpenPosition = true;
_userBalanceService.SetBuyPrice(candle);
Console.WriteLine($"Buy crypto currency. Date: {candle.StartDateTime}; Price: ${candle.ClosePrice}; Rate: {_userBalanceService.Rate}\n");
return(Task.FromResult(0));
}
/// <summary>
/// Initialisation du modèle (lors du chargement du modèle dans le DocData)
/// </summary>
/// <param name="model">The model.</param>
/// <param name="fileName">Name of the file.</param>
internal void SetModel(CandleModel model, string fileName)
{
// On ne charge que celui de la solution courante (au cas ou on a ouvert d'autre modèle en navigant)
string folder = Path.GetDirectoryName(fileName);
try
{
if (!Utils.StringCompareEquals(folder, ServiceLocator.Instance.ShellHelper.SolutionFolder))
{
return;
}
}
catch
{
// Aucune solution ouverte
return;
}
fileName = Path.ChangeExtension(fileName, FileExtension);
if (_config != null && fileName == _filePath)
{
return;
}
// Si il y avait un modèle, on se désabonne.
if (_model != null && _model.Store != null)
{
Dispose(true);
model.Store.EventManagerDirectory.ElementAdded.Remove(
new EventHandler <ElementAddedEventArgs>(OnElementAdded));
model.Store.EventManagerDirectory.ElementDeleted.Remove(
new EventHandler <ElementDeletedEventArgs>(OnElementDeleted));
model.Store.EventManagerDirectory.ElementPropertyChanged.Remove(
new EventHandler <ElementPropertyChangedEventArgs>(OnPropertyChanged));
_initialized = false;
}
_filePath = fileName;
_model = model;
if (model != null)
{
if (Initialize())
{
Load();
try
{
ServiceLocator.Instance.ShellHelper.AddFileToSolution(_filePath);
}
catch
{
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PublishAsTemplateCommand"/> class.
/// </summary>
/// <param name="selection">The selection.</param>
/// <param name="fileName">Name of the file.</param>
public PublishAsTemplateCommand(object selection, string fileName)
{
this._fileName = fileName;
NodeShape shape = selection as NodeShape;
if (shape != null)
{
this._model = shape.ModelElement as CandleModel;
}
}
/// <summary>
/// Copie les executables et les artefacts dans le répertoire d'exécution
/// </summary>
/// <param name="model">The model.</param>
public static void CopyToRuntimeFolder(CandleModel model)
{
if (model.Component == null)
{
return;
}
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
string targetFolder = string.Empty;
try
{
// Recherche du projet de démarrage pour savoir dans quel répertoire copier les artifacts
object[] files = (object[])ServiceLocator.Instance.ShellHelper.Solution.SolutionBuild.StartupProjects;
if (files == null || files.Length == 0)
{
return; // Pas trouvé
}
string startupProjectName = (string)files[0];
startupProjectName = Path.GetFileNameWithoutExtension(startupProjectName);
EnvDTE.Project startupProject = ServiceLocator.Instance.ShellHelper.FindProjectByName(startupProjectName);
if (startupProject == null)
{
// Recherche diffèrente pour un projet web
startupProjectName = Path.GetFileName(startupProjectName);
startupProject = ServiceLocator.Instance.ShellHelper.FindProjectByName(startupProjectName);
if (startupProject == null)
{
if (logger != null)
{
logger.Write("Copy binary to runtime folder error", "Unable to find the startup project " + startupProjectName, LogType.Warning);
}
return;
}
}
// Vérification des dépendances
ReferencesHelper.CheckReferences(false, null, new ConfigurationMode(), ReferenceScope.Runtime, model);
ConfigurationMode mode = new ConfigurationMode(startupProject);
// Répertoire destination
targetFolder = Path.Combine(Path.GetDirectoryName(startupProject.FullName), mode.BinPath);
CopyInFolder(targetFolder, model, mode);
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Copy to runtime folder", String.Format("erreur when copying runtime artifacts to {0}", targetFolder), ex);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GetLastVersionCommand"/> class.
/// </summary>
/// <param name="shape">The shape.</param>
public GetLastVersionCommand(object shape)
{
if (shape != null && shape is PresentationElement)
{
_externalComponent = ((PresentationElement)shape).ModelElement as ExternalComponent;
if (_externalComponent != null)
{
_externalModel = _externalComponent.ReferencedModel;
this._force = _externalComponent.MetaData.IsLastVersion();
}
}
}
ProfitModel IUserBalanceService.GetProfit(decimal sellPrice, DateTime candleDateTime)
{
var sellProfit = sellPrice * Rate - _defaultAmount;
_profit += sellProfit;
LastPrice = new CandleModel
{
ClosePrice = sellPrice,
StartDateTime = candleDateTime
};
return(GetProfit(sellProfit));
}
/// <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;
}
}
}
public Task SellAsync(CandleModel candle)
{
_hasOpenPosition = false;
_userBalanceService.TradingCount++;
var profit = _userBalanceService.GetProfit(candle.ClosePrice, candle.StartDateTime);
var msg = $"Sell crypto currency. Date: {candle.StartDateTime}; Price: ${candle.ClosePrice}; Rate: {_userBalanceService.Rate}\n" +
$"Profit: ${profit.Profit}\n" +
$"Trading time in hours: {Math.Round(profit.TradingTimeInMinutes / 60.0, 2)}\n";
Console.WriteLine(msg);
return(Task.FromResult(0));
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportWsdlCommand"/> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="obj">The obj.</param>
public ImportWsdlCommand(IServiceProvider serviceProvider, object obj)
{
this._serviceProvider = serviceProvider;
_nodeShape = obj as ISupportArrangeShapes;
if (obj is SoftwareComponentShape)
{
this._component = ((SoftwareComponentShape)obj).ModelElement as SoftwareComponent;
_model = _component.Model;
}
else if (obj is Diagram)
{
this._model = ((Diagram)obj).ModelElement as CandleModel;
}
}
/// <summary>
/// Populates the specified current component.
/// </summary>
/// <param name="currentComponent">The current component.</param>
/// <param name="model">The model.</param>
private void Populate(SoftwareComponent currentComponent, CandleModel model)
{
_currentComponent = currentComponent;
lstInheritedConfigurations.AutoGenerateColumns = false;
lstConfigurations.AutoGenerateColumns = false;
if (currentComponent != null)
{
foreach (SoftwareLayer layer in currentComponent.Layers)
{
ColLayer.Items.Add(layer.Name);
}
colVisibility.Items.Add(Visibility.Public);
colVisibility.Items.Add(Visibility.Private);
// Remplissage des configurations courantes
_items = new ItemList();
foreach (SoftwareLayer layer in currentComponent.Layers)
{
foreach (ConfigurationPart cfg in layer.Configurations)
{
Item item = new Item();
item.ConfigName = cfg.Name;
item.XmlContent = cfg.XmlContent;
item.LayerName = layer.Name;
item.LayerId = layer.Id;
item.InitialEnabled = item.Enabled = cfg.Enabled;
item.IsExternal = false;
item.Visibility = cfg.Visibility;
_items.Add(item);
}
}
lstConfigurations.DataSource = _items;
}
else // On enlève cette page
{
tabControl1.TabPages.RemoveAt(0);
}
// Configurations externes
ReferenceWalker walker = new ReferenceWalker(ReferenceScope.Runtime, new ConfigurationMode());
ConfigurationVisitor visitor = new ConfigurationVisitor(true);
walker.Traverse(visitor, model);
lstInheritedConfigurations.DataSource =
visitor.Configurations.FindAll(delegate(ConfigurationPart p) { return(p.Enabled); });
}
/// <summary>
/// Contextual dependency properties filter
/// </summary>
/// <param name="modelElement"></param>
/// <returns></returns>
public override PropertyDescriptorCollection GetCustomProperties(ModelElement modelElement)
{
PropertyDescriptorCollection collections = base.GetCustomProperties(modelElement);
_appName = CandleModel.GetInstance(modelElement.Store).Name;
if (modelElement is ServiceContract || modelElement is ClassImplementation ||
modelElement is Operation || modelElement is Layer)
{
collections.Add(LogCallHandlerProperty.Register(modelElement));
collections.Add(CacheCallHandlerProperty.Register(modelElement));
collections.Add(PerformanceCounterCallHandlerProperty.Register(modelElement));
}
return(collections);
}
