//----------------------------------------------------
public static string GetIdUniverselFromId(Type typeElement, int nId)
{
string strNomTable = CContexteDonnee.GetNomTableForType(typeElement);
CStructureTable structure = CStructureTable.GetStructure(typeElement);
C2iRequeteAvancee rq = new C2iRequeteAvancee();
rq.TableInterrogee = strNomTable;
rq.FiltreAAppliquer = new CFiltreData(
structure.ChampsId[0].NomChamp + "=@1", nId);
rq.ListeChamps.Add(new C2iChampDeRequete(
"UniversalId",
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
CResultAErreur result = rq.ExecuteRequete(0);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
if (table.Rows.Count > 0)
{
return((string)table.Rows[0][0]);
}
}
return("");
}
public CResultAErreur MAJ_Champs()
{
CResultAErreur result = CResultAErreur.True;
if (m_preferenceEditee != null && m_gestionnaireModeEdition.ModeEdition)
{
if (m_txtFiltre.Text == "")
{
m_preferenceEditee.FiltrePrefere = null;
}
else
{
string strNomTable = CContexteDonnee.GetNomTableForType(m_preferenceEditee.TypeObjets);
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(m_txtFiltre.Text, strNomTable);
if (!result)
{
return(result);
}
CFiltreDataAvance filtre = new CFiltreDataAvance(strNomTable, "");
filtre.ComposantPrincipal = result.Data as CComposantFiltre;
m_panelParametres.AffecteToFiltre(filtre);
m_preferenceEditee.FiltrePrefere = filtre;
}
}
return(result);
}
/// ///////////////////////////////////////////////////////////
private void FillNode(TreeNode nodeParent)
{
CGroupeStructurant groupe = null;
IList liste = null;
if (nodeParent != null)
{
groupe = (CGroupeStructurant)nodeParent.Tag;
liste = new ArrayList();
foreach (IRelationGroupeGroupeNecessaire relation in groupe.RelationsGroupesNecessitants)
{
liste.Add(relation.GroupeNecessitant);
}
}
else
{
liste = new CListeObjetsDonnees(sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant, m_typeGroupes);
string strNomTable = CContexteDonnee.GetNomTableForType(m_typeGroupes);
((CListeObjetsDonnees)liste).Filtre = new CFiltreDataAvance(strNomTable, "HasNo(RelationsGroupesNecessitants.Id)");
}
foreach (CGroupeStructurant grp in liste)
{
TreeNode node = new TreeNode(grp.Libelle);
node.Tag = grp;
if (nodeParent == null)
{
m_arbre.Nodes.Add(node);
}
else
{
nodeParent.Nodes.Add(node);
}
FillNode(node);
}
}
public static CResultAErreur VerifieUnicite(
CContexteDonnee contexte,
Type typeObjets,
DataRowState states)
{
CResultAErreur result = CResultAErreur.True;
DataTable table = contexte.Tables[CContexteDonnee.GetNomTableForType(typeObjets)];
List <CInfoFiltreUnique> lstFiltres = GetFiltres(typeObjets);
if (lstFiltres.Count == 0)
{
return(result);
}
if (table != null)
{
ArrayList lstCopie = new ArrayList(table.Rows);
foreach (DataRow row in table.Rows)
{
if ((row.RowState & states) != 0)
{
result = VerifieUnicite(row, lstFiltres, typeObjets);
if (!result)
{
return(result);
}
}
}
}
return(result);
}
//--------------------------------------------------------------------------
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 CreateTableSimpleInDataset(C2iTableExport tableExport, CContexteDonnee contexteDest, Type typeParent)
{
CResultAErreur result = CResultAErreur.True;
PropertyInfo property = typeParent.GetProperty(tableExport.ChampOrigine.NomProprieteSansCleTypeChamp);
if (property == null)
{
result.EmpileErreur(I.T("The property @1 was not found in the @2 type|105", tableExport.ChampOrigine.NomPropriete, typeParent.ToString()));
return(result);
}
Object[] attribs = property.GetCustomAttributes(typeof(RelationAttribute), true);
Type typeObjet = null;
DataTable tableDestination = null;
if (attribs.Length != 0)
{
RelationAttribute relParente = (RelationAttribute)attribs[0];
tableDestination = contexteDest.GetTableSafe(relParente.TableMere);
typeObjet = CContexteDonnee.GetTypeForTable(relParente.TableMere);
}
else
{
attribs = property.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length != 0)
{
RelationFilleAttribute relFille = (RelationFilleAttribute)attribs[0];
tableDestination = contexteDest.GetTableSafe(CContexteDonnee.GetNomTableForType(relFille.TypeFille));
typeObjet = relFille.TypeFille;
}
else
{
result.EmpileErreur(I.T("The property @1 cannot be integrated into a simple export|106", tableExport.ChampOrigine.NomPropriete));
return(result);
}
}
foreach (C2iChampExport champ in tableExport.Champs)
//Crée les colonnes calculées
{
result = CreateChampInTable(champ, tableDestination);
if (!result)
{
result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
return(result);
}
}
foreach (C2iTableExport tableFille in tableExport.TablesFilles)
{
result &= CreateTableSimpleInDataset(tableFille, contexteDest, typeObjet);
if (!result)
{
return(result);
}
}
return(result);
}
//----------------------------------------------------------
public CResultAErreur AnnuleModificationPrevisionnelle(CVersionDonneesObjet versionObjet)
{
CContexteDonnee contexte = versionObjet.ContexteDonnee;
CResultAErreur result = CResultAErreur.True;
int nIdObjet = versionObjet.IdElement;
Type typeObjet = versionObjet.TypeElement;
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
int nIdVersion = versionPrev.Id;
//Vérifie que l'utilisateur peut travailler avec cette version
result = versionPrev.EnregistreEvenement(CVersionDonnees.c_eventBeforeUtiliser, true);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Suppression de l'objet associé
string strPrimKey = contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(typeObjet)).PrimaryKey[0].ColumnName;
CListeObjetsDonnees listeTmp = new CListeObjetsDonnees(contexte, typeObjet);
listeTmp.Filtre = new CFiltreData(
CSc2iDataConst.c_champIdVersion + "=@1 and " +
"(" + CSc2iDataConst.c_champOriginalId + "=@2 or " +
strPrimKey + "=@2)",
nIdVersion,
nIdObjet);
listeTmp.Filtre.IgnorerVersionDeContexte = true;
result = CObjetDonneeAIdNumerique.Delete(listeTmp);
if (!result)
{
return(result);
}
//Suppression de la version objet
result = versionObjet.Delete();
if (!result)
{
return(result);
}
//Force la modification de l'objet pour mettre à jour les versions suivantes
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(nIdObjet))
{
//Passe dans la version de l'objet
result = contexte.SetVersionDeTravail(objet.IdVersionDatabase, false);
if (!result)
{
return(result);
}
objet.Row.Row.SetModified();
}
return(result);
}
//////////////////////////////////////////////////////////////////
/// <summary>
/// fonctionnement interne, voir ShouldCreateObjetSpv
/// </summary>
/// <param name="objetTimos"></param>
/// <returns></returns>
private static bool StaticShouldCreateObjetSpv(TypeTimos objetTimos)
{
string strNomTable = CContexteDonnee.GetNomTableForType(typeof(TypeSpv));
CMappableTimosServeur <TypeTimos, TypeSpv> instanceDeThis = CContexteDonnee.GetTableLoader(strNomTable, null, objetTimos.ContexteDonnee.IdSession) as CMappableTimosServeur <TypeTimos, TypeSpv>;
if (instanceDeThis != null)
{
return(instanceDeThis.ShouldAutoCreateObjetSpv(objetTimos));
}
return(false);
}
public CObjetDonneeAIdNumerique GetObjetWithSpecifiedID(int nId, CContexteDonnee ctxUsed)
{
string strChampID = ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(TypeElement)).PrimaryKey[0].ColumnName;
CFiltreData filtre = new CFiltreData(strChampID + " =@1", nId);
CListeObjetsDonnees lstEle = new CListeObjetsDonnees(ctxUsed, TypeElement, filtre);
if (lstEle.Count == 1)
{
return((CObjetDonneeAIdNumerique)lstEle[0]);
}
return(null);
}
private void m_lnkDemarrer_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iStructureImport structure = m_panelStructure.GetStructureFinale();
if (structure.Mappages.Select(m => m.IsCle).Count() == 0)
{
if (MessageBox.Show(I.T("Warning, You didn't select any identification field. Continue ?|20052"),
"",
MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
}
string strFichier = m_panelStructure.NomFichier;
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
ctx.SetVersionDeTravail(CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail, false);
using (CWaitCursor waiter = new CWaitCursor())
{
result = structure.Importer(strFichier, ctx);
}
if (result)
{
DataTable table = ctx.GetTableSafe(CContexteDonnee.GetNomTableForType(structure.TypeCible));
int nNbUpdate = structure.NbUpdated;
int nNbCreate = structure.NbCreated;
if (CFormAlerte.Afficher(I.T("This opération will create @1 and update @2 elements. Do you confirm this operation ?|20050",
nNbCreate.ToString(),
nNbUpdate.ToString()), EFormAlerteType.Question) == DialogResult.Yes)
{
result = ctx.SaveAll(true);
if (result)
{
CFormAlerte.Afficher(I.T("Import ended with success|20051"), EFormAlerteType.Info);
}
}
}
}
}
catch (Exception ex)
{
result.EmpileErreur(new CErreurException(ex));
}
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
}
//-------------------------------------------------------
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);
}
//////////////////////////////////////////////////////////////////
private static void PropageObjetTimos(
CContexteDonnee contexte,
Hashtable tableData,
ref CResultAErreur result)
{
if (!result)
{
return;
}
DataTable dt = contexte.Tables[CContexteDonnee.GetNomTableForType(typeof(TypeTimos))];
ArrayList rows = new ArrayList(dt.Rows);
foreach (DataRow row in rows)
{
if (row.RowState != DataRowState.Unchanged)
{
switch (row.RowState)
{
case DataRowState.Added:
case DataRowState.Modified:
TypeTimos objetTimos = Activator.CreateInstance(typeof(TypeTimos), new object[] { row }) as TypeTimos;
try
{
TypeSpv objetSpv = CMappableAvecTimos <TypeTimos, TypeSpv> .GetObjetSpvFromObjetTimos(objetTimos);
if (objetSpv == null && StaticShouldCreateObjetSpv(objetTimos))
{
objetSpv = CMappableAvecTimos <TypeTimos, TypeSpv> .GetObjetSpvFromObjetTimosAvecCreation(objetTimos);
}
else if (objetSpv != null)
{
objetSpv.CopyFromObjetTimos(objetTimos);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while applying supervision datas from @1|20006", objetTimos.DescriptionElement));
return;
}
break;
default:
break;
}
}
}//foreach (DataRow row in rows)
}
//--------------------------------------------------------
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);
}
public static void RegisterHook(Type tp, TraitementSauvegardeExterne traitement)
{
List <TraitementSauvegardeExterne> lst = null;
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
if (strNomTable != null && strNomTable != "")
{
if (!m_listeHooksParType.TryGetValue(strNomTable, out lst))
{
lst = new List <TraitementSauvegardeExterne>();
m_listeHooksParType[strNomTable] = lst;
}
if (!lst.Contains(traitement))
{
lst.Add(traitement);
}
}
}
//-------------------------------------------------------------------
public void AppliquerFiltre()
{
string strFiltre = "";
CFiltreDataAvance tempFiltre = new CFiltreDataAvance(CActeur.c_nomTable, strFiltre);
int nNumParam = 1;
AddToFiltre(ref strFiltre, m_txtNom, CActeur.c_champNom);
AddToFiltre(ref strFiltre, m_txtCodePostal, CActeur.c_champCodePostal);
AddToFiltre(ref strFiltre, m_txtVille, CActeur.c_champVille);
if (m_cmbGroupes.SelectedValue != null)
{
if (strFiltre != "")
{
strFiltre += " AND ";
}
strFiltre += "RelationsGroupes.GroupeActeur." + CGroupeActeur.c_champId + " = @" + nNumParam;
tempFiltre.Parametres.Add(((CGroupeActeur)m_cmbGroupes.SelectedValue).Id);
nNumParam++;
}
if (m_cmbRoles.SelectedValue != null)
{
CRoleActeur role = (CRoleActeur)m_cmbRoles.SelectedValue;
string strNomtable = CContexteDonnee.GetNomTableForType(role.TypeDonneeActeur);
if (strFiltre != "")
{
strFiltre += " AND ";
}
strFiltre += strNomtable + "." + CActeur.c_champId + " >= 0";
nNumParam++;
}
if (strFiltre == "")
{
strFiltre = "1 = 1";
}
tempFiltre.Filtre = strFiltre;
Filtre = tempFiltre;;
OnAppliqueFiltre(new object(), null);
}
/// ////////////////////////////////////////////////////////////////
public static void FindRelation(string strTable, Type type, ref CInfoRelationComposantFiltre relationTrouvee)
{
//TESTDBKEYTODO
if (relationTrouvee != null)
{
return;
}
string strKeyChamp = "";
if (DecomposeNomPropriete(strTable, ref strKeyChamp))
{
string strTableEntite = CContexteDonnee.GetNomTableForType(type);
//Si strKeyChamp est un int, il s'agit d'un id de champ custom
//ce cas peut se présenter lors de la relecture d'un filtre sous forme de
//test par exemple dans une fonction ObjectList
relationTrouvee = new CInfoRelationEValeurChampCustomToDisplay(CDbKey.CreateFromStringValue(strKeyChamp), strTableEntite);
}
//relationTrouvee = new CInfoRelationEValeurChampCustomToDisplay(relToChamp.DbKeyChamp, relToChamp.TableFille);
}
//-----------------------------------------------------------
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);
}
/// ////////////////////////////////////////////////////////////////////////////
private bool FiltreChamp(CDefinitionProprieteDynamique def)
{
if (def is CDefinitionProprieteDynamiqueRelation)
{
CDefinitionProprieteDynamiqueRelation rel = def as CDefinitionProprieteDynamiqueRelation;
string strTableSource = CContexteDonnee.GetNomTableForType(m_typeSource);
if (rel.Relation.TableParente == strTableSource)
{
return(true);
}
}
/*if (def is CDefinitionProprieteDynamiqueChampCustomFils)
* return true;*/
if (def is CDefinitionProprieteDynamiqueRelationTypeId)
{
return(true);
}
return(false);
}
public static List <CInfoTypeElementInDb> GetInfosInDatabase(int nIdSession)
{
List <CInfoTypeElementInDb> lst = new List <CInfoTypeElementInDb>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(tp);
requete.ListeChamps.Add(new C2iChampDeRequete("NBELEMENTS", new CSourceDeChampDeRequete(structure.Champs[0].NomChamp),
typeof(int), OperationsAgregation.Number, false));
CInfoTypeElementInDb info = new CInfoTypeElementInDb(tp);
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElements = (int)((DataTable)result.Data).Rows[0][0];
}
if (!typeof(IObjetSansVersion).IsAssignableFrom(tp))
{
requete.FiltreAAppliquer = new CFiltreData(CSc2iDataConst.c_champIdVersion + " is not null and " +
CSc2iDataConst.c_champIsDeleted + "=@1", false);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElementsPrevisionnels = (int)((DataTable)result.Data).Rows[0][0];
}
requete.FiltreAAppliquer = new CFiltreData(CSc2iDataConst.c_champIsDeleted + "=@1", true);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElementsSupprimes = (int)((DataTable)result.Data).Rows[0][0];
}
}
lst.Add(info);
}
return(lst);
}
public CFiltreData GetFiltreForType(Type tp)
{
CFiltreData filtre = null;
if (
m_ArbreModules.SelectedNode != null &&
m_chkAppliquerFiltre.Checked &&
m_contexte != null &&
typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
CModuleParametrage module = m_ArbreModules.SelectedNode.Tag as CModuleParametrage;
if (module != null)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexte, typeof(CRelationElement_ModuleParametrage));
lst.Filtre = new CFiltreDataAvance(
CRelationElement_ModuleParametrage.c_nomTable,
CRelationElement_ModuleParametrage.c_champTypeElement + "=@1 and " +
CModuleParametrage.c_nomTable + "." + CModuleParametrage.c_champCodeSystemeComplet + " like @2",
tp.ToString(),
module.CodeSystemeComplet + "%");
if (lst.Count != 0)
{
StringBuilder bl = new StringBuilder();
foreach (CRelationElement_ModuleParametrage rel in lst)
{
bl.Append(rel.IdElement);
bl.Append(';');
}
bl.Remove(bl.Length - 1, 1);
DataTable table = m_contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(tp),
table.PrimaryKey[0].ColumnName + " in {" +
bl.ToString() + "}");
}
}
}
return(filtre);
}
/// <summary>
/// Traite les ajouts d'éléments avec des valeurs de champs customs
/// associés aux nouveaux éléments
/// </summary>
/// <param name="table"></param>
/// <param name="tableParametres"></param>
/// <param name="result"></param>
public static void AfterSaveExterneChampCustom(DataTable table, Hashtable tableParametres, ref CResultAErreur result)
{
if (!result)
{
return;
}
CContexteDonnee contexte = (CContexteDonnee)table.DataSet;
Dictionary <DataRow, int> dicElementsNouveaux = tableParametres[typeof(CRelationElementAChamp_ChampCustomServeur).ToString()] as Dictionary <DataRow, int>;
if (dicElementsNouveaux == null || dicElementsNouveaux.Count == 0)
{
return;
}
Type tp = CContexteDonnee.GetTypeForTable(table.TableName);
string strPrimKey = table.PrimaryKey[0].ColumnName;
//Trouve tous les types qui implémentent CRelationElementAChamp_ChampCustom
CInfoClasseDynamique[] types = DynamicClassAttribute.GetAllDynamicClassHeritant(typeof(CRelationElementAChamp_ChampCustom));
foreach (CInfoClasseDynamique infoClasse in types)
{
string strNomTable = CContexteDonnee.GetNomTableForType(infoClasse.Classe);
DataTable tableValeurs = contexte.Tables[strNomTable];
if (tableValeurs != null)
{
foreach (KeyValuePair <DataRow, int> rowToId in dicElementsNouveaux)
{
DataRow[] rowsValeurs = tableValeurs.Select(CRelationElementAChamp_ChampCustom.c_champValeurString + "='" +
tp.ToString() + "' and " +
CRelationElementAChamp_ChampCustom.c_champValeurInt + "=" +
rowToId.Value);
foreach (DataRow rowValeur in rowsValeurs)
{
rowValeur[CRelationElementAChamp_ChampCustom.c_champValeurInt] = rowToId.Key[strPrimKey];
}
}
}
}
}
private void RenommeNomTablesSimples()
{
if (!m_bIsStructureComplexe && Table != null)
{
string strNom = CContexteDonnee.GetNomTableForType(m_typeSource);
if (strNom != null && strNom != "")
{
Table.NomTable = strNom;
}
ArrayList lstTables = new ArrayList();
lstTables.AddRange(Table.GetToutesLesTablesFilles());
foreach (ITableExport table in lstTables)
{
if (table is C2iTableExport && table.ChampOrigine != null)
{
strNom = CContexteDonnee.GetNomTableForType(table.ChampOrigine.TypeDonnee.TypeDotNetNatif);
if (strNom != null && strNom != "")
{
table.NomTable = strNom;
}
}
}
}
}
/// ////////////////////////////////////////////////////////
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 override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
//Vérifie que l'expression condition est OK
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);
result = ConditionApplication.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
CComposantFiltreOperateur opPrincipal = null;
string strNomChamp = m_champ.NomPropriete;
if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
CDbKey keyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
strNomChamp = m_champ.NomPropriete;
string strAcces = "";
//Trouve le nom du champ et le chemin d'accès
int nPos = strNomChamp.LastIndexOf(".");
if (nPos != -1)
{
strAcces = strNomChamp.Substring(0, nPos + 1);
strNomChamp = strNomChamp.Substring(nPos + 1);
}
strAcces += "RelationsChampsCustom.";
CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
// TESTDBKEYOK
if (keyChamp.IsNumericalId())
{
operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
}
else
{
operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CObjetDonnee.c_champIdUniversel, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
}
operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(keyChamp.GetValeurInDb()));
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opPrincipal.Parametres.Add(operateurIdChamp);
Type typeChamp = m_champ.TypeDonnee.TypeDotNetNatif;
if (typeChamp == typeof(double))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
}
else if (typeChamp == typeof(int))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
}
else if (typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
}
else if (typeChamp == typeof(bool))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
}
else
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
}
strNomChamp = strAcces + strNomChamp;
}
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
CComposantFiltre composantRecherche = new CComposantFiltreRechercheAvancee();
CComposantFiltre composantValeur = null;
result = ExpressionValeur.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ExpressionValeur.GetString()));
result.Data = null;
return(result);
}
composantValeur = new CComposantFiltreConstante(result.Data.ToString());
composantRecherche.Parametres.Add(composantChamp);
composantRecherche.Parametres.Add(composantValeur);
if (opPrincipal != null)
{
opPrincipal.Parametres.Add(composantRecherche);
composantRecherche = opPrincipal;
}
result.Data = composantRecherche;
return(result);
}
//--------------------------------------------------------------------------------------------------------------------
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 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;*/
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
//Vérifie que l'expression condition est OK
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);
result = ConditionApplication.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
string strNomChamp = m_champ.NomPropriete;
CDbKey dbKeyChampCustom = null;
if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
CComposantFiltreOperateur opPrincipal = null;
dbKeyChampCustom = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
strNomChamp = m_champ.NomPropriete;
string strAcces = "";
//Trouve le nom du champ et le chemin d'accès
int nPos = strNomChamp.LastIndexOf(".");
if (nPos != -1)
{
strAcces = strNomChamp.Substring(0, nPos + 1);
strNomChamp = strNomChamp.Substring(nPos + 1);
}
strAcces += "RelationsChampsCustom.";
int nIdChamp = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
CComposantFiltreChamp compo1 = new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
compo1.IdChampCustom = nIdChamp;
operateurIdChamp.Parametres.Add(compo1);
operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(nIdChamp));
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opPrincipal.Parametres.Add(operateurIdChamp);
//Stef, 28072008 : pour tester si un champ est null, on vérifie CRelationElementAChamp_ChampCustom.c_champValeurNull
//et non pas les valeurs suivant le type
/*if ( typeChamp == typeof(double))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
* else if ( typeChamp == typeof(int))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
* else if ( typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx) )
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
* else if ( typeChamp == typeof(bool))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
* else
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
*/
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurNull;
strNomChamp = strAcces + strNomChamp;
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChamp.IdChampCustom = nIdChamp;
CComposantFiltre composantOperateur = new CComposantFiltreOperateur(
m_bTestNull ? CComposantFiltreOperateur.c_IdOperateurDifferent : CComposantFiltreOperateur.c_IdOperateurEgal);
composantOperateur.Parametres.Add(composantChamp);
composantOperateur.Parametres.Add(new CComposantFiltreConstante(0));
opPrincipal.Parametres.Add(composantOperateur);
composantOperateur = opPrincipal;
result.Data = composantOperateur;
//Stef 28072008, fin modif
}
else
{
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChamp.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltre composantOperateur;
if (!m_bTestNull)
{
composantOperateur = new CComposantFiltreHas();
}
else
{
composantOperateur = new CComposantFiltreHasNo();
}
composantOperateur.Parametres.Add(composantChamp);
result.Data = composantOperateur;
}
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 CResultAErreur ExecuteRequete(C2iRequete requete, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables, bool bStructureOnly)
{
CResultAErreur result = CResultAErreur.True;
Type typeReference = requete.TypeReferencePourConnexion;
if (typeReference != null)
{
///TODO
///Problème VersionObjet
object objServeur = CContexteDonnee.GetTableLoader(CContexteDonnee.GetNomTableForType(typeReference), null, IdSession);
if (objServeur != null)
{
typeReference = objServeur.GetType();
}
else
{
typeReference = null;
}
}
IDatabaseConnexion con;
if (typeReference == null)
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
}
else
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeReference);
}
object[] lstParams = null;
string strRequete = GetTexteRequeteFinaleSql(requete, elementAVariables, ref lstParams, con);
int nOldTimeOut = con.CommandTimeOut;
con.CommandTimeOut = 60 * 10;
IDataAdapter adapter = con.GetAdapterForRequete(strRequete, lstParams);
DataSet ds = new DataSet();
try
{
lock (con)
{
if (bStructureOnly)
{
adapter.FillSchema(ds, SchemaType.Source);
}
else
{
adapter.Fill(ds);
}
}
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
if (requete.TableauCroise != null)
{
result = requete.TableauCroise.CreateTableCroisee(table);
if (result)
{
table = (DataTable)result.Data;
}
}
table.TableName = "DONNEES_REQUETE";
result.Data = table;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in the request '@1'|102", strRequete));
}
finally
{
con.CommandTimeOut = nOldTimeOut;
CUtilDataAdapter.DisposeAdapter(adapter);
}
return(result);
}
/// /////////////////////////////////////////////
///Le data du result contient le filtre
public CResultAErreur GetFiltreData( )
{
CResultAErreur result = CResultAErreur.True;
if (ComposantPrincipal == null)
{
result.Data = null;
return(result);
}
if (m_typeElementsFiltres == null)
{
result.EmpileErreur(I.T("The type of filter elements isn't valid|174"));
return(result);
}
string strTable = CContexteDonnee.GetNomTableForType(m_typeElementsFiltres);
if (strTable == "")
{
result.EmpileErreur(I.T("No table is associated with @1|175", DynamicClassAttribute.GetNomConvivial(m_typeElementsFiltres)));
return(result);
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(this);
CFiltreDataAvance filtre = new CFiltreDataAvance(strTable, "");
if (FormuleIntegrerParentsHierarchiques != null)
{
result = FormuleIntegrerParentsHierarchiques.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.IntergerParentsHierarchiques = true;
}
else
{
filtre.IntergerParentsHierarchiques = false;
}
}
if (FormuleIntegrerFilsHierarchiques != null)
{
result = FormuleIntegrerFilsHierarchiques.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.IntegrerFilsHierarchiques = true;
}
else
{
filtre.IntegrerFilsHierarchiques = false;
}
}
if (FormuleNeConserverQueLesRacines != null)
{
result = FormuleNeConserverQueLesRacines.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.NeConserverQueLesRacines = true;
}
else
{
filtre.NeConserverQueLesRacines = false;
}
}
result = CResultAErreur.True;
result = m_composantFiltre.GetComposantFiltreData(this, filtre);
if (!result)
{
result.Data = null;
result.EmpileErreur(I.T("Error in filter|176"));
return(result);
}
CComposantFiltre composant = (CComposantFiltre)result.Data;
if (composant == null)
{
filtre.Filtre = "1=1";
}
else
{
filtre.ComposantPrincipal = composant;
}
result.Data = filtre;
return(result);
}