/// ///////////////////////////////////////////////////
public CListeRestrictionsUtilisateurSurType GetListeRestrictions(int?nIdVersion)
{
CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType();
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
CDonneesActeurUtilisateur user = Utilisateur;
//C'est pas une session système
if (user != null)
{
liste.Combine(user.GetRestrictions(nIdVersion));
}
liste.Combine(GetListeRestrictionsModulesClient());
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
if (UserLicence != null && UserLicence.IsReadOnly)
{
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CRestrictionUtilisateurSurType rest = liste.GetRestriction(tp);
CRestrictionUtilisateurSurType restRO = new CRestrictionUtilisateurSurType(tp);
restRO.RestrictionSysteme = ERestriction.ReadOnly;
rest.Combine(restRO);
liste.AddRestriction(rest);
}
}
return(liste);
}
//--------------------------------------------------------------------------
public CResultAErreur ReadAllDbKeys()
{
m_indicateurProgression.PushLibelle(I.T("Reading references|20015"));
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
ReadRefsForType(tp);
}
m_indicateurProgression.PopLibelle();
m_bHasAllDbKeys = true;
return(CResultAErreur.True);
}
//----------------------------------------------------------------
public void RefreshNombreUtilises()
{
lock (typeof(CLockerNbUsed))
{
m_listRecords = new List <CNombreUtilisePourTypeLicence>();
Dictionary <string, int?> dicUsed = new Dictionary <string, int?>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
if (m_LicenceLogiciel is CLicenceDemo)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
string strNomType = DynamicClassAttribute.GetNomConvivial(tp);
dicUsed[strNomType] = GetNbUsedInDbForType(tp);
Attribute attr = tp.GetCustomAttribute(typeof(TableAttribute), true);
if (attr != null)
{
string strNomTable = ((TableAttribute)attr).NomTable;
m_dicNomTableToIdTypeLimite[strNomTable] = strNomType;
m_dicTablesLimitees[strNomTable] = true;
}
}
}
else
{
object[] attribs = tp.GetCustomAttributes(typeof(LicenceCountAttribute), true);
if (attribs != null && attribs.Length > 0)
{
LicenceCountAttribute counter = attribs[0] as LicenceCountAttribute;
int?nNb = null;
if (!dicUsed.TryGetValue(counter.CountTypeName, out nNb))
{
nNb = 0;
}
nNb += GetNbUsedInDbForType(tp);
dicUsed[counter.CountTypeName] = nNb;
}
}
}
foreach (KeyValuePair <string, int?> kv in dicUsed)
{
CNombreUtilisePourTypeLicence nb = new CNombreUtilisePourTypeLicence(kv.Key, kv.Value.Value);
m_listRecords.Add(nb);
}
}
}
//----------------------------------------------------------------------------
/// <summary>
/// Retourne la liste des types pour lesquels il y a une restriction suivant les
/// objets
/// </summary>
/// <returns></returns>
public List <Type> GetTypesARestrictionsSurObjets(int?nIdVersion)
{
Dictionary <Type, bool> dicTypesARestrictionsSurObjets = new Dictionary <Type, bool>();
foreach (CRelationUtilisateur_Profil relProfil in RelationsProfils)
{
relProfil.AddTypesARestrictionsSurObjets(dicTypesARestrictionsSurObjets, nIdVersion);
}
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
if (typeof(IElementARestrictionsSpecifiques).IsAssignableFrom(tp))
{
dicTypesARestrictionsSurObjets[tp] = true;
}
}
List <Type> lst = new List <Type>(dicTypesARestrictionsSurObjets.Keys);
return(lst);
}
//------------------------------------------------------------
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);
}
public static CResultAErreur Init(
string strEventJournalName,
string strEventJournalTexte,
IIndicateurProgression indicateurProgress)
{
CResultAErreur result = CResultAErreur.True;
try
{
int nValeurIndicateur = 0;
C2iEventLog.Init(strEventJournalName, strEventJournalTexte, NiveauBavardage.VraiPiplette);
CConteneurIndicateurProgression indicateur = CConteneurIndicateurProgression.GetConteneur(indicateurProgress);
if (indicateur != null)
{
indicateur.PushSegment(0, 13);
}
CTraducteur.ReadFichier("");
#region Configuration du remoting
indicateur.SetValue(nValeurIndicateur++);
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
C2iSponsor.EnableSecurite();
#endregion
#region Configuration de l'allocateur d'objets
Dictionary <string, MarshalByRefObject> dicLocalSingleton = new Dictionary <string, MarshalByRefObject>();
dicLocalSingleton["sc2i.multitiers.client.IGestionnaireSessions"] = new CGestionnaireSessionSagexProSolo();
C2iFactory.InitEnLocal(new C2iObjetServeurFactory(), dicLocalSingleton);
indicateur.SetValue(nValeurIndicateur++);
CSessionClient session = CSessionClient.CreateInstance();
result = session.OpenSession(new CAuthentificationSessionServer(), "SagexProSolo", ETypeApplicationCliente.Service);
if (!result)
{
result.EmpileErreur(I.T("Opening session error|30010"));
return(result);
}
CSc2iDataServer.AddDefinitionConnexion(
new CDefinitionConnexionDataSource(
c_droitsDataSource,
typeof(CGestionnaireDroitsUtilisateurs),
""));
CSc2iDataServer.SetIdConnexionForClasse(typeof(CDroitUtilisateurServeur), c_droitsDataSource);
#endregion
#region Configuration de la base de données
indicateur.SetValue(nValeurIndicateur++);
Type typeConnexion = typeof(CAccess97DatabaseConnexion);
//Récuperation du type de connection
CSc2iDataServer.Init(
new CDefinitionConnexionDataSource(
c_mainDataSource,
typeConnexion,
"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\"C:\\Documents and Settings\\GENERIC\\Mes documents\\BASEVIDE2000.MDB\"",
""));
#endregion
#region Ajout des références DLL
indicateur.SetValue(nValeurIndicateur++);
AppDomain.CurrentDomain.Load("sc2i.data.client");
AppDomain.CurrentDomain.Load("sc2i.data.serveur");
AppDomain.CurrentDomain.Load("sc2i.data.dynamic");
AppDomain.CurrentDomain.Load("sc2i.data.dynamic.loader");
AppDomain.CurrentDomain.Load("sc2i.process");
AppDomain.CurrentDomain.Load("sc2i.process.serveur");
AppDomain.CurrentDomain.Load("sc2i.expression");
AppDomain.CurrentDomain.Load("sc2i.Formulaire");
AppDomain.CurrentDomain.Load("futurocom.vectordb.data");
AppDomain.CurrentDomain.Load("futurocom.vectordb.data.server");
AppDomain.CurrentDomain.Load("futurocomapp.data");
AppDomain.CurrentDomain.Load("futurocomapp.data.server");
AppDomain.CurrentDomain.Load("sagexpro.data");
AppDomain.CurrentDomain.Load("sagexpro.data.serveur");
foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
{
CContexteDonnee.AddAssembly(ass);
}
#endregion
#region Teste la connexion
indicateur.SetValue(nValeurIndicateur++);
IDatabaseConnexion cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(session.IdSession, c_mainDataSource);
//Attend la connexion pendant au max 5 minutes pour que ça démarre
DateTime dtStartAttente = DateTime.Now;
TimeSpan delaiAttente = DateTime.Now - dtStartAttente;
result = cnx.IsConnexionValide();
while (!result && delaiAttente.TotalSeconds < 5 * 60)
{
C2iEventLog.WriteErreur(result.MessageErreur);
delaiAttente = DateTime.Now - dtStartAttente;
C2iEventLog.WriteErreur(I.T("Connection not availiable(@1)|30014", delaiAttente.TotalSeconds.ToString() + " s)") +
Environment.NewLine);
string messageErreur = I.T("The connection with the database could not have been established. Verify the connection string and check if the database has been started|30015");
C2iEventLog.WriteErreur(messageErreur);
result.EmpileErreur(messageErreur);
return(result);
}
if (typeof(CSqlDatabaseConnexion).IsAssignableFrom(typeConnexion))
{
cnx.RunStatement("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED");
}
#endregion
//Initialisation des classes autoexecutables
CAutoexecuteurClasses.RunAutoexecs();
//Initialisation du serveur de documents GED
//Initialise les restrictions standards
#region Vérifie que les champs des tables font bien moins de 25 cars
indicateur.SetValue(nValeurIndicateur++);
DateTime dt = DateTime.Now;
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure.NomTable.Length > 25)
{
result.EmpileErreur("Table " + structure.NomTable + " (" + tp.ToString() + ")=" + structure.NomTable.Length + "cars");
}
if (structure.NomTable.ToUpper() != structure.NomTable)
{
result.EmpileErreur(I.T("Table name @1 must be uppercase|30018", structure.NomTable));
}
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.NomChamp.Length > 25)
{
result.EmpileErreur("Table " + structure.NomTable + " (" + tp.ToString() + ")\t champ " + champ.NomChamp + "=" + champ.NomChamp.Length + "cars");
}
if (champ.NomChamp.ToUpper() != champ.NomChamp)
{
result.EmpileErreur(I.T("The name of the field '@1' of the field '@2' must be uppercase|30019", champ.NomChamp, structure.NomTable));
}
}
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine(I.T("Table name verification |30020") + sp.TotalMilliseconds);
if (!result)
{
return(result);
}
#endregion
#region Mise à jour de la structure de la base
indicateur.SetValue(nValeurIndicateur++);
CUpdaterDataBase updaterDataBase = CUpdaterDataBase.GetInstance(cnx, new CSagexproStructureBase());
//S'assure que la gestion des éléments est initialisé dans les licences
//CLicenceCheckElementNb.GetInstance();
result = updaterDataBase.UpdateStructureBase(indicateur);
if (!result)
{
return(result);
}
#endregion
//Restrictions sur applications
//Initialisation du serveur de documents GED
//Initialisation de la base d'utilisateurs AD
//CAdBase.Init(CfuturocomappServeurRegistre.RacineAd,"","");
//Initialise les fournisseurs de services
//CSessionClientSurServeur.RegisterFournisseur( new CFournisseurFiltresForSynchronisation() );
CGestionnaireEvenements.Init();
if (!result)
{
return(result);
}
//CGestionnaireObjetsAttachesASession.OnAttacheObjet += new LinkObjectEventHandler(CGestionnaireObjetsAttachesASession_OnAttacheObjet);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-----------------------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtresSynchro)
{
if (m_filtreDejaCalcule != null)
{
return(m_filtreDejaCalcule);
}
Type tp = CContexteDonnee.GetTypeForTable(m_strNomTable);
if (tp == null)
{
return(null);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure == null)
{
return(null);
}
HashSet <int> lstIdsALire = new HashSet <int>();
List <CInfoRelation> relationsFilles = new List <CInfoRelation>();
foreach (Type tpTest in CContexteDonnee.GetAllTypes())
{
CStructureTable s = CStructureTable.GetStructure(tpTest);
if (s != null)
{
foreach (CInfoRelation relation in s.RelationsParentes)
{
if (relation.TableParente == m_strNomTable)
{
relationsFilles.Add(relation);
}
}
}
}
//va chercher les dépendances filles qui auront besoin d'éléments de ce type
foreach (CInfoRelation relation in relationsFilles)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relation.TableFille);
//Vérifie qu'il n'y a pas de filtre FilsDe ou FilsComposition sur la table
bool bPrendreCetteTable = true;
foreach (IFiltreSynchronisation filtre in filtresSynchro.GetFiltresSynchroPourTable(relation.TableFille))
{
if (relation.Composition && filtre is CFiltreSynchronisationFilsCompositions)
{
bPrendreCetteTable = false;
break;
}
CFiltreSynchronisationFilsDe filsDe = filtre as CFiltreSynchronisationFilsDe;
if (filsDe != null)
{
if (filsDe.TablesParentes.Contains(m_strNomTable))
{
bPrendreCetteTable = false;
break;
}
}
}
if (bPrendreCetteTable)
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = relation.TableFille;
if (relation.TableFille != m_strNomTable)
{
requete.FiltreAAppliquer = filtresSynchro.GetFiltreForTable(nIdSession, relation.TableFille);
}
requete.ListeChamps.Add(
new C2iChampDeRequete(relation.ChampsFille[0],
new CSourceDeChampDeRequete(relation.ChampsFille[0]),
typeof(int),
OperationsAgregation.None,
true));
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
}
}
}
}
}
}
if (lstIdsALire.Count == 0)
{
m_filtreDejaCalcule = new CFiltreDataImpossible();
return(m_filtreDejaCalcule);
}
StringBuilder bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId);
bl.Append(',');
}
bl.Remove(bl.Length - 1, 1);
m_filtreDejaCalcule = new CFiltreData(structure.ChampsId[0].NomChamp + " in (" + bl.ToString() + ")");
return(m_filtreDejaCalcule);
}
public CResultAErreur Execute(int nIdSession, System.Collections.Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
session.BeginTrans();
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(nIdSession, typeof(CVersionDonneesObjetServeur));
//Supprime les versions
string strRequete = "delete from " + CVersionDonneesObjetOperation.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
strRequete = "delete from " + CVersionDonneesObjet.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(CVersionDonnees.c_nomTable))
{
if (info.TableParente == CVersionDonnees.c_nomTable)
{
strRequete = "update " + info.TableFille + " set " +
info.ChampsFille[0] + "=null where " +
info.ChampsFille[0] + " is not null";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
strRequete = "delete from " + CVersionDonnees.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Charge toutes les tables
List <Type> typesAChamps = new List <Type>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
typesAChamps.Add(tp);
}
}
/*Problème sur les champs custom : parfois (c'est rare, mais ça arrive
* les valeurs de champs ne sont pas supprimées alors que l'entité est bien
* supprimée. On ne sait pas pourquoi, mais les lignes suivantes
* règlent le problème*/
foreach (Type tp in typesAChamps)
{
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexte });
string strTableValeurs = elt.GetNomTableRelationToChamps();
strRequete = "Update " + strTableValeurs + " set " +
CSc2iDataConst.c_champIsDeleted + "=1 where " +
elt.GetChampId() + " in (select " + elt.GetChampId() + " from " +
strNomTable + " where " + CSc2iDataConst.c_champIsDeleted + "=1)";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
ArrayList lstTables = CContexteDonnee.GetTableOrderDelete(contexte);
DataTable tableChampsCustomEnDernier = null;
foreach (DataTable table in lstTables)
{
/* J'ai un problème avec la table Champs Custom
* La requête suivante ne passe pas même directement dans SQL Server
* DELETE FROM CUSTOM_FIELD WHERE (SC2I_VERSION IS NOT NULL) OR (SC2I_DELETED = 1)
* Si je ne traite pas cette table, la purge se passe bien
* */
if (table.TableName == CChampCustom.c_nomTable)
{
tableChampsCustomEnDernier = table;
continue;
}
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
strRequete = "delete from " + table.TableName + " where " +
CSc2iDataConst.c_champIdVersion + " is not null or " +
CSc2iDataConst.c_champIsDeleted + "=1";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
//if (tableChampsCustomEnDernier != null)
//{
// if (tableChampsCustomEnDernier.Columns.Contains(CSc2iDataConst.c_champIdVersion))
// {
// strRequete = "delete from " + tableChampsCustomEnDernier.TableName + " where " +
// CSc2iDataConst.c_champIdVersion + " is not null or " +
// CSc2iDataConst.c_champIsDeleted + "=1";
// result = connexion.RunStatement(strRequete);
// if (!result)
// return result;
// }
//}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
if (!result)
{
session.RollbackTrans();
}
else
{
result = session.CommitTrans();
}
}
}
return(result);
}