//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGrilleGenerique grille = (CGrilleGenerique)objet;
if (grille.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("Grid label cannot be empty|317"));
}
//Controler que le libellé est unique pour le type
if (!CObjetDonneeAIdNumerique.IsUnique(grille, CGrilleGenerique.c_champLibelle, grille.Libelle))
{
result.EmpileErreur(I.T("Another Grid has the same label|318"));
}
if (grille.Code.Trim() != "")
{
if (!CObjetDonneeAIdNumerique.IsUnique(grille, CGrilleGenerique.c_champCode, grille.Code))
{
result.EmpileErreur(I.T("Another Grid has the same code|319"));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEquipementLogique typeEquipementLogique = (CTypeEquipementLogique)objet;
if (typeEquipementLogique.Libelle == "")
{
result.EmpileErreur(I.T("Logical equipment type label cannot be empty|20006"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(typeEquipementLogique, CTypeEquipementLogique.c_champLibelle, typeEquipementLogique.Libelle))
{
result.EmpileErreur(I.T("This logical equipment type label already exists|20007"));
}
if (typeEquipementLogique.Famille == null)
{
result.EmpileErreur(I.T("The logical equipment type must be associated to a family|20008"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CParametreSynchronisationInDb parametre = (CParametreSynchronisationInDb)objet;
if (parametre.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The parameter name cannot be empty|129"));
}
if (parametre.Code.Trim() == "")
{
result.EmpileErreur(I.T("The parameter code cannot be empty|130"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(parametre, CParametreSynchronisationInDb.c_champCode, parametre.Code))
{
result.EmpileErreur(I.T("Another parameter with this code already exist|131"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CRestrictionChampCustom flag = (CRestrictionChampCustom)objet;
if (flag.Libelle == "")
{
result.EmpileErreur(I.T("Flag label cannot be empty|280"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(flag, CRestrictionChampCustom.c_champValeurFlag, flag.ValeurFlag.ToString()))
{
result.EmpileErreur(I.T("A flag already exist with this value|281"));
}
if (flag.ValeurFlag > 31 || flag.ValeurFlag < 1)
{
result.EmpileErreur(I.T("Flag value must be ranking between 1 and 31|282"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGroupeUtilisateursSynchronisation groupe = (CGroupeUtilisateursSynchronisation)objet;
if (groupe.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The group name cannot be empty|124"));
}
if (groupe.Code.Trim() == "")
{
result.EmpileErreur(I.T("The group code cannot be empty|123"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeUtilisateursSynchronisation.c_champCode, groupe.Code))
{
result.EmpileErreur(I.T("Another group with this code already exist|122"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
///////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CChampCalcule champ = (CChampCalcule)objet;
if (champ.Nom == "")
{
result.EmpileErreur(I.T("The calculated field name cannot be empty|105"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(champ, CChampCalcule.c_champNom, champ.Nom))
{
result.EmpileErreur(I.T("A calculated field with this name already exist|106"));
}
if (champ.TypeObjets == null)
{
result.EmpileErreur(I.T("The associated object type with the calculated field is false|107"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CSequenceNumerotation SequenceNumerotation = (CSequenceNumerotation)objet;
if (SequenceNumerotation.Libelle == "")
{
result.EmpileErreur(I.T("Sequence Label cannot be empty|20175"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(SequenceNumerotation, CSequenceNumerotation.c_champLibelle, SequenceNumerotation.Libelle))
{
result.EmpileErreur(I.T("Sequence '@1' already exist|20176", SequenceNumerotation.Libelle));
}
if (SequenceNumerotation.FormatNumerotation == null)
{
result.EmpileErreur(I.T("Select a numbering format|20177"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CComportementGenerique comportement = (CComportementGenerique)objet;
if (comportement.Libelle == "")
{
result.EmpileErreur(I.T("The label of the behavior cannot be empty|102"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(comportement, CComportementGenerique.c_champLibelle, comportement.Libelle))
{
result.EmpileErreur(I.T("A behavior with this label already exists|103"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//////////////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEntreeAgenda typeEntree = (CTypeEntreeAgenda)objet;
if (typeEntree.Libelle == "")
{
result.EmpileErreur(I.T("Diary entry type label should not be empty|347"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(typeEntree, CTypeEntreeAgenda.c_champLibelle, typeEntree.Libelle))
{
result.EmpileErreur(I.T("Another type of diary entry already has this label|249"));
}
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Diary entry type data error|348"));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CUniteCoordonnee uniteCoordonnee = (CUniteCoordonnee)objet;
if (uniteCoordonnee.Libelle == "")
{
result.EmpileErreur(I.T("The label of the unit cannot be empty|174"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(uniteCoordonnee, CUniteCoordonnee.c_champLibelle, uniteCoordonnee.Libelle))
{
result.EmpileErreur(I.T("The unit '@1' already exists|173", uniteCoordonnee.Libelle));
}
if (uniteCoordonnee.Abreviation == "")
{
result.EmpileErreur(I.T("The abbreviation of the unit cannot be empty|175"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(uniteCoordonnee, CUniteCoordonnee.c_champAbreviation, uniteCoordonnee.Abreviation))
{
result.EmpileErreur(I.T("The abbreviation '@1' already exists|176", uniteCoordonnee.Abreviation));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
///////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CConsultationAlarmesEnCoursInDb consultAl = objet as CConsultationAlarmesEnCoursInDb;
if (consultAl.Libelle.Length == 0)
{
result.EmpileErreur(I.T("Consultation name should be defined|60007"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(consultAl, CConsultationAlarmesEnCoursInDb.c_champLibelle, consultAl.Libelle))
{
result.EmpileErreur(I.T("The consultation '@1' already exist|60007", consultAl.Libelle));
}
if (consultAl.Parametres.ListeColonnes.Length <= 0)
{
result.EmpileErreur(I.T("Select data to display|60010"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CModeleTexte modele = (CModeleTexte)objet;
if (modele.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("Text Model label cannot be empty|321"));
}
//Controler que le libellé est unique pour le type
if (!CObjetDonneeAIdNumerique.IsUnique(modele, CModeleTexte.c_champLibelle, modele.Libelle))
{
result.EmpileErreur(I.T("Another model has the same label|322"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CStatutEquipement statutEquipement = (CStatutEquipement)objet;
if (statutEquipement.Libelle == "")
{
result.EmpileErreur(I.T("The Equipment Status label cannot be empty|118"));
}
if (statutEquipement.Code == "")
{
result.EmpileErreur(I.T("The Equipment Status code can not be empty|119"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(statutEquipement, CStatutEquipement.c_champLibelle, statutEquipement.Libelle))
{
result.EmpileErreur(I.T("Another equipment status with the same name already exists|120"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(statutEquipement, CStatutEquipement.c_champCode, statutEquipement.Code))
{
result.EmpileErreur(I.T("Another equipment status with the same code already exists|121"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CFormatNumerotation formatNumerotation = (CFormatNumerotation)objet;
if (formatNumerotation.Libelle == "")
{
result.EmpileErreur(I.T("The numbering format label cannot be empty|192"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(formatNumerotation, CFormatNumerotation.c_champLibelle, formatNumerotation.Libelle))
{
result.EmpileErreur(I.T("The numbering format '@1' already exists|193", formatNumerotation.Libelle));
}
//lstcrscfn.Filtre = new CFiltreData(CFormatNumerotation.c_champId + " = @1", CFormatNumerotation.c_champId);
if (IsUsed(new int[] { formatNumerotation.Id }))
{
result.EmpileErreur(I.T("The numbering format is used by one or more coordinate systems : it cannot be modified|194"));
return(result);
}
if (!formatNumerotation.Romain)
{
//Longueur Sequence
if (formatNumerotation.Sequence.Trim().Length < 1)
{
result.EmpileErreur(I.T("The sequence must contain at least two characters|195"));
}
//Verifie une redondance de séquence
foreach (char c in formatNumerotation.Sequence.Trim().ToUpper().ToCharArray())
{
if (c == CSystemeCoordonnees.c_separateurNumerotations)
{
result.EmpileErreur(I.T("Bad separator character '@1' |240", CSystemeCoordonnees.c_separateurNumerotations.ToString()));
break;
}
else if (formatNumerotation.Sequence.Trim().ToUpper().IndexOf(c) != formatNumerotation.Sequence.Trim().ToUpper().LastIndexOf(c))
{
result.EmpileErreur(I.T("Invalid sequence due to redundancy|136"));
break;
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeEquipement typeEquipement = (CTypeEquipement)objet;
if (typeEquipement.Libelle == "")
{
result.EmpileErreur(I.T("The equipment type label cannot be empty|255"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(typeEquipement, CTypeEquipement.c_champLibelle, typeEquipement.Libelle))
{
result.EmpileErreur(I.T("This equipment type label already exist|256"));
}
//Vérifie les héritages cycliques !!
foreach (CRelationTypeEquipement_Heritage heritage in typeEquipement.RelationsTypesFils)
{
if (typeEquipement.HeriteDe(heritage.TypeFils))
{
result.EmpileErreur(I.T("Cyclic inheritance (child) @1|257", heritage.TypeFils.Libelle));
break;
}
}
foreach (CRelationTypeEquipement_Heritage heritage in typeEquipement.RelationsTypesParents)
{
if (heritage.TypeParent.HeriteDe(typeEquipement))
{
result.EmpileErreur(I.T("Cyclic inheritance (parent) @1|258", heritage.TypeFils.Libelle));
break;
}
}
if (typeEquipement.Famille == null)
{
result.EmpileErreur(I.T("The Equipment Type must be associated to a family|124"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CEvenement evt = (CEvenement)objet;
if (evt.Libelle.Trim() == string.Empty)
{
result.EmpileErreur(I.T("The Event label could not be empty|114"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(evt, CEvenement.c_champLibelle, evt.Libelle))
{
result.EmpileErreur("An Event with the same label already exist|116");
}
if (evt.TypeCible == null)
{
result.EmpileErreur(I.T("Target Type incorrect|107"));
}
if (evt.TypeEvenement == TypeEvenement.Date)
{
if (evt.ProprieteSurveillee == null)
{
result.EmpileErreur(I.T("The supervised property is not valid|108"));
}
else
{
if (evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(DateTime) &&
evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(CDateTimeEx) &&
evt.ProprieteSurveillee.TypeDonnee.TypeDotNetNatif != typeof(DateTime?))
{
result.EmpileErreur(I.T("The supervised property must be of the Date/Time type|109"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGroupeActeur groupe = (CGroupeActeur)objet;
if (groupe.Nom == "")
{
result.EmpileErreur(I.T("Member Group name cannot be empty|273"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeActeur.c_champNom, groupe.Nom))
{
result.EmpileErreur(I.T("Member Group name already exists|274"));
}
if (groupe.IdGroupeAd != "")
{
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeActeur.c_champGroupeWindowsCorrespondant, groupe.IdGroupeAd))
{
result.EmpileErreur(I.T("Another Member Group is already associated with this AD Group|275"));
}
}
int[] nIdsGroupesContenus = groupe.GetHierarchieGroupesContenus();
int[] nIdsGroupeContenants = groupe.GetHierarchieGroupesContenants();
foreach (int i in nIdsGroupeContenants)
{
foreach (int j in nIdsGroupesContenus)
{
if (i == j && i != groupe.Id && j != groupe.Id)
{
result.EmpileErreur(I.T("Incorrect Group hierarchy|276"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CStock stock = (CStock)objet;
if (stock.Libelle == "")
{
result.EmpileErreur(I.T("Stock label cannot be empty|111"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(stock, CStock.c_champLibelle, stock.Libelle))
{
result.EmpileErreur(I.T("Another Stock with the same label already exists|112"));
}
if (stock.TypeStock == null)
{
result.EmpileErreur(I.T("Stock Type cannot be empty|116"));
}
if (stock.Site == null)
{
result.EmpileErreur(I.T("The Stock related Site cannot be empty|117"));
}
if (result)
{
result = SObjetAFilsACoordonneeServeur.VerifieDonnees(stock);
}
if (result)
{
result = stock.VerifieCoordonnee();
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CEasyQueryInDb easyQueryInDb = (CEasyQueryInDb)objet;
if (easyQueryInDb.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The Stored query name cannot be empty|20009"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(easyQueryInDb, CEasyQueryInDb.c_champLibelle, easyQueryInDb.Libelle))
{
result.EmpileErreur(I.T("The stored query name '@1' is already used|20008", easyQueryInDb.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CProcessInDb process = (CProcessInDb)objet;
if (process.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The Action label could not be empty|113"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(process, CProcessInDb.c_champLibelle, process.Libelle))
{
result.EmpileErreur(I.T("An Action with the same label already exist|115"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CFormulaire formulaire = (CFormulaire)objet;
if (formulaire.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The form name cannot be empty|119"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(formulaire, CFormulaire.c_champLibelle, formulaire.Libelle))
{
result.EmpileErreur(I.T("The form name '@1' is already used|120", formulaire.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGroupeParametrage groupe = (CGroupeParametrage)objet;
if (groupe.Libelle.Trim() == "")
{
result.EmpileErreur(I.T("The label of the group of parameter setting should not be empty|111"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeParametrage.c_champLibelle, groupe.Libelle))
{
result.EmpileErreur(I.T("The @1 group already exists|112", groupe.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGPSCarte carte = (CGPSCarte)objet;
if (carte.Libelle == "")
{
result.EmpileErreur(I.T("GPS map Label cannot be empty|20002"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(carte, CGPSCarte.c_champLibelle, carte.Libelle))
{
result.EmpileErreur(I.T("GPS map '@1' already exist|20003", carte.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeContrat type_Contrat = (CTypeContrat)objet;
if (type_Contrat.Libelle == "")
{
result.EmpileErreur(I.T("Contract type label can not be empty|353"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(type_Contrat, CTypeContrat.c_champLibelle, type_Contrat.Libelle))
{
result.EmpileErreur(I.T("This contract type Label already exists|354"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
///////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeDonneeCumulee type = (CTypeDonneeCumulee)objet;
if (type.Libelle == "")
{
result.EmpileErreur(I.T("The value label cannot be empty|141"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(type, CTypeDonneeCumulee.c_champCode, type.Code))
{
result.EmpileErreur(I.T("A data type with this code already exist|142"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CConfigMapDatabase config = (CConfigMapDatabase)objet;
if (config.Libelle == "")
{
result.EmpileErreur(I.T("Map setup should not be empty|20000"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(config, CConfigMapDatabase.c_champLibelle, config.Libelle))
{
result.EmpileErreur(I.T("Map setup '@1' already exist|20001", config.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CSnmpMibModule SnmpMibModule = (CSnmpMibModule)objet;
if (SnmpMibModule.Libelle == "")
{
result.EmpileErreur(I.T("Mib module label can not be empty|20143"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(SnmpMibModule, CSnmpMibModule.c_champModuleId, SnmpMibModule.ModuleId))
{
result.EmpileErreur(I.T("Mib module '@1' already exist|20144", SnmpMibModule.ModuleId));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGPSTypePoint type = (CGPSTypePoint)objet;
if (type.Libelle == "")
{
result.EmpileErreur(I.T("GPS point type Label cannot be empty|20008"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(type, CGPSTypePoint.c_champLibelle, type.Libelle))
{
result.EmpileErreur(I.T("GPS point type '@1' already exist|20009", type.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeAgentSnmp TypeAgentSnmp = (CTypeAgentSnmp)objet;
if (TypeAgentSnmp.Libelle == "")
{
result.EmpileErreur(I.T("Agent type label can not be empty|200145"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(TypeAgentSnmp, CTypeAgentSnmp.c_champLibelle, TypeAgentSnmp.Libelle))
{
result.EmpileErreur(I.T("An agent type with the same label already exists (@1)|20146", TypeAgentSnmp.Libelle));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CTypeStock TypeStock = (CTypeStock)objet;
if (TypeStock.Libelle == "")
{
result.EmpileErreur(I.T("The stock type label can not be empty|114"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(TypeStock, CTypeStock.c_champLibelle, TypeStock.Libelle))
{
result.EmpileErreur(I.T("Another Stock Type with the same name already exists|115"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
