/// ////////////////////////////////////////////////////////////////////
/// <summary>
/// Fait sélectionner les valeurs à l'utilisateur
/// </summary>
/// <param name="filtre"></param>
/// <returns></returns>
public static CFiltreData GetFiltreData(CFiltreDynamique filtre)
{
using (CFormFiltreDynamic form = new CFormFiltreDynamic())
{
form.m_filtreDyn = filtre;
//Vérifie qu'il y a qq chose dans le formulaire !
bool bNeedDialog = false;
foreach (IVariableDynamique variable in filtre.ListeVariables)
{
if (variable.IsChoixUtilisateur())
{
bNeedDialog = true;
break;
}
}
if (!bNeedDialog || form.ShowDialog() == DialogResult.OK)
{
CResultAErreur result = CResultAErreur.True;
result = filtre.GetFiltreData();
if (!result)
{
CFormAlerte.Afficher(result);
}
else
{
return(( CFiltreData )result.Data);
}
}
}
return(null);
}
/// ///////////////////////////////////////////////////////////////////////
/// <summary>
/// Retourne le filtre qui indique les éléments autorisés comme étant éléments suivis
/// </summary>
public CFiltreData GetFiltreDataElementSuivi()
{
CFiltreDynamique filtreDynamique = TypeDossier.FiltreDynamiqueElementsSuivisPossibles;
if (filtreDynamique == null)
{
return(null);
}
try
{
foreach (IVariableDynamique variable in filtreDynamique.ListeVariables)
{
if (variable.Nom == CTypeDossierSuivi.c_nomChampDossier)
{
filtreDynamique.SetValeurChamp(variable, this);
break;
}
}
CResultAErreur result = filtreDynamique.GetFiltreData();
if (result)
{
return((CFiltreData)result.Data);
}
}
catch
{
}
return(null);
}
/// ////////////////////////////////////////////////////////////////////
public void AppliquerFiltre( )
{
if (m_filtre == null)
{
return;
}
CResultAErreur result = m_panelFiltre.AffecteValeursToElement();
if (result)
{
try
{
result = m_filtre.GetFiltreData();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
if (!result)
{
CFormAlerte.Afficher(result);
return;
}
m_filtreData = (CFiltreData)result.Data;
if (OnAppliqueFiltre != null)
{
OnAppliqueFiltre(this, new EventArgs());
}
}
/// /////////////////////////////////////////////////////////
/// result.Data contient le CListeObjetDonnee
public CResultAErreur CalculeListe(CContexteDonnee contexteDonnee)
{
CResultAErreur result = CResultAErreur.True;
if (Filtre.TypeElements == null)
{
result.EmpileErreur(I.T("The objects created type isn't defined|156"));
return(result);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteDonnee, Filtre.TypeElements, m_bAppliquerFiltreParDefaut);
liste.PreserveChanges = true;
if (m_filtreDynamique == null)
{
result.Data = liste;
return(result);
}
m_filtreDynamique.ContexteDonnee = contexteDonnee;
m_filtreDynamique.ElementAVariablesExterne = Process;
result = m_filtreDynamique.GetFiltreData();
if (!result)
{
result.EmpileErreur(I.T("Error during the filter evaluation|157"));
return(result);
}
liste.Filtre = (CFiltreData)result.Data;
result.Data = liste;
return(result);
}
//-------------------------------------------
public override object[] GetObjets(CNodeConsultationHierarchique nodeParent, CContexteDonnee contexte)
{
try
{
if (m_filtreDynamique == null || m_filtreDynamique.TypeElements == null)
{
return(new object[0]);
}
CVariableDynamique variable = AssureVariableParent();
if (variable != null)
{
m_filtreDynamique.SetValeurChamp(variable, nodeParent);
}
CResultAErreur result = m_filtreDynamique.GetFiltreData();
if (!result)
{
return(new object[0]);
}
CListeObjetsDonnees lst = new CListeObjetsDonnees(contexte, m_filtreDynamique.TypeElements);
lst.Filtre = (CFiltreData)result.Data;
return((object[])lst.ToArray(typeof(object)));
}
catch
{
}
return(new object[0]);
}
private void m_btnFiltreDynamique_Click(object sender, EventArgs e)
{
CFiltreDynamique filtre = new CFiltreDynamique();
filtre.TypeElements = m_typeEdite;
if (CFormEditFiltreDynamique.EditeFiltre(filtre, true, true, null))
{
CResultAErreur result = filtre.GetFiltreData();
if (result)
{
CFiltreData filtreData = result.Data as CFiltreData;
m_txtFiltre.Text += filtreData.Filtre;
}
}
}
private void ApplyFiltre(CFiltreDynamique filtre)
{
if (filtre != null)
{
m_lastFiltreDynamique = filtre;
CResultAErreur result = filtre.GetFiltreData();
if (!result)
{
CFormAlerte.Afficher(result.Erreur.Erreurs);
return;
}
m_filtreUser = result.Data as CFiltreData;
Init();
}
}
//---------------------------------------------------------------------------------------
private CFiltreData GetFiltre(CFiltreDynamique filtre)
{
if (filtre == null)
{
return(null);
}
if (m_elementAVariables != null)
{
IVariableDynamique variable = AssureVariableElementCible(filtre, m_elementAVariables.GetType());
filtre.SetValeurChamp(variable.IdVariable, m_elementAVariables);
}
CResultAErreur result = filtre.GetFiltreData();
if (result)
{
return((CFiltreData)result.Data);
}
return(null);
}
/// //////////////////////////////////////////////////////////
private void item_Liste_Click(object sender, EventArgs e)
{
if (sender is CMenuItemListe)
{
CListeEntites liste = ((CMenuItemListe)sender).Liste;
if (liste == null)
{
m_panelListe.ListeObjets.Filtre = null;
m_panelListe.RemplirGrille();
}
else
{
if (liste.IsDynamique)
{
CFiltreDynamique filtre = liste.FiltreDynamique;
CResultAErreur result = filtre.GetFiltreData();
if (result.Data is CFiltreData)
{
m_panelListe.ListeObjets.Filtre = (CFiltreData)result.Data;
m_panelListe.RemplirGrille();
}
}
else
{
string strFiltre = "";
foreach (CObjetDonneeAIdNumerique objet in liste.ElementsLies)
{
strFiltre += objet.Id.ToString() + ",";
}
if (strFiltre.Length > 0)
{
strFiltre = strFiltre.Substring(0, strFiltre.Length - 1);
}
CStructureTable structure = CStructureTable.GetStructure(liste.TypeElements);
m_panelListe.ListeObjets.Filtre = new CFiltreData(
structure.ChampsId[0].NomChamp + " in (" +
strFiltre + ")");
m_panelListe.RemplirGrille();
}
}
}
}
/// //////////////////////////////////////////////////////////////////
protected static CResultAErreur ExecuteActionListe(CActionSur2iLinkAfficherListe action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
CFiltreDynamique filtre = action.Filtre;
if (filtre == null || filtre.TypeElements == null)
{
result.EmpileErreur(I.T("Link parameter error : filter is null|30077"));
return(result);
}
if (objetCible != null)
{
CObjetPourSousProprietes objetPourSousProp = null;
objetPourSousProp = new CObjetPourSousProprietes(objetCible);
IVariableDynamique variable = CActionSur2iLinkAfficherListe.AssureVariableElementCible(filtre, objetPourSousProp);
/*if ( variable.TypeDonnee.TypeDotNetNatif != objetCible.GetType() )
* {
* result.EmpileErreur(I.T("Expected type in the filter does not correspond to object type|30078"));
* return result;
* }*/
if (variable != null)
{
filtre.SetValeurChamp(variable.IdVariable, objetCible);
}
}
result = filtre.GetFiltreData();
if (!result)
{
result.EmpileErreur(I.T("Filter error|30079"));
return(result);
}
CFiltreData filtreData = (CFiltreData)result.Data;
Type tp = CFormFinder.GetTypeFormToList(filtre.TypeElements);
try
{
if (tp != null || tp.IsSubclassOf(typeof(CFormListeStandard)))
{
CFormListeStandard form = ( CFormListeStandard )Activator.CreateInstance(tp, new object[0]);
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetCible);
ctxEval.AttacheObjet(typeof(CContexteDonnee), CSc2iWin32DataClient.ContexteCourant);
if (action.FormuleContexte != null)
{
result = action.FormuleContexte.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form context evaluation error|30080"));
return(result);
}
if (result.Data != null)
{
form.ContexteUtilisation = result.Data.ToString();
}
}
if (action.FormuleTitre != null)
{
result = action.FormuleTitre.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Form title evaluation error|30081"));
return(result);
}
if (result.Data != null)
{
form.TitreForce = result.Data.ToString();
}
}
form.FiltreDeBase = filtreData;
form.AffectationsPourNouveauxElements = action.Affectations;
form.ObjetReferencePourAffectationsInitiales = objetCible;
form.BoutonAjouterVisible = action.ShowBoutonAjouter;
form.BoutonModifierVisible = action.ShowBoutonDetail;
form.BoutonSupprimerVisible = action.ShowBoutonSupprimer;
if (action.IdFiltreDynamiqueAUtiliser >= 0)
{
CFiltreDynamiqueInDb filtretoUse = new CFiltreDynamiqueInDb(CContexteDonneeSysteme.GetInstance());
if (filtretoUse.ReadIfExists(action.IdFiltreDynamiqueAUtiliser))
{
CFiltreDynamique filtreDyn = filtretoUse.Filtre;
if (filtreDyn != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetCible);
foreach (CFormuleNommee formule in action.ValeursVariablesFiltre)
{
if (formule.Formule != null)
{
CResultAErreur res = formule.Formule.Eval(ctx);
if (res)
{
try
{
string strId = formule.Id;
filtreDyn.SetValeurChamp(strId, res.Data);
}
catch { }
}
}
}
form.FiltrePrefere = filtreDyn;
}
}
}
if (action.ActionSurDetail != null)
{
CExecuteurActionSurPanelListeSpeedStandard executeur = new CExecuteurActionSurPanelListeSpeedStandard(action.ActionSurDetail, form);
form.SetModifierElementDelegate(new CPanelListeSpeedStandard.ModifierElementDelegate(executeur.ExecuteAction));
}
CTimosApp.Navigateur.AffichePage(form);
}
else
{
result.EmpileErreur(I.T("Not avaliable|30082"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//---------------------------------------------------------------
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);
}
}
}
}
}
protected override void OnChangeElementEdite(object element)
{
if (element != null &&
WndFiltreRapide != null)
{
CFiltreData filtreData;
if (WndFiltreRapide.Filter != null)
{
CElementAVariablesDynamiques eltAVar = new CElementAVariablesDynamiques();
CVariableDynamiqueStatique var = new CVariableDynamiqueStatique(eltAVar);
var.Nom = "EditedElement";
var.IdVariable = "0";
var.SetTypeDonnee(new CTypeResultatExpression(element.GetType(), false));
eltAVar.AddVariable(var);
eltAVar.SetValeurChamp(var, element);
CFiltreDynamique filtreDyn = WndFiltreRapide.Filter;
filtreDyn.ElementAVariablesExterne = eltAVar;
filtreData = (CFiltreData)filtreDyn.GetFiltreData().Data;
}
else
{
filtreData = null;
}
Type typePropriete = null;
if (WndFiltreRapide.Property != null)
{
typePropriete = WndFiltreRapide.Property.TypeDonnee.TypeDotNetNatif;
}
else if (WndFiltreRapide.Filter != null)
{
typePropriete = WndFiltreRapide.Filter.TypeElements;
}
if (typePropriete != null)
{
string strDesc = DescriptionFieldAttribute.GetDescriptionField(typePropriete, "DescriptionElement");
C2iTextBoxFiltreRapide txtRapide = m_selectionneur as C2iTextBoxFiltreRapide;
if (txtRapide != null)
{
txtRapide.InitAvecFiltreDeBase(typePropriete, strDesc, filtreData, true);
}
else
{
CComboBoxListeObjetsDonnees cmb = m_selectionneur as CComboBoxListeObjetsDonnees;
cmb.NullAutorise = true;
cmb.TextNull = I.T("None|19");
if (cmb != null)
{
cmb.Init(
typePropriete,
filtreData,
strDesc,
true);
}
}
if (WndFiltreRapide.Property != null)
{
CObjetDonnee valeur = CInterpreteurProprieteDynamique.GetValue(EditedElement, WndFiltreRapide.Property).Data as CObjetDonnee;
m_selectionneur.ElementSelectionne = valeur;
}
}
}
}
//--------------------------------------------------
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 CResultAErreurType <CObjetDonnee> FindObjet(
DataRow rowSource,
CContexteImportDonnee contexteImport,
CValeursImportFixe valeursFixes,
ref string strFiltre)
{
CResultAErreurType <CObjetDonnee> resObjet = new CResultAErreurType <CObjetDonnee>();
CResultAErreur res = CResultAErreur.True;
StringBuilder blFiltre = new StringBuilder();
if (valeursFixes != null)
{
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
blFiltre.Append(kv.Key);
blFiltre.Append("=");
blFiltre.Append(kv.Value == null ? "null" : kv.Value.ToString());
blFiltre.Append(";");
}
}
//Création du filtre
CComposantFiltreDynamiqueEt compoPrincipal = new CComposantFiltreDynamiqueEt();
//Recherche à partir des champs simples
foreach (CMappageChampSimple mapSimple in MappagesChampsSimples)
{
if (mapSimple.UseAsKey)
{
res = mapSimple.GetValue(rowSource, contexteImport);
if (!res)
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
//Stockage valeur témoin
CSourceSmartImportField sourceField = mapSimple.Source as CSourceSmartImportField;
if (sourceField != null)
{
contexteImport.SetValeurTemoin(sourceField.NomChampSource, res.Data);
}
blFiltre.Append(mapSimple.Propriete.NomPropriete);
if (res.Data == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = mapSimple.Propriete;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = mapSimple.Propriete;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(res.Data);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(res.Data.ToString());
blFiltre.Append(";");
}
}
}
//Recherche à partir des objets parents
foreach (CMappageEntiteParente mapParent in m_listeMappagesParents)
{
if (mapParent.UseAsKey)
{
CResultAErreurType <CObjetDonnee> resParent = mapParent.GetObjetAssocie(rowSource, contexteImport, false);
if (!resParent)
{
resObjet.EmpileErreur(resParent.Erreur);
return(resObjet);
}
CObjetDonneeAIdNumerique objetId = resParent.DataType as CObjetDonneeAIdNumerique;
CDefinitionProprieteDynamique defId = null;
object valeurTest = null;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet(
"Id",
"Id",
new CTypeResultatExpression(typeof(int), false),
false,
true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = objetId != null?objetId.Id:-1;
}
else if (CObjetDonnee.TypeManageIdUniversel(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet("Universal id",
"IdUniversel",
new CTypeResultatExpression(typeof(string), false),
false, true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = resParent.DataType != null ? resParent.DataType.IdUniversel : null;
}
else
{
resObjet.EmpileErreur(I.T("Can not search objet of type @1|20094",
DynamicClassAttribute.GetNomConvivial(mapParent.Propriete.TypeDonnee.TypeDotNetNatif)));
return(resObjet);
}
blFiltre.Append(defId.NomPropriete);
if (resParent.DataType == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = defId;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = defId;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(valeurTest);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(valeurTest.ToString());
blFiltre.Append(";");
}
}
}
if (blFiltre.Length == 0)//Pas de filtre
{
return(resObjet);
}
strFiltre = blFiltre.ToString();
CObjetDonnee objet = contexteImport.GetEntiteForFiltre(TypeEntite, strFiltre);
if (objet != null)
{
resObjet.DataType = objet;
return(resObjet);
}
CFiltreDynamique filtre = new CFiltreDynamique(contexteImport.ContexteDonnee);
filtre.TypeElements = TypeEntite;
filtre.ComposantPrincipal = compoPrincipal;
res = filtre.GetFiltreData();
if (res && res.Data is CFiltreDataAvance)
{
if (valeursFixes != null)
{
CFiltreDataAvance filtreData = res.Data as CFiltreDataAvance;
StringBuilder blAdd = new StringBuilder();
int nParam = filtreData.Parametres.Count + 1;
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
if (kv.Value == null)
{
blAdd.Append("HasNo(");
blAdd.Append(kv.Key);
blAdd.Append(") and ");
}
else
{
blAdd.Append(kv.Key);
blAdd.Append("=@");
blAdd.Append((nParam++));
blAdd.Append(" and ");
filtreData.Parametres.Add(kv.Value);
}
}
blAdd.Remove(blAdd.Length - 5, 5);
if (filtreData.Filtre.Length > 0)
{
blAdd.Insert(0, " and ");
}
filtreData.Filtre += blAdd;
}
objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
if (objet.ReadIfExists(((CFiltreData)res.Data)))
{
contexteImport.SetEntiteForFiltre(strFiltre, objet);
resObjet.DataType = objet;
return(resObjet);
}
}
else
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
return(resObjet);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Si la session qui execute est une session de l'utilisateur associé à la branche,
//Tente d'afficher le EditerElement sur cette session,
//Sinon, enregistre une Intervention sur l'utilisateur
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceVisualisationListeObjetsDonnee);
if (service != null)
{
sponsor.Register(service);
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
string strContexte = "";
string strTitre = "";
if (ExpressionContexteFenetre != null)
{
result = ExpressionContexteFenetre.Eval(ctxEval);
if (!result)
{
return(result);
}
if (result.Data != null)
{
strContexte = result.Data.ToString();
}
}
if (ExpressionTitreFenetre != null)
{
result = ExpressionTitreFenetre.Eval(ctxEval);
if (!result)
{
return(result);
}
if (result.Data != null)
{
strTitre = result.Data.ToString();
}
}
if (Filtre.TypeElements == null)
{
result.EmpileErreur(I.T("The object type is not defined|418"));
return(result);
}
CFiltreData filtre = null;
if (m_filtreDynamique != null)
{
m_filtreDynamique.ContexteDonnee = contexte.ContexteDonnee;
m_filtreDynamique.ElementAVariablesExterne = Process;
result = m_filtreDynamique.GetFiltreData();
if (!result)
{
result.EmpileErreur(I.T("Error while calculating the filter|419"));
return(result);
}
filtre = (CFiltreData)result.Data;
}
CParametreServiceVisuListeObjets parametre = new CParametreServiceVisuListeObjets(
Filtre.TypeElements,
filtre,
m_bAppliquerFiltreParDefaut,
strTitre,
strContexte);
if (result)
{
result = service.RunService(parametre);
}
//Fin du process
result.Data = null;
if (result)
{
foreach (CLienAction lien in this.GetLiensSortantHorsErreur())
{
if (!(lien is CLienUtilisateurAbsent))
{
result.Data = lien;
}
}
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
