/// <summary> /// Affichage d'une trace /// </summary> /// <param name="origin">Décrit qui est à l'origine du message</param> /// <param name="message">Le message.</param> /// <param name="messageType">Le type du message.</param> public void Write(string origin, string message, LogType messageType) { if (_wnd != null && messageType != LogType.Debug) // sauf debug { _wnd.AddText(message, messageType); } try { IIDEHelper ide = ServiceLocator.Instance.IDEHelper; if (ide != null) { if (messageType == LogType.Error) { ide.LogError(false, message, 0, 0, origin); } if (messageType == LogType.Warning) { ide.LogError(true, message, 0, 0, origin); } if (messageType != LogType.Debug || CandleSettings.GenerationTraceEnabled) { string pad = new string(' ', _tab); ide.LogMessage(String.Concat(pad, message), origin); } } } catch {// TODO créer un logger pour le repository } }
/// <summary> /// Création de l'instance de la strategie contenu dans le manifest /// </summary> /// <param name="owner"></param> /// <param name="manifest">Manifest contenant la stratégie</param> /// <returns></returns> public StrategyBase AddStrategy(CandleElement owner, StrategyManifest manifest) { InternalPackage package = GetPackage(manifest.PackageName); if (package == null) { return(null); } StrategyBase strategy = package.CreateStrategyInstance(manifest.StrategyTypeName, manifest.StrategyConfiguration); if (strategy != null) { strategy.Owner = GetStrategyOwnerName(owner); // Vérification des doublons foreach (StrategyBase other in _strategies) { if (other.Owner == strategy.Owner && other.StrategyId == strategy.StrategyId) { return(other); } } try { strategy.OnLoading(this, new EventArgs()); _strategies.Add(strategy); } catch (Exception ex) { IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>(); if (ide != null) { ide.ShowMessageBox("Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, "Error", System.Windows.Forms.MessageBoxButtons.OK); ide.LogError(false, "Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, 0, 0, "StrategyManager"); } } } return(strategy); }
/// <summary> /// Chargement /// </summary> /// <param name="store">The store.</param> /// <param name="fileName">Name of the file.</param> /// <returns></returns> public static StrategyManager Load(Store store, string fileName) { ILogger logger = ServiceLocator.Instance.GetService <ILogger>(); if (String.IsNullOrEmpty(fileName)) { return(null); } StrategyManager sm = null; try { using (StreamReader reader = new StreamReader(fileName)) { // Désérialization de la description XmlSerializer serializer = new XmlSerializer(typeof(StrategyManager)); sm = (StrategyManager)serializer.Deserialize(reader); // Lecture et chargement des types List <Type> types = new List <Type>(); foreach (StrategyTypeReference str in sm.StrategyTypes) { InternalPackage package = sm.GetPackage(str.PackageName); if (package != null) { Type type = package.GetStrategyType(str.StrategyTypeName); if (type != null) { types.Add(type); } } } // D'abord chargement de la stratégie de nommage if (sm.NamingStrategyNode != null) { using (XmlNodeReader nr = new XmlNodeReader(sm.NamingStrategyNode)) { serializer = new XmlSerializer(typeof(BaseNamingStrategy), types.ToArray()); sm._namingStrategy = (INamingStrategy)serializer.Deserialize(nr); } } // Chargement des strategies if (sm.StrategiesNode != null) { using (XmlNodeReader nr = new XmlNodeReader(sm.StrategiesNode)) { serializer = new XmlSerializer(typeof(StrategyCollection), types.ToArray()); sm._strategies = (StrategyCollection)serializer.Deserialize(nr); } foreach (StrategyBase strategy in sm._strategies) { try { strategy.OnLoading(sm, new EventArgs()); StrategyPackage package = sm.GetPackage(strategy.PackageName) as StrategyPackage; if (package != null) { strategy.StrategyFolder = package.PackageFolder; } } catch (Exception ex) { IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>(); if (ide != null) { ide.ShowMessageBox("Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, "Error", System.Windows.Forms.MessageBoxButtons.OK); ide.LogError(false, "Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, 0, 0, "StrategyManager"); } } } } } } catch (Exception ex) { string text = ex.Message; XmlException xex = ex as XmlException; StringBuilder sb = new StringBuilder(ex.Message); if (xex != null) { sb.AppendFormat(" line={0}, column={1}", xex.LineNumber, xex.LinePosition); } Exception iex = ex.InnerException; while (iex != null) { sb.Append(" - "); sb.Append(iex.Message); iex = iex.InnerException; } text = sb.ToString(); if (logger != null) { logger.WriteError("StrategyManager", String.Format("Loading error {0}", text), ex); } IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>(); if (ide != null) { ide.ShowMessage("Error when reading the strategies file (see error in the task list). A new empty file will be initialized. The current strategies file will be saved with a .bak extension"); } try { // Sauvegarde du fichier en erreur if (File.Exists(fileName)) { Utils.CopyFile(fileName, fileName + ".bak"); } } catch { } } if (sm == null) { // Génération d'un fichier par défaut sm = new StrategyManager(); sm.FileName = fileName; sm.Save(store); } else { sm.FileName = fileName; } return(sm); }
/// <summary> /// Création d'une dépendance avec une assembly importée /// </summary> /// <param name="asm">The asm.</param> internal void InsertDependencies(Assembly asm) { // Gestion des dépendances List <AssemblyName> referencedAssemblies = GetAssemblyListToCreate(asm); if (referencedAssemblies.Count == 0) { return; } // On va demander de faire le mapping entre l'assembly et les modèles // Fenetre permettant de trouver le lien entre une assembly et son modèle ReferencedAssembliesForm form = new ReferencedAssembliesForm(this, referencedAssemblies.ToArray()); if (form.ShowDialog() == DialogResult.OK) { // Création des composants externes List <ExternalComponent> externalComponents = new List <ExternalComponent>(); foreach (ComponentMetadataMap map in form.SelectedAssemblyBindings) { if (!map.AlreadyExists) { externalComponents.Add(map.CreateComponent(Component.Model)); } } // Puis création des relations avec eux foreach (ExternalComponent externalComponent in externalComponents) { // Pour l'instant, on ne crée des références qu'avec des composants binaires if (externalComponent == null || externalComponent.MetaData == null || externalComponent.MetaData.ComponentType != ComponentType.Library) { continue; } if (externalComponent.Ports.Count == 1) { if (ExternalServiceReference.GetLink(this, externalComponent.Ports[0]) == null) { ExternalServiceReference esr = new ExternalServiceReference(this, externalComponent.Ports[0]); esr.Scope = ReferenceScope.Runtime; } } else if (externalComponent.Ports.Count > 1) { string assemblyName = asm.GetName().Name; foreach (ExternalPublicPort port in externalComponent.Ports) { if (Utils.StringCompareEquals(port.Name, assemblyName) || Utils.StringCompareEquals(port.Parent.Name, assemblyName)) { if (ExternalServiceReference.GetLink(this, port) == null) { ExternalServiceReference esr = new ExternalServiceReference(this, port); esr.Scope = ReferenceScope.Runtime; } break; } } } else { IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>(); ide.LogError(false, String.Format("Can not create relationship between {0} and {1}", this.Name, externalComponent.Name), 0, 0, "Import"); } } } }