//-------------------------------------------------------------------
public CDroitUtilisateurServeur(int nIdSession)
: base(nIdSession)
{
if (!CSc2iDataServer.ExitsConnexion(c_droitsDataSource))
{
InitGestionDroits();
}
}
///////////////////////////////////////////
public static CResultAErreur Init(CDefinitionConnexionDataSource defConnexionParDefaut)
{
if (m_instance != null)
{
m_instance.Dispose();
m_instance = null;
}
CResultAErreur result = CResultAErreur.True;
m_instance = new CSc2iDataServer(defConnexionParDefaut);
return(result);
}
//-------------------------------------------------------------------
/// <summary>
/// Initialise la gestion de droits.
/// </summary>
public static void InitGestionDroits()
{
if (!CSc2iDataServer.ExitsConnexion(c_droitsDataSource))
{
CSc2iDataServer.AddDefinitionConnexion(
new CDefinitionConnexionDataSource(
c_droitsDataSource,
typeof(CGestionnaireDroitsUtilisateurs),
""));
}
CSc2iDataServer.SetIdConnexionForClasse(typeof(CDroitUtilisateurServeur), c_droitsDataSource);
}
/// ///////////////////////////////////////////////////////
/*public override DataTable Read ( CFiltreData filtre, int nStart, int nEnd )
* {
* IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion (IdSession, GetType());
* string str
* IDataAdapter adapter = connexion.GetSimpleReadAdapter( strReq, filtre );
* DataSet ds = new DataSet();
* adapter.TableMappings.Add("Table",GetNomTable());
* adapter.FillSchema( ds, SchemaType.Mapped );
* adapter.Fill(ds);
* DataTable tbl = ds.Tables[GetNomTable()];
* foreach ( string strChampBlob in lstBlobs )
* tbl.Columns.Add ( strChampBlob, typeof(CDonneeBinaireInRow)).DefaultValue = DBNull.Value;
*
* nEnd = Math.Min ( nEnd, tbl.Rows.Count );
* if ( nStart >= 0 && nEnd >= 0 )
* {
* DataTable tblNew = tbl.Clone();
*
* for ( int n = nStart; n < nEnd; n++ )
* tblNew.ImportRow ( tbl.Rows[n] );
* tbl = tblNew;
* }
* return tbl;
* }*/
//////////////////////////////////////////////////
public override CDataTableFastSerialize FillSchema()
{
DataTable tbl = (DataTable)m_tableSchema[GetNomTable()];
if (tbl != null)
{
return(tbl.Clone());
}
IDataAdapter adapter = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, GetType()).GetTableAdapter(GetNomTableInDb());
adapter.TableMappings.Add("Table", GetNomTable());
DataSet ds = new DataSet();
adapter.FillSchema(ds, SchemaType.Mapped);
CUtilDataAdapter.DisposeAdapter(adapter);
DataTable table = ds.Tables[GetNomTable()];
if (table == null)
{
table = ds.Tables[GetNomTableInDb()];
if (table != null)
{
table.TableName = GetNomTable();
}
}
CStructureTable structure = CStructureTable.GetStructure(GetTypeObjets());
foreach (CInfoChampTable info in structure.Champs)
{
if (info.TypeDonnee == typeof(CDonneeBinaireInRow) && table.Columns[info.NomChamp] != null)
{
table.Columns[info.NomChamp].DataType = typeof(CDonneeBinaireInRow);
}
}
tbl = ds.Tables[GetNomTable()];
FaitLesCorrectionsSurLeSchema(tbl);
m_tableSchema[GetNomTable()] = tbl.Clone();
return(tbl);
}
//---------------------------------
public void OnCloseSession()
{
CSc2iDataServer.OnCloseSession(IdSession);
Dispose();
}
virtual public CResultAErreur CreationOuUpdateTableFromType(Type tp, ArrayList strChampsAutorisesANull)
{
CResultAErreur result = CResultAErreur.True;
CStructureTable structure = CStructureTable.GetStructure(tp);
object objServeur = null;
try
{
objServeur = CContexteDonnee.GetTableLoader(structure.NomTable, null, Connection.IdSession);
}
catch
{
}
if (objServeur == null)
{
return(result);
}
//Vérifie que le type est bien lié à cette connexion
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(
Connection.IdSession,
objServeur.GetType());
if (connexion == null || connexion.ConnexionString != Connection.ConnexionString)
{
return(result);
}
if (!result)
{
return(result);
}
//S'assure que toutes les tables parentes existent
foreach (CInfoRelation relation in structure.RelationsParentes)
{
if (relation.TableParente != structure.NomTable && relation.IsInDb)
{
string strNomTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(relation.TableParente);
if (!TableExists(strNomTableParenteInDb))
{
result = CreationOuUpdateTableFromType(CContexteDonnee.GetTypeForTable(relation.TableParente));
if (!result)
{
return(result);
}
}
}
}
if (TableExists(structure.NomTableInDb))
{
result = UpdateTable(structure, strChampsAutorisesANull);
}
else
{
result = CreateTable(structure);
}
return(result);
}
/// //////////////////////////////////////////////////////////////////
//le result du dataset contient le dataset à appliquer à la base secondaire
public CResultAErreur PutSecondaryIntoMain(CContexteDonneesSynchroSecondaire dsSecondaire)
{
CResultAErreur result = CResultAErreur.True;
//Répercute les modifs de la base secondaire sur la base primaire
using (CContexteDonneesSynchroMain donneesMain = new CContexteDonneesSynchroMain(IdSession, true))
{
IDatabaseConnexionSynchronisable connexionMain;
connexionMain = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
int nIdSyncMain = connexionMain.IdSyncSession;
result = donneesMain.ChargeDonneesAMettreAJour(dsSecondaire);
if (result)
{
result = donneesMain.AjouteNouveaux(dsSecondaire);
}
if (result)
{
result = donneesMain.Update(dsSecondaire);
}
if (result)
{
result = donneesMain.Delete(dsSecondaire);
}
try
{
connexionMain.BeginTrans();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while data synchronization|208"));
return(result);
}
if (result)
{
result = donneesMain.WriteChanges(dsSecondaire);
}
//Augmente d'un le numéro de version de la base principale
if (result)
{
while (connexionMain.IdSyncSession < nIdSyncMain + 2)
{
connexionMain.IncrementeSyncSession();
}
result = connexionMain.CommitTrans();
result.Data = dsSecondaire;
}
else
{
connexionMain.RollbackTrans();
}
}
return(result);
}
/// //////////////////////////////////////////////////////////////////
public int IncrementeIdSynchroMain()
{
IDatabaseConnexionSynchronisable connexion = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
connexion.IncrementeSyncSession();
return(connexion.IdSyncSession);
}
///--------------------------------------
public void UnlockSyncSessionLocale()
{
IDatabaseConnexionSynchronisable connexion = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
connexion.UnlockSyncSessionLocal( );
}
/// //////////////////////////////////////////////////////////////////
public void LockSyncSessionLocalTo(int nIdLockSyncSession)
{
IDatabaseConnexionSynchronisable connexion = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
connexion.LockSyncSessionLocalTo(nIdLockSyncSession);
}
/// //////////////////////////////////////////////////////////////////
public CResultAErreur PutMainIntoSecondary(CContexteDonneesSynchro ctxMain)
{
CResultAErreur result = CResultAErreur.True;
IDatabaseConnexionSynchronisable connexionSecondaire = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
//Toutes les modifs apportées sur la base secondaire doivent porter l'id de synchro
//Initial de la base secondaire, sinon les modifs font du
//ping pong entre secondaire et main,
//Ces modifs ne doivent surtout pas apparaitre
//lors d'une synchro de sec->main !
connexionSecondaire.LockSyncSessionLocalTo(connexionSecondaire.LastSyncIdPutInBasePrincipale);
//Répercute les modifs de la base secondaire sur la base primaire
using (CContexteDonneesSynchroSecondaire donneeSec = new CContexteDonneesSynchroSecondaire(IdSession, true))
{
result = donneeSec.ChargeDonneesAMettreAJour(ctxMain);
donneeSec.EnforceConstraints = false;
if (result)
{
result = donneeSec.AjouteNouveaux(ctxMain);
}
if (result)
{
result = donneeSec.Update(ctxMain);
}
if (result)
{
result = donneeSec.Delete(ctxMain);
}
donneeSec.EnforceConstraints = true;
try
{
connexionSecondaire.BeginTrans();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while data synchronization|208"));
return(result);
}
if (result)
{
result = donneeSec.WriteChanges(ctxMain);
}
if (result)
{
if (connexionSecondaire.LastSyncIdPutInBasePrincipale == -1)
{
connexionSecondaire.LastSyncIdPutInBasePrincipale = connexionSecondaire.IdSyncSession;
}
connexionSecondaire.UnlockSyncSessionLocal();
while (connexionSecondaire.IdSyncSession < ctxMain.IdSynchro)
{
connexionSecondaire.IncrementeSyncSession();
}
connexionSecondaire.LastSyncIdVueDeBasePrincipale = ctxMain.IdSynchro == -1?0:ctxMain.IdSynchro;
connexionSecondaire.CommitTrans();
}
if (!result)
{
connexionSecondaire.RollbackTrans();
}
}
return(result);
}
/// //////////////////////////////////////////////////////////////////
/// le data du result contient le dataset à appliquer à la base distante
public CResultAErreur GetModifsInMain(
int nIdSyncSessionFrom,
int nIdSyncSessionSecondaireCourant,
string strCodeGroupeSynchronisation)
{
CResultAErreur result = CResultAErreur.True;
CFiltresSynchronisation filtres = GetFiltres(strCodeGroupeSynchronisation);
IDatabaseConnexionSynchronisable connexionMain = (IDatabaseConnexionSynchronisable)CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, m_strIdConnexion);
int nIdSyncMain = connexionMain.IdSyncSession;
while (connexionMain.IdSyncSession <= nIdSyncSessionSecondaireCourant)
{
connexionMain.IncrementeSyncSession();
}
CContexteDonneesSynchro ctxMain = new CContexteDonneesSynchro(IdSession, true);
bool bHasChange = false;
ctxMain.FillWithModifsFromVersion(nIdSyncSessionFrom == -1?-1:nIdSyncSessionFrom + 1, nIdSyncMain, ref bHasChange, filtres, false);
if (bHasChange)
{
DataSet dsRetour = new DataSet();
foreach (DataTable table in ctxMain.Tables)
{
if (table.Rows.Count != 0)
{
DataTable tableCopie = CUtilDataSet.AddTableCopie(table, dsRetour);
ArrayList lst = new ArrayList();
foreach (DataColumn col in tableCopie.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
lst.Add(col);
}
}
foreach (DataColumn col in lst)
{
tableCopie.Columns.Remove(col);
}
foreach (DataRow row in table.Rows)
{
tableCopie.ImportRow(row);
}
}
}
dsRetour.ExtendedProperties[c_cleIdSynchro] = nIdSyncMain;
result.Data = dsRetour;
}
return(result);
}