//-----------------------------------------------------------
private C2iRequeteAvancee GetRequete(CParametreInspirationProprieteDeType parametre)
{
C2iRequeteAvancee requete = null;
if (m_dicRequetes.TryGetValue(parametre, out requete))
{
return(requete);
}
if (parametre.Type == null)
{
return(null);
}
CDefinitionProprieteDynamiqueChampCustom defCustom = parametre.Champ as CDefinitionProprieteDynamiqueChampCustom;
if (defCustom != null)
{
requete = GetRequeteChampCustom(parametre);
}
CDefinitionProprieteDynamiqueDotNet defDotNet = parametre.Champ as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
requete = GetRequeteChampDotNet(parametre);
}
m_dicRequetes[parametre] = requete;
return(requete);
}
//----------------------------------------------------------------
private static int GetNbUsedInDbForType(Type tp)
{
MethodInfo info = tp.GetMethod(c_MethodeCompteElementsInBase);
if (info != null)
{
return((int)info.Invoke(null, new object[0]));
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
CStructureTable structure = CStructureTable.GetStructure(tp);
requete.TableInterrogee = structure.NomTable;
C2iChampDeRequete champ = new C2iChampDeRequete(structure.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.Number,
false);
requete.ListeChamps.Add(champ);
requete.FiltreAAppliquer = new CFiltreData(CSc2iDataConst.c_champIdVersion + " is null");
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer.IntegrerLesElementsSupprimes = false;
CResultAErreur result = requete.ExecuteRequete(0);
if (!result)
{
return(0);
}
DataTable table = result.Data as DataTable;
return((int)table.Rows[0][0]);
}
//--------------------------------------------------------------------------
public CResultAErreur ReadRefsForType(Type tp)
{
CResultAErreur result = CResultAErreur.True;
if (tp == null)
{
return(result);
}
List <string> lst = new List <string>();
m_dicTypeToKeys[tp] = lst;
if (m_configuration.IsIgnore(tp))
{
return(result);
}
NoIdUniverselAttribute att = tp.GetCustomAttribute <NoIdUniverselAttribute>(true);
if (att != null)
{
return(result);
}
m_indicateurProgression.SetInfo(DynamicClassAttribute.GetNomConvivial(tp));
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
//Compte les éléments dans la table
using (CContexteDonnee ctx = new CContexteDonnee(m_nIdSession, true, false))
{
CListeObjetsDonnees lstCount = new CListeObjetsDonnees(ctx, tp);
int nNb = lstCount.CountNoLoad;
if (nNb > m_configuration.LimiteNbPourRechercheReference)
{
m_setTypesIgnoresAutomatiquement.Add(tp);
return(result);
}
}
C2iRequeteAvancee r = new C2iRequeteAvancee(null);
r.TableInterrogee = strNomTable;
r.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel,
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
result = r.ExecuteRequete(m_nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
lst.Add((string)row[0]);
m_dicKeyToTypes[(string)row[0]] = tp;
}
}
}
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serialiser)
{
int nVersion = GetNumVersion();
CResultAErreur result = serialiser.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serialiser.TraiteString(ref m_strNomTable);
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
obj = m_requete;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_requete = (C2iRequeteAvancee)obj;
if (m_requete == null)
{
m_requete = new C2iRequeteAvancee(null);
}
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_filtreAAppliquer = (CFiltreDynamique)obj;
if (nVersion >= 1)
{
obj = m_tableauCroise;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_tableauCroise = (CTableauCroise)obj;
}
if (nVersion >= 2)
{
serialiser.TraiteBool(ref m_bNePasCalculer);
}
return(result);
}
public static List <string> GetListeRubriques(CContexteDonnee contexteDonnee)
{
C2iRequeteAvancee requete = new C2iRequeteAvancee(contexteDonnee.IdVersionDeTravail);
C2iChampDeRequete champ = new C2iChampDeRequete(
CChampCustom.c_champFolder, new CSourceDeChampDeRequete(CChampCustom.c_champFolder),
typeof(string), OperationsAgregation.None, true);
requete.ListeChamps.Add(champ);
requete.TableInterrogee = CChampCustom.c_nomTable;
CResultAErreur result = requete.ExecuteRequete(contexteDonnee.IdSession);
HashSet <string> setRubriques = new HashSet <string>();
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataRow row in table.Rows)
{
if (row[0] != DBNull.Value)
{
setRubriques.Add(row[0].ToString());
}
}
}
requete = new C2iRequeteAvancee(contexteDonnee.IdVersionDeTravail);
champ = new C2iChampDeRequete(
CChampCalcule.c_champRubrique, new CSourceDeChampDeRequete(CChampCalcule.c_champRubrique),
typeof(string), OperationsAgregation.None, true);
requete.ListeChamps.Add(champ);
requete.TableInterrogee = CChampCalcule.c_nomTable;
result = requete.ExecuteRequete(contexteDonnee.IdSession);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataRow row in table.Rows)
{
if (row[0] != DBNull.Value)
{
setRubriques.Add(row[0].ToString());
}
}
}
List <string> lstRubriques = new List <string>();
foreach (string strRub in setRubriques)
{
lstRubriques.Add(strRub);
}
lstRubriques.Sort((x, y) => x.CompareTo(y));
return(lstRubriques);
}
//-------------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CEasyQuery query = Query;
CResultAErreur result = CResultAErreur.True;
if (result && TypeSource == null)
{
result.EmpileErreur(I.T("###Table object must be specified |"));
}
if (query == null || sources == null)
{
result.EmpileErreur(I.T("###Query needs a source to provide datas|"));
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(TypeSource);
result = FiltreDynamique.GetFiltreData();
if (!result)
{
return(result);
}
if (result.Data is CFiltreData)
{
requete.FiltreAAppliquer = result.Data as CFiltreData;
}
foreach (IColumnDeEasyQuery col in Columns)
{
CColumnDeEasyQueryChampDeRequete colR = col as CColumnDeEasyQueryChampDeRequete;
requete.ListeChamps.Add(colR);
}
DataTable table = null;
if (requete.ListeChamps.Count > 0)
{
result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
if (!result)
{
result.EmpileErreur(I.T("###Error on table @1|"));
return(result);
}
table = result.Data as DataTable;
}
else
{
table = new DataTable();
}
table.TableName = NomFinal;
return(result);
}
//-------------------------------------------------------------------
public bool IsUsed(int[] nIdsFormats)
{
if (nIdsFormats.Length == 0)
{
return(false);
}
string strIds = "";
foreach (int nId in nIdsFormats)
{
strIds += nId + ",";
}
strIds = strIds.Substring(0, strIds.Length - 1);
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CSystemeCoordonnees.c_nomTable;
requete.FiltreAAppliquer = new CFiltreDataAvance(
CSystemeCoordonnees.c_nomTable,
CRelationSystemeCoordonnees_FormatNumerotation.c_nomTable + "." +
CFormatNumerotation.c_champId + " in (" + strIds + ")");
requete.ListeChamps.Add(new C2iChampDeRequete("ID", new CSourceDeChampDeRequete(CSystemeCoordonnees.c_champId), typeof(int), OperationsAgregation.None, true));
CResultAErreur result = requete.ExecuteRequete(IdSession);
if (!result)
{
return(true);
}
DataTable table = (DataTable)result.Data;
if (table.Rows.Count == 0)
{
return(false);
}
List <int> idsSystemes = new List <int>();
foreach (DataRow row in table.Rows)
{
idsSystemes.Add((int)row[0]);
}
CSystemeCoordonneesServeur serveur = new CSystemeCoordonneesServeur(IdSession);
return(serveur.IsUsed(idsSystemes.ToArray()));
}
//-----------------------------------------------------------
private void FillInspirations(int nIdSession)
{
lock (typeof(CLockerInspiration))
{
this.m_dateLastRefresh = DateTime.Now;
m_listeInspirations = new List <string>();
HashSet <string> set = new HashSet <string>();
if (m_dicRequetes == null)
{
m_dicRequetes = new Dictionary <CParametreInspirationProprieteDeType, C2iRequeteAvancee>();
}
C2iRequeteAvancee requete = GetRequete(m_parametre);
if (requete != null)
{
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
string strVal = row[0] as string;
if (strVal != null)
{
strVal = strVal.Trim();
int nIndex;
if (strVal.Length > 0)
{
do
{
set.Add(strVal);
nIndex = strVal.IndexOf(' ');
if (nIndex >= 0)
{
strVal = strVal.Substring(nIndex + 1).Trim()
;
}
} while (nIndex >= 0);
}
}
}
}
}
}
m_listeInspirations.AddRange(set.ToArray());
}
}
//--------------------------------------------------------
public CResultAErreur GetDonneesSource(CFiltreData filtre, params string[] strIdsColonnesSource)
{
CResultAErreur result = CResultAErreur.True;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(m_typeSource);
requete.FiltreAAppliquer = filtre;
List <string> lstIdsCols = new List <string>();
HashSet <string> setToAdd = null;
if (strIdsColonnesSource != null && strIdsColonnesSource.Length > 0)
{
setToAdd = new HashSet <string>();
foreach (string strIdCol in strIdsColonnesSource)
{
setToAdd.Add(strIdCol);
}
}
string strChampId = "";
//Lecture de la table de base
foreach (IColumnDefinition col in Columns)
{
CColumnDefinitionChampDeTable colChamp = col as CColumnDefinitionChampDeTable;
if (colChamp != null)
{
if (setToAdd == null || setToAdd.Contains(colChamp.ColumnName))
{
C2iChampDeRequete champ = new C2iChampDeRequete(
col.ColumnName,
new CSourceDeChampDeRequete(col.ColumnName),
colChamp.DataType,
OperationsAgregation.None,
false);
requete.ListeChamps.Add(champ);
}
}
}
result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
if (!result || !(result.Data is DataTable))
{
return(result);
}
return(result);
}
//------------------------------------------------------
private CResultAErreur GetIdsFilles(
Type typeFils,
CFiltreData filtre,
out int[] lstIdsSortie)
{
lstIdsSortie = new int[0];
CResultAErreur result = CResultAErreur.True;
result = TestTypePurgeable(typeFils);
if (!result)
{
return(result);
}
CStructureTable structureFille = CStructureTable.GetStructure(typeFils);
//Sélectionne tous les éléments
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = structureFille.NomTable;
string strChampIdFille = structureFille.ChampsId[0].NomChamp;
requete.ListeChamps.Add(new C2iChampDeRequete(
strChampIdFille,
new CSourceDeChampDeRequete(strChampIdFille),
typeof(int),
OperationsAgregation.None,
false));
requete.FiltreAAppliquer = filtre;
result = requete.ExecuteRequete(IdSession);
if (!result)
{
return(result);
}
DataTable table = result.Data as DataTable;
List <int> lstIdsFille = new List <int>();
foreach (DataRow row in table.Rows)
{
lstIdsFille.Add((int)row[strChampIdFille]);
}
lstIdsSortie = lstIdsFille.ToArray();
return(result);
}
//-----------------------------------------------------------
private C2iRequeteAvancee GetRequeteChampDotNet(CParametreInspirationProprieteDeType parametre)
{
CStructureTable structure = CStructureTable.GetStructure(parametre.Type);
string strNomProp = parametre.Champ.NomProprieteSansCleTypeChamp;
foreach (CInfoChampTable info in structure.Champs)
{
if (info.Propriete == strNomProp)
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(parametre.Type);
requete.ListeChamps.Add(new C2iChampDeRequete("LABEL",
new CSourceDeChampDeRequete(info.NomChamp),
typeof(string),
OperationsAgregation.None,
true));
return(requete);
}
}
return(null);
}
//-------------------------------------------------------------------
public bool IsUsed(int[] nIdsSystemesCoordonnees)
{
if (nIdsSystemesCoordonnees == null ||
nIdsSystemesCoordonnees.Length == 0)
{
return(false);
}
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CParametrageSystemeCoordonnees.c_nomTable;
string strIds = "";
foreach (int nId in nIdsSystemesCoordonnees)
{
strIds += nId.ToString() + ",";
}
strIds = strIds.Substring(0, strIds.Length - 1);
requete.FiltreAAppliquer = new CFiltreData(
CSystemeCoordonnees.c_champId + " in (" + strIds + ")");
requete.ListeChamps.Add(new C2iChampDeRequete("ID", new CSourceDeChampDeRequete(CParametrageSystemeCoordonnees.c_champId), typeof(int), OperationsAgregation.None, true));
CResultAErreur result = requete.ExecuteRequete(IdSession);
if (!result)
{
return(true);
}
DataTable table = (DataTable)result.Data;
List <int> idsParametrage = new List <int>();
foreach (DataRow row in table.Rows)
{
idsParametrage.Add((int)row[0]);
}
CParametrageSystemeCoordonneesServeur paramServeur = new CParametrageSystemeCoordonneesServeur(IdSession);
return(paramServeur.IsUsed(idsParametrage.ToArray()));
}
//-----------------------------------------------------------
private C2iRequeteAvancee GetRequeteChampCustom(CParametreInspirationProprieteDeType parametre)
{
CDefinitionProprieteDynamiqueChampCustom defChampCustom = parametre.Champ as CDefinitionProprieteDynamiqueChampCustom;
if (defChampCustom == null || parametre.Type == null || defChampCustom.DbKeyChamp == null)
{
return(null);
}
DataTable table = new DataTable();
DataRow row = table.NewRow();
IObjetDonneeAChamps objet = Activator.CreateInstance(parametre.Type, new object[] { row }) as IObjetDonneeAChamps;
if (objet != null)
{
string strTableValeurs = objet.GetNomTableRelationToChamps();
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strTableValeurs;
requete.ListeChamps.Add(new C2iChampDeRequete("LABEL",
new CSourceDeChampDeRequete(CRelationElementAChamp_ChampCustom.c_champValeurString),
typeof(string),
OperationsAgregation.None,
true));
int nIdChamp = -1;
//TESTDBKEYOK SC 31/03/2014
if (defChampCustom.DbKeyChamp.IsNumericalId())
{
nIdChamp = (int)defChampCustom.DbKeyChamp.GetValeurInDb();
}
else
{
nIdChamp = CChampCustom.GetIdFromDbKey(defChampCustom.DbKeyChamp);
}
requete.FiltreAAppliquer = new CFiltreData(CChampCustom.c_champId + "=@1", nIdChamp);
return(requete);
}
return(null);
}
//------------------------------------------------------------------------
//Démarre la prochaine étape de la liste
private void StartNextEtape()
{
//C2iEventLog.WriteInfo("DEBUG_TODO - StartNextEtape()");
CParametresStartEtapeInPile parametreToRun = null;
lock (typeof(CLockerEtapes))
{
if (m_listeEtapes.Count == 0)
{
return;
}
m_listeEtapes.Sort((x, y) => x.DateStart.CompareTo(y.DateStart));
Dictionary <int, bool?> dicSessionsPrets = new Dictionary <int, bool?>();
foreach (CParametresStartEtapeInPile parametre in m_listeEtapes)
{
bool?bIsPrete = null;
if (parametre.IdSessionMain != null)
{
if (!dicSessionsPrets.TryGetValue(parametre.IdSessionMain.Value, out bIsPrete))
{
bIsPrete = IsTransactionTerminee(parametre.IdSessionMain.Value);
dicSessionsPrets[parametre.IdSessionMain.Value] = bIsPrete;
}
}
else
{
bIsPrete = true;
}
if (bIsPrete.Value)
{
//Vérifie que l'étape existe
C2iRequeteAvancee req = new C2iRequeteAvancee();
req.TableInterrogee = CEtapeWorkflow.c_nomTable;
req.ListeChamps.Add(new C2iChampDeRequete("ID",
new CSourceDeChampDeRequete(CEtapeWorkflow.c_champId),
typeof(int),
OperationsAgregation.None,
true));
req.FiltreAAppliquer = new CFiltreData(CEtapeWorkflow.c_champId + "=@1",
parametre.IdEtape);
//C2iEventLog.WriteInfo("DEBUG_TODO - StartNextEtape() - Vérifie que l'étape existe Id = " + parametre.IdEtape);
CResultAErreur result = req.ExecuteRequete(m_session.IdSession);
if (result && result.Data is DataTable && ((DataTable)result.Data).Rows.Count > 0)
{
//C2iEventLog.WriteInfo("DEBUG_TODO - StartNextEtape() - OK l'étape existe Id = " + parametre.IdEtape);
parametreToRun = parametre;
break;
}
}
}
if (parametreToRun != null)
{
m_listeEtapes.Remove(parametreToRun);
}
}
if (parametreToRun != null)
{
ExecuteEtape(parametreToRun);
}
}
/// /////////////////////////////////////////////////////////
public CResultAErreur EndInsertData(DataSet ds)
{
CResultAErreur result = CResultAErreur.True;
if (m_bNePasCalculer)
{
return(result);
}
if (m_mapIdBaseParentToReadToIdTable == null || m_mapIdBaseParentToReadToIdTable.Count == 0)
{
return(result);
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (m_tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
string strListe = "";
foreach (int nId in m_mapIdBaseParentToReadToIdTable.Keys)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
CFiltreData filtreDeBase = new CFiltreDataAvance(
m_requete.TableInterrogee,
m_strChampIdParent + " in {" + strListe + "}");
result = GetFiltreDataAAppliquer(m_elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
string strChampParent = m_strChampIdParent + "_CLE_DB";
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(m_strChampIdParent),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
requete.FiltreAAppliquer = leFiltreComplet;
result = requete.ExecuteRequete(m_nIdSession);
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (m_tableauCroise != null)
{
CTableauCroise newTableau = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
newTableau.AddChampCle(new CCleTableauCroise(strChampParent, typeof(int)));
result = newTableau.CreateTableCroisee(tableDonnees);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
foreach (DataRow row in tableDonnees.Rows)
{
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
newRow[colFille] = (int)m_mapIdBaseParentToReadToIdTable[row[strChampParent]];
}
table.Rows.Add(newRow);
}
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
int nValeurIndicateur = 0;
indicateur.SetBornesSegment(0, m_tableauCroise == null?2:3);
if (list == null)
{
return(result);
}
if (!(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Attempt of cumulated table on something other that a data list|125"));
return(result);
}
CListeObjetsDonnees listeDonnees = (CListeObjetsDonnees)list;
if (relationToObjetParent == null)
{
//Principe de la lecture en une fois :
//Si la liste des une liste objets contenus, c'est que chaque élément
//est un composant d'un parent. On stock donc tous les parents
//Pour lesquels on veut les données,
//et elles seront lues dans le EndInsertTable.
//Par contre si la liste contenu a un filtre, on ne peut plus
//stocker juste ça, il faudrait en plus stocker le filtre et ça
//devient compliqué.
if (listeDonnees is CListeObjetsDonneesContenus &&
(listeDonnees.Filtre == null ||
!listeDonnees.Filtre.HasFiltre))
{
CListeObjetsDonneesContenus listeContenu = (CListeObjetsDonneesContenus)listeDonnees;
if (listeContenu.ObjetConteneur != null &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeContenu.ObjetConteneur.GetType()))
{
if (m_mapIdBaseParentToReadToIdTable == null)
{
m_mapIdBaseParentToReadToIdTable = new Hashtable();
}
m_mapIdBaseParentToReadToIdTable[((CObjetDonneeAIdNumerique)listeContenu.ObjetConteneur).Id] = nValeursCle[0];
m_strChampIdParent = listeContenu.ChampsFille[0];
m_tableParente = tableParente;
listeContenu.GetFiltreForRead();
m_nIdSession = listeContenu.ContexteDonnee.IdSession;
m_elementAVariablePourFiltres = elementAVariablePourFiltres;
return(result);
}
}
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
CFiltreData filtreDeBase = listeDonnees.GetFiltreForRead();
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = m_requete;
CTableauCroise tableauCroise = m_tableauCroise;
string strChampParent = "";
if (relationToObjetParent != null)
{
requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
strChampParent = relationToObjetParent.ChampsParent[0] + "_CLE_DB";
Type typeChampParent = typeof(string);
IChampDeTable champParent = tableParente.Champs.FirstOrDefault(c => c.NomChamp == strChampParent);
if (champParent != null)
{
typeChampParent = champParent.TypeDonnee;
}
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(relationToObjetParent.ChampsFils[0]),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
string strListe = "";
foreach (int nId in nValeursCle)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
leFiltreComplet = CFiltreData.GetAndFiltre(leFiltreComplet, new CFiltreDataAvance(
requete.TableInterrogee,
relationToObjetParent.ChampsFils[0] + " in {" + strListe + "}"));
if (tableauCroise != null)
{
tableauCroise = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
tableauCroise.AddChampCle(new CCleTableauCroise(strChampParent, typeChampParent));
}
}
requete.FiltreAAppliquer = leFiltreComplet;
indicateur.SetInfo(I.T("Table @1 (request)|127", NomTable));
if (ChampOrigine == null)
{
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(listeDonnees.TypeObjets);
}
result = requete.ExecuteRequete(listeDonnees.ContexteDonnee.IdSession);
indicateur.SetValue(nValeurIndicateur++);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (tableauCroise != null)
{
indicateur.SetInfo(I.T("Table @1 (cross table)|128", NomTable));
result = tableauCroise.CreateTableCroisee(tableDonnees);
indicateur.SetValue(nValeurIndicateur++);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
indicateur.SetInfo(I.T("Storage|129"));
indicateur.PushSegment(nValeurIndicateur, nValeurIndicateur + 1);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
int nFrequence = Math.Min(tableDonnees.Rows.Count / 20, 500) + 1;
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
int nCompteur = 0;
foreach (DataRow row in tableDonnees.Rows)
{
nCompteur++;
if (nCompteur % nFrequence == 0)
{
indicateur.SetValue(nCompteur);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
if (relationToObjetParent == null)
{
newRow[colFille] = nValeursCle[0];
}
else
{
newRow[colFille] = row[strChampParent];
}
}
table.Rows.Add(newRow);
}
indicateur.PopSegment();
return(result);
}
public bool IsUsed(int[] nIdsParametrages)
{
if (nIdsParametrages == null ||
nIdsParametrages.Length == 0)
{
return(false);
}
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
C2iRequeteAvancee requete = new C2iRequeteAvancee(contexte.IdVersionDeTravail);
string strIds = "";
foreach (int nId in nIdsParametrages)
{
strIds += nId.ToString() + ",";
}
strIds = strIds.Substring(0, strIds.Length - 1);
lock (typeof(CLockerIsUsed))
{
if (m_strRequeteParametrageInUse == "")
{
#region Construction de la requête
foreach (CInfoRelation relation in CContexteDonnee.GetListeRelationsTable(CParametrageSystemeCoordonnees.c_nomTable))
{
if (relation.TableFille == CParametrageSystemeCoordonnees.c_nomTable)
{
string strTableObjetAFils = relation.TableParente;
Type tp = CContexteDonnee.GetTypeForTable(strTableObjetAFils);
if (typeof(IObjetASystemeDeCoordonnee).IsAssignableFrom(tp))
{
IObjetASystemeDeCoordonnee objTmp = (IObjetASystemeDeCoordonnee)Activator.CreateInstance(tp, contexte);
string strProprieteToObjetsAFils = objTmp.ProprieteVersObjetsAFilsACoordonneesUtilisantLeParametrage;
if (strProprieteToObjetsAFils != "")
{
PropertyInfo info = objTmp.GetType().GetProperty(strProprieteToObjetsAFils);
if (info == null)
{
throw new Exception(I.T("@1 does not have the property @2|242", tp.ToString(), strProprieteToObjetsAFils));
}
object[] attributs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attributs == null || attributs.Length != 1)
{
throw new Exception(I.T("The property @1 of the @2 type have no 'ChildAttributeRelation'|243", strProprieteToObjetsAFils, objTmp.GetType().ToString()));
}
tp = ((RelationFilleAttribute)attributs[0]).TypeFille;
}
if (typeof(IObjetAFilsACoordonnees).IsAssignableFrom(tp))
{
CStructureTable structure = CStructureTable.GetStructure(tp);
//C'est un fils àcoordonnées
//Cherche toutes les relations de ce fils avec des objets àcoordonnées
foreach (CInfoRelation relationToObjetACoordonnee in structure.RelationsFilles)
{
if (relationToObjetACoordonnee.TableParente == strTableObjetAFils)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relationToObjetACoordonnee.TableFille);
if (typeof(IObjetACoordonnees).IsAssignableFrom(tpFils))
{
string strPrefixe = strProprieteToObjetsAFils;
if (strPrefixe != "")
{
strPrefixe += ".";
}
//On a une relation vers un fils
m_strRequeteParametrageInUse += "has(" + strPrefixe + strTableObjetAFils + "." + relationToObjetACoordonnee.Propriete + "." + relationToObjetACoordonnee.ChampsFille[0] + ") or ";
}
}
}
}
}
}
}
if (m_strRequeteParametrageInUse != "")
{
m_strRequeteParametrageInUse = m_strRequeteParametrageInUse.Substring(0, m_strRequeteParametrageInUse.Length - 4);
}
#endregion
}
}
if (m_strRequeteParametrageInUse == "")
{
return(false);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CParametrageSystemeCoordonnees));
liste.Filtre = new CFiltreDataAvance(
CParametrageSystemeCoordonnees.c_nomTable,
CParametrageSystemeCoordonnees.c_champId + " in (" +
strIds + ") and (" +
m_strRequeteParametrageInUse + ")");
if (liste.CountNoLoad == 0)
{
return(false);
}
}
return(true);
}
public static CResultAErreur GetTableSource(IElementAVariablesDynamiquesAvecContexteDonnee elt, IDefinitionJeuDonnees defDonnees, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (!(defDonnees is CStructureExportAvecFiltre))
{
/*
* if (defDonnees is C2iRequete)
* return defDonnees.GetDonnees(elt, null, indicateur);
* if (defDonnees is CDefinitionJeuDonneesEasyQuery)
* {
* defDonnees.GetDonnees(elt, null, indicateur);
*
* }*/
result = defDonnees.GetDonnees(elt, null, indicateur);
if (result)
{
DataSet ds = result.Data as DataSet;
if (ds != null && ds.Tables.Count > 0)
{
DataTable tableOrg = ds.Tables[0];
DataTable tableRetour = tableOrg.Clone();
tableRetour.BeginLoadData();
foreach (DataRow row in tableOrg.Rows)
{
tableRetour.ImportRow(row);
}
tableRetour.EndLoadData();
result.Data = tableRetour;
}
return(result);
}
}
if (defDonnees is CStructureExportAvecFiltre)
{
C2iStructureExport structure = ((CStructureExportAvecFiltre)defDonnees).Structure;
ITableExport table = structure.Table;
List <C2iChampDeRequete> lstGroupBy = new List <C2iChampDeRequete>();
if (table is C2iTableExport)
{
bool bFirst = true;
if (table is C2iTableExport)
{
//Vérifie que toutes les tables filles sont similaires
foreach (ITableExport tableFilleTmp in table.TablesFilles)
{
if (!(tableFilleTmp is C2iTableExportCumulee))
{
result.EmpileErreur(I.T("Child tables must all be Cumulated tables|186"));
return(result);
}
C2iRequeteAvancee requete = ((C2iTableExportCumulee)tableFilleTmp).Requete;
if (bFirst)
{
foreach (C2iChampDeRequete champ in requete.Champs)
{
if (champ.GroupBy)
{
lstGroupBy.Add(champ);
}
}
}
else
{
List <C2iChampDeRequete> lst = new List <C2iChampDeRequete>();
foreach (C2iChampDeRequete champ in requete.Champs)
{
if (champ.GroupBy)
{
lst.Add(champ);
}
}
bool bErreur = false;
if (lst.Count == lstGroupBy.Count)
{
foreach (C2iChampDeRequete champ in lst)
{
if (!lstGroupBy.Contains(champ))
{
bErreur = true;
break;
}
}
}
else
{
bErreur = true;
}
if (bErreur)
{
result.EmpileErreur(I.T("All child tables must have the same 'group by' clause|286"));
return(result);
}
}
bFirst = false;
}
}
}
result = defDonnees.GetDonnees(elt, null, indicateur);
if (!result)
{
return(result);
}
DataSet ds = (DataSet)result.Data;
if (table is C2iTableExport && table.TablesFilles.Length != 0)
{
//Met à plat la table
ds.EnforceConstraints = false;
DataTable tableParent = ds.Tables[structure.Table.NomTable];
DataTable tableFille = ds.Tables[structure.Table.TablesFilles[0].NomTable];
DataRelation relation = null;
//Cherche la relation entre la table Fille et la table parente
if (tableFille != null && tableParent != null)
{
foreach (DataRelation rel in tableParent.ChildRelations)
{
if (rel.ChildTable.TableName == tableFille.TableName)
{
relation = rel;
break;
}
}
}
if (tableParent == null || tableFille == null || relation == null)
{
result.EmpileErreur(I.T("Inexpected error on exported data|187"));
return(result);
}
//Ajoute les colonnes de la table parente
List <string> strCols = new List <String>();
foreach (DataColumn col in tableParent.Columns)
{
string strNewCol = tableParent.TableName + "_" + col.ColumnName;
DataColumn newCol = tableFille.Columns.Add(strNewCol, col.DataType);
newCol.AllowDBNull = col.AllowDBNull;
strCols.Add(strNewCol);
}
//Rempli les données dans la table filles
foreach (DataRow row in tableParent.Rows)
{
object[] datas = row.ItemArray;
foreach (DataRow rowFille in row.GetChildRows(relation))
{
for (int i = 0; i < datas.Length; i++)
{
rowFille[strCols[i]] = datas[i];
}
}
}
if (table.TablesFilles.Length > 1)
{
//Plus d'1 table, ajoute les colonnes des autres tables
//Repère les lignes par group by
Hashtable tableGrpByToRow = new Hashtable();
List <string> lstNomsGroupBy = new List <string>();
foreach (DataColumn col in relation.ChildColumns)
{
lstNomsGroupBy.Add(col.ColumnName);
}
foreach (C2iChampDeRequete champ in lstGroupBy)
{
lstNomsGroupBy.Add(champ.NomChamp);
}
foreach (DataRow row in tableFille.Rows)
{
tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)] = row;
}
//Ajoute les données des tables filles
for (int nTableFille = 1; nTableFille < table.TablesFilles.Length; nTableFille++)
{
//Crée la liste des champs groupBy
DataTable tableTmp = ds.Tables[structure.Table.TablesFilles[nTableFille].NomTable];
lstNomsGroupBy.Clear();
foreach (DataColumn col in tableTmp.ParentRelations[0].ChildColumns)
{
lstNomsGroupBy.Add(col.ColumnName);
}
foreach (C2iChampDeRequete champ in lstGroupBy)
{
lstNomsGroupBy.Add(champ.NomChamp);
}
//AJoute les colonnes
foreach (DataColumn col in tableTmp.Columns)
{
if (!col.AutoIncrement && !tableFille.Columns.Contains(col.ColumnName))
{
tableFille.Columns.Add(col.ColumnName, col.DataType);
}
}
foreach (DataRow row in tableTmp.Rows)
{
DataRow rowDest = (DataRow)tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)];
if (rowDest == null)
{
rowDest = tableFille.NewRow();
//copie les valeurs parentes sur la nouvelle row
DataRow rowParente = row.GetParentRow(tableTmp.ParentRelations[0]);
foreach (DataColumn col in rowParente.Table.Columns)
{
string strCol = tableParent.TableName + "_" + col.ColumnName;
if (tableFille.Columns[strCol] != null)
{
rowDest[strCol] = rowParente[col.ColumnName];
}
}
tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)] = rowDest;
}
foreach (DataColumn col in tableTmp.Columns)
{
if (tableFille.Columns.Contains(col.ColumnName))
{
rowDest[col.ColumnName] = row[col];
}
}
if (rowDest.RowState == DataRowState.Detached)
{
tableFille.Rows.Add(rowDest);
}
}
}
}
result.Data = tableFille;
}
else
{
result.Data = ds.Tables[table.NomTable];
}
return(result);
}
return(result);
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
foreach (CInfoRelation relation in structure.RelationsFilles)
{
Type tpFille = CContexteDonnee.GetTypeForTable(relation.TableFille);
if (manager.ConfigurationRecherche.IsIgnore(tpFille))
{
return(lst);
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = CFiltreData.CreateFiltreAndSurValeurs(relation.ChampsFille, objet.GetValeursCles());
requete.TableInterrogee = relation.TableFille;
bool bHasUniversalId = tpFille.GetCustomAttribute <NoIdUniverselAttribute>(true) == null;
if (bHasUniversalId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel,
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
}
else
{
CStructureTable sFille = CStructureTable.GetStructure(tpFille);
foreach (CInfoChampTable infoChamp in sFille.ChampsId)
{
requete.ListeChamps.Add(new C2iChampDeRequete(infoChamp.NomChamp,
new CSourceDeChampDeRequete(infoChamp.NomChamp),
infoChamp.TypeDonnee,
OperationsAgregation.None,
true));
}
}
string strNomProp = relation.NomConvivial;
if (strNomProp.Length == 0)
{
strNomProp = "List of " + DynamicClassAttribute.GetNomConvivial(tpFille);
}
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataRow row in table.Rows)
{
if (bHasUniversalId)
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille, CDbKey.GetNewDbKeyOnUniversalIdANePasUtiliserEnDehorsDeCDbKeyAddOn((string)row[0])));
}
else
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpFille,
row.ItemArray));
}
}
}
}
return(lst);
}
//---------------------------------------------------------------
private void CalculeSetIdsInterventionsVisibles()
{
if (m_filtreDynamicApplique == null && m_listeEntitesSelectionnee == null)
{
m_setIdsInterventionsVisiblesCalculéDefiltreEtListe = null;
return;
}
HashSet <int> setIdsFromfiltre = null;
HashSet <int> setIdsFromListe = null;
if (m_filtreDynamicApplique != null && m_chkIntersFiltre.Checked)
{
CFiltreData filtre = null;
CResultAErreur res = m_filtreDynamicApplique.GetFiltreData();
if (res && res.Data is CFiltreData)
{
filtre = res.Data as CFiltreData;
}
if (filtre != null)
{
setIdsFromfiltre = new HashSet <int>();
C2iRequeteAvancee requete = new C2iRequeteAvancee(m_contexteDonnee.IdVersionDeTravail);
requete.FiltreAAppliquer = filtre;
requete.TableInterrogee = CIntervention.c_nomTable;
requete.ListeChamps.Add(new C2iChampDeRequete(
"INTER_ID",
new CSourceDeChampDeRequete(CIntervention.c_champId),
typeof(int),
OperationsAgregation.None,
false));
res = requete.ExecuteRequete(m_contexteDonnee.IdSession);
if (res && res.Data is DataTable)
{
foreach (DataRow row in ((DataTable)res.Data).Rows)
{
setIdsFromfiltre.Add((int)row["INTER_ID"]);
}
}
}
}
if (m_listeEntitesSelectionnee != null && m_chkIntersSurListe.Checked)
{
setIdsFromListe = new HashSet <int>();
foreach (CIntervention inter in m_listeEntitesSelectionnee.ElementsLies)
{
setIdsFromListe.Add(inter.Id);
}
}
if (setIdsFromListe != null || setIdsFromfiltre != null)
{
if (setIdsFromListe == null)
{
m_setIdsInterventionsVisiblesCalculéDefiltreEtListe = setIdsFromfiltre;
}
else if (setIdsFromfiltre == null)
{
m_setIdsInterventionsVisiblesCalculéDefiltreEtListe = setIdsFromListe;
}
else
{
m_setIdsInterventionsVisiblesCalculéDefiltreEtListe = new HashSet <int>();
foreach (int nId in setIdsFromListe)
{
if (setIdsFromfiltre.Contains(nId))
{
m_setIdsInterventionsVisiblesCalculéDefiltreEtListe.Add(nId);
}
}
}
}
}
/// ////////////////////////////////
public CResultAErreur ExecuteRequete(C2iRequeteAvancee requete)
{
CResultAErreur result = CResultAErreur.True;
string strTable = requete.TableInterrogee;
//S'il y a un filtre sur la requête avancée,
//On prépare d'abord la sous requête de sélection des ids qui nous
//Interessent
Type typeReference = CContexteDonnee.GetTypeForTable(strTable);
if (typeReference == null)
{
result.EmpileErreur(I.T("Impossible to define the associated type with @1|121", strTable));
return(result);
}
IDatabaseConnexion con;
if (typeReference == null)
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
}
else
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeReference);
}
CFiltreData filtre = requete.FiltreAAppliquer;
CArbreTable arbre = null;
bool bHasVersionSurTablePrincipale = false;
Type tpObjet = CContexteDonnee.GetTypeForTable(requete.TableInterrogee);
if (tpObjet != null && !typeof(IObjetSansVersion).IsAssignableFrom(tpObjet) &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjet))
{
bHasVersionSurTablePrincipale = true;
}
if (bHasVersionSurTablePrincipale)
{
CFiltreDataAvance filtreVersion = new CFiltreDataAvance(strTable, "");
//Lecture dans le référentiel
if (requete.IdVersionDeTravail == null && (filtre == null || !filtre.IgnorerVersionDeContexte))
{
filtreVersion.Filtre = "HasNo(" + CSc2iDataConst.c_champIdVersion + ")";
}
//Ignorer les suppressions
if (filtre != null && !filtre.IntegrerLesElementsSupprimes)
{
if (filtreVersion.Filtre != "")
{
filtreVersion.Filtre += " and ";
}
filtreVersion.Filtre += CSc2iDataConst.c_champIsDeleted + "=0";
}
//Lecture dans une version
if (requete.IdVersionDeTravail != null && (filtre == null || !filtre.IgnorerVersionDeContexte) && requete.IdVersionDeTravail >= 0)
{
if (filtre == null)
{
filtre = new CFiltreData();
}
filtre.IdsDeVersionsALire = CVersionDonnees.GetVersionsToRead(IdSession, (int)requete.IdVersionDeTravail);
}
if (filtreVersion.Filtre != "")
{
filtre = CFiltreData.GetAndFiltre(filtre, filtreVersion);
}
}
if (filtre != null && filtre is CFiltreDataAvance)
{
result = ((CFiltreDataAvance)filtre).GetArbreTables();
if (!result)
{
return(result);
}
arbre = (CArbreTable)result.Data;
}
result = requete.CalculeArbre(arbre);
if (!result)
{
return(result);
}
arbre = (CArbreTable)result.Data;
int nOldTimeOut = con.CommandTimeOut;
con.CommandTimeOut = 60 * 2;
result = con.ExecuteRequeteComplexe(requete.Champs, arbre, filtre);
con.CommandTimeOut = nOldTimeOut;
return(result);
}
// 3 - Creation Filtre + Execution Requete et Ajout aux possibles
private static int GetChildren(EObjetACoordonnee tPeres, EObjetACoordonnee tFils, string coor)
{
List <string> idsPeres = GetListIDsPere(tPeres);
if (idsPeres.Count == 0 && !FirstSearch)
{
return(0);
}
CFiltreDataAvance filtre = null;
if (!FirstSearch)
{
filtre = GetFiltreForFindChildren(tPeres, tFils, coor);
}
else
{
filtre = GetFiltreForFindHead(tPeres, coor);
}
List <CObjetACoordonneesPossible> lstObjsPoss = GetListObjsPoss(tFils);
string nomTable = "";
string colID = "";
string colCoor = "";
switch (tFils)
{
case EObjetACoordonnee.EntiteOrganisationnelle:
nomTable = CEntiteOrganisationnelle.c_nomTable;
colID = CEntiteOrganisationnelle.c_champId;
colCoor = CEntiteOrganisationnelle.c_champCoordonnee;
break;
case EObjetACoordonnee.Site:
nomTable = CSite.c_nomTable;
colID = CSite.c_champId;
colCoor = CSite.c_champCoordonnee;
break;
case EObjetACoordonnee.Stock:
nomTable = CStock.c_nomTable;
colID = CStock.c_champId;
colCoor = CStock.c_champCoordonnee;
break;
case EObjetACoordonnee.Equipement:
nomTable = CEquipement.c_nomTable;
colID = CEquipement.c_champId;
colCoor = CEquipement.c_champCoordonnee;
break;
default:
break;
}
if (nomTable == "" || colID == "")
{
return(0);
}
CResultAErreur result = CResultAErreur.True;
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = nomTable;
C2iChampDeRequete champID = new C2iChampDeRequete(
"Id",
new CSourceDeChampDeRequete(colID),
typeof(int),
OperationsAgregation.None,
false);
C2iChampDeRequete champCoor = new C2iChampDeRequete(
"Coor",
new CSourceDeChampDeRequete(colCoor),
typeof(string),
OperationsAgregation.None,
false);
requete.ListeChamps.Add(champID);
requete.ListeChamps.Add(champCoor);
requete.FiltreAAppliquer = filtre;
result = requete.ExecuteRequete(m_ctx.IdSession);
if (result)
{
DataTable table = (DataTable)result.Data;
foreach (DataRow row in table.Rows)
{
lstObjsPoss.Add(new CObjetACoordonneesPossible(((int)row["Id"]).ToString().Trim(), (string)row["Coor"]));
}
return(table.Rows.Count);
}
else
{
return(0);
}
}
//--------------------------------------------------------
public CFiltreData GetFiltreData(int nIdSession, CFiltresSynchronisation filtresSynchro)
{
if (m_filtreDejaCalcule != null)
{
return(m_filtreDejaCalcule);
}
Type tp = CContexteDonnee.GetTypeForTable(m_strNomTableFille);
if (tp == null)
{
return(null);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure == null)
{
return(null);
}
CFiltreData filtre = null;
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (relationParente.Composition &&
(relationParente.TableParente == m_strNomTableParenteDeComposition ||
m_strNomTableParenteDeComposition.Length == 0))
{
Type tpParent = CContexteDonnee.GetTypeForTable(relationParente.TableParente);
CStructureTable structParente = CStructureTable.GetStructure(tpParent);
if (structParente != null && structParente.NomTable != m_strNomTableFille)
{
HashSet <int> lstIdsALire = new HashSet <int>();
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = relationParente.TableParente;
requete.FiltreAAppliquer = filtresSynchro.GetFiltreForTable(nIdSession, relationParente.TableParente);
requete.ListeChamps.Add(
new C2iChampDeRequete(structParente.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structParente.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.None,
true));
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
}
}
}
}
if (lstIdsALire.Count > 0)
{
StringBuilder bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId.ToString());
bl.Append(',');
}
bl.Remove(bl.Length - 1, 1);
filtre = CFiltreData.GetOrFiltre(filtre,
new CFiltreData(relationParente.ChampsFille[0] + " in (" + bl.ToString() + ")"));
}
}
}
}
if (filtre == null)
{
filtre = new CFiltreDataImpossible();
}
m_filtreDejaCalcule = filtre;
return(m_filtreDejaCalcule);
}
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
IDataBaseCreator createur = connection.GetDataBaseCreator();
string strNomTableInContexte = CContexteDonnee.GetNomTableForType(m_type);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTableInContexte);
createur.CreationOuUpdateTableFromType(m_type);
string strChampIdObjet = m_strChampIdObjet;
if (m_strChampIdObjet.StartsWith("#SQL#"))
{
strChampIdObjet = m_strChampIdObjet.Substring("#SQL#".Length);
}
CObjetServeur.ClearCacheSchemas();
if (createur.ChampExists(strNomTableInDb, strChampIdObjet) &&
createur.ChampExists(strNomTableInDb, m_strChampDbKey))
{
using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strNomTableInDb;
CStructureTable structure = CStructureTable.GetStructure(m_type);
/*
* requete.ListeChamps.Add ( new C2iChampDeRequete (
* "ID",
* new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
* typeof(int),
* OperationsAgregation.None,
* true ));*/
requete.ListeChamps.Add(new C2iChampDeRequete(
"IDOBJET",
new CSourceDeChampDeRequete(m_strChampIdObjet),
typeof(int),
OperationsAgregation.None,
true));
if (m_typeObjetFixe == null)
{
requete.ListeChamps.Add(new C2iChampDeRequete(
"TYPEOBJET",
new CSourceDeChampDeRequete(m_strChampTypeObjet),
typeof(string),
OperationsAgregation.None,
true));
}
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
DataTable table = result.Data as DataTable;
Dictionary <int, int?> dicIdToIdObjet = new Dictionary <int, int?>();
string strFieldIdObjetInTable = m_strChampIdObjet.Replace("#SQL#", "");
foreach (DataRow row in table.Rows)
{
object val = row["IDOBJET"];
int? nValId = val == DBNull.Value?null:(int?)val;
if (nValId != null && nValId >= 0)
{
CDbKey key = null;
Type tp = m_typeObjetFixe;
if (tp == null)//Type non fixe
{
string strType = (string)row["TYPEOBJET"];
tp = CActivatorSurChaine.GetType(strType);
}
if (tp != null)
{
CObjetDonneeAIdNumerique objPointe = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, ctx);
if (objPointe.ReadIfExists(nValId.Value))
{
key = objPointe.DbKey;
}
}
if (key != null)
{
string strRequete = "Update " + strNomTableInDb + " set " +
m_strChampDbKey + "=" + connection.GetStringForRequete(key.StringValue) + " where " +
strFieldIdObjetInTable + "=" + nValId.Value;
if (m_typeObjetFixe == null)
{
strRequete += " and " + m_strChampTypeObjet + "='" +
row["TYPEOBJET"].ToString() + "'";
}
connection.RunStatement(strRequete);
}
}
}
}
//Supprime le champ
createur.DeleteChamp(strNomTableInDb, strChampIdObjet);
}
return(result);
}
//------------------------------------------------------------------------------------
public CFiltreData GetFiltreFinal(int nIdSession, string strNomTable, CFiltreData filtreNonAutoRef)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp == null)
{
return(null);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure == null)
{
return(null);
}
//Va lire les ids non autoref dans la base
HashSet <int> lstIdsALire = new HashSet <int>();
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strNomTable;
requete.FiltreAAppliquer = filtreNonAutoRef;
requete.ListeChamps.Add(
new C2iChampDeRequete(structure.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.None,
true));
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
}
}
}
}
CFiltreData filtre = new CFiltreDataImpossible();
if (lstIdsALire.Count > 0)
{
StringBuilder bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId.ToString());
bl.Append(',');
}
do
{
bl.Remove(bl.Length - 1, 1);
filtre = new CFiltreData(m_strNomChampParentId + " in (" + bl.ToString() + ")");
//Va lire les ids des fils, jusqu'à ce qu'on ne trouve plus de fils
HashSet <int> lstNewIds = new HashSet <int>();
requete.FiltreAAppliquer = filtre;
result = requete.ExecuteRequete(nIdSession);
if (!result)
{
return(new CFiltreDataImpossible());
}
DataTable table = result.Data as DataTable;
bl = new StringBuilder();
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int?nVal = row[0] as int?;
if (nVal != null)
{
lstIdsALire.Add(nVal.Value);
bl.Append(nVal.Value);
bl.Append(',');
}
}
}
}while (bl.Length > 0);
bl = new StringBuilder();
foreach (int nId in lstIdsALire)
{
bl.Append(nId);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
filtre = new CFiltreData(structure.ChampsId[0].NomChamp + " in (" +
bl.ToString() + ")");
}
}
return(filtre);
}
//--------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CColumnDeEasyQueryChampDeRequete> resCol = GetColonneIdSource();
m_dicRowsParentes = null;
if (!resCol)
{
result.EmpileErreur(resCol.Erreur);
return(result);
}
IODEQTableFromFramework tableSource = this.ElementsSource[0] as IODEQTableFromFramework;
if (tableSource != null)
{
result = tableSource.GetDatas(sources);
if (!result)
{
return(result);
}
DataTable tableParente = result.Data as DataTable;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(TypeElements);
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnDeEasyQueryChampDeRequete colR = col as CColumnDeEasyQueryChampDeRequete;
requete.ListeChamps.Add(colR);
}
if (requete.ListeChamps.Count == 0)
{
result.Data = new DataTable();
return(result);
}
bool bRelTrouve = false;
CComposantFiltreOperateur cpOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurIn);
CComposantFiltre cpFinal = cpOperateur;
result = FiltreDynamique.GetFiltreData();
if (!result)
{
return(result);
}
CFiltreDataAvance filtre = result.Data as CFiltreDataAvance;
if (filtre == null)
{
filtre = new CFiltreDataAvance(requete.TableInterrogee, "");
}
CDefinitionProprieteDynamiqueRelation rel = m_definitionSource as CDefinitionProprieteDynamiqueRelation;
string strNomChampParent = null;
//// Relation standard
if (rel != null)
{
//m_definitionSource.GetDefinitionInverse(TypeElements);
if (rel.Relation.TableParente == requete.TableInterrogee)
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(rel.Relation.ChampsParent[0], requete.TableInterrogee));
strNomChampParent = rel.Relation.ChampsParent[0];
}
else
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(rel.Relation.ChampsFille[0], requete.TableInterrogee));
strNomChampParent = rel.Relation.ChampsFille[0];
}
bRelTrouve = true;
}
else
{
///Relation Type id
CDefinitionProprieteDynamiqueRelationTypeId relTypeId = m_definitionSource as CDefinitionProprieteDynamiqueRelationTypeId;
if (relTypeId != null)
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(relTypeId.Relation.ChampId, requete.TableInterrogee));
strNomChampParent = relTypeId.Relation.ChampId;
cpFinal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
cpFinal.Parametres.Add(cpOperateur);
CComposantFiltre cpType = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
cpType.Parametres.Add(new CComposantFiltreChamp(relTypeId.Relation.ChampType, requete.TableInterrogee));
cpType.Parametres.Add(new CComposantFiltreVariable("@" + (filtre.Parametres.Count + 1).ToString("0")));
filtre.Parametres.Add(tableSource.TypeElements.ToString());
cpFinal.Parametres.Add(cpType);
bRelTrouve = true;
}
}
if (strNomChampParent != null)
{
requete.ListeChamps.Add(new C2iChampDeRequete(c_nomChampParentId, new CSourceDeChampDeRequete(strNomChampParent), typeof(int), OperationsAgregation.None, false));
}
if (!bRelTrouve)
{
result.EmpileErreur(I.T("Can not find link for table @1|20076", NomFinal));
return(result);
}
int nParametre = filtre.Parametres.Count;
cpOperateur.Parametres.Add(new CComposantFiltreVariable("@" + (filtre.Parametres.Count + 1).ToString("0")));
filtre.Parametres.Add(new int[0]);
if (filtre.ComposantPrincipal == null)
{
filtre.ComposantPrincipal = cpFinal;
}
else
{
CComposantFiltreOperateur opEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opEt.Parametres.Add(cpFinal);
opEt.Parametres.Add(filtre.ComposantPrincipal);
filtre.ComposantPrincipal = opEt;
}
m_dicRowsParentes = new Dictionary <object, DataRow>();
DataTable maTable = null;
int nLectureParLot = 500;
for (int nRow = 0; nRow < tableParente.Rows.Count; nRow += nLectureParLot)
{
int nMax = Math.Min(nRow + nLectureParLot, tableParente.Rows.Count);
List <int> lstIds = new List <int>();
for (int n = nRow; n < nMax; n++)
{
DataRow row = tableParente.Rows[n];
int nVal = (int)row[resCol.DataType.ColumnName];
lstIds.Add(nVal);
m_dicRowsParentes[nVal] = row;
}
filtre.Parametres[nParametre] = lstIds.ToArray();
DataTable tableTmp = null;
requete.FiltreAAppliquer = filtre;
result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error on table @1|20070", NomFinal));
return(result);
}
tableTmp = result.Data as DataTable;
if (maTable == null)
{
maTable = tableTmp;
}
else
{
maTable.Merge(tableTmp);
}
}
if (maTable == null)
{
maTable = new DataTable(NomFinal);
foreach (IColumnDeEasyQuery colEQ in ColonnesOrCalculees)
{
DataColumn col = new DataColumn(colEQ.ColumnName, colEQ.DataType);
try
{
maTable.Columns.Add(col);
}
catch { }
}
DataColumn colParent = new DataColumn(c_nomChampParentId, typeof(int));
try
{
maTable.Columns.Add(colParent);
}
catch { }
}
else
{
//Ajoute les colonnes from parent
Dictionary <CColumnEQFromSource, string> dicColFromSourceToNom = new Dictionary <CColumnEQFromSource, string>();
foreach (CColumnEQFromSource colFromSource in m_listeColonnesFromParent)
{
if (!maTable.Columns.Contains(colFromSource.ColumnName))
{
maTable.Columns.Add(colFromSource.ColumnName, colFromSource.DataType);
}
IColumnDeEasyQuery colSource = tableSource.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
if (colSource != null && tableParente.Columns.Contains(colSource.ColumnName))
{
dicColFromSourceToNom[colFromSource] = colSource.ColumnName;
}
}
if (maTable.Columns.Contains(c_nomChampParentId))
{
foreach (DataRow row in maTable.Rows)
{
if (row[c_nomChampParentId] is int)
{
DataRow rowParente = null;
if (m_dicRowsParentes.TryGetValue((int)row[c_nomChampParentId], out rowParente))
{
if (rowParente != null)
{
foreach (KeyValuePair <CColumnEQFromSource, string> kv in dicColFromSourceToNom)
{
row[kv.Key.ColumnName] = rowParente[kv.Value];
}
}
}
}
}
maTable.Columns.Remove(c_nomChampParentId);
}
}
result.Data = maTable;
}
return(result);
}
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (!typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(m_type) || !CObjetDonnee.TypeManageIdUniversel(m_type))
{
result.EmpileErreur(m_type.ToString() + " can not have Universal Id");
}
string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
CStructureTable structure = CStructureTable.GetStructure(m_type);
string strChampId = structure.ChampsId[0].NomChamp;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(m_type);
requete.ListeChamps.Add(new C2iChampDeRequete(strChampId, new CSourceDeChampDeRequete(strChampId),
typeof(int),
OperationsAgregation.None, true));
Console.WriteLine("Update Universal id on " + strNomTable);
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable);
DataTable table = result.Data as DataTable;
int nNb = 0;
bool bWasInTrans = connection.IsInTrans();
if (bWasInTrans)
{
connection.CommitTrans();
}
DateTime dt = DateTime.Now;
if (table.Rows.Count > 0)
{
if (table.Rows.Count > 10000 && connection is COracleDatabaseConnexion)
{
string strQuery = "Update " + strNomTableInDb + " set " + CObjetDonnee.c_champIdUniversel +
"=CONCAT('" + strNomTableInDb + "'," + strChampId + ")";
result = connection.RunStatement(strQuery);
}
else
{
foreach (DataRow row in table.Rows)
{
string strQuery = "Update " + strNomTableInDb + " set " +
CObjetDonnee.c_champIdUniversel + "='" + CUniqueIdentifier.GetNew() + "' where " +
strChampId + "=" + row[0].ToString();
result = connection.ExecuteScalar(strQuery);
if (!result)
{
break;
}
nNb++;
if (nNb % 100 == 0)
{
TimeSpan sp = DateTime.Now - dt;
double fVal = (double)sp.TotalSeconds / (double)nNb * (double)(table.Rows.Count - nNb);
Console.WriteLine(strNomTableInDb + " " + nNb + "/" + table.Rows.Count + " reste " + fVal.ToString("0s"));
}
}
}
}
if (bWasInTrans)
{
connection.BeginTrans();
}
return(result);
/*
*
* //Trouve tous les éléments du type qui n'ont pas d'id universel
* using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
* {
* CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, m_type, false);
* lst.Filtre = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
* lst.Filtre.IgnorerVersionDeContexte = true;
* lst.AppliquerFiltreAffichage = false;
*
* foreach (IObjetDonnee objet in lst.ToArrayList())
* {
* objet.Row[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
* }
* string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
* CObjetServeur objetServeur = CContexteDonnee.GetTableLoader(strNomTable, null, connection.IdSession) as CObjetServeur;
* int nCount = ctx.Tables[strNomTable].Rows.Count;
* DataTable tableSource = ctx.Tables[strNomTable];
*
* List<string> lstChampsExclus = new List<string>();
* HashSet<string> lstIDs = new HashSet<string>();
* CStructureTable structure = CStructureTable.GetStructure(m_type);
* foreach (CInfoChampTable info in structure.ChampsId)
* lstIDs.Add(info.NomChamp);
*
* foreach (CInfoChampTable champ in structure.Champs)
* if (champ.NomChamp != CObjetDonnee.c_champIdUniversel && !lstIDs.Contains(champ.NomChamp))
* lstChampsExclus.Add(champ.NomChamp);
*
* IDataAdapter adapter = objetServeur.GetDataAdapter(DataRowState.Modified, lstChampsExclus.ToArray());
*
* for (int nRow = 0; nRow < nCount; nRow += 5000)
* {
*
* using (DataSet dsCopie = new DataSet())
* {
* dsCopie.EnforceConstraints = false;
* DataTable tableCopie = ctx.Tables[strNomTable].Clone();
* tableCopie.BeginLoadData();
* dsCopie.Tables.Add(tableCopie);
* int nMax = Math.Min(nRow + 5000, nCount);
* DateTime dt = DateTime.Now;
* for (int n = nRow; n < nMax; n++)
* {
* tableCopie.ImportRow(tableSource.Rows[n]);
* }
* TimeSpan sp = DateTime.Now - dt;
* Console.WriteLine("Write 1" + strNomTable + " " + nRow + "/" + nCount+" "+sp.TotalSeconds.ToString());
* adapter.Update(dsCopie);
* sp = DateTime.Now - dt;
* Console.WriteLine("Write 2" + strNomTable + " " + nRow + "/" + nCount + " " + sp.TotalSeconds.ToString());
* }
* }
* }
* return result;*/
}
//---------------------------------------------
/// <summary>
/// Retourne un dictionnaire contenant tous les champs modifiés pour
/// des versions données et des objets donnés
/// </summary>
/// <returns></returns>
public Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > > GetDictionnaireChampsModifies(
int nIdSession,
string strIdsVersionsConcernees,
Type typeElements,
DataRow[] rowsConcernees)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeElements))
{
return(null);
}
if (rowsConcernees.Length == 0)
{
return(new Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > >());
}
//Récupère le type des éléments à champs
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(typeElements, new object[] { rowsConcernees[0] });
Type typeElementsAChamps = rel.GetTypeElementAChamps();
//Récupère la clé des éléments à champ
string strPrimKey = rel.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(typeElementsAChamps)).PrimaryKey[0].ColumnName;
//Crée la liste des ids pour lesquelles on cherche les valeurs
Hashtable tableIds = new Hashtable();
foreach (DataRow row in rowsConcernees)
{
rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(typeElements, new object[] { rowsConcernees[0] });
CObjetDonnee element = (CObjetDonnee)rel.ElementAChamps;
if (element.Row[CSc2iDataConst.c_champOriginalId] != DBNull.Value)
{
tableIds[element.Row[CSc2iDataConst.c_champOriginalId]] = true;
}
else
{
tableIds[row[strPrimKey]] = true;
}
}
StringBuilder blIds = new StringBuilder();
foreach (int nId in tableIds.Keys)
{
blIds.Append(nId.ToString());
blIds.Append(",");
}
blIds.Remove(blIds.Length - 1, 1);
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = CVersionDonneesObjetOperation.c_nomTable;
requete.ListeChamps.Add(new C2iChampDeRequete("Id",
new CSourceDeChampDeRequete(CVersionDonneesObjet.c_nomTable + "." + CVersionDonneesObjet.c_champIdElement),
typeof(int),
OperationsAgregation.None,
true));
requete.ListeChamps.Add(new C2iChampDeRequete("Field",
new CSourceDeChampDeRequete(CVersionDonneesObjetOperation.c_champChamp),
typeof(string),
OperationsAgregation.None,
true));
requete.ListeChamps.Add(new C2iChampDeRequete("FieldType",
new CSourceDeChampDeRequete(CVersionDonneesObjetOperation.c_champTypeChamp),
typeof(string),
OperationsAgregation.None,
true));
requete.ListeChamps.Add(new C2iChampDeRequete("IdVersion",
new CSourceDeChampDeRequete(CVersionDonneesObjet.c_nomTable + "." + CVersionDonnees.c_champId),
typeof(int),
OperationsAgregation.None,
true));
CFiltreData filtre = new CFiltreDataAvance(CVersionDonneesObjetOperation.c_nomTable,
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonnees.c_champId + " in (" + strIdsVersionsConcernees + ") and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champIdElement + " in (" + blIds + ") and " +
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champTypeElement + "=@1 and " +
CVersionDonneesObjetOperation.c_champTypeChamp + "=@2",
typeElementsAChamps.ToString(),
CChampCustomPourVersion.c_typeChamp);
filtre.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer = filtre;
Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > > dicoChampsModifies = new Dictionary <int, Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > >();
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (!result)
{
return(null);
}
foreach (DataRow rowModif in ((DataTable)result.Data).Rows)
{
int nIdVersion = (int)rowModif["IdVersion"];
Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > dicoChampsDeVersion = null;
if (!dicoChampsModifies.TryGetValue(nIdVersion, out dicoChampsDeVersion))
{
dicoChampsDeVersion = new Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> >();
dicoChampsModifies[nIdVersion] = dicoChampsDeVersion;
}
Dictionary <CReferenceChampPourVersion, bool> dicoChampsDeId = new Dictionary <CReferenceChampPourVersion, bool>();
if (!dicoChampsDeVersion.TryGetValue((int)rowModif["Id"], out dicoChampsDeId))
{
dicoChampsDeId = new Dictionary <CReferenceChampPourVersion, bool>();
dicoChampsDeVersion[(int)rowModif["Id"]] = dicoChampsDeId;
}
dicoChampsDeId[
new CReferenceChampPourVersion((string)rowModif["FieldType"], (string)rowModif["Field"])] = true;
}
return(dicoChampsModifies);
}
/// ////////////////////////////////////////////////////////
private CResultAErreur CleanType(
CContexteExecutionAction contexteExecution,
Type tpToClean,
RelationTypeIdAttribute rel)
{
if (tpToClean == typeof(CVersionDonneesObjet))
{
return(CResultAErreur.True);
}
if (contexteExecution.IndicateurProgression != null)
{
contexteExecution.IndicateurProgression.SetInfo("Cleaning " +
DynamicClassAttribute.GetNomConvivial(tpToClean));
}
CResultAErreur result = CResultAErreur.True;
//Identifie tous les types liés
C2iRequeteAvancee requete = new C2iRequeteAvancee(null);
requete.TableInterrogee = rel.TableFille;
requete.ListeChamps.Add(new C2iChampDeRequete(
"TYPE_ELEMENT",
new CSourceDeChampDeRequete(rel.ChampType),
typeof(string),
OperationsAgregation.None,
true));
result = requete.ExecuteRequete(contexteExecution.IdSession);
if (!result)
{
return(result);
}
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpToClean))
{
return(result);
}
DataTable table = result.Data as DataTable;
if (table == null || table.Rows.Count == 0)
{
return(result);
}
CStructureTable structRel = CStructureTable.GetStructure(tpToClean);
foreach (DataRow row in table.Rows)
{
if (row[0] is string)
{
Type tpLie = CActivatorSurChaine.GetType((string)row[0]);
string strNomTable = tpLie != null?CContexteDonnee.GetNomTableForType(tpLie) : null;
if (strNomTable != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpLie))
{
System.Console.WriteLine(tpToClean.ToString() + " / " + tpLie.ToString());
//trouve tous les ids associés
requete = new C2iRequeteAvancee(null);
requete.TableInterrogee = rel.TableFille;
requete.ListeChamps.Add(new C2iChampDeRequete(
"ETT_ID",
new CSourceDeChampDeRequete(rel.ChampId),
typeof(int),
OperationsAgregation.None,
true));
requete.FiltreAAppliquer = new CFiltreData(rel.ChampType + "=@1",
tpLie.ToString());
result = requete.ExecuteRequete(contexteExecution.IdSession);
if (!result)
{
return(result);
}
DataTable tableIds = result.Data as DataTable;
List <int> lstIdsCherchees = new List <int>();
if (tableIds != null)
{
StringBuilder bl = new StringBuilder();
foreach (DataRow rowId in tableIds.Rows)
{
if (rowId[0] is int)
{
lstIdsCherchees.Add((int)rowId[0]);
bl.Append((int)rowId[0]);
bl.Append(',');
}
}
if (bl.Length > 0)
{
CStructureTable structure = CStructureTable.GetStructure(tpLie);
bl.Remove(bl.Length - 1, 1);
requete = new C2iRequeteAvancee(null);
requete.TableInterrogee = strNomTable;
requete.ListeChamps.Add(new C2iChampDeRequete(
"ETT_ID",
new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.None,
false));
requete.FiltreAAppliquer = new CFiltreData(
structure.ChampsId[0].NomChamp + " in (" +
bl.ToString() + ")");
result = requete.ExecuteRequete(contexteExecution.IdSession);
if (!result)
{
return(result);
}
DataTable tableIdsTrouvees = result.Data as DataTable;
HashSet <int> setTrouves = new HashSet <int>();
if (tableIdsTrouvees != null)
{
foreach (DataRow rowId in tableIdsTrouvees.Rows)
{
if (rowId[0] is int)
{
setTrouves.Add((int)rowId[0]);
}
}
bl = new StringBuilder();
foreach (int nId in lstIdsCherchees.ToArray())
{
if (!setTrouves.Contains(nId))
{
bl.Append(nId);
bl.Append(',');
}
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
//Trouve la liste des relTypesIds à virer
requete = new C2iRequeteAvancee(null);
requete.TableInterrogee = rel.TableFille;
requete.ListeChamps.Add(new C2iChampDeRequete(
structRel.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structRel.ChampsId[0].NomChamp),
typeof(int),
OperationsAgregation.None,
true));
requete.FiltreAAppliquer = new CFiltreData(
rel.ChampId + " in (" + bl.ToString() + ") and " +
rel.ChampType + "=@1", tpLie.ToString());
result = requete.ExecuteRequete(contexteExecution.IdSession);
if (!result)
{
return(result);
}
DataTable tableIdsToDelete = result.Data as DataTable;
if (tableIdsToDelete != null)
{
List <int> lstToDelete = new List <int>();
foreach (DataRow rowDel in tableIdsToDelete.Rows)
{
if (rowDel[0] is int)
{
lstToDelete.Add((int)rowDel[0]);
}
}
if (contexteExecution.IndicateurProgression != null)
{
contexteExecution.IndicateurProgression.PushLibelle(
DynamicClassAttribute.GetNomConvivial(tpToClean) + "/" +
DynamicClassAttribute.GetNomConvivial((tpLie)));
}
for (int nPart = 0; nPart < lstToDelete.Count; nPart += 100)
{
List <int> lstTmp = new List <int>();
int nMin = Math.Min(nPart + 100, lstToDelete.Count);
for (int n = nPart; n < nMin; n++)
{
lstTmp.Add(lstToDelete[n]);
}
if (contexteExecution.IndicateurProgression != null)
{
contexteExecution.IndicateurProgression.SetInfo(nPart.ToString() + "/" +
lstToDelete.Count);
}
result = CActionSupprimerEntite.PurgeEntites(contexteExecution.IdSession,
tpToClean, lstTmp.ToArray());
if (contexteExecution.IndicateurProgression != null &&
contexteExecution.IndicateurProgression.CancelRequest)
{
result.EmpileErreur("User cancellation");
}
if (!result)
{
return(result);
}
}
if (contexteExecution.IndicateurProgression != null)
{
contexteExecution.IndicateurProgression.PopLibelle();
}
}
}
}
}
}
}
}
}
return(result);
}
public static CCamusatQowisioData GetDataAt(
CSite site,
DateTime?dtLimite,
bool bOnlyWithExternalProbeConnected)
{
if (site == null)
{
return(null);
}
CFiltreData filtreDatas = new CFiltreData("(" +
CCamusatQowisioData.c_champFuSite_Id + " = @1 OR " +
CCamusatQowisioData.c_champFuPickup_Id + " = @1)",
site.Id);
if (dtLimite != null)
{
filtreDatas.Filtre += " and " +
CCamusatQowisioData.c_champQwDateTime + "< @2";
filtreDatas.Parametres.Add(dtLimite.Value.AddSeconds(10));
}
if (bOnlyWithExternalProbeConnected)
{
filtreDatas.Filtre += " and " + CCamusatQowisioData.c_champQwExFP_Id + "<>@3";
filtreDatas.Parametres.Add("");
}
C2iRequeteAvancee rq = new C2iRequeteAvancee();
rq.TableInterrogee = CCamusatQowisioData.c_nomTable;
rq.FiltreAAppliquer = filtreDatas;
rq.ListeChamps.Add(new C2iChampDeRequete(
"MAXDATE", new CSourceDeChampDeRequete(CCamusatQowisioData.c_champQwDateTime),
typeof(DateTime), OperationsAgregation.Max, false));
CResultAErreur result = rq.ExecuteRequete(site.ContexteDonnee.IdSession);
if (result)
{
DataTable table = result.Data as DataTable;
if (table != null && table.Rows.Count == 1)
{
if (table.Rows[0][0] is DateTime)
{
DateTime dtMax = (DateTime)table.Rows[0][0];
CFiltreData filtre = new CFiltreData("(" +
CCamusatQowisioData.c_champFuSite_Id + " = @1 OR " +
CCamusatQowisioData.c_champFuPickup_Id + " = @1) and " +
CCamusatQowisioData.c_champQwDateTime + "=@2",
site.Id,
dtMax);
CCamusatQowisioData data = new CCamusatQowisioData(site.ContexteDonnee);
if (data.ReadIfExists(filtre))
{
return(data);
}
}
}
}
/*CListeObjetDonneeGenerique<CCamusatQowisioData> listeDatas =
* new CListeObjetDonneeGenerique<CCamusatQowisioData>(site.ContexteDonnee, filtreDatas);
* listeDatas.Tri = CCamusatQowisioData.c_champQwDateTime + " desc";
* listeDatas.StartAt = 0;
* listeDatas.EndAt = 0;
*
* foreach (object obj in listeDatas)
* {
* return obj as CCamusatQowisioData;
* }*/
return(null);
}
