//-------------------------------------------------------------------------
private void LoadEtapesDepuisBase()
{
if (m_lastDateLookInDb == null ||
((TimeSpan)(DateTime.Now - m_lastDateLookInDb.Value)).TotalMilliseconds > c_nDelailLookInDb)
{
m_lastDateLookInDb = DateTime.Now;
AssureSession();
if (m_session != null)
{
using (CContexteDonnee ctx = new CContexteDonnee(m_session.IdSession, true, false))
{
CFiltreData filtre = new CFiltreData(
CEtapeWorkflow.c_champEtat + "=@1",
(int)EEtatEtapeWorkflow.ADemarrer);
CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, typeof(CEtapeWorkflow));
lst.Filtre = filtre;
lst.AssureLectureFaite();
List <CParametresStartEtapeInPile> lstToStart = new List <CParametresStartEtapeInPile>();
foreach (CEtapeWorkflow etape in lst)
{
//TESTDBKEYTODO
CParametresStartEtapeInPile parametre = new CParametresStartEtapeInPile(
m_session.IdSession,
etape.Id,
etape.KeyDémarreur,
etape.DateDebut != null ? etape.DateDebut.Value : DateTime.Now);
lstToStart.Add(parametre);
}
AddEtapesADemarrer(lstToStart.ToArray());
}
}
}
}
//----------------------------------------------------
private CResultAErreur AssureSessionEtContexte()
{
CResultAErreur resErreur = CResultAErreur.True;
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
if (m_sessionClient == null || !m_sessionClient.IsConnected)
{
m_sessionClient = CSessionClient.CreateInstance();
resErreur = m_sessionClient.OpenSession(new CAuthentificationSessionServer(),
I.T("Alarm management|20154"),
ETypeApplicationCliente.Service);
if (!resErreur)
{
resErreur.EmpileErreur(resErreur.Erreur);
C2iEventLog.WriteErreur(I.T("Error while open alarm management session|20155"));
resErreur.EmpileErreur(I.T("Error while open alarm management session|20155"));
return(resErreur);
}
}
if (m_contexteDonnee == null)
{
m_contexteDonnee = new CContexteDonnee(m_sessionClient.IdSession, true, true);
CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CTypeAlarme));
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChampsCustomListe");
lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CSeveriteAlarme));
lst.AssureLectureFaite();
}
return(resErreur);
}
//------------------------------------------------------------------
public static void PreloadBesoinsSatisfaits(CListeObjetsDonnees lstSatisfactions)
{
if (m_cacheRelations == null)
{
return;
}
if (lstSatisfactions == null || lstSatisfactions.Count == 0)
{
return;
}
Type tp = lstSatisfactions.TypeObjets;
if (!typeof(ISatisfactionBesoin).IsAssignableFrom(tp))
{
return;
}
string strType = tp.ToString();
StringBuilder bl = new StringBuilder();
foreach (CObjetDonneeAIdNumerique sat in lstSatisfactions)
{
if (sat.IsValide() && !m_cacheRelations.IsLoaded((ISatisfactionBesoin)sat))
{
bl.Append(sat.Id);
bl.Append(',');
}
}
if (bl.Length == 0)
{
return;
}
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(
lstSatisfactions.ContexteDonnee,
typeof(CRelationBesoin_Satisfaction),
new CFiltreData(CRelationBesoin_Satisfaction.c_champTypeElement + "=@1 and " +
CRelationBesoin_Satisfaction.c_champIdElement + " in (" + bl.ToString() + ")", strType));
lst.AssureLectureFaite();
lst.InterditLectureInDB = true;
foreach (ISatisfactionBesoin satisfaction in lstSatisfactions)
{
lst.Filtre = new CFiltreData(CRelationBesoin_Satisfaction.c_champTypeElement + "=@1 and " +
CRelationBesoin_Satisfaction.c_champIdElement + "=@2",
strType,
satisfaction.Id);
m_cacheRelations.SetRelations(satisfaction, lst);
}
}
/// //////////////////////////////
///
public CResultAErreur Init(
CListeObjetsDonnees liste,
string strProprieteAffiche,
string strChampFiltre,
Type typeFormEditionStandard
)
{
m_filtrePrincipal = liste.Filtre;
m_listeObjets = liste;
m_listeObjets.AssureLectureFaite();
m_listeObjets.InterditLectureInDB = true;
m_strProprieteAffichee = strProprieteAffiche;
m_strChampFiltre = strChampFiltre;
m_typeFormEdition = typeFormEditionStandard;
return(m_combo.Init(liste, strProprieteAffiche, typeFormEditionStandard, true));
}
//----------------------------------------------------------------------------------
public CResultAErreur CreateChampInTable(IChampDeTable champExport, DataTable table)
{
CResultAErreur result = CResultAErreur.True;
if (champExport is C2iChampExport && ((C2iChampExport)champExport).Origine is C2iOrigineChampExportChampCustom)
{
C2iOrigineChampExportChampCustom origineCustom = (C2iOrigineChampExportChampCustom)((C2iChampExport)champExport).Origine;
//Récupère les noms et les types des champs custom
CContexteDonnee ctx = null;
if (table.DataSet is CContexteDonnee)
{
ctx = (CContexteDonnee)table.DataSet;
}
else
{
ctx = new CContexteDonnee(0, true, false);
}
//Lit les champs custom
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(ctx, typeof(CChampCustom));
listeChamps.AssureLectureFaite();
foreach (int nIdChamp in origineCustom.IdsChampCustom)
{
CChampCustom champ = new CChampCustom(ctx);
if (champ.ReadIfExists(nIdChamp))
{
if (champ.TypeDonneeChamp.TypeDonnee != TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
DataColumn colChamp = new DataColumn(c_strPrefixeChampCustom + champ.Nom, champ.TypeDonnee.TypeDotNetNatif);
colChamp.AllowDBNull = true;
table.Columns.Add(colChamp);
}
}
}
return(result);
}
if (table.Columns.Contains(champExport.NomChamp))
{
return(result);
}
DataColumn col = new DataColumn(champExport.NomChamp, champExport.TypeDonnee);
table.Columns.Add(col);
return(result);
}
//-------------------------------------------------------------------
private static void AlloueCode(CObjetHierarchique objet, ref int nLastCodeAlloue)
{
CFiltreData filtre = null;
if (objet.ObjetParent != null)
{
filtre = new CFiltreData(objet.ChampIdParent + "=@1",
objet.ObjetParent.Id);
}
else
{
filtre = new CFiltreData(objet.ChampIdParent + " is null and " +
objet.ChampCodeSystemePartiel + ">@1", GetCle(nLastCodeAlloue, objet.NbCarsParNiveau));
}
CListeObjetsDonnees listeSoeurs = new CListeObjetsDonnees(objet.ContexteDonnee, objet.GetType(), filtre);
listeSoeurs.AssureLectureFaite();
listeSoeurs.InterditLectureInDB = true;
Hashtable tableCodesUtilises = new Hashtable();
foreach (CObjetHierarchique obj in listeSoeurs)
{
tableCodesUtilises[obj.CodeSystemePartiel] = true;
}
//Cherche le prochain numéro libre
int nCpt = nLastCodeAlloue;
string strCle = "";
do
{
nCpt++;
strCle = GetCle(nCpt, objet.NbCarsParNiveau);
/*listeSoeurs.Filtre = new CFiltreData(objet.ChampCodeSystemePartiel + "=@1",
* strCle);*/
}while (tableCodesUtilises.ContainsKey(strCle));
nLastCodeAlloue = nCpt;
objet.ChangeCodePartiel(strCle);
}
//-------------------------------------------------------------
private static CResultAErreur IntegreReleve(TID.releve.CReleveSite releve,
CContexteDonnee ctx)
{
CResultAErreur result = CResultAErreur.True;
CReleveSite releveTimos = new CReleveSite(ctx);
releveTimos.CreateNewInCurrentContexte();
CSite site = GetObjetTimos <CSite>(releve.Row[TID.CSite.c_champId], ctx);
if (site == null)
{
result.EmpileErreur("Site doesn't exists");
return(result);
}
try
{
//Précharge les données
CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, typeof(CTypeEquipement));
lst.AssureLectureFaite();
lst = new CListeObjetsDonnees(ctx, typeof(CRelationTypeEquipement_Constructeurs));
lst.AssureLectureFaite();
lst = site.Equipements;
releveTimos.Site = site;
releveTimos.DateReleve = releve.DateReleve;
CListeEntitesDeMemoryDb <TID.releve.CReleveEquipement> lstEqpts = releve.RelevesEquipement;
lstEqpts.Filtre = new CFiltreMemoryDb(TID.releve.CReleveEquipement.c_champIdContenant + " is null");
foreach (TID.releve.CReleveEquipement relEq in lstEqpts)
{
result = IntegreReleveEquipement(relEq, null, releveTimos);
if (!result)
{
return(result);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
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);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
private void ReadDependanceParente(
string strPropriete,
CListeObjetsDonnees lstSource,
CListeObjetsDonnees.CArbreProps arbre,
CInfoRelation relation)
{
int nNbTotal = lstSource.Count;
string strKey = relation.RelationKey;
Type tp = null;
PropertyInfo info = lstSource.TypeObjets.GetProperty(strPropriete);
if (info == null)
{
return;
}
tp = info.PropertyType;
if (tp != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
//Crée les paquets
ArrayList lstPaquets = new ArrayList();
Hashtable tableIdsParentTraites = new Hashtable();
int nPaquet = 0;
string strChampFille = relation.ChampsFille[0];
string strPaquetEnCours = "";
int nNbInPaquet = 0;
for (int n = 0; n < lstSource.View.Count; n++)
{
DataRow row = lstSource.View.GetRow(n);
string strCle = row[strChampFille].ToString();
if (strCle != "")
{
if (tableIdsParentTraites[strCle] == null)
{
tableIdsParentTraites[strCle] = true;
strPaquetEnCours += strCle + ",";
nNbInPaquet++;
if (nNbInPaquet >= CListeObjetsDonnees.c_nNbLectureParLotFils)
{
strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
lstPaquets.Add(strPaquetEnCours);
strPaquetEnCours = "";
nNbInPaquet = 0;
}
}
}
}
if (strPaquetEnCours.Length > 0)
{
strPaquetEnCours = "(" + strPaquetEnCours.Substring(0, strPaquetEnCours.Length - 1) + ")";
lstPaquets.Add(strPaquetEnCours);
}
//Lit les relations par paquet
int nNbPaquets = lstPaquets.Count;
for (nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
{
string strPaquet = (string)lstPaquets[nPaquet];
if (strPaquet != "()")
{
CListeObjetsDonnees listeParent = new CListeObjetsDonnees(lstSource.ContexteDonnee, tp);
listeParent.ModeSansTri = true;
listeParent.PreserveChanges = true;
listeParent.Filtre = new CFiltreData(relation.ChampsParent[0] + " in " + strPaquet);
listeParent.AssureLectureFaite();
//Indique que les lignes ont été lues
//Stef 2/12/2011 : non, on n'indique pas que c'est lu puisqu'il
//s'agit de dépendances parentes !
//Ca pose le problème suivant : si on est sur une table hiérarchique,
//lorsqu'on lit le parent (d'un projet par exemple), le fait de
//dire que les dépendances sont lues implique qu'on indique
//qu'on a lu les fils.
//De ma compréhension à ce jour, on ne gère pas de colonne
//indiquant si la dépendance a été chargé pour des dépendances
//parentes
/*if ( lstSource.View.Table.Columns[strKey] != null )
* {
* for ( int nRow = 0; nRow < lstSource.View.Count; nRow++ )
* {
* CContexteDonnee.ChangeRowSansDetectionModification ( lstSource.View.GetRow ( nRow ), strKey, true );
* }
* }*/
listeParent.ReadDependances(arbre);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Lit les dépendances filles du type de donné
/// </summary>
/// <returns></returns>
private void ReadDependanceFille(
string strPropriete,
CListeObjetsDonnees lstSource,
CListeObjetsDonnees.CArbreProps arbre,
CInfoRelation relation,
List <string> listePaquets)
{
CResultAErreur result = CResultAErreur.True;
Type tpFille = null;
PropertyInfo info = lstSource.TypeObjets.GetProperty(strPropriete);
if (info == null)
{
return;
}
object[] attrs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attrs == null || attrs.Length < 0)
{
return;
}
tpFille = ((RelationFilleAttribute)attrs[0]).TypeFille;
DataTable table = lstSource.ContexteDonnee.GetTableSafe(lstSource.NomTable);
//S'assure que la table fille est chargée
lstSource.ContexteDonnee.GetTableSafe(relation.TableFille);
string strKey = relation.RelationKey;
DataColumn colDependance = table.Columns[strKey];
if (listePaquets == null)
{
listePaquets = lstSource.GetPaquetsPourLectureFils(relation.ChampsParent[0], colDependance);
}
int nNbPaquets = listePaquets.Count;
//Lit les relations par paquet
for (int nPaquet = 0; nPaquet < nNbPaquets; nPaquet++)
{
string strPaquet = (string)listePaquets[nPaquet];
if (strPaquet.Length > 0)
{
CListeObjetsDonnees listeFille = new CListeObjetsDonnees(lstSource.ContexteDonnee, tpFille);
listeFille.Filtre = new CFiltreData(relation.ChampsFille[0] + " in " + strPaquet);
if (arbre.Filtre.Length > 0)
{
listeFille.Filtre.Filtre += " and " + arbre.Filtre;
}
listeFille.ModeSansTri = true;
listeFille.PreserveChanges = true;
listeFille.AssureLectureFaite();
int nMax = Math.Min(lstSource.Count, (nPaquet + 1) * CListeObjetsDonnees.c_nNbLectureParLotFils);
if (colDependance != null && arbre.Filtre.Length == 0)
{
//Indique que les lignes ont été lues
for (int nRow = nPaquet * CListeObjetsDonnees.c_nNbLectureParLotFils; nRow < nMax; nRow++)
{
DataRow row = lstSource.View.GetRow(nRow);
DataRowState oldState = row.RowState;
row[colDependance] = true;
if (oldState == DataRowState.Unchanged)
{
row.AcceptChanges();
}
}
}
listeFille.ReadDependances(arbre);
}
}
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="table"></param>
/// <param name="result"></param>
///
private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
///Stef 22/07/08 : l'appel à shouldDeclenche peut
///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
///dans un contexte sans gestion par tables complètes, on est mal, parce que
///ça va génerer une requête par champ.
///Donc, on lit tous les champs custom avant de commencer
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés
listeChamps.AssureLectureFaite();
DateTime dt = DateTime.Now;
CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);
//Pour empêcher de regarder deux fois les évenements d'un même objet
//Type->Dictionnaire des ids vus
Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();
DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);
Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;
if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
{
listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >();
m_listeElementsARepasser[contexte] = listeElementsARepasser;
}
bool bFirstPasse = true;
int nLimiteurPasses = 0;
while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
{
nLimiteurPasses++;
foreach (DataTable table in lstTables)
{
if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
{
string strChampCle = table.PrimaryKey[0].ColumnName;
Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
{
continue;
}
Type typeOriginal = tpObjets;
//Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
//Mais le champ peut l'être
if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
{
int nLigne = 0;
bool bGoOut = false;
while (table.Rows.Count > nLigne && !bGoOut)
{
if (table.Rows[nLigne].RowState != DataRowState.Deleted)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
tpObjets = rel.ElementAChamps.GetType();
strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
bGoOut = true;
}
nLigne++;
}
}
//Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
{
continue;
}
ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);
//Id des éléments modifiés
List <int> listeIdsElementsAVerifierHandlers = new List <int>();
string strPrimaryKey = "";
if (table.PrimaryKey.Length == 1 &&
table.PrimaryKey[0].DataType == typeof(int))
{
strPrimaryKey = table.PrimaryKey[0].ColumnName;
}
Dictionary <int, bool> tableIdsVues = null;
if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
{
tableIdsVues = new Dictionary <int, bool>();
elementsVus[tpObjets] = tableIdsVues;
}
Dictionary <int, bool> listeARepasserPourTable = null;
if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
{
listeARepasserPourTable = null;
}
List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();
//Stef 16/11/2012 :
//Si c'est un élément à champs, il est consideré comme modifié
//si un de ses champs custom est modifiés
//Ca a été fait parce que les handlers d'évenement n'étaient
//Pas pris en compte sur modif de champ custom
//On n'enlève pas pour autant l'ancienne méthode qui consiste
//à considérer l'élément modifié losrqu'on passe sur la table des
//valeurs de champs custom
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
{
//Regarde s'il y a des relations
IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
string strTableChamps = objAChamp.GetNomTableRelationToChamps();
//Trouve la relation à la table
DataTable tableChamps = contexte.Tables[strTableChamps];
if (tableChamps != null)//Si la table champs n'est pas là, c'est
//qu'elle n'a pas été modifiée !! c'est logique çà
{
DataRelation rel = null;
foreach (DataRelation relTest in tableChamps.ParentRelations)
{
if (relTest.ParentTable.TableName == table.TableName)
{
rel = relTest;
break;
}
}
if (rel != null)//On peut vérifier !
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
{
DataRow[] rowsChamps = row.GetChildRows(rel);
foreach (DataRow rowChamp in rowsChamps)
{
if (rowChamp.RowState != DataRowState.Unchanged)
{
//Aloue l'objet pour s'assurer que la ligne est bien pleine
CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
objTmp.AssureData();
row.SetModified();
string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
if (strOldContexte.Length == 0)
{
row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
}
break;
}
}
}
}
}
}
}
foreach (DataRow row in new ArrayList(table.Rows))
{
CObjetDonneeAIdNumerique objet = null;
if (lstEvenements.Count > 0)
{
if (row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Deleted)
{
objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
{
lstObjetsAvecEvenementsSpecifiques.Add(objet);
}
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
{
CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
if (objet.Row.RowState == DataRowState.Unchanged)
{
objet.Row.Row.SetModified();
}
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (rel.ContexteDeModification.Length != 0 &&
objet.ContexteDeModification.Length == 0)
{
objet.ContexteDeModification = rel.ContexteDeModification;
}
}
if (!tableIdsVues.ContainsKey(objet.Id) || (
listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
{
tableIdsVues[objet.Id] = true;
foreach (CEvenement evt in lstEvenements)
{
if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
{
//Attention, si c'est une valeur de champ custom, envoie la valeur,
//c'est elle qui sera testée.
CInfoDeclencheurProcess infoDeclencheur = null;
if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
{
infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
infoDeclencheur.Info = evt.Libelle;
traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
}
}
}
}
}
}
//Regarde les handle d'évenement sur l'objet
if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
{
listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
}
}
if (listeARepasserPourTable != null)
{
listeARepasserPourTable.Clear();
}
if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
{
//traitement par paquet de 500
for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
{
int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
StringBuilder bl = new StringBuilder();
for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
{
bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
bl.Append(",");
}
string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
//Recherche tous les handlers d'évenement pour les objets concernés
CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
listeHandler.Filtre = new CFiltreData(
CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champTypeEvenement + "=@2",
tpObjets.ToString(),
(int)TypeEvenement.Modification);
listeHandler.PreserveChanges = true;
foreach (CHandlerEvenement handler in listeHandler)
{
if (handler.Row.RowState != DataRowState.Deleted)
{
CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
if (objetTmp.ReadIfExists(handler.IdElementCible))
{
CInfoDeclencheurProcess infoDeclencheur = null;
if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
{
if (infoDeclencheur != null && handler.EvenementLie != null)
{
infoDeclencheur.Info = handler.EvenementLie.Libelle;
}
traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
}
}
}
}
}
}
//Annule les évenements spécifiques, ils ont été traités !
foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
{
EvenementAttribute.ClearEvenements(objet);
}
}
}
//Execute ce qui peut être executé tout de suite
foreach (DataTable table in contexte.Tables)
{
table.RowChanged += handlerRedo;
}
listeElementsARepasser.Clear();
foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
{
if (couple.Objet is CObjetDonneeAIdNumerique &&
couple.PeutEtreExecuteSurLePosteClient)
{
result = couple.OnDeclencheSurClient();
if (!result)
{
return(result);
}
}
}
foreach (DataTable table in contexte.Tables)
{
table.RowChanged -= handlerRedo;
}
bFirstPasse = false;
}
if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
{
tableData[c_cleDonneeListeTraitements] = traitement;
}
m_listeElementsARepasser.Remove(contexte);
return(result);
}
private static ArrayList GetListeEvenementsAutoSur(Type tp, int?nIdVersion)
{
ArrayList lst = null;
if (nIdVersion == null)
{
lst = (ArrayList)m_tableTypeToEvenements[tp];
}
if (lst == null)
{
CContexteDonnee contextePourRechercheDeProcess = Contexte;
if (nIdVersion != null)
{
contextePourRechercheDeProcess = new CContexteDonnee(0, true, false);
contextePourRechercheDeProcess.SetVersionDeTravail(nIdVersion, false);
}
try
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contextePourRechercheDeProcess, typeof(CEvenement));
if (m_bEvenementsChanged && nIdVersion == null)
{
liste.AssureLectureFaite();
}
if (nIdVersion == null)
{
m_bEvenementsChanged = false;
}
lst = new ArrayList();
liste.InterditLectureInDB = nIdVersion == null;
liste.Filtre = new CFiltreData(
CEvenement.c_champTypeCible + "=@1 and " +
CEvenement.c_champTypeEvenement + "<>@2" /* and " +
* CEvenement.c_champTypeEvenement + "<>@3"*/,
tp.ToString(),
(int)TypeEvenement.Manuel /*,
* (int)TypeEvenement.Date*/);
foreach (CEvenement evt in liste)
{
lst.Add(evt);
}
lock (typeof(CLockerCacheEvenements))
{
if (nIdVersion == null)
{
m_tableTypeToEvenements[tp] = lst;
}
}
}
catch
{
}
finally
{
if (nIdVersion != null)
{
contextePourRechercheDeProcess.Dispose();
}
}
}
return(lst);
}
//------------------------------------
public CResultAErreur Importer(string strFichier, CContexteDonnee contexteDestination)
{
CResultAErreur result = m_parametre.LectureFichier(strFichier);
m_nNbUpdated = 0;
m_nNbCreated = 0;
if (!result)
{
return(result);
}
if (m_bChargerTouteLaCible)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(contexteDestination, m_typeCible);
lst.AssureLectureFaite();
}
//Vérifie que l'utilisateur a le droit de faire un import
CSessionClient session = CSessionClient.GetSessionForIdSession(contexteDestination.IdSession);
bool bALeDroit = false;
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null)
{
bALeDroit = info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitImport) != null;
}
}
if (!bALeDroit)
{
result.EmpileErreur(I.T("Your are not allowed to import data|20048"));
return(result);
}
DataTable table = result.Data as DataTable;
if (table == null)
{
result.EmpileErreur(I.T("Import error, can not read source data|20043"));
return(result);
}
int nParametre = 1;
string strFiltre = "";
foreach (CMappageChampImport mappage in Mappages)
{
if (mappage.IsCle)
{
result = mappage.GetFiltreCle(m_typeCible, nParametre);
if (!result)
{
return(result);
}
nParametre++;
strFiltre += result.Data.ToString() + " and ";
}
}
CFiltreData filtreCle = null;
if (strFiltre.Length > 0)
{
filtreCle = new CFiltreData(strFiltre.Substring(0, strFiltre.Length - 5));
}
foreach (DataRow row in table.Rows)
{
result = ImporteRow(row, filtreCle, contexteDestination);
if (!result)
{
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
List <Type> lstTypesAVerifier = new List <Type>();
//Trouve tous les types héritant de CMappableTimos
foreach (Assembly ass in sc2i.common.CGestionnaireAssemblies.GetAssemblies())
{
foreach (Type tp in ass.GetTypes())
{
if (typeof(IObjetSPVAvecObjetTimos).IsAssignableFrom(tp))
{
lstTypesAVerifier.Add(tp);
}
}
}
List <string> lstTablesDansOrdre = new List <string>();
using (CContexteDonnee ctxTmp = new CContexteDonnee(contexte.IdSession, true, false))
{
foreach (Type tp in lstTypesAVerifier)
{
string strTable = CContexteDonnee.GetNomTableForType(tp);
if (strTable != null)
{
ctxTmp.GetTableSafe(strTable);
}
}
foreach (DataTable table in ctxTmp.GetTablesOrderInsert())
{
lstTablesDansOrdre.Add(table.TableName);
}
}
foreach (string strNomTable in lstTablesDansOrdre)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
Type tpParent = tp;
Type[] generics = new Type[0];
while (tpParent != null && generics.Length == 0)
{
if (tpParent.IsGenericType && tpParent.GetGenericTypeDefinition() == typeof(CMappableAvecTimos <,>))
{
generics = tpParent.GetGenericArguments();
}
tpParent = tpParent.BaseType;
}
if (generics.Length == 0)
{
continue;
}
IObjetSPVAvecObjetTimos obj = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as IObjetSPVAvecObjetTimos;
Type typeTimos = obj.GetTypeObjetsTimos();
//Lit tous les objets TIMOS
CListeObjetsDonnees lstObjetsTimos = new CListeObjetsDonnees(contexte.ContexteDonnee, typeTimos);
lstObjetsTimos.AssureLectureFaite();
CListeObjetsDonnees lstObjetsSpv = new CListeObjetsDonnees(contexte.ContexteDonnee, obj.GetType());
lstObjetsSpv.AssureLectureFaite();
string strIdObjetTimosInObjetSpv = obj.GetChampIdObjetTimos();
Type tpMappable = typeof(CMappeurTimos <,>).MakeGenericType(generics);
IMappeurTimosNonGenerique mappeur = Activator.CreateInstance(tpMappable) as IMappeurTimosNonGenerique;
foreach (CObjetDonneeAIdNumerique objTimos in (CObjetDonneeAIdNumerique[])lstObjetsTimos.ToArray(typeof(CObjetDonneeAIdNumerique)))
{
CObjetDonneeAIdNumerique objSpv = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (!objSpv.ReadIfExists(new CFiltreData(strIdObjetTimosInObjetSpv + "=@1",
objTimos.Id), false))
{
mappeur.GetObjetSpvFromObjetTimosAvecCreationSansGenerique(objTimos);
}
}
}
return(result);
}
//------------------------------------------------------------------------------------------
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
string strIdChamp = "";
string strPropriete = "";
string strCle = "";
if (listeSource.Count == 0)
{
return;
}
bool bFromEntiteToChamp = false;
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
return;
}
if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
{
//c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
//Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
listeSource.ReadDependances(arbre);
return;
}
//On a affaire à une liste source qui contient des valeurs qui sont pointées
//par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs
CChampCustom champ = new CChampCustom(listeSource.ContexteDonnee);
CDbKey dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);
if (!champ.ReadIfExists(dbKeyChamp))
{
return;
}
//Vérifie que la liste source est bien du type de données du champ custom
if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
{
return;
}
IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;
if (obj == null)
{
return;
}
string strChampId = obj.GetChampId();
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
}
//Trouve le type des éléments à champs
Type typeElementsFinaux = champ.Role.TypeAssocie;
//Trouve le type des relations aux elementAchamp_ChampCustom
IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;
if (elt == null)
{
return;
}
string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
Type tpRelToChamp = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);
if (tpRelToChamp == null)
{
return;
}
foreach (string strPaquet in lstPaquetsALire)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);
//TESTDBKEYTODO
string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;
lst.Filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(typeElementsFinaux),
strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
strPaquet,
dbKeyChamp.GetValeurInDb());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
//**********************************************************************************
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
if (listeSource.Count == 0)
{
return;
}
CObjetDonneeAIdNumerique objExemple = listeSource[0] as CObjetDonneeAIdNumerique;
if (objExemple == null)
{
return;
}
string strCle = "";
string strPropSansCle = "";
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropSansCle))
{
return;
}
//trouve la relation correspondante à l'identifiant de la propriété
RelationTypeIdAttribute relation = null;
foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
{
if (relTest.IdRelation == strPropSansCle)
{
relation = relTest;
break;
}
}
if (relation == null)
{
return;
}
string strNomColDep = relation.GetNomColDepLue();
DataColumn col = objExemple.Table.Columns[strNomColDep];
if (col == null)
{
col = new DataColumn(strNomColDep, typeof(bool));
col.DefaultValue = false;
col.AllowDBNull = false;
objExemple.Table.Columns.Add(col);
}
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(objExemple.GetChampId(), col);
}
foreach (string strPaquet in lstPaquetsALire)
{
if (strPaquet != null && strPaquet.Trim().Length > 0)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relation.TableFille));
lst.Filtre = new CFiltreData(
relation.ChampType + "=@1 and " +
relation.ChampId + " in " + strPaquet,
listeSource.TypeObjets.ToString());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
foreach (CObjetDonneeAIdNumerique obj in listeSource)
{
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row, strNomColDep, true);
}
}
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);
}
//-------------------------------------------------------------------
private static void AlloueCode(IObjetHierarchiqueACodeHierarchique objet, ref int nLastCodeAlloue)
{
if (nLastCodeAlloue == 0 && m_dicLastCodeForType.ContainsKey(objet.GetType()))
{
nLastCodeAlloue = m_dicLastCodeForType[objet.GetType()];
}
string strCle = "";
if (nLastCodeAlloue > 0 && objet.ObjetParent == null)
{
//Teste la valeur suivante
int nTmp = nLastCodeAlloue + 1;
strCle = GetCle(nTmp, objet.NbCarsParNiveau);
CListeObjetsDonnees lstExt = new CListeObjetsDonnees(objet.ContexteDonnee,
objet.GetType(),
new CFiltreData(objet.ChampIdParent + " is null and " +
objet.ChampCodeSystemePartiel + "=@1", strCle));
if (lstExt.CountNoLoad == 0)
{
nLastCodeAlloue = nTmp;
objet.ChangeCodePartiel(strCle);
m_dicLastCodeForType[objet.GetType()] = nLastCodeAlloue;
return;
}
}
CFiltreData filtre = null;
if (objet.ObjetParent != null)
{
filtre = new CFiltreData(objet.ChampIdParent + "=@1",
objet.ObjetParent.Id);
}
else
{
filtre = new CFiltreData(objet.ChampIdParent + " is null and " +
objet.ChampCodeSystemePartiel + ">@1", GetCle(nLastCodeAlloue, objet.NbCarsParNiveau));
}
CListeObjetsDonnees listeSoeurs = new CListeObjetsDonnees(objet.ContexteDonnee, objet.GetType(), filtre);
listeSoeurs.PreserveChanges = true;
listeSoeurs.AssureLectureFaite();
listeSoeurs.InterditLectureInDB = true;
Hashtable tableCodesUtilises = new Hashtable();
foreach (IObjetHierarchiqueACodeHierarchique obj in listeSoeurs)
{
tableCodesUtilises[obj.CodeSystemePartiel] = true;
}
//Cherche le prochain numéro libre
int nCpt = nLastCodeAlloue;
strCle = "";
do
{
nCpt++;
strCle = GetCle(nCpt, objet.NbCarsParNiveau);
/*listeSoeurs.Filtre = new CFiltreData(objet.ChampCodeSystemePartiel + "=@1",
* strCle);*/
}while (tableCodesUtilises.ContainsKey(strCle));
nLastCodeAlloue = nCpt;
objet.ChangeCodePartiel(strCle);
m_dicLastCodeForType[objet.GetType()] = nLastCodeAlloue;
}
public void UpdateOnglets()
{
this.SuspendDrawing();
try
{
/*if (!LockEdition)
* {
* //valide les modifs car on va tout supprimer
* MAJ_Champs();
* }*/
Crownwood.Magic.Controls.TabPage pageSelect = this.SelectedTab;
m_bIsInitializing = true;
Hashtable tablePagesToHide = new Hashtable();
ArrayList pages = new ArrayList(TabPages);
foreach (Crownwood.Magic.Controls.TabPage page in pages)
{
m_tablePagesInit[page] = false;
tablePagesToHide[page] = true;
TabPages.Remove(page);
}
if (m_elementEdite == null)
{
return;
}
/* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
CSessionClient session = null;
IObjetDonneeAIdNumerique objetDonnee = m_elementEdite as IObjetDonneeAIdNumerique;
if (objetDonnee != null)
{
session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
}
else
{
session = CSessionClient.GetSessionUnique();
}
ArrayList lstFormulaires = new ArrayList(m_listeFormulaires);
lstFormulaires.Sort(new CSorterFormulaires());
//Lit les champs liés et leurs valeurs
StringBuilder bl = new StringBuilder();
foreach (CFormulaire formulaire in lstFormulaires)
{
bl.Append(formulaire.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
}
foreach (CFormulaire formulaire in lstFormulaires)
{
Crownwood.Magic.Controls.TabPage page = null;
m_tableIdFormulaireToTabPage.TryGetValue(formulaire.Id, out page);
CCreateur2iFormulaireObjetDonnee createur = null;
if (page == null)
{
C2iWndFenetre wnd = formulaire.Formulaire;
if (wnd != null)
{
page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
page.Name = formulaire.IdUniversel;
if (wnd.Text == "")
{
page.Title = formulaire.Libelle;
}
TabPages.Add(page);
if (m_tableCreateurs.ContainsKey(page))
{
m_tableCreateurs.Remove(page);
}
m_tablePageTo2iWnd[page] = wnd;
m_tableIdFormulaireToTabPage[formulaire.Id] = page;
m_tablePageToIdFormulaire[page] = formulaire.Id;
}
}
else
{
m_tableCreateurs.TryGetValue(page, out createur);
}
if (page != null)
{
if (!TabPages.Contains(page))
{
TabPages.Add(page);
}
tablePagesToHide.Remove(page);
}
}
/*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
* if ( champs.Length != 0 )
* {
* UpdatePageChamps( nRest );
* if ( m_pageGrid != null )
* tablePagesToHide.Remove(m_pageGrid);
* }*/
foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
{
if (TabPages.Contains(pageToDel))
{
TabPages.Remove(pageToDel);
}
}
if (TabPages.Count == 1)
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
}
else
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
}
if (TabPages.Contains(pageSelect))
{
SelectedTab = pageSelect;
}
if (SelectedTab != null)
{
InitPageWithObjetCourant(SelectedTab);
}
}
finally
{
this.ResumeDrawing();
}
m_bIsInitializing = false;
}
//----------------------------------------------------------------------------------
public CResultAErreur ExportSimple(int nIdSession, IEnumerable list, ref DataSet ds, IIndicateurProgression indicateur)
{
if (m_cacheValeurs == null)
{
m_cacheValeurs = new CCacheValeursProprietes();
}
DateTime dt = DateTime.Now;
CResultAErreur result = CResultAErreur.True;
if (list != null && !(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Impossible to use a simple export with something other than a Data Object list|102"));
return(result);
}
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
CContexteDonnee contexteDestination = new CContexteDonnee(nIdSession, true, false);
result = contexteDestination.SetVersionDeTravail(listeObjets.ContexteDonnee.IdVersionDeTravail, false);
if (!result)
{
return(result);
}
contexteDestination.EnforceConstraints = false; //Ca gagne un temps fou !!!
ds = contexteDestination;
//Crée la table principale
DataTable tablePrincipale = contexteDestination.GetTableSafe(CContexteDonnee.GetNomTableForType(m_typeSource));
if (tablePrincipale == null)
{
result.EmpileErreur(I.T("Error during the creation of the main table|103"));
return(result);
}
if (listeObjets != null)
{
//Exporte les objets dans la table principale
foreach (CObjetDonnee objet in listeObjets)
{
tablePrincipale.ImportRow(objet.Row.Row);
}
}
foreach (C2iChampExport champ in Table.Champs)
//Crée les colonnes calculées et champs custom
{
result = CreateChampInTable(champ, tablePrincipale);
if (!result)
{
result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
return(result);
}
}
//Crée les autres tables
foreach (C2iTableExport tableFille in Table.TablesFilles)
{
CreateTableSimpleInDataset(tableFille, contexteDestination, m_typeSource);
}
foreach (DataTable table in contexteDestination.Tables)
{
ArrayList lstColsToDelete = new ArrayList();
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
lstColsToDelete.Add(col);
}
}
foreach (DataColumn col in lstColsToDelete)
{
table.Columns.Remove(col);
}
}
if (listeObjets == null)
{
AddTablesCalculees(contexteDestination, null);
}
if (listeObjets == null)
{
return(result);
}
CListeObjetsDonnees listeDestination = new CListeObjetsDonnees(contexteDestination, m_typeSource, false);
listeDestination.InterditLectureInDB = true;
//Lit les dépendances dans le contexte
//Récupère toutes les sous tables nécéssaires
string[] definitionsOrigines = GetDependancesDeTableSimple(listeObjets.ContexteDonnee);
Hashtable tableDependances = new Hashtable();
foreach (string def in definitionsOrigines)
{
tableDependances[def] = true;
}
string[] strDependances = new string[tableDependances.Count];
int nDependance = 0;
foreach (string strDependance in tableDependances.Keys)
{
strDependances[nDependance] = strDependance;
nDependance++;
}
listeDestination.ReadDependances(strDependances);
//Et voila, le tour est joué, toutes les données sont dans le dataset de destination
//Il manque juste les compositions des éléments nouveaux
if (listeObjets != null)
{
//Exporte les compositions des objets nouveaux
foreach (CObjetDonnee objet in listeObjets)
{
if (objet.IsNew()) //Si nouveau, charge directement toutes ses données
{
objet.ContexteDonnee.CopieRowTo(objet.Row.Row, contexteDestination, true, false, false);
}
}
}
//S'assure que toutes les données sont lues
foreach (DataTable table in contexteDestination.Tables)
{
DataView view = new DataView(table);
view.RowFilter = CContexteDonnee.c_colIsToRead + "=1";
foreach (DataRowView rowView in view)
{
contexteDestination.ReadRow(rowView.Row);
}
}
//Ramène les champs calculés
List <ITableExport> toutesLesTables = ToutesLesTables();
m_cacheValeurs.CacheEnabled = true;
int nNbTotalPrincipal = tablePrincipale.Rows.Count;
//Récupère les champs par ID
//Id->Nom du champ
Dictionary <int, CChampCustom> dicoChamps = new Dictionary <int, CChampCustom>();
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexteDestination, typeof(CChampCustom));
foreach (CChampCustom champ in listeChamps)
{
dicoChamps[champ.Id] = champ;
}
//Liste des tables à conserver au final
Hashtable tableTablesAConserver = new Hashtable();
foreach (C2iTableExport table in toutesLesTables)
{
string strNomTable = "";
DataTable tableDestination = tablePrincipale;
if (table.ChampOrigine != null)
{
strNomTable = CContexteDonnee.GetNomTableForType(table.ChampOrigine.TypeDonnee.TypeDotNetNatif);
tableDestination = contexteDestination.Tables[strNomTable];
}
if (tableDestination != null)
{
tableTablesAConserver[tableDestination.TableName] = true;
List <C2iChampExport> champsCalcules = new List <C2iChampExport>();
List <C2iChampExport> champsCustoms = new List <C2iChampExport>();
foreach (C2iChampExport champ in table.Champs)
{
if (champ.Origine is C2iOrigineChampExportExpression)
{
champsCalcules.Add(champ);
}
if (champ.Origine is C2iOrigineChampExportChampCustom)
{
champsCustoms.Add(champ);
}
}
if (champsCalcules.Count != 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
foreach (DataRow row in tableDestination.Rows)
{
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(tp);
objet.SetRow(row);
#else
object objet = Activator.CreateInstance(tp, new object[] { row });
#endif
foreach (C2iChampExport chp in champsCalcules)
{
if (chp.Origine is C2iOrigineChampExportExpression)
{
object valeur = chp.GetValeur(objet, m_cacheValeurs, null);
if (valeur == null)
{
valeur = DBNull.Value;
}
row[chp.NomChamp] = valeur;
}
}
m_cacheValeurs.ResetCache( );
}
}
if (champsCustoms.Count > 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
IObjetDonneeAChamps element = (IObjetDonneeAChamps)Activator.CreateInstance(tp, contexteDestination);
string strTableValeursChamps = element.GetNomTableRelationToChamps();
Type tpValeursChamps = CContexteDonnee.GetTypeForTable(strTableValeursChamps);
//Travaille les valeurs de champs customs par paquet de 500;
int nTaillePaquet = 500;
int nMax = tableDestination.Rows.Count;
string strChampId = tableDestination.PrimaryKey[0].ColumnName;
for (int nPaquet = 0; nPaquet < nMax; nPaquet += nTaillePaquet)
{
StringBuilder bl = new StringBuilder();
int nFin = Math.Min(nMax, nPaquet + nTaillePaquet);
for (int nRow = nPaquet; nRow < nFin; nRow++)
{
bl.Append(tableDestination.Rows[nRow][strChampId]);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
string strIds = bl.ToString();
foreach (C2iChampExport champACustom in champsCustoms)
{
C2iOrigineChampExportChampCustom origineChamp = (C2iOrigineChampExportChampCustom)champACustom.Origine;
//C'est un élément à champ, donc, va requeter dans les champs customs pour avoir les
//valeurs
CListeObjetsDonnees listeValeurs = new CListeObjetsDonnees(contexteDestination, tpValeursChamps);
StringBuilder blIdsChamps = new StringBuilder();
foreach (int nId in origineChamp.IdsChampCustom)
{
blIdsChamps.Append(nId);
blIdsChamps.Append(',');
}
if (blIdsChamps.Length > 0)
{
blIdsChamps.Remove(blIdsChamps.Length - 1, 1);
listeValeurs.Filtre = new CFiltreData(
CChampCustom.c_champId + " in (" + blIdsChamps.ToString() + ") and " +
strChampId + " in (" + strIds + ")");
listeValeurs.AssureLectureFaite();
//On n'a plus qu'à rebasculer les valeurs dans la table
foreach (CRelationElementAChamp_ChampCustom valeur in listeValeurs)
{
try
{
DataRow rowAttachee = tableDestination.Rows.Find(valeur.Row[strChampId]);
if (rowAttachee != null)
{
object valTmp = valeur.Valeur;
if (valTmp == null)
{
valTmp = DBNull.Value;
}
rowAttachee[c_strPrefixeChampCustom + valeur.ChampCustom.Nom] = valTmp;
}
}
catch
{ }
}
}
}
}
}
}
}
}
}
m_cacheValeurs.ResetCache();
ArrayList lstTablesToDelete = new ArrayList();
foreach (DataTable table in contexteDestination.Tables)
{
if (tableTablesAConserver[table.TableName] == null)
{
lstTablesToDelete.Add(table);
}
}
foreach (DataTable table in lstTablesToDelete)
{
contexteDestination.SupprimeTableEtContraintes(table);
}
AddTablesCalculees(contexteDestination, null);
return(result);
}
//----------------------------------------------------------
public List <ITranchePlanning> GetTranchesForElementsAInterventionBetween(DateTime dateDebut, DateTime dateFin)
{
List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();
Hashtable tableTypeToIds = new Hashtable();
if (m_listeElementsAInterventions.Count == 0)
{
return(lstRetour);
}
//Si tous les elements à Intervention sont du même type
foreach (IElementAIntervention elt in m_listeElementsAInterventions)
{
string strIds = (string)tableTypeToIds[elt.GetType()];
if (strIds == null)
{
strIds = elt.Id + "";
}
else
{
strIds += ";" + elt.Id;
}
tableTypeToIds[elt.GetType()] = strIds;
}
dateFin = dateFin.AddDays(1);
foreach (DictionaryEntry entry in tableTypeToIds)
{
Type tp = (Type)entry.Key;
string strIds = (string)entry.Value;
if (tp == typeof(CSite))
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CFractionIntervention));
liste.PreserveChanges = true;
liste.Filtre = new CFiltreDataAvance(
CFractionIntervention.c_nomTable,
CIntervention.c_nomTable + "." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
CFractionIntervention.c_champDateFinPlanifiee + ">@2",
dateFin,
dateDebut
);
//Lit dans la base
liste.AssureLectureFaite();
liste.ReadDependances("Intervention");
m_contexteDonnee.GetTableSafe(CIntervention.c_nomTable);
strIds = strIds.Replace(';', ',');
string strNomRelation = m_contexteDonnee.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
//Et filtre sur les existants (pour prendre les nouveaux en compte)
string strFiltre = "Parent(" + strNomRelation + ")." + CIntervention.c_champIdElementLie + " in (" + strIds + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
DataTable table = m_contexteDonnee.Tables[CFractionIntervention.c_nomTable];
DataRow[] rows = table.Select(strFiltre);
foreach (DataRow row in rows)
{
lstRetour.Add(new CFractionIntervention(row));
}
}
}
return(lstRetour);
}
/// <summary>
/// Stocke le résultat d'une requête pour un type de données
/// </summary>
/// <param name="nIdTypeDonnee"></param>
/// <param name="requete"></param>
/// <returns></returns>
public CResultAErreur StockeResultat(int nIdTypeDonnee, IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
if (m_tableCalculsEnCours[nIdTypeDonnee] != null)
{
result.EmpileErreur(I.T("The recalculation for this cumulated data type is already in progress|143"));
return(result);
}
m_tableCalculsEnCours[nIdTypeDonnee] = true;
CSessionProcessServeurSuivi sessionSuivi = null;
try
{
//Crée une session pour le calcul
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session == null)
{
result.EmpileErreur(I.T("Session error|144"));
return(result);
}
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
sessionSuivi = new CSessionProcessServeurSuivi();
result = sessionSuivi.OpenSession(new CAuthentificationSessionServer(),
I.T("Recalculation of datas @1|145", nIdTypeDonnee.ToString()),
session);
if (!result)
{
result.EmpileErreur(I.T("Opening session error|146"));
return(result);
}
IdSession = sessionSuivi.IdSession;
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
//Récupère le type de donnée
CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexte);
if (!typeDonnee.ReadIfExists(nIdTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|147", nIdTypeDonnee.ToString()));
return(result);
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Existing datas recovery|148"));
indicateur.SetValue(0);
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
//Lit les données pour ce type de donnée cumulée
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CDonneeCumulee));
liste.Filtre = new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1",
nIdTypeDonnee);
liste.AssureLectureFaite();
if (parametre.ViderAvantChaqueCalcul)
{
result = VideTable(nIdTypeDonnee, contexte.Tables[CDonneeCumulee.c_nomTable]);
if (!result)
{
return(result);
}
}
//Liste des champs clé à lire
ArrayList lstClesALire = new ArrayList();
//Liste des champs destination des clés
ArrayList lstDestClesALire = new ArrayList();
//Liste des valeurs décimales à lire
ArrayList lstValeursDecimalesALire = new ArrayList();
//Liste des champs destinatation des valeurs décimales
ArrayList lstDestValeursDecimalesALire = new ArrayList();
//Liste des valeurs dates à lire
ArrayList lstValeursDatesALire = new ArrayList();
//Liste des champs destinatation des valeurs dates
ArrayList lstDestValeursDatesALire = new ArrayList();
//Liste des valeurs texte à lire
ArrayList lstValeursTextesALire = new ArrayList();
//Liste des champs destinatation des valeurs texte
ArrayList lstDestValeursTextesALire = new ArrayList();
//Change les clés de la table de données pour qu'elles
//correspondent aux clés déclarées
//Pour des recherches ultérieures plus rapides
DataTable tableDonnees = contexte.Tables[CDonneeCumulee.c_nomTable];
DataColumn[] oldKey = tableDonnees.PrimaryKey;
ArrayList lstCles = new ArrayList();
for (int nCle = 0; nCle < CParametreDonneeCumulee.c_nbChampsCle; nCle++)
{
if (parametre.GetChampCle(nCle) != null &&
parametre.GetChampCle(nCle).Champ != "")
{
lstClesALire.Add(parametre.GetChampCle(nCle).Champ);
string strChampDest = CDonneeCumulee.c_baseChampCle + nCle.ToString();
lstDestClesALire.Add(strChampDest);
lstCles.Add(tableDonnees.Columns[strChampDest]);
}
}
try
{
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
catch
{
//On n'y arrive pas, on a probablement changé la requete ->On vide tout !
result = VideTable(nIdTypeDonnee, tableDonnees);
if (!result)
{
return(result);
}
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
//Repère les données à lire
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsValeur; nChamp++)
{
string strChamp = parametre.GetValueField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDecimalesALire.Add(strChamp);
lstDestValeursDecimalesALire.Add(CDonneeCumulee.c_baseChampValeur + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsDate; nChamp++)
{
string strChamp = parametre.GetDateField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDatesALire.Add(strChamp);
lstDestValeursDatesALire.Add(CDonneeCumulee.c_baseChampDate + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsTexte; nChamp++)
{
string strChamp = parametre.GetTextField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursTextesALire.Add(strChamp);
lstDestValeursTextesALire.Add(CDonneeCumulee.c_baseChampTexte + nChamp.ToString());
}
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Request execution|149"));
indicateur.SetValue(10);
}
IDefinitionJeuDonnees defJeu = typeDonnee.Parametre.DefinitionDeDonnees;
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = null;
if (defJeu is C2iRequete)
{
eltAVariables = (IElementAVariablesDynamiquesAvecContexteDonnee)defJeu;
}
else if (defJeu is CStructureExportAvecFiltre)
{
eltAVariables = ((CStructureExportAvecFiltre)defJeu).Filtre;
if (eltAVariables == null)
{
CFiltreDynamique filtre = new CFiltreDynamique(contexte);
filtre.TypeElements = defJeu.TypeDonneesEntree;
eltAVariables = filtre;
}
((CFiltreDynamique)eltAVariables).ContexteDonnee = contexte;
}
result = CParametreDonneeCumulee.GetTableSource(eltAVariables, defJeu, indicateur);
//Calcule le résultat de la requête demandée
if (!result)
{
result.EmpileErreur(I.T("Error in request|150"));
return(result);
}
//Liste des lignes trouvées dans la requête
Hashtable tableExistantes = new Hashtable();
DataTable tableSource = (DataTable)result.Data;
if (indicateur != null)
{
indicateur.SetInfo(I.T("Result Storage|151"));
indicateur.SetValue(20);
indicateur.PushSegment(20, 80);
indicateur.SetBornesSegment(0, tableSource.Rows.Count);
}
int nIndex = 0;
foreach (DataRow row in tableSource.Rows)
{
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
lstCles.Clear();
for (int nCle = 0; nCle < lstClesALire.Count; nCle++)
{
lstCles.Add(row[(string)lstClesALire[nCle]]);
}
DataRow rowDest = tableDonnees.Rows.Find((object[])lstCles.ToArray(typeof(object)));
if (rowDest == null)
{
rowDest = tableDonnees.NewRow();
rowDest[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
for (int nCle = 0; nCle < lstCles.Count; nCle++)
{
rowDest[(string)lstDestClesALire[nCle]] = lstCles[nCle];
}
rowDest[CTypeDonneeCumulee.c_champId] = nIdTypeDonnee;
tableDonnees.Rows.Add(rowDest);
}
// Rempli les valeurs décimales de destination
for (int nChampVal = 0; nChampVal < lstValeursDecimalesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDecimalesALire[nChampVal]] = Convert.ToDouble(row[(string)lstValeursDecimalesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampValeur + nChampVal.ToString()] = 0;
}
}
// Rempli les valeurs Dates de destination
for (int nChampVal = 0; nChampVal < lstValeursDatesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDatesALire[nChampVal]] = Convert.ToDateTime(row[(string)lstValeursDatesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampDate + nChampVal.ToString()] = DBNull.Value;
}
}
// Rempli les valeurs Texte de destination
for (int nChampVal = 0; nChampVal < lstValeursTextesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursTextesALire[nChampVal]] = (row[(string)lstValeursTextesALire[nChampVal]]).ToString();
}
catch
{
rowDest[CDonneeCumulee.c_baseChampTexte + nChampVal.ToString()] = "";
}
}
tableExistantes[rowDest] = true;
}
//Remet la clé à la valeur initiale
tableDonnees.PrimaryKey = oldKey;
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.PushSegment(80, 90);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
indicateur.SetInfo(I.T("Deleting of old values|152"));
}
if (!parametre.PasDeSuppression)
{
//Supprime les lignes à supprimer
ArrayList lstRows = new ArrayList(tableDonnees.Rows);
nIndex = 0;
foreach (DataRow row in lstRows)
{
if (!tableExistantes.Contains(row))
{
row.Delete();
}
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
}
}
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.SetInfo(I.T("Datas saving|153"));
}
contexte.EnableTraitementsAvantSauvegarde = false;
result = contexte.SaveAll(true);
if (indicateur != null)
{
indicateur.SetInfo(I.T("Finished calculation|154"));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
finally
{
if (sessionSuivi != null)
{
sessionSuivi.CloseSession();
}
m_tableCalculsEnCours.Remove(nIdTypeDonnee);
}
return(result);
}
}
//----------------------------------------------------------
public List <ITranchePlanning> GetOccupationsForRessourcesBetween(DateTime dateDebut, DateTime dateFin)
{
List <ITranchePlanning> lstRetour = new List <ITranchePlanning>();
Hashtable tableTypeToIds = new Hashtable();
if (m_listeRessources.Count == 0)
{
return(lstRetour);
}
CContexteDonnee contexte = m_listeRessources[0].ContexteDonnee;
foreach (IRessourceEntreePlanning ressource in Ressources)
{
if (tableTypeToIds[ressource.GetType()] == null)
{
tableTypeToIds[ressource.GetType()] = ressource.Id + "";
}
else
{
string strId = (string)tableTypeToIds[ressource.GetType()];
strId += "," + ressource.Id;
tableTypeToIds[ressource.GetType()] = strId;
}
}
dateFin = dateFin.AddDays(1);
///IdFraction->True si elle a déjà été ajoutée
Hashtable tableFractions = new Hashtable();
foreach (DictionaryEntry entry in tableTypeToIds)
{
Type tp = (Type)entry.Key;
string strIds = (string)entry.Value;
CListeObjetsDonnees liste;
string strClauseRessource = "";
string strDependancesRessources = "";
string strTableLienRessource = "";
string strChampIdRessourceInTableLien = "";
Type typeLienRessource = null;
if (tp == typeof(CActeur))
{
strClauseRessource = CIntervention_Intervenant.c_nomTable + "." + CActeur.c_champId + " in (" + strIds + ")";
strDependancesRessources = "Intervention.RelationsIntervenants";
strTableLienRessource = CIntervention_Intervenant.c_nomTable;
typeLienRessource = typeof(CIntervention_Intervenant);
strChampIdRessourceInTableLien = CActeur.c_champId;
}
else if (tp == typeof(CRessourceMaterielle))
{
strClauseRessource = CIntervention_Ressource.c_nomTable + "." + CRessourceMaterielle.c_champId + " in (" + strIds + ")";
strDependancesRessources = "Intervention.RelationsRessourcesMaterielles";
strTableLienRessource = CIntervention_Ressource.c_nomTable;
typeLienRessource = typeof(CIntervention_Ressource);
strChampIdRessourceInTableLien = CRessourceMaterielle.c_champId;
}
else
{
throw new Exception("Type de ressource non prévu : " + tp.ToString());
}
liste = new CListeObjetsDonnees(contexte, typeof(CFractionIntervention));
liste.PreserveChanges = true;
liste.Filtre = new CFiltreDataAvance(
CFractionIntervention.c_nomTable,
CIntervention.c_nomTable + "." +
strClauseRessource + " and " +
CFractionIntervention.c_champDateDebutPlanifie + "<@1 and " +
CFractionIntervention.c_champDateFinPlanifiee + ">@2",
dateFin,
dateDebut
);
//Lit dans la base
liste.AssureLectureFaite();
liste.ReadDependances("Intervention", strDependancesRessources);
contexte.GetTableSafe(CIntervention.c_nomTable);
contexte.GetTableSafe(strTableLienRessource);
string strNomRelationIntervention = contexte.GetForeignKeyName(typeof(CFractionIntervention), "Intervention");
//Ne sélectionne que ceux qui sont liés à la ressource
CListeObjetsDonnees listeInterventionIt = new CListeObjetsDonnees(contexte, typeLienRessource);
listeInterventionIt.InterditLectureInDB = true;
listeInterventionIt.Filtre = new CFiltreData(strChampIdRessourceInTableLien + " in (" + strIds + ")");
string strIdsInterventions = "";
foreach (IEntreePlanning_Ressource it in listeInterventionIt)
{
strIdsInterventions += it.EntreePlanning.Id + ",";
}
if (strIdsInterventions.Length > 0)
{
string strFiltre = "Parent(" + strNomRelationIntervention + ")." + CIntervention.c_champId + " in (" + strIdsInterventions + ") and " +
CFractionIntervention.c_champDateDebutPlanifie + "<=" + dateFin.ToString("#MM/dd/yyyy#") + " and " +
CFractionIntervention.c_champDateFinPlanifiee + ">=" + dateDebut.ToString("#MM/dd/yyyy#") + "";
DataTable table = contexte.Tables[CFractionIntervention.c_nomTable];
DataRow[] rows = table.Select(strFiltre);
foreach (DataRow row in rows)
{
if (!tableFractions.Contains(row[CFractionIntervention.c_champId]))
{
lstRetour.Add(new CFractionIntervention(row));
tableFractions[row[CFractionIntervention.c_champId]] = true;
}
}
}
}
return(lstRetour);
}
/// /////////////////////////////////////////////////////////
public DataSet GetAddAndUpdateInTableMain(
string strNomTable,
int nSessionSyncDebut,
int nSessionSyncFin,
string strCodeGroupeSynchronisation)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
DataSet dsDest = null;
if (tp == null)
{
return(null);
}
//Récupère les filtres
CFiltresSynchronisation filtres = GetFiltres(strCodeGroupeSynchronisation);
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CFiltreData filtreSynchro = null;
if (filtres != null)
{
filtreSynchro = filtres.GetFiltreForTable(m_nIdSession, strNomTable);
}
if (filtreSynchro == null)
{
filtreSynchro = new CFiltreData();
}
int nNumParametreIdSync = filtreSynchro.Parametres.Count + 1;
string strFiltre = filtreSynchro.Filtre;
filtreSynchro.Filtre = "(" + CSc2iDataConst.c_champIdSynchro + ">=@" + nNumParametreIdSync.ToString() + " and " +
CSc2iDataConst.c_champIdSynchro + "<=@" + (nNumParametreIdSync + 1).ToString();
if (nSessionSyncDebut == -1)
//C'est la première synchro, intègre les éléments modifiés avant prise en charge
//des synchros
{
if (filtreSynchro is CFiltreDataAvance)
{
filtreSynchro.Filtre += " or hasno(" + CSc2iDataConst.c_champIdSynchro + ")";
}
else
{
filtreSynchro.Filtre += " or " + CSc2iDataConst.c_champIdSynchro + " is null";
}
}
filtreSynchro.Filtre += ")";
if (strFiltre != "")
{
filtreSynchro.Filtre += " and (" + strFiltre + ")";
}
filtreSynchro.Parametres.Add(nSessionSyncDebut);
filtreSynchro.Parametres.Add(nSessionSyncFin);
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, tp, false);
liste.Filtre = filtreSynchro;
liste.AssureLectureFaite();
//Charge les données de synchronisation
CFiltreData filtreDataSync = new CFiltreData(CEntreeLogSynchronisation.c_champTable + "=@1 and " +
CSc2iDataConst.c_champIdSynchro + ">=@2 and " +
CSc2iDataConst.c_champIdSynchro + "<=@3",
strNomTable, nSessionSyncDebut, nSessionSyncFin);
liste = new CListeObjetsDonnees(contexte, typeof(CEntreeLogSynchronisation), false);
liste.Filtre = filtreDataSync;
liste.AssureLectureFaite();
//Transforme le contexte en dataset (pour sérialisation web !! )
dsDest = new DataSet();
foreach (DataTable table in contexte.Tables)
{
DataTable tableDest = CUtilDataSet.AddTableCopie(table, dsDest);
foreach (DataRow row in table.Rows)
{
tableDest.ImportRow(row);
}
//Supprime les colonnes blob
for (int nCol = tableDest.Columns.Count - 1; nCol >= 0; nCol--)
{
if (tableDest.Columns[nCol].DataType == typeof(CDonneeBinaireInRow))
{
tableDest.Columns.RemoveAt(nCol);
}
}
}
}
return(dsDest);
}
public void UpdateOnglets()
{
if (!LockEdition)
{
//valide les modifs car on va tout supprimer
MAJ_Champs();
}
m_bIsInitializing = true;
Hashtable tablePagesToHide = new Hashtable();
foreach (Crownwood.Magic.Controls.TabPage page in TabPages)
{
m_tablePagesInit[page] = false;
tablePagesToHide[page] = true;
}
if (m_elementEdite == null)
{
return;
}
/* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
CSessionClient session = null;
IObjetDonneeAIdNumeriqueAuto objetDonnee = m_elementEdite as IObjetDonneeAIdNumeriqueAuto;
if (objetDonnee != null)
{
session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
}
else
{
session = CSessionClient.GetSessionUnique();
}
ArrayList lstFormulaires = new ArrayList(m_elementEdite.GetFormulaires());
lstFormulaires.Sort(new CSorterFormulaires());
//Lit les champs liés et leurs valeurs
StringBuilder bl = new StringBuilder();
foreach (CFormulaire formulaire in lstFormulaires)
{
bl.Append(formulaire.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
}
foreach (CFormulaire formulaire in lstFormulaires)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(m_elementEdite.GetType());
if (session.GetInfoUtilisateur() != null)
{
int?nIdVersion = null;
IObjetAContexteDonnee objetAContexte = m_elementEdite as IObjetAContexteDonnee;
if (objetAContexte != null)
{
nIdVersion = objetAContexte.ContexteDonnee.IdVersionDeTravail;
}
restriction = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_elementEdite, nIdVersion);
}
ERestriction restrictionFormulaire = restriction.GetRestriction(formulaire.CleRestriction);
if ((restrictionFormulaire & ERestriction.Hide) != ERestriction.Hide)
{
Crownwood.Magic.Controls.TabPage page = (Crownwood.Magic.Controls.TabPage)m_tableIdFormulaireToTabPage[formulaire.Id];
CCreateur2iFormulaire createur = null;
if (page == null)
{
C2iWndFenetre wnd = formulaire.Formulaire;
if (wnd != null)
{
page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
page.SuspendLayout();
if (wnd.Text == "")
{
page.Title = formulaire.Libelle;
}
TabPages.Add(page);
m_tableCreateurs[page] = null;
m_tablePageTo2iWnd[page] = wnd;
m_tableIdFormulaireToTabPage[formulaire.Id] = page;
}
}
else
{
createur = (CCreateur2iFormulaire)m_tableCreateurs[page];
}
if (page != null)
{
m_tablePageToRestriction[page] = restrictionFormulaire;
if (!TabPages.Contains(page))
{
TabPages.Add(page);
}
tablePagesToHide.Remove(page);
}
}
}
/*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
* if ( champs.Length != 0 )
* {
* UpdatePageChamps( nRest );
* if ( m_pageGrid != null )
* tablePagesToHide.Remove(m_pageGrid);
* }*/
foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
{
TabPages.Remove(pageToDel);
}
if (TabPages.Count == 1)
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
}
else
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
}
if (SelectedTab != null)
{
InitPageWithObjetCourant(SelectedTab);
}
m_bIsInitializing = false;
}
//Initialise la base des alarmes en cours avec les alarmes de la base
private void LoadAlarmesForElement(string strChampDansAlarme, CDictionnaireConcerne dicConcernes)
{
List <CDbKey> lstKeysElements = new List <CDbKey>();
lstKeysElements.AddRange(dicConcernes.Keys);
int nSizePaquet = 100;
for (int nPaquet = 0; nPaquet < lstKeysElements.Count; nPaquet += nSizePaquet)
{
int nMax = Math.Min(nPaquet + nSizePaquet, lstKeysElements.Count);
StringBuilder bl = new StringBuilder();
for (int nId = 0; nId < nMax; nId++)
{
bl.Append(lstKeysElements[nId]);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
//Charge tous les Liens d'alarme pour les éléments
CListeObjetsDonnees lstAlarmes = new CListeObjetsDonnees(m_contexteDonnee, typeof(CAlarme));
lstAlarmes.Filtre = new CFiltreData(strChampDansAlarme + " in (" +
bl.ToString() + ") and " +
CAlarme.c_champDateFin + " is null");
lstAlarmes.AssureLectureFaite();
//CMemoryDb database = new CMemoryDb();
foreach (CAlarme alarme in lstAlarmes)
{
if (alarme != null && alarme.AlarmesFilles.Count == 0)
{
CLocalAlarme locAlrm = alarme.GetLocalAlarme(m_database, true);
//m_dicAlarmes[info.IdSpvEvtAlarme] = info;
m_dicAlarmes[locAlrm.Id] = locAlrm;
StartAlarme(locAlrm);
}
}
/*
* foreach ( CSpvLienAccesAlarme lienAlarme in lstAlarmes )
* {
* 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);
* }*/
}
}
}