//------------------------------------------------------------
public CResultAErreur PurgeEntites(Type typeObjets, int[] lstIds)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info == null)
{
result.EmpileErreur(I.T("Invalid session in Purge entities|20014"));
return(result);
}
if (info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministrationSysteme) == null)
{
result.EmpileErreur(I.T("Purge entity is allowed to administrators only|20015"));
return(result);
}
result = session.BeginTrans();
if (!result)
{
return(result);
}
CDonneeNotificationModificationContexteDonnee dataModif = new CDonneeNotificationModificationContexteDonnee(IdSession);
result = PurgeEntites(typeObjets, lstIds, dataModif);
if (result)
{
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { dataModif });
result = session.CommitTrans();
}
else
{
session.RollbackTrans();
}
return(result);
}
//------------------------------------------------------------------------------------
private void OnChangementDansObjets(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee modif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in modif.ListeModifications)
{
if (m_datasetRecherche.Tables[info.NomTable] != null)
{
lock ( m_datasetRecherche )
{
m_datasetRecherche.Tables.Remove(info.NomTable);
}
}
}
}
if (donnee is CDonneeNotificationAjoutEnregistrement)
{
string strNomTable = ((CDonneeNotificationAjoutEnregistrement)donnee).NomTable;
if (m_datasetRecherche.Tables[strNomTable] != null)
{
lock ( m_datasetRecherche )
{
m_datasetRecherche.Tables.Remove(strNomTable);
}
}
}
}
/// /////////////////////////////////////////////////////////////////////////////////
private static void OnModifSurDonnees(IDonneeNotification donnee)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee donneeContexte = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in donneeContexte.ListeModifications)
{
if (info.NomTable == CEvenement.c_nomTable)
{
m_bEvenementsChanged = true;
lock (typeof(CLockerCacheEvenements))
{
m_tableTypeToEvenements.Clear();
}
break;
}
}
}
if (donnee is CDonneeNotificationAjoutEnregistrement)
{
CDonneeNotificationAjoutEnregistrement donneeAjout = (CDonneeNotificationAjoutEnregistrement)donnee;
if (donneeAjout.NomTable == CEvenement.c_nomTable)
{
m_bEvenementsChanged = true;
lock (typeof(CLockerCacheEvenements))
{
m_tableTypeToEvenements.Clear();
}
}
}
}
//----------------------------------------------------
private CResultAErreur SauvegardeOptimisee(CContexteDonnee ctxEdition)
{
CResultAErreur result = CResultAErreur.True;
m_sessionClient.BeginTrans();
try
{
CAlarmeServeur serveur = new CAlarmeServeur(m_sessionClient.IdSession);
serveur.TraitementAvantSauvegarde(ctxEdition);
CDonneeNotificationModificationContexteDonnee donneeNotif = new CDonneeNotificationModificationContexteDonnee(m_sessionClient.IdSession);
CListeRestrictionsUtilisateurSurType lst = new CListeRestrictionsUtilisateurSurType();
CContexteSauvegardeObjetsDonnees ctx = new CContexteSauvegardeObjetsDonnees(ctxEdition, donneeNotif, lst);
result = serveur.SaveAll(ctx, DataRowState.Modified | DataRowState.Added);
if (result)
{
CRelationAlarme_ChampCustomServeur chServeur = new CRelationAlarme_ChampCustomServeur(m_sessionClient.IdSession);
result = chServeur.SaveAll(ctx, DataRowState.Modified | DataRowState.Added);
}
if (result)
{
result = serveur.TraitementApresSauvegarde(ctxEdition, true);
}
if (result)
{
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { ctx.DonneeNotification });
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
result = m_sessionClient.CommitTrans();
}
else
{
m_sessionClient.RollbackTrans();
}
}
return(result);
}
//-----------------------------------------------------------------------------
private static void m_recepteurModification_OnReceiveNotification(IDonneeNotification donnee)
{
lock (typeof(CFournisseurConstantesEntitesNommees))
{
CDonneeNotificationModificationContexteDonnee modif = donnee as CDonneeNotificationModificationContexteDonnee;
if (modif == null)
{
return;
}
foreach (sc2i.data.CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in modif.ListeModifications)
{
if (info.NomTable == CNommageEntite.c_nomTable)
{
m_listeExpression = null;
break;
}
}
}
}
////////////////////////////////////////////////////////////////////////////
protected static void OnReceiveNotificationModif(IDonneeNotification donnee)
{
if (!(donnee is CDonneeNotificationModificationContexteDonnee))
{
return;
}
//Marque tous les éléments comme étant à relire depuis la base de données
CDonneeNotificationModificationContexteDonnee donneeModif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in donneeModif.ListeModifications)
{
if (info.NomTable == CTypeActiviteActeur.c_nomTable)
{
lock (typeof(CLockerArbres))
{
m_arbreVocabulaire = null;
}
return;
}
}
}
private CResultAErreur VideTable(int nIdTypeDonnee, DataTable table)
{
ArrayList lstRows = new ArrayList(table.Rows);
CDonneeNotificationModificationContexteDonnee donnee = new CDonneeNotificationModificationContexteDonnee(IdSession);
foreach (DataRow row in lstRows)
{
donnee.AddModifiedRecord(table.TableName, true, new object[] { row[table.PrimaryKey[0]] });
}
CResultAErreur result = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "").RunStatement(
"delete from " +
CDonneeCumulee.c_nomTable + " where " +
CTypeDonneeCumulee.c_champId + "=" + nIdTypeDonnee.ToString());
if (!result)
{
return(result);
}
table.Rows.Clear();
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { donnee });
return(result);
}
//-----------------------------------------------------------------------------------
static void m_recepteurModifs_OnReceiveNotification(IDonneeNotification donnee)
{
if (m_tableIdUserEtTypeToFiltre.Count > 0)
{
if (donnee is CDonneeNotificationModificationContexteDonnee)
{
CDonneeNotificationModificationContexteDonnee dataModif = (CDonneeNotificationModificationContexteDonnee)donnee;
foreach (CDonneeNotificationModificationContexteDonnee.CInfoEnregistrementModifie info in dataModif.ListeModifications)
{
if (info.NomTable == CProfilUtilisateur.c_nomTable ||
info.NomTable == CProfilUtilisateur_Restriction.c_nomTable ||
info.NomTable == CRelationUtilisateur_Profil.c_nomTable ||
info.NomTable == CRelationUtilisateur_Profil_EO.c_nomTable ||
info.NomTable == CProfilUtilisateur_Inclusion.c_nomTable)
{
m_tableIdUserEtTypeToFiltre.Clear();
break;
}
}
}
}
}
//------------------------------------------------------------
public CResultAErreur PurgeEntites(
Type typeObjets,
int[] nIdsElementsTotal,
CDonneeNotificationModificationContexteDonnee dataModifs)
{
CResultAErreur result = TestTypePurgeable(typeObjets);
if (!result)
{
return(result);
}
//travaille par paquets de 100;
for (int nPaquet = 0; nPaquet < nIdsElementsTotal.Length; nPaquet += 100)
{
List <int> lstTmp = new List <int>();
int nMin = Math.Min(nPaquet + 100, nIdsElementsTotal.Length);
for (int n = nPaquet; n < nMin; n++)
{
lstTmp.Add(nIdsElementsTotal[n]);
}
int[] nIdsElements = lstTmp.ToArray();
if (nIdsElements.Count() == 0)
{
return(result);
}
string strNomTable = CContexteDonnee.GetNomTableForType(typeObjets);
if (strNomTable == null)
{
result.EmpileErreur(I.T("Can not find table for type '@1'|20011"),
DynamicClassAttribute.GetNomConvivial(typeObjets));
return(result);
}
CStructureTable structure = CStructureTable.GetStructure(typeObjets);
StringBuilder blIds = new StringBuilder();
foreach (int nId in nIdsElements)
{
blIds.Append(nId);
blIds.Append(',');
}
if (blIds.Length == 0)
{
return(result);
}
blIds.Remove(blIds.Length - 1, 1);
//Si autoref, va tout chercher d'un coup
if (typeof(IObjetDonneeAutoReference).IsAssignableFrom(typeObjets))
{
HashSet <int> setIds = new HashSet <int>();
foreach (int nId in nIdsElements)
{
setIds.Add(nId);
}
//Va cherche toutes les dépendances
int nNbLast = setIds.Count();
while (true)
{
foreach (CInfoRelation rel in CContexteDonnee.GetListeRelationsTable(strNomTable))
{
if (rel.TableFille == rel.TableParente)
{
int[] idsFilles = null;
CFiltreData filtre = new CFiltreData(rel.ChampsFille[0] + " in (" + blIds.ToString() + ")");
result = GetIdsFilles(
typeObjets,
filtre,
out idsFilles);
if (!result)
{
return(result);
}
foreach (int nId in idsFilles)
{
setIds.Add(nId);
}
}
}
nIdsElements = setIds.ToArray();
if (nNbLast == setIds.Count)
{
break;
}
blIds = new StringBuilder();
foreach (int nId in setIds)
{
blIds.Append(nId);
blIds.Append(',');
}
blIds.Remove(blIds.Length - 1, 1);
nNbLast = setIds.Count;
}
}
//Suppression des relations filles
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(strNomTable))
{
if (info.TableParente == strNomTable && info.TableFille != strNomTable)
{
Type typeFils = CContexteDonnee.GetTypeForTable(info.TableFille);
int[] lstIdsFils = null;
CFiltreData filtre = new CFiltreData(
info.ChampsFille[0] + " in (" + blIds.ToString() + ")");
result = GetIdsFilles(typeFils,
filtre,
out lstIdsFils);
if (!result)
{
return(result);
}
if (lstIdsFils.Count() > 0)
{
result = PurgeEntites(typeFils, lstIdsFils, dataModifs);
}
if (!result)
{
return(result);
}
}
}
//Suppression des relations TypeId
if (typeObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length == 0)
{
foreach (RelationTypeIdAttribute rel in CContexteDonnee.RelationsTypeIds)
{
if (rel.IsAppliqueToType(typeObjets))
{
Type typeFils = CContexteDonnee.GetTypeForTable(rel.TableFille);
result = TestTypePurgeable(typeFils);
if (!result)
{
return(result);
}
CFiltreData filtre = new CFiltreData(
rel.ChampId + " in (" + blIds + ") and " +
rel.ChampType + "=@1",
typeObjets.ToString());
int[] lstIdsFils = null;
result = GetIdsFilles(
typeFils,
filtre,
out lstIdsFils);
if (!result)
{
return(result);
}
if (lstIdsFils.Count() > 0)
{
result = PurgeEntites(typeFils, lstIdsFils, dataModifs);
}
if (!result)
{
return(result);
}
}
}
}
//Suppression des valeurs de champs
if (m_listeTypesValeursChamps == null)
{
m_listeTypesValeursChamps = new List <Type>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
m_listeTypesValeursChamps.Add(tp);
}
}
}
foreach (Type tp in m_listeTypesValeursChamps)
{
CFiltreData filtre = new CFiltreData(
CRelationElementAChamp_ChampCustom.c_champValeurInt + " in (" +
blIds.ToString() + ") and " +
CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1",
typeObjets.ToString());
int[] idsFils = null;
result = GetIdsFilles(tp, filtre, out idsFils);
if (!result)
{
return(result);
}
if (idsFils.Length > 0)
{
result = PurgeEntites(tp, idsFils, dataModifs);
}
if (!result)
{
return(result);
}
}
//Prépare les notifications
foreach (int nId in nIdsElements)
{
dataModifs.AddModifiedRecord(strNomTable,
true,
new object[] { nId });
}
//supprime les éléments
//Et c'est parti pour la requete de suppression
IDatabaseConnexion con;
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeObjets);
string strWhere = structure.ChampsId[0].NomChamp + " in (" + blIds + ")";
strWhere = COracleDatabaseConnexion.PasseLaLimiteDesMilleIn(strWhere);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable);
result = con.ExecuteScalar("delete from " + strNomTableInDb + " where " + strWhere);
if (!result)
{
return(result);
}
}
return(result);
}
