/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 1 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableAModifier = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableAModifier);
}
I2iSerializable objet = m_expressionValeur;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expressionValeur = (C2iExpression)objet;
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CRelationTypeEquipement_TypeTableParametrable relation = (CRelationTypeEquipement_TypeTableParametrable)objet;
if (relation.TypeEquipement == null)
{
result.EmpileErreur(I.T("The Equipment type cannot be null|109"));
}
if (relation.TypeTableParametrable == null)
{
result.EmpileErreur(I.T("Custom table type cannot be empty|379"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------
private void VerifieCoordonnee()
{
CResultAErreur result = CResultAErreur.True;
string strNum = m_niveau.RelationSysCoor_FormatNum.IsolerReference(m_txtValeur.Text);
if (m_txtValeur.Text != "")
{
result = m_niveau.RelationSysCoor_FormatNum.GetIndex(m_txtValeur.Text);
}
if (!result)
{
m_txtValeur.BackColor = Color.Red;
m_tooltip.SetToolTip(m_txtValeur, result.Erreur.ToString());
}
else
{
m_txtValeur.BackColor = Color.White;
SetAideTooltip();
}
if (OnChangeValue != null)
{
OnChangeValue(this, new EventArgs());
}
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonnee objetDonnee = objet as CObjetDonnee;
if (objetDonnee == null)
{
result.Data = null;
return(result);
}
int nIdSmartField = -1;
try
{
nIdSmartField = Int32.Parse(strPropriete);
}
catch
{
result.EmpileErreur(I.T("Bad SmartField field format (@1)|20059", strPropriete));
return(result);
}
CContexteDonnee contexte = objetDonnee.ContexteDonnee;
CSmartField smartField = new CSmartField(contexte);
if (!smartField.ReadIfExists(nIdSmartField))
{
result.EmpileErreur(I.T("Smart field @1 doesn't exists|20060", strPropriete));
return(result);
}
if (smartField.Definition != null)
{
return(CInterpreteurProprieteDynamique.GetValue(objet, smartField.Definition));
}
result.Data = null;
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteObject <CReferenceObjetDonnee>(ref m_reference);
if (!result)
{
return(result);
}
string strLibelle = "";
if (serializer.Mode == ModeSerialisation.Ecriture && m_strLibelle == null)
{
//S'assure que le libellé est bien chargé
strLibelle = Libelle;
}
serializer.TraiteString(ref m_strLibelle);
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CRelationUtilisateur_Profil_EO rel = (CRelationUtilisateur_Profil_EO)objet;
if (rel.UtilisateurProfil == null)
{
result.EmpileErreur(I.T("The relation to User/Profile cannot be null|300"));
}
if (rel.EntiteOrganisationnelle == null)
{
result.EmpileErreur(I.T("The profile of the Organisational Entity cannot be null|301"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
public CNiveauCoordonnee[] DecodeCoordonnee(string strCoordonnee)
{
List <CNiveauCoordonnee> lst = new List <CNiveauCoordonnee>();
if (strCoordonnee == null || strCoordonnee == "")
{
return(null);
}
string[] strNiveaux = strCoordonnee.Split(CSystemeCoordonnees.c_separateurNumerotations);
if (strNiveaux.Length > RelationParametragesNiveau.Count())
{
return(null);
}
CParametrageNiveau[] parametragesNiveaux = ParametragesNiveauxOrdonnees;
//On va remonter niveau par niveau
int nI = 0;
foreach (CParametrageNiveau parametrageNiv in ParametragesNiveauxOrdonnees)
{
string strNiv = strNiveaux[nI];
//Vérification syntaxique de la partie de coordonnée
string strPrefixe = parametrageNiv.RelationSysCoor_FormatNum.IsolerPrefixe(strNiv);
CResultAErreur result = parametrageNiv.RelationSysCoor_FormatNum.GetIndex(strNiv);
if (!result)
{
return(null);
}
int nIndex = (int)result.Data;
lst.Add(new CNiveauCoordonnee(strNiv, strPrefixe, nIndex));
}
return(lst.ToArray());
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le fichier ou l'url
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleLibelle.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the Label evaluation|20002"));
return(result);
}
CVersionDonnees version = new CVersionDonnees(contexte.ContexteDonnee);
version.CreateNew();
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Etiquette;
version.Libelle = (string)result.Data;
version.Date = DateTime.Now;
result = version.CommitEdit();
if (!result)
{
return(result);
}
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
public override sc2i.common.CResultAErreur MyMajChamps()
{
CResultAErreur result = base.MyMajChamps();
if (!result)
{
return(result);
}
if (Equipement != null && m_spvEquip == null && m_extModeEdition.ModeEdition)
{
m_spvEquip = CSpvEquip.GetSpvEquipFromEquipementAvecCreation(Equipement);
}
m_spvEquip.AdresseIP = m_txtBoxIPAddress.Text;
m_spvEquip.IndexSnmp = m_txtBoxSnmpIndex.Text;
m_spvEquip.CommunauteSnmp = m_txtBoxSnmpCommunity.Text;
m_spvEquip.ReferenceSnmpTypeEquipement = m_txtBoxEquiptTypeSnmpReference.Text;
m_spvEquip.EquipementDeMediation = m_txtBoxMediationEquipment.Text;
m_spvEquip.ARedecouvrirPeriodiquement = m_chkToRediscover.Checked;
m_spvEquip.ASuperviser = m_chkToSurv.Checked;
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CCalendrier calendrier = (CCalendrier)objet;
if (calendrier.Libelle == "")
{
result.EmpileErreur(I.T("The label cannot be empty|126"));
}
if (calendrier.HoraireParDefaut == null)
{
result.EmpileErreur(I.T("The default daily schedule must be defined|169"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
if (table == null)
{
return(result);
}
ArrayList lst = new ArrayList(table.Rows);
foreach (DataRow row in table.Rows)
{
if (row.RowState == DataRowState.Modified)
{
}
}
return(result);
}
//-------------------------------------------------------
public CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_generator != null)
{
if (CurrentItemIndex != null)
{
ItemControl.MajChamps();
}
List <CMapLineDessin> lst = new List <CMapLineDessin>();
foreach (CCustomizableListItem item in Items)
{
CMapLineDessin dessin = item.Tag as CMapLineDessin;
if (dessin != null)
{
dessin.Index = item.Index;
lst.Add(dessin);
}
}
m_generator.LinesDessin = lst.ToArray();
}
return(result);
}
private void m_btnOk_Click(object sender, EventArgs e)
{
//Vérifie l'équipement
CResultAErreur result = CResultAErreur.True;
result = m_selectTypeEquipement.MajChamps();
result &= m_panelCoordonnee.MajChamps();
if (m_releveEqpt.TypeEquipement == null)
{
result.EmpileErreur(I.T("Select equipment type|20030"));
}
if (result)
{
m_releveEqpt.NumeroSerie = m_txtSerial.Text;
}
if (result)
{
foreach (Control ctrl in m_panelChampsCustom.Controls)
{
CControleForCustomFieldReleve c = ctrl as CControleForCustomFieldReleve;
if (c != null)
{
result = c.MajChamp();
}
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
Close();
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CRelationTypeEO_FormulaireParType rel = (CRelationTypeEO_FormulaireParType)objet;
if (rel.TypeEntiteOrganisationnelle == null)
{
result.EmpileErreur(I.T("The Organisational Entity Type cannot be null|298"));
}
if (rel.Formulaire == null)
{
result.EmpileErreur(I.T("The form cannot be null|299"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------------------------------------
public CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <IPostFilter> resPost = new CResultAErreurType <IPostFilter>();
if (m_editeurEnCours != null)
{
resPost = m_editeurEnCours.MajChamps();
if (!resPost)
{
result.EmpileErreur(resPost.Erreur);
return(result);
}
if (m_odeqTable != null)
{
m_odeqTable.PostFilter = resPost.DataType;
}
}
else
{
m_odeqTable.PostFilter = null;
}
return(result);
}
///////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
//TODO : Insérer la logique de vérification de donnée
CSpvFamilleMibmodule familleSPV = (CSpvFamilleMibmodule)objet;
// Vérifier que le libellé est renseigné
if (familleSPV.ChampLibelle == "")
{
result.EmpileErreur(I.T("The family label must be specified|50008"));
}
// Vérifier que la famille n'est pas son propre parent
CSpvFamilleMibmodule familleMere = familleSPV.FamilleParente;
while (familleMere != null)
{
if (familleMere == familleSPV)
{
result.EmpileErreur(I.T("Error in the family hierarchy, the family is its own parent family|50009"));
return(result);
}
familleMere = familleMere.FamilleParente;
}
// Vérifier que la famille est unique dans la branche
result = VerifieUnicite(familleSPV);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
bool bErreur = false;
if (GetNbParametresNecessaires() >= 0 && Parametres.Count != GetNbParametresNecessaires())
{
result.EmpileErreur(I.T("The expected number of parameters isn't correct (@1 expected)|172", GetNbParametresNecessaires().ToString()));
return(result);
}
try
{
result = Parametres2i[0].Eval(ctx);
bErreur = !result.Result;
if (result.Data is Double && Double.IsNaN((double)result.Data))
{
result = Parametres2i[1].Eval(ctx);
}
}
catch
{
bErreur = true;
}
if (bErreur)
{
result = Parametres2i[1].Eval(ctx);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = base.TraitementAvantSauvegarde(contexte);
DataTable table = contexte.Tables[CLienReseauSupport.c_nomTable];
if (table != null)
{
ArrayList lstRows = new ArrayList(table.Rows);
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
{
CLienReseauSupport sup = new CLienReseauSupport(row);
/* if(!sup.EstSupporte.CanSupport(sup.Supporte))
* {
* result.EmpileErreur("Impossible to add the link : the supported link @1 is supported by the supporting link @2|", sup.Supporte.Libelle,sup.EstSupporte.Libelle);
* return result;
* }*/
}
}
}
return(result);
}
/// <summary>
/// Cette méthode va vérifier que pour la coordonnee et son occupation il n'y a une interaction <br/>
/// avec d'une liste d'objets à coordonnées
/// </summary>
/// <param name="strCoordonneeDebut">Coordonnée souhaité</param>
/// <param name="strCoordonneeFin">Coordonnée de fin (Coordonnée Souhaité + Occupation)</param>
/// <param name="lstobj">Liste des objets à tester pour savoir si il y a une interaction</param>
/// <returns>Renvoi faux si aucune interaction</returns>
public CResultAErreur Test_Interactions(
string strCoordonneeDebut,
string strCoordonneeFin,
List <IObjetACoordonnees> lstobj)
{
CResultAErreur result = CResultAErreur.True;
List <IObjetACoordonnees> conflits = new List <IObjetACoordonnees>();
foreach (IObjetACoordonnees obj in lstobj)
{
if (obj.Coordonnee != null && obj.Coordonnee != "")
{
string strCoorfilsdebut = obj.Coordonnee;
string strCoorfilsfin = strCoorfilsdebut;
//Il faut que la fin du fils soit avant le debut de la coor
int compare1 = SystemeCoordonnees.CompareAdresse(strCoorfilsdebut, strCoordonneeDebut, true);
//Ou que le debut du fils soit apres la fin de la coor
int compare2 = SystemeCoordonnees.CompareAdresse(strCoorfilsfin, strCoordonneeFin, true);
if (compare1 < 0 || compare2 > 0)
{
continue;
}
else
{
result.EmpileErreur(I.T("@1 occupies a coordinate in conflict with the coordinate @2 (at @3)|180", obj.DescriptionElement, strCoordonneeDebut, strCoordonneeFin));
conflits.Add(obj);
}
}
}
result.Data = conflits;
return(result);
}
/// ////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees()
{
CResultAErreur result = CResultAErreur.True;
if (m_expressionElementSource == null)
{
result.EmpileErreur(I.T("Incorrect formula for Edited element|385"));
}
if (!(m_expressionElementSource.TypeDonnee.TypeDotNetNatif.IsSubclassOf(typeof(CObjetDonnee))) ||
m_expressionElementSource.TypeDonnee.IsArrayOfTypeNatif)
{
result.EmpileErreur(I.T("The edited element formula must return an entity|386"));
}
if (m_formuleParametresImpression == null ||
!typeof(string).IsAssignableFrom(m_formuleParametresImpression.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("Print setup formula is not correct|20041"));
}
if (m_nIdModeleAImprimer < 0)
{
result.EmpileErreur(I.T("The text modele must be selected|20040"));
}
return(result);
}
//-------------------------------------------------------------
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = SerializeParent <CTypeSite>(serializer);
if (result)
{
result = SerializeParent <CTypeSite>(serializer);
}
if (result)
{
result = SerializeParent <CSite>(serializer);
}
if (result)
{
result = SerializeParent <CTypeEquipement>(serializer);
}
if (result)
{
result = SerializeParent <CStock>(serializer);
}
if (result)
{
result = SerializeParent <CEquipement>(serializer);
}
if (result)
{
result = SerializeParent <CSystemeCoordonnees>(serializer);
}
return(result);
}
/// ////////////////////////////////////////////
public CResultAErreur ExecuteAction(string strCodeAction, Hashtable valeursParametres)
{
//Alloue l'action
Type tp = (Type)m_tableCodeActionToType[strCodeAction];
CResultAErreur result = CResultAErreur.True;
if (tp == null)
{
result.EmpileErreur(I.T("No action with the code '@1' exists|104", strCodeAction));
return(result);
}
IActionSurServeur action = null;
try
{
action = (IActionSurServeur)Activator.CreateInstance(tp);
}
catch
{
result.EmpileErreur(I.T("Impossible to allocate an action of the @1 type|105", strCodeAction));
return(result);
}
return(action.Execute(IdSession, valeursParametres));
}
//------------------------------------------------------
public static void EditeRestricitionsSpecifiques(
IElementARestrictionsSpecifiques element,
bool bModeEdition)
{
CFormEditRestrictionsSpecifiques form = new CFormEditRestrictionsSpecifiques();
CObjetDonneeAIdNumerique objet = element as CObjetDonneeAIdNumerique;
objet.BeginEdit();
form.m_elementARestrictions = objet as IElementARestrictionsSpecifiques;
form.m_extModeEdition.ModeEdition = bModeEdition;
if (form.ShowDialog() == DialogResult.OK && bModeEdition)
{
CResultAErreur result = objet.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
else
{
objet.CancelEdit();
}
form.Dispose();
}
public CResultAErreur MajChamps()
{
CResultAErreur result = m_linkField.FillObjetFromDialog(m_agentFinder);
if (result)
{
m_agentFinder.FormuleDeclenchement = m_txtFormuleCondition.Formule;
m_agentFinder.GenericRequestedValue = m_cmbGenericCode.SelectedItem as GenericCode?;
}
m_agentFinder.AutoUpdateIpOnMediationServices = m_chkUpdateIPOnMediation.Checked;
m_agentFinder.AutoUpdateIpOnTimosDatabase = m_chkUpdateIpInTimos.Checked;
m_agentFinder.FormuleCleSpecifique = m_txtFormuleCleSpecifiqueAgent.Formule;
if (result)
{
result = m_agentFinder.VerifieDonnees();
}
if (result)
{
m_originalAgentFinder.Database.Merge(m_agentFinder.Database, false);// ImporteObjet(m_handler, true, true);
//CCloner2iSerializable.CopieTo(m_handler, m_originalHandler);
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
string strFormat = "";
if (Parametres.Count == 2)
{
strFormat = valeursParametres[1].ToString();
}
object objet = valeursParametres[0];
if (objet == null)
{
result.Data = null;
}
else
{
if (strFormat != "")
{
MethodInfo method = objet.GetType().GetMethod("ToString", new Type[] { typeof(string) });
if (method != null)
{
result.Data = method.Invoke(objet, new object[] { strFormat });
}
else
{
result.Data = objet.ToString();
}
}
else
{
result.Data = objet.ToString();
}
}
return(result);
}
/// //////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = MyExecute(contexte);
if (!result)
{
result.EmpileErreur(I.T("@1 action execution error|203", Libelle));
return(result);
}
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length < 1)
{
result.Data = null;
}
else if (liens.Length == 1)
{
result.Data = liens[0];
}
else
{
result.Data = liens;
}
return(result);
}
//----------------------------------------------
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = SerializeChamps(serializer,
c_champIp,
c_champCommunaute,
c_champPort,
c_champVersionSnmp);
if (result)
{
result = SerializeParent <CTypeAgentPourSupervision>(serializer);
}
if (result)
{
result = SerializeChilds <CEntiteSnmpPourSupervision>(serializer);
}
if (nVersion >= 1 && result)
{
result = SerializeChamp(serializer, c_champTrapsIp);
}
if (nVersion >= 2 && result)
{
result = SerializeChilds <CSnmpPollingSetup>(serializer);
}
if (nVersion >= 3 && result)
{
result = SerializeChilds <CSnmpHotelPollingSetup>(serializer);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
try
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CActeur));
CFiltreData filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
"Has(" + CEOplanifiee_Acteur.c_nomTable + "." + CEOplanifiee_Acteur.c_champId + ")");
liste.Filtre = filtre;
foreach (CActeur acteur in liste)
{
//Il suffit de modifier l'acteur pour qu'on recalcule ces eos
CUtilElementAEO.UpdateEOSInCurrentContext(acteur);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
MyDispose();
CResultAErreur result = CResultAErreur.True;
CActionCopierLocalDansGed.CParametresCopierLocalDansGed paramCopie = parametre as CActionCopierLocalDansGed.CParametresCopierLocalDansGed;
if (paramCopie == null)
{
result.EmpileErreur(I.T("Bad parameter value for service GetLocalFile|20121"));
return(result);
}
if (paramCopie.NomFichierLocal.ToUpper().StartsWith("FTP://"))
{
//Si FTP récupère le fichier FTP et l'envoie dans un fichier local temporaire
result = GetFileFromFtp(paramCopie);
if (!result)
{
return(result);
}
paramCopie.NomFichierLocal = m_fichierTemporaireFromFTP.NomFichier;
}
string strNomFichier = paramCopie.NomFichierLocal;
if (!File.Exists(strNomFichier))
{
result.EmpileErreur(I.T("File @1 doesn't exists|20122", strNomFichier));
return(result);
}
m_streamFichier = new FileStream(strNomFichier, FileMode.Open, FileAccess.Read);
CSourceDocumentStream source = new CSourceDocumentStream(
m_streamFichier, Path.GetExtension(strNomFichier));
result.Data = source;
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CCategorieGED cat = (CCategorieGED)objet;
if (cat.Libelle == "")
{
result.EmpileErreur(I.T("The category label cannot be empty|105"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(cat, CCategorieGED.c_champLibelle, cat.Libelle))
{
result.EmpileErreur(I.T("Another category with this label already exists|106"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
