//-------------------------------------------------------------------
/// <summary>
/// Retourne dans le data du result un CSourceDocument lié sur le document
/// </summary>
/// <param name="reference"></param>
/// <returns></returns>
public static CResultAErreur GetDocument(int nIdSession, CReferenceDocument reference)
{
CResultAErreur result = CResultAErreur.True;
///TODO
///Problème VersionObjet
IDocumentServeur doc = (IDocumentServeur)CContexteDonnee.GetTableLoader(CDocumentGED.c_nomTable, null, nIdSession);
result = doc.GetDocument(reference);
return(result);
}
//////////////////////////////////////////////////////////////////
/// <summary>
/// fonctionnement interne, voir ShouldCreateObjetSpv
/// </summary>
/// <param name="objetTimos"></param>
/// <returns></returns>
private static bool StaticShouldCreateObjetSpv(TypeTimos objetTimos)
{
string strNomTable = CContexteDonnee.GetNomTableForType(typeof(TypeSpv));
CMappableTimosServeur <TypeTimos, TypeSpv> instanceDeThis = CContexteDonnee.GetTableLoader(strNomTable, null, objetTimos.ContexteDonnee.IdSession) as CMappableTimosServeur <TypeTimos, TypeSpv>;
if (instanceDeThis != null)
{
return(instanceDeThis.ShouldAutoCreateObjetSpv(objetTimos));
}
return(false);
}
//-------------------------------------------------------------------
public static CResultAErreur SaveDocument(
int nIdSession,
CSourceDocument source,
CTypeReferenceDocument tpRef,
CReferenceDocument versionPrecedente,
bool bIncrementeVersionFichier)
{
CResultAErreur result = CResultAErreur.True;
///TODO
///Problème VersionObjet
IDocumentServeur doc = (IDocumentServeur)CContexteDonnee.GetTableLoader(CDocumentGED.c_nomTable, null, nIdSession);
result = doc.SaveDocument(source, tpRef, versionPrecedente, bIncrementeVersionFichier);
return(result);
}
public static CResultAErreur DoTraitementExterneAvantSauvegarde(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
Type tp;
ArrayList lst = new ArrayList(contexte.Tables);
foreach (DataTable table in lst)
{
tp = null;
ArrayList listeChampsDate = (ArrayList)m_tableChampsDate[table.TableName];
#region récupération des champs date
if (listeChampsDate == null)
{
listeChampsDate = new ArrayList();
//Premier passage, cherche les champs date
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(DateTime) ||
col.DataType == typeof(CDateTimeEx) ||
col.DataType == typeof(DateTime?))
{
listeChampsDate.Add(col.ColumnName);
}
}
m_tableChampsDate[table.TableName] = listeChampsDate;
}
#endregion
if (listeChampsDate.Count > 0 && table.PrimaryKey.Length == 1)
{
Hashtable tablesQuiOntChange = new Hashtable();
//NomChamp->Méthode set associée
Hashtable tableChampToMethode = new Hashtable();
string strCle = table.PrimaryKey[0].ColumnName;
ArrayList lstRows = new ArrayList(table.Rows);
if (tp == null)
{
tp = CContexteDonnee.GetTypeForTable(table.TableName);
}
//Travaille par paquets de 500
for (int nRowLot = 0; nRowLot < lstRows.Count; nRowLot += 500)
{
int nMin = Math.Min(lstRows.Count, nRowLot + 500);
StringBuilder bl = new StringBuilder();
for (int nRow = nRowLot; nRow < nMin; nRow++)
{
DataRow rowTest = (DataRow)lstRows[nRow];
if (rowTest.RowState == DataRowState.Modified)
{
bl.Append(rowTest[strCle]);
bl.Append(",");
}
}
string strIds = bl.ToString();
if (strIds.Length > 0)
{
Type typeMainElementAChamp = null;
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
CRelationElementAChamp_ChampCustom relation = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { contexte });
typeMainElementAChamp = relation.GetTypeElementAChamps();
}
strIds = strIds.Substring(0, strIds.Length - 1);
CFiltreData filtrePrinc = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + " in (" + strIds + ") and " +
CSynchronismeDonnees.c_champTypeSource + "=@1",
typeMainElementAChamp == null?tp.ToString():typeMainElementAChamp.ToString());
CListeObjetsDonnees listeSynchro = new CListeObjetsDonnees(contexte, typeof(CSynchronismeDonnees), filtrePrinc);
listeSynchro.AssureLectureFaite();
listeSynchro.InterditLectureInDB = true;
CFiltreData filtreChercheMesSynchros = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + "=@1", 0);
CFiltreData filtreChercheMesSynchrosChamp = new CFiltreData(
CSynchronismeDonnees.c_champIdSource + "=@1 and " +
CSynchronismeDonnees.c_champChampSource + "=@2",
0, "");
if (listeSynchro.Count > 0)
{
foreach (DataRow row in lstRows)
{
if (row.RowState == DataRowState.Modified)
{
int nCleElement = (int)row[strCle];
filtreChercheMesSynchros.Parametres[0] = nCleElement;
listeSynchro.Filtre = filtreChercheMesSynchros;
if (listeSynchro.Count > 0)
{
foreach (string strChamp in listeChampsDate)
{
if (row[strChamp, DataRowVersion.Original] != DBNull.Value &&
row[strChamp, DataRowVersion.Current] != DBNull.Value)
{
string strIdChampSynchronisme = strChamp;
DateTime dtOrg, dtNew;
dtOrg = (DateTime)row[strChamp, DataRowVersion.Original];
dtNew = (DateTime)row[strChamp, DataRowVersion.Current];
if (!dtNew.Equals(dtOrg))
{
//La colonne a change. Cherche tous les synchronismes liés à cet élément
//Si c'est un champ custom, on cherche un synchro sur le type
//contenant le champ custom
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
CRelationElementAChamp_ChampCustom relation = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(row);
strIdChampSynchronisme = CSynchronismeDonnees.c_idChampCustom + row[CChampCustom.c_champId];
nCleElement = relation.ElementAChamps.Id;
}
if (tp != null && tp.IsSubclassOf(typeof(CObjetDonneeAIdNumerique)))
{
filtreChercheMesSynchrosChamp.Parametres[0] = nCleElement;
filtreChercheMesSynchrosChamp.Parametres[1] = strIdChampSynchronisme;
listeSynchro.Filtre = filtreChercheMesSynchrosChamp;
if (listeSynchro.Count > 0)
{
TimeSpan sp = (DateTime)row[strChamp, DataRowVersion.Current] -
(DateTime)row[strChamp, DataRowVersion.Original];
foreach (CSynchronismeDonnees synchro in listeSynchro)
{
CObjetDonneeAIdNumerique objetDest = synchro.ObjetDest;
if (objetDest != null)
{
string strChampDest = synchro.ChampDest;
//La donnée n'est synchronisée que si elle est
//égale à sa valeur d'origine
if (synchro.ChampDest.IndexOf(CSynchronismeDonnees.c_idChampCustom) == 0)
{
//C'est un champ custom.
if (objetDest is IElementAChamps)
{
CListeObjetsDonnees listeRels = ((IElementAChamps)objetDest).RelationsChampsCustom;
int nIdChamp = Int32.Parse(synchro.ChampDest.Substring(
CSynchronismeDonnees.c_idChampCustom.Length));
listeRels.Filtre = new CFiltreData(CChampCustom.c_champId + "=@1",
nIdChamp);
if (listeRels.Count != 0)
{
objetDest = (CObjetDonneeAIdNumerique)listeRels[0];
strChampDest = CRelationElementAChamp_ChampCustom.c_champValeurDate;
}
else
{
objetDest = null;
}
}
else
{
objetDest = null;
}
}
if (objetDest != null && objetDest.Row[strChampDest] != DBNull.Value)
{
object valeurOld = null;
object valeurCourante = objetDest.Row[strChampDest, DataRowVersion.Current];
if (objetDest.Row.HasVersion(DataRowVersion.Original))
{
valeurOld = objetDest.Row[strChampDest, DataRowVersion.Original];
}
if (objetDest.Row.RowState != DataRowState.Deleted &&
(objetDest.Row.RowState != DataRowState.Modified ||
valeurCourante.Equals(valeurOld)))
{
MethodInfo method = (MethodInfo)tableChampToMethode[strChampDest];
if (method == null)
///Cherche la méthode associée au champ
{
CStructureTable structure = CStructureTable.GetStructure(objetDest.GetType());
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.NomChamp == strChampDest)
{
PropertyInfo prop = objetDest.GetType().GetProperty(champ.Propriete);
if (prop != null)
{
method = prop.GetSetMethod(true);
tableChampToMethode[strChampDest] = method;
}
break;
}
}
}
DateTime dt = (DateTime)objetDest.Row[strChampDest];
dt = dt.Add(sp);
if (method == null)
{
objetDest.Row[strChampDest] = dt;
}
else
{
method.Invoke(objetDest, new object[] { dt });
}
tablesQuiOntChange[objetDest.GetNomTable()] = true;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
foreach (string strNomTable in tablesQuiOntChange.Keys)
{
result += contexte.GetTableLoader(strNomTable).TraitementAvantSauvegarde(contexte);
if (!result)
{
break;
}
}
}
}
return(result);
}
//---------------------------------------------------------------------------------
public static CResultAErreur TraiteAlarmesManuellement(int nIdSession, CMemoryDb dbContenantLesAlarmesATraiter)
{
IAlarmeServeur alrm = CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession) as IAlarmeServeur;
return(alrm.TraiteAlarmesManuellement(dbContenantLesAlarmesATraiter));
}
/// ////////////////////////////////
public CResultAErreur ExecuteRequete(C2iRequete requete, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables, bool bStructureOnly)
{
CResultAErreur result = CResultAErreur.True;
Type typeReference = requete.TypeReferencePourConnexion;
if (typeReference != null)
{
///TODO
///Problème VersionObjet
object objServeur = CContexteDonnee.GetTableLoader(CContexteDonnee.GetNomTableForType(typeReference), null, IdSession);
if (objServeur != null)
{
typeReference = objServeur.GetType();
}
else
{
typeReference = null;
}
}
IDatabaseConnexion con;
if (typeReference == null)
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
}
else
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeReference);
}
object[] lstParams = null;
string strRequete = GetTexteRequeteFinaleSql(requete, elementAVariables, ref lstParams, con);
int nOldTimeOut = con.CommandTimeOut;
con.CommandTimeOut = 60 * 10;
IDataAdapter adapter = con.GetAdapterForRequete(strRequete, lstParams);
DataSet ds = new DataSet();
try
{
lock (con)
{
if (bStructureOnly)
{
adapter.FillSchema(ds, SchemaType.Source);
}
else
{
adapter.Fill(ds);
}
}
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
if (requete.TableauCroise != null)
{
result = requete.TableauCroise.CreateTableCroisee(table);
if (result)
{
table = (DataTable)result.Data;
}
}
table.TableName = "DONNEES_REQUETE";
result.Data = table;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in the request '@1'|102", strRequete));
}
finally
{
con.CommandTimeOut = nOldTimeOut;
CUtilDataAdapter.DisposeAdapter(adapter);
}
return(result);
}
/// <summary>
/// Purge l'historique des process jusqu'à une date limite
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
public static CResultAErreur Purger(DateTime dt, int nIdSession)
{
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
return(processServeur.Purger(dt));
}
}
/// /////////////////////////////////////////////////////////////
public static CResultAErreur StartProcessMultiples(CProcess process,
CInfoDeclencheurProcess infoDeclencheur,
CReferenceObjetDonnee[] refsCible,
int nIdSession,
int?nIdVersion,
IIndicateurProgression indicateur)
{
process.InfoDeclencheur = infoDeclencheur;
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
CAppelleurFonctionAsynchrone appelleur = new CAppelleurFonctionAsynchrone();
CResultAErreur defaultResult = CResultAErreur.True;
defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "StartProcessMultiples"));
return(appelleur.StartFonctionAndWaitAvecCallback(
typeof(IProcessEnExecutionInDbServeur),
processServeur,
"StartProcessMultiples",
"",
defaultResult,
new CValise2iSerializable(process),
refsCible,
nIdVersion,
indicateur) as CResultAErreur);
}
}
/// /////////////////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdAction, IIndicateurProgression indicateur)
{
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, ContexteDonnee.IdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
return(processServeur.RepriseProcess(Id, nIdAction, indicateur));
}
}
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);
}
/// //////////////////////////////////////////
///<summary>
///Charge les données de la table qui vont devoir être mise à jour
///à partir des données modifiées dans la table source
///</summary>
public CResultAErreur ChargeDonneesAMettreAJour(DataSet donneesSources)
{
CResultAErreur result = CResultAErreur.True;
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(donneesSources);
foreach (DataTable table in lstTables)
{
DataTable tableDest = null;
//S'assure que la table est bien chargée
try
{
tableDest = GetTableSafe(table.TableName);
}
catch
{
//La table n'existe pas
}
if (tableDest != null && m_mappeurTablesToClass.IsSynchronisable(table.TableName) && table.Rows.Count != 0)
{
IObjetServeur serveur = CContexteDonnee.GetTableLoader(tableDest.TableName, null, IdSession);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(tableDest.TableName);
if (serveur.CountRecords(strNomTableInDb, new CFiltreData("1=1")) != 0) //Première maj : copie complète
{
string strColPrim = table.PrimaryKey[0].ColumnName;
string strFiltre = "";
foreach (DataRow row in table.Rows)
{
strFiltre += row[strColPrim].ToString() + ",";
}
if (strFiltre.Length != 0)
{
//Supprime la dernière virgule;
strFiltre = strFiltre.Substring(0, strFiltre.Length - 1);
strFiltre = strColPrim += " in (" + strFiltre + ")";
IObjetServeur loader = GetTableLoader(table.TableName);
DataTable tableNew = loader.Read(new CFiltreData(strFiltre));
if (table == null)
{
result.EmpileErreur(I.T("Error while reading table @1|128", table.TableName));
return(result);
}
IntegreTable(tableNew, false);
}
}
}
}
//Charge les éléments à supprimer
CContexteDonnee contexteForListe = new CContexteDonnee(IdSession, true, false);
DataTable tableSync = donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable];
DataTable tableCopie = CUtilDataSet.AddTableCopie(donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable], contexteForListe);
foreach (DataRow row in tableSync.Rows)
{
tableCopie.ImportRow(row);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForListe, typeof(CEntreeLogSynchronisation));
liste.InterditLectureInDB = true;
liste.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champType + "=@1", (int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete);
foreach (CEntreeLogSynchronisation entree in liste)
{
DataTable table = GetTableSafe(entree.TableConcernee);
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)GetNewObjetForTable(table);
objet.ReadIfExists(entree.IdElement);
}
return(result);
}
public static CResultAErreur Purger(DateTime dateLimite, int nIdSession)
{
IVersionDonneesServeur serveur = (IVersionDonneesServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
return(serveur.PurgerHistorique(dateLimite));
}
public static bool HasInterventions(int nIdSession, CDbKey keyUtilisateur)
{
///TODO
///Problème VersionObjet
IBesoinInterventionProcessServeur serveur = (IBesoinInterventionProcessServeur)CContexteDonnee.GetTableLoader(CBesoinInterventionProcess.c_nomTable, null, nIdSession);
return(serveur.HasInterventions(keyUtilisateur));
}