//------------------------------------------------------------------------------------------------
protected static string GetRequeteRelation(CInfoRelation rel)
{
string strNomTableFille = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
string strNomTableParente = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableParente);
string strRequeteRelation = "";
strRequeteRelation += "ALTER TABLE " + strNomTableFille + " ";
strRequeteRelation += "ADD CONSTRAINT " + rel.RelationKey;
strRequeteRelation += " FOREIGN KEY (";
foreach (string strChamp in rel.ChampsFille)
{
strRequeteRelation += strChamp + ",";
}
strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1);
strRequeteRelation += ") ";
strRequeteRelation += "REFERENCES " + strNomTableParente + "(";
foreach (string strChamp in rel.ChampsParent)
{
strRequeteRelation += strChamp + ",";
}
strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1);
strRequeteRelation += ")";
return(strRequeteRelation);
}
protected virtual string GetRequeteCreateCleEtrangere(CInfoRelation rel)
{
string strTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
string strTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableParente);
string strRequeteRelation = "";
strRequeteRelation += "ALTER TABLE " + strTableFilleInDb + " ";
strRequeteRelation += "ADD CONSTRAINT " + GetNewNomClefEtrangere(rel);
strRequeteRelation += " FOREIGN KEY (";
foreach (string strChamp in rel.ChampsFille)
{
strRequeteRelation += strChamp + ",";
}
strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1);
strRequeteRelation += ") ";
strRequeteRelation += "REFERENCES " + strTableParenteInDb + "(";
foreach (string strChamp in rel.ChampsParent)
{
strRequeteRelation += strChamp + ",";
}
strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1);
strRequeteRelation += ")";
return(strRequeteRelation);
}
private void SoitConcernePar(CListeObjetsDonnees lstEquips)
{
if (m_relationToEquipSpv == null)
{
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(CEquipementLogique.c_nomTable))
{
if (info.TableParente == CEquipementLogique.c_nomTable && info.TableFille == CSpvEquip.c_nomTable)
{
m_relationToEquipSpv = info;
break;
}
}
}
lstEquips.GetDependances(m_relationToEquipSpv).AssureLectureFaite();
foreach (CEquipementLogique eqpt in lstEquips)
{
CSpvEquip spvEquip = new CSpvEquip(eqpt.ContexteDonnee);
if (spvEquip.ReadIfExists(new CFiltreData(CSpvEquip.c_champSmtEquipementLogique_Id + "=@1",
eqpt.Id), false))
{
m_dicEquipementsSpvConcernant[spvEquip.Id] = true;
}
}
lstEquips = lstEquips.GetDependances("EquipementsLogiquesContenus");
if (lstEquips.Count > 0)
{
SoitConcernePar(lstEquips);
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
protected virtual bool ShouldDeleteIndexRelation(string strNomTable, CInfoRelation infoRelation)
{
if (!infoRelation.Indexed && IndexExists(strNomTable, infoRelation.ChampsFille))
{
return(true);
}
return(false);
}
public CDefinitionProprieteDynamiqueRelation(
string strNomConvivial,
string strPropriete,
CInfoRelation relation,
CTypeResultatExpression typeDonnee
)
: base(strNomConvivial, strPropriete, typeDonnee, true, true)
{
m_relation = relation;
}
////////////////////////////////////////////////////////////////////////
public CFiltreSynchronisation GetFilsForRelation(CInfoRelation relation)
{
foreach (CFiltreSynchronisation filtre in m_listeFils)
{
if (filtre.RelationToParent.RelationKey == relation.RelationKey)
{
return(filtre);
}
}
return(null);
}
protected virtual string GetRequeteDeleteClefEtrangere(CInfoRelation relationToDelete)
{
string nomcleetr = GetNomClefEtrangere(relationToDelete);
string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(relationToDelete.TableFille);
if (nomcleetr == "")
{
return("");
}
return("ALTER TABLE " + strNomTableFilleInDb + " DROP CONSTRAINT " + nomcleetr);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomTable);
I2iSerializable objet = m_filtreDynamique;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_filtreDynamique = (CFiltreDynamique)objet;
objet = m_relationToParent;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_relationToParent = (CInfoRelation)objet;
serializer.TraiteBool(ref m_bTouteLaTable);
result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
NettoieFiltresFils();
foreach (CFiltreSynchronisation filtre in m_listeFils)
{
filtre.DefinitParent(this, filtre.RelationToParent);
}
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bIsAutoAdd);
}
return(result);
}
/////////////////////////////////////////////////////////////////
//S'assure que les CInfoRelation vers les objets SPV sont bien connues
private void AssureRelationsToSpv()
{
if (m_relationFromEquipementSpvToEquipement == null)
{
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(CEquipementLogique.c_nomTable))
{
if (relation.TableParente == CEquipementLogique.c_nomTable && relation.TableFille == CSpvEquip.c_nomTable)
{
m_relationFromEquipementSpvToEquipement = relation;
break;
}
}
}
if (m_relationFromLiaisonSpvToLiaison == null)
{
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(CLienReseau.c_nomTable))
{
if (relation.TableParente == CLienReseau.c_nomTable && relation.TableFille == CSpvLiai.c_nomTable)
{
m_relationFromLiaisonSpvToLiaison = relation;
break;
}
}
}
if (m_relationFromSiteSpvToSite == null)
{
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(CSite.c_nomTable))
{
if (relation.TableParente == CSite.c_nomTable && relation.TableFille == CSpvSite.c_nomTable)
{
m_relationFromSiteSpvToSite = relation;
break;
}
}
}
if (m_relationFromEquipementSpvToEquipement == null)
{
throw new Exception("Error in finding relation from site to Supervised site");
}
if (m_relationFromLiaisonSpvToLiaison == null)
{
throw new Exception("Error in finding relation form link to Supervised link");
}
if (m_relationFromSiteSpvToSite == null)
{
throw new Exception("Error in finding relation from site to supervised site");
}
}
////////////////////////////////////////////////////////////////////////
private void PrivateAddFiltre(CFiltreSynchronisation filtre)
{
ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[filtre.NomTable];
if (lst == null)
{
lst = new ArrayList();
m_tableTableToFiltreSynchronisation[filtre.NomTable] = lst;
}
CInfoRelation relation = filtre.RelationToParent;
if (relation != null)
{
//Regarde s'il y a un filtre sur la table complète avant d'aller plus loin !
foreach (CFiltreSynchronisation filtreExistant in lst)
{
if (filtreExistant.IsLienToFullTableParente &&
filtreExistant.RelationToParent.Equals(relation))
{
//Il y a un filtre sur toute la table liée, on n'ajoute pas celui-ci
return;
}
}
if (filtre.IsLienToFullTableParente)
{
//Supprime tous les autres filtres pour la même relation
//puisqu'on ajoute un filtre sur toute la table liée
for (int nFiltre = lst.Count - 1; nFiltre >= 0; nFiltre--)
{
CFiltreSynchronisation filtreExistant = (CFiltreSynchronisation)lst[nFiltre];
if (relation.Equals(filtreExistant.RelationToParent))
{
lst.RemoveAt(nFiltre);
}
}
}
}
lst.Add(filtre);
foreach (CFiltreSynchronisation filtreFils in filtre.FiltresFils)
{
PrivateAddFiltre(filtreFils);
}
}
public CFiltreDynamiqueParentTablePleine(string strTableConcernee, CInfoRelation relationToTableFille)
{
m_strNomTable = strTableConcernee;
m_relationToTableFille = relationToTableFille;
//Crée un filtre sur le parent pour qu'il ait un id > 0,
CComposantFiltreDynamiqueValeurChamp composant = new CComposantFiltreDynamiqueValeurChamp();
composant.IdOperateur = CComposantFiltreOperateur.c_IdOperateurSuperieurOuEgal;
composant.Champ = new CDefinitionProprieteDynamique(
relationToTableFille.ChampsParent[0],
relationToTableFille.ChampsParent[0],
new CTypeResultatExpression(typeof(int), false),
false,
true);
composant.ConditionApplication = new C2iExpressionVrai();
composant.ExpressionValeur = new C2iExpressionConstante(0);
ComposantPrincipal = composant;
TypeElements = CContexteDonnee.GetTypeForTable(strTableConcernee);
}
/// ////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable obj = m_relation;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_relation = (CInfoRelation)obj;
return(result);
}
////////////////////////////////////////////////////////////////////////
public void AddFils(CFiltreSynchronisation filtreFils, CInfoRelation relationToParent)
{
m_listeFils.Add(filtreFils);
filtreFils.DefinitParent(this, relationToParent);
}
protected override string GetNewNomClefEtrangere(CInfoRelation rel)
{
string strNomTable = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille);
return(GetNewNom(EntiteTable.ClefEtrangere, strNomTable));
}
/// <summary>
/// Enregistre dans la table m_tableCodesVisibles
/// les ids des éléments qui peuvent être affichés
/// </summary>
private void PrepareFiltre()
{
if (m_filtre == null || !m_filtre.HasFiltre)
{
m_tableCodesVisibles = null;
m_tableIdsElementsVisibles = null;
return;
}
m_tableCodesVisibles = new Hashtable(2000, 0.5f);
CListeObjetsDonnees liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, m_typeObjets);
liste.Filtre = m_filtre;
Hashtable tableTmp = new Hashtable();
if (typeof(IObjetHierarchiqueACodeHierarchique).IsAssignableFrom(m_typeObjets))
{
foreach (IObjetHierarchiqueACodeHierarchique objet in liste)
{
string strCode = objet.CodeSystemeComplet;
bool bForceTrue = true;
while (strCode.Length > 0)
{
if (bForceTrue)
{
m_tableCodesVisibles[strCode] = true;
}
else
if (!m_tableCodesVisibles.Contains(strCode))
{
m_tableCodesVisibles[strCode] = false;
}
bForceTrue = false;
strCode = strCode.Substring(0, strCode.Length - objet.NbCarsParNiveau);
}
}
}
else
{
m_tableIdsElementsSelectionnables.Clear();
string strChampParent = null;
foreach (IObjetDonneeAutoReference objet in liste)
{
m_tableIdsElementsVisibles.Add(objet.Id);
m_tableIdsElementsSelectionnables.Add(objet.Id);
strChampParent = objet.ChampParent;
}
//lecture des parents
if (strChampParent != null)
{
int nCount = liste.Count;
CStructureTable structure = CStructureTable.GetStructure(m_typeObjets);
CInfoRelation relToParent = null;
foreach (CInfoRelation rel in structure.RelationsParentes)
{
if (rel.ChampsFille[0] == strChampParent && rel.TableParente == rel.TableFille)
{
relToParent = rel;
}
}
CListeObjetsDonnees lst = liste.GetDependances(relToParent);
while (lst.Count != 0)
{
foreach (IObjetDonneeAutoReference objet in lst)
{
m_tableIdsElementsVisibles.Add(objet.Id);
}
lst = lst.GetDependances(relToParent);
}
}
}
}
//--------------------------------------------------------------------------------------
protected override bool ShouldDeleteIndexRelation(string strNomTable, CInfoRelation infoRelation)
{
return(false);//Toutes les relations sont indexées dans ACCESS
}
////////////////////////////////////////////////////////////////////////
protected void DefinitParent(CFiltreSynchronisation filtre, CInfoRelation relationToParent)
{
m_filtreParent = filtre;
m_relationToParent = relationToParent;
}
protected virtual string GetNewNomClefEtrangere(CInfoRelation rel)
{
return(rel.RelationKey);
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
CStructureTable structure = CStructureTable.GetStructure(vo.TypeElement);
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut ForceSetOnMacro, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(strNom);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length != 0)
{
bAdd = true;
}
}
if (bAdd)
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", def.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
if (objet is IObjetDonneeAChamps)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((IObjetDonneeAChamps)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == rel.ChampCustom.DbKey);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", rel.ChampCustom.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
if (def == null)
{
CInfoRelation relation = structureObjet.RelationsParentes.FirstOrDefault(i => i.ChampsFille.Length == 1 && i.ChampsFille[0] == strNomChamp);
if (relation != null)
{
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == relation.Propriete);
}
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == champCustom.DbKey);
}
}
if (def != null)
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut TiagRelation, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(def.NomProprieteSansCleTypeChamp);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length > 0)
{
bAdd = true;
}
}
if (bAdd)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
object val = valeur.GetValeur();
if (val != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(def.TypeDonnee.TypeDotNetNatif) && valeur.TypeValeur == typeof(int))
{
CObjetDonneeAIdNumerique objetParent = Activator.CreateInstance(def.TypeDonnee.TypeDotNetNatif, new object[] { objet.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (objetParent.ReadIfExists((int)valeur.GetValeur()))
{
val = objetParent;
}
else
{
val = null;
}
}
if (!FillMacroValeurWithValue(mv, val, dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of @2 in macro", valeur.NomChampConvivial,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
else
{
AddValeur(mv);
}
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
//Initialise la base des alarmes en cours avec les alarmes de la base et les acces concernant chaque élément
private void LoadAlarmesEtLiensTransForElement(string strChampDansAcces, CDictionnaireConcerne dicConcernes)
{
//Récupère la relation entre CSpvLienAccesAlarme et CSpvLienAccesAlarmeRep
if (m_relationFromLienAlarmeToLienAlarmeRep == null)
{
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(CSpvLienAccesAlarme.c_nomTable))
{
if (relation.TableFille == CSpvLienAccesAlarme_Rep.c_nomTable && relation.TableParente == CSpvLienAccesAlarme.c_nomTable)
{
m_relationFromLienAlarmeToLienAlarmeRep = relation;
break;
}
}
}
List <int> lstIdsElements = new List <int>();
lstIdsElements.AddRange(dicConcernes.Keys);
int nSizePaquet = 100;
for (int nPaquet = 0; nPaquet < lstIdsElements.Count; nPaquet += nSizePaquet)
{
int nMax = Math.Min(nPaquet + nSizePaquet, lstIdsElements.Count);
StringBuilder bl = new StringBuilder();
for (int nId = 0; nId < nMax; nId++)
{
bl.Append(lstIdsElements[nId]);
bl.Append(';');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
//Charge tous les Liens d'alarme pour les éléments
CListeObjetsDonnees lstLiensAccesAlarme = new CListeObjetsDonnees(m_contexteDonnee, typeof(CSpvLienAccesAlarme));
lstLiensAccesAlarme.Filtre = new CFiltreDataAvance(CSpvLienAccesAlarme.c_nomTable,
CSpvAccesAlarme.c_nomTable + "." + strChampDansAcces + " in (" +
bl.ToString() + ")");
lstLiensAccesAlarme.AssureLectureFaite();
// Chargement des acces correspondant
CListeObjetsDonnees lstAcces = lstLiensAccesAlarme.GetDependances("AccesAlarmeOne");
lstAcces.InterditLectureInDB = true;
CListeObjetsDonnees lstEtatAlarme = lstLiensAccesAlarme.GetDependances(m_relationFromLienAlarmeToLienAlarmeRep);
lstEtatAlarme.Filtre = new CFiltreData(CSpvLienAccesAlarme_Rep.c_champALARM_ID + " is not null");
lstEtatAlarme.AssureLectureFaite();
lstEtatAlarme.InterditLectureInDB = true;
// Chargement des données alarmes
CListeObjetsDonnees listAlarmesDonnees = lstEtatAlarme.GetDependances("AlarmeDonnee");
listAlarmesDonnees.AssureLectureFaite();
listAlarmesDonnees.InterditLectureInDB = true;
lstLiensAccesAlarme.InterditLectureInDB = true;
lstEtatAlarme.InterditLectureInDB = true;
foreach (CSpvAlarmeDonnee donneeAlarme in listAlarmesDonnees)
{
if (donneeAlarme != null)
{
CInfoAlarmeAffichee info = new CInfoAlarmeAffichee(donneeAlarme);
//m_dicAlarmes[info.IdSpvEvtAlarme] = info;
m_dicAlarmes[info.IdSpvAlarmeData] = info;
StartAlarme(info);
}
}
foreach (CSpvLienAccesAlarme lienAlarme in lstLiensAccesAlarme)
{
CSpvAcces acces = lienAlarme.AccesAlarmeOne;
if (acces != null)
{
int?nId = acces.Row[strChampDansAcces] as int?;
if (nId != null)
{
List <CInfoElementDeSchemaSupervise> lst = null;
if (dicConcernes.TryGetValue(nId.Value, out lst))
{
foreach (CInfoElementDeSchemaSupervise info in lst)
{
info.SetConcerneParAlarmes();
if (lienAlarme.MaskAdminDateMin != null && lienAlarme.MaskBriDateMin > DateTime.Now)
{
if (lienAlarme.MaskAdminDateMax == null || lienAlarme.MaskAdminDateMax < DateTime.Now)
{
info.SetMasquageAdministrateur(lienAlarme.Id, true);
}
}
if (lienAlarme.MaskBriDateMin != null && lienAlarme.MaskBriDateMin > DateTime.Now)
{
if (lienAlarme.MaskBriDateMax == null || lienAlarme.MaskBriDateMax < DateTime.Now)
{
info.SetMasquageBrigadier(lienAlarme.Id, true);
}
}
}
}
}
}
}
if (m_infoSchemaRacine != null)
{
List <CInfoElementDeSchemaSupervise> lstTmp = new List <CInfoElementDeSchemaSupervise>();
m_infoSchemaRacine.RecalculeToutLeMasquage(lstTmp);
}
}
}
}
protected override string GetNewNomClefEtrangere(CInfoRelation rel)
{
return(GetNewId("FK_"));
}
