//-----------------------------------------------------------------
public override void OnMouseUpNonStandard(object sender, MouseEventArgs e)
{
if (ModeSourisCustom == EModeSourisCustom.Join && e.Button == MouseButtons.Left)
{
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
CODEQBase table = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (table != null && table != m_table1Join)
{
IColumnDeEasyQuery colEndJoin = table.GetColonneAt(ptLogique);
if (colEndJoin != null)
{
CODEQJointure jointure = new CODEQJointure();
jointure.Parent = ObjetEdite;
jointure.ElementsSource = new IObjetDeEasyQuery[] { m_table1Join, table };
jointure.NomFinal = m_table1Join.NomFinal + "-" + table.NomFinal;
if (jointure.AddParametre(m_colStartJoin, colEndJoin))
{
Rectangle rct = Rectangle.Union(m_table1Join.RectangleAbsolu, table.RectangleAbsolu);
rct.Offset(rct.Width / 2 - jointure.Size.Width / 2, rct.Height / 2 - jointure.Size.Height / 2);
jointure.Position = new Point(rct.Left, rct.Top);
ObjetEdite.AddChild(jointure);
ModeSouris = EModeSouris.Selection;
}
}
}
m_colStartJoin = null;
m_table1Join = null;
Refresh();
}
}
//---------------------------------------------------
public bool AddParametre(IColumnDeEasyQuery colFromTable1, IColumnDeEasyQuery colFromTable2)
{
if (Table1 == null || Table2 == null)
{
return(false);
}
CDefinitionProprieteDynamique def1 = null;
CDefinitionProprieteDynamique def2 = null;
foreach (CDefinitionProprieteDynamique def in Table1.GetDefinitionsChamps(Table1.GetType()))
{
if (def.NomProprieteSansCleTypeChamp == colFromTable1.ColumnName)
{
def1 = def;
break;
}
}
foreach (CDefinitionProprieteDynamique def in Table2.GetDefinitionsChamps(Table2.GetType()))
{
if (def.NomProprieteSansCleTypeChamp == colFromTable2.ColumnName)
{
def2 = def;
break;
}
}
if (def1 != null && def2 != null)
{
CParametreJointure parametre = new CParametreJointure(
new C2iExpressionChamp(def1),
new C2iExpressionChamp(def2));
m_listeParametresJointure.Add(parametre);
return(true);
}
return(false);
}
public void InitFromColonneSource(IColumnDeEasyQuery colonne, CODEQBase objetDeQuery)
{
m_colonneSource = colonne;
CEasyQuery query = objetDeQuery.Query;
if (query != null)
{
//cherche la source
ITableDefinition tableDef = null;
IColumnDefinition colDef = null;
IsReadOnly = true;
Description = "";
if (query.FindSource(colonne, objetDeQuery, out tableDef, out colDef))
{
CColumnDefinitionSNMP colSnmp = colDef as CColumnDefinitionSNMP;
if (colSnmp != null)
{
if (tableDef is CTableDefinitionSNMP ||
tableDef is CTableDefinitionSnmpOfScalar)
{
Description = colSnmp.Description;
IsReadOnly = colSnmp.IsReadOnly;
}
}
}
}
}
//-----------------------------------------
public CColumnEQFromSource(IColumnDeEasyQuery colSource)
{
m_strIdColonne = Guid.NewGuid().ToString();
m_strNomColonne = colSource.ColumnName;
m_strIdColonneSource = colSource.Id;
m_typeDonnee = colSource.DataType;
}
//---------------------------------------------------------------
private void FillListeColonnes()
{
if (m_tableFromDataHotel.TableDefinition != null)
{
foreach (IColumnDefinition col in m_tableFromDataHotel.TableDefinition.Columns)
{
ListViewItem item = new ListViewItem(col.ColumnName);
IColumnDeEasyQuery colFromDataHotel = m_tableFromDataHotel.GetColonneFor(col);
if (colFromDataHotel != null)
{
item.Text = colFromDataHotel.ColumnName;
item.Checked = true;
}
item.SubItems.Add(col.ColumnName);
item.Tag = col;
m_wndListeColonnes.Items.Add(item);
}
}
foreach (IColumnDeEasyQuery col in m_tableFromDataHotel.Columns)
{
if (col is CColonneCalculeeDataHotel)
{
ListViewItem item = new ListViewItem(col.ColumnName);
FillItemCalcul(item, (CColonneCalculeeDataHotel)col);
m_wndListeColonnes.Items.Add(item);
}
}
}
//-------------------------------------------------------
public Rectangle GetRectAbsoluColonne(IColumnDeEasyQuery col)
{
Rectangle rct = new Rectangle(0, 0, 0, 0);
m_dicColonneToRect.TryGetValue(col, out rct);
return(rct);
}
//---------------------------------------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20004"));
return;
}
m_tableFromDataHotel.NomFinal = m_txtNomTable.Text;
m_tableFromDataHotel.UseCache = m_chkUseCache.Checked;
List <IColumnDeEasyQuery> lst = new List <IColumnDeEasyQuery>();
foreach (ListViewItem item in m_wndListeColonnes.Items)
{
if (item.Checked)
{
IColumnDefinition colFromSource = item.Tag as IColumnDefinition;
if (colFromSource != null)
{
IColumnDeEasyQuery newCol = m_tableFromDataHotel.GetColonneFor(colFromSource);
if (newCol == null)
{
newCol = new CColumnEQFromSource(colFromSource);
}
newCol.ColumnName = item.Text;
lst.Add(newCol);
}
CColonneCalculeeDataHotel colCalc = item.Tag as CColonneCalculeeDataHotel;
if (colCalc != null)
{
colCalc.ColumnName = item.Text;
lst.Add(colCalc);
}
}
}
m_tableFromDataHotel.SetColonnesOrCalculees(lst);
List <CColonneEQCalculee> colsCalc = new List <CColonneEQCalculee>();
foreach (CColonneEQCalculee col in m_ctrlFormulesNommees.GetFormules())
{
colsCalc.Add(col);
}
m_tableFromDataHotel.ColonnesCalculees = colsCalc;
CResultAErreur result = m_panelOptions.MajChamps(m_tableFromDataHotel);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
Close();
}
//-------------------------------------------------------
public IColumnDefinition GetColumnDefinitionFor(IColumnDeEasyQuery colonne)
{
CColumnEQFromSource colFromSource = colonne as CColumnEQFromSource;
if (m_definitionTable != null && colFromSource != null)
{
return(m_definitionTable.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource));
}
return(null);
}
//-----------------------------------------
public CResultAErreur OnRemplaceColSource(IColumnDeEasyQuery oldCol, IColumnDeEasyQuery newCol)
{
CResultAErreur result = CResultAErreur.True;
if (oldCol.Id == IdColumnSource)
{
m_strIdColonneSource = newCol.Id;
m_typeDonnee = oldCol.DataType;
}
return(result);
}
//--------------------------------------------------------------
public void Init(
CEasyQuery query,
IObjetDeEasyQuery table,
CDHFiltreValeur comparaison)
{
m_query = query;
m_table = table;
if (comparaison == null)
{
comparaison = new CDHFiltreValeur();
}
m_comparaison = comparaison;
List <COperateurComparaisonMassStorage> ops = new List <COperateurComparaisonMassStorage>();
foreach (EOperateurComparaisonMassStorage op in COperateurComparaisonMassStorage.ValeursEnumPossibles)
{
ops.Add(new COperateurComparaisonMassStorage(op));
}
m_comboOperateur.ListDonnees = ops;
m_comboOperateur.ProprieteAffichee = "Libelle";
m_comboOperateur.SelectedValue = new COperateurComparaisonMassStorage(comparaison.Operateur);
IColumnDeEasyQuery colSel = null;
List <CColumnEQFromSource> cols = new List <CColumnEQFromSource>();
foreach (IColumnDeEasyQuery col in m_table.Columns)
{
CColumnEQFromSource cs = col as CColumnEQFromSource;
if (cs != null && col.DataType == typeof(double))
{
cols.Add(cs);
if (cs.IdColumnSource == m_comparaison.ColumnHotelId)
{
colSel = col;
}
}
}
m_comboChamp.ListDonnees = cols;
m_comboChamp.ProprieteAffichee = "ColumnName";
m_comboChamp.SelectedValue = colSel;
m_txtFormuleValeur.Init(
new CFournisseurGeneriqueProprietesDynamiques(),
new CObjetPourSousProprietes(m_query));
m_txtFormuleValeur.Formule = comparaison.FormuleValeur;
m_txtFormuleCondition.Init(
new CFournisseurGeneriqueProprietesDynamiques(),
new CObjetPourSousProprietes(m_query));
m_txtFormuleCondition.Formule = comparaison.FormuleApplication;
}
//-----------------------------------------------------------------
public override void OnMouseMoveNonStandard(object sender, MouseEventArgs e)
{
if (ModeSourisCustom == EModeSourisCustom.Join && m_colStartJoin != null && e.Button == MouseButtons.Left)
{
Graphics g = CreateGraphics();
Point ptCentre = new Point(m_rectColStartJoin.Left + m_rectColStartJoin.Width / 2,
m_rectColStartJoin.Top + m_rectColStartJoin.Height / 2);
Rectangle rct = m_rectJoin;
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
IColumnDeEasyQuery colDest = null;
CODEQBase dest = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (dest == m_table1Join)
{
dest = null;
}
colDest = dest != null?dest.GetColonneAt(ptLogique) : null;
Rectangle rctDest = new Rectangle(e.X, e.Y, 1, 1);
if (colDest != null)
{
rctDest = dest.GetRectAbsoluColonne(colDest);
rctDest = new Rectangle(GetDisplayPointFromLogical(rctDest.Location),
GetDisplaySizeFromLogical(rctDest.Size));
}
rct.Inflate(2, 2);
using (Bitmap bmp = DernierApercuToDispose)
g.DrawImage(bmp, rct, rct, GraphicsUnit.Pixel);
Pen pen = new Pen(Color.Blue);
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
Brush br = new SolidBrush(Color.FromArgb(128, 0, 0, 255));
g.FillRectangle(br, m_rectColStartJoin);
if (colDest != null)
{
g.FillRectangle(br, rctDest);
}
br.Dispose();
g.DrawLine(pen, ptCentre, new Point(e.X, e.Y));
pen.Dispose();
g.Dispose();
m_rectJoin = Rectangle.Union(m_rectColStartJoin, rctDest);
}
}
private void FillListeColonnes()
{
if (m_tableFromBase.TableDefinition != null)
{
foreach (IColumnDefinition col in m_tableFromBase.TableDefinition.Columns)
{
ListViewItem item = new ListViewItem(col.ColumnName);
IColumnDeEasyQuery colFromBase = m_tableFromBase.GetColonneFor(col);
if (colFromBase != null)
{
item.Text = colFromBase.ColumnName;
item.Checked = true;
}
item.SubItems.Add(col.ColumnName);
item.Tag = col;
m_wndListeColonnes.Items.Add(item);
}
}
}
public override void OnMouseDownNonStandard(object sender, MouseEventArgs e)
{
m_colStartJoin = null;
if (ModeSourisCustom == EModeSourisCustom.Join && e.Button == MouseButtons.Left)
{
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
m_table1Join = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (m_table1Join != null)
{
m_colStartJoin = m_table1Join.GetColonneAt(ptLogique);
if (m_colStartJoin != null)
{
Rectangle rctCol = m_table1Join.GetRectAbsoluColonne(m_colStartJoin);
rctCol = new Rectangle(GetDisplayPointFromLogical(rctCol.Location),
GetDisplaySizeFromLogical(rctCol.Size));
m_rectColStartJoin = rctCol;
m_rectJoin = m_rectColStartJoin;
}
}
}
}
//------------------------------------------------------
public IEnumerable <string> GetListeIdsEntites(CEasyQuery query)
{
HashSet <string> lst = new HashSet <string>();
if (query != null)
{
CODEQBase table = query.GetObjet(m_strIdTable) as CODEQBase;
IColumnDeEasyQuery colSel = null;
if (table != null)
{
foreach (IColumnDeEasyQuery col in table.Columns)
{
if (col.Id == m_strIdColonne)
{
colSel = col;
}
}
}
if (colSel != null)
{
CResultAErreur result = table.GetDatas(new CListeQuerySource(query.Sources));
if (result && result.Data is DataTable)
{
DataTable tableRes = result.Data as DataTable;
if (tableRes.Columns[colSel.ColumnName] != null)
{
foreach (DataRow row in tableRes.Rows)
{
object val = row[colSel.ColumnName];
if (val != DBNull.Value && val != null)
{
lst.Add(val.ToString());
}
}
}
}
}
}
return(lst);
}
//-------------------------------------------------------------
public bool FindSource(IColumnDeEasyQuery colonne,
IObjetDeEasyQuery objetContenantLaColonne,
out ITableDefinition tableSource,
out IColumnDefinition colSource)
{
CColumnEQFromSource colFromSource = colonne as CColumnEQFromSource;
tableSource = null;
colSource = null;
if (colFromSource == null)
{
return(false);
}
CODEQFromObjetsSource objASource = objetContenantLaColonne as CODEQFromObjetsSource;
if (objASource != null)
{
foreach (IObjetDeEasyQuery source in objASource.ElementsSource)
{
//Certaines tables n'ont pas leur propres colonnes (les filtres par exemple, mais contiennent directement
//les colonnes de leur source. Il faut donc également chercher dans les colonnes source qui
//ont l'id de la colonne.
IColumnDeEasyQuery colDeSource = source.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource || c.Id == colFromSource.Id);
if (colDeSource != null)
{
return(FindSource(colDeSource, source, out tableSource, out colSource));
}
}
}
CODEQTableFromBase objFromBase = objetContenantLaColonne as CODEQTableFromBase;
if (objFromBase != null)
{
tableSource = objFromBase.TableDefinition;
colSource = tableSource.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
return(colSource != null);
}
return(false);
}
//-------------------------------------------------------
public IColumnDeEasyQuery GetColumnParenteFor(IColumnDeEasyQuery colonne)
{
CColumnEQFromSource colFromSource = colonne as CColumnEQFromSource;
if (colFromSource == null)
{
return(null);
}
IColumnDeEasyQuery retour = null;
if (Table1 != null)
{
retour = Table1.Columns.FirstOrDefault(c => c is CColumnEQFromSource &&
((CColumnEQFromSource)c).Id == colFromSource.IdColumnSource);
}
if (retour == null)
{
retour = Table2.Columns.FirstOrDefault(c => c is CColumnEQFromSource &&
((CColumnEQFromSource)c).Id == colFromSource.IdColumnSource);
}
return(retour);
}
//-----------------------------------
private void FillListeColonnes(ListView wndListe, IObjetDeEasyQuery table)
{
wndListe.Items.Clear();
if (table == null)
{
return;
}
foreach (IColumnDeEasyQuery col in table.Columns)
{
ListViewItem item = new ListViewItem(col.ColumnName);
item.SubItems.Add(col.ColumnName);
IColumnDeEasyQuery colFinale = m_objetJointure.GetColonneFinaleFor(col);
if (colFinale != null)
{
item.Text = colFinale.ColumnName;
item.Checked = true;
colFinale.DataType = col.DataType;
}
item.Tag = col;
wndListe.Items.Add(item);
}
}
//-------------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CEasyQuery query = Query;
CResultAErreur result = CResultAErreur.True;
if (result && TableDefinition == null)
{
result.EmpileErreur(I.T("Table object must be specified |20001"));
}
if (query == null || sources == null)
{
result.EmpileErreur(I.T("Query needs a source to provide datas|20000"));
}
CEasyQuerySource source = sources.GetSourceFromId(TableDefinition.SourceId);
if (source == null)
{
result.EmpileErreur(I.T("Query needs a source to provide datas|20000"));
}
if (result)
{
IEnumerable <string> lstCols = new List <string>();
if (m_definitionTable != null && m_listeColonnes != null && m_listeColonnes.Count() != m_definitionTable.Columns.Count())
{
lstCols = from c in m_listeColonnes where c is CColumnEQFromSource select((CColumnEQFromSource)c).IdColumnSource;
}
ITableDefinitionRequetableCAML tblCAML = TableDefinition as ITableDefinitionRequetableCAML;
if (tblCAML != null && m_CAMLQuery != null)
{
result = tblCAML.GetDatasWithCAML(source, Parent as CEasyQuery, m_CAMLQuery, lstCols.ToArray());
}
else
{
result = TableDefinition.GetDatas(source, lstCols.ToArray());
}
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
foreach (DataColumn col in new ArrayList(table.Columns))
{
IColumnDefinition def = TableDefinition.Columns.FirstOrDefault(c => c.ColumnName.ToUpper() == col.ColumnName.ToUpper());
IColumnDeEasyQuery laCol = null;
if (def == null || (laCol = GetColonneFor(def)) == null)
{
table.Columns.Remove(col);
}
else
{
col.ColumnName = laCol.ColumnName;
col.ExtendedProperties[CODEQBase.c_extPropColonneId] = laCol.Id;
}
}
if (tblCAML == null && m_CAMLQuery != null)
{
string strRowFilter = m_CAMLQuery.GetRowFilter(Parent as CEasyQuery);
if (strRowFilter.Length > 0)
{
HashSet <DataRow> rows = new HashSet <DataRow>();
foreach (DataRow row in table.Select(strRowFilter))
{
rows.Add(row);
}
foreach (DataRow row in new ArrayList(table.Rows))
{
if (!rows.Contains(row))
{
table.Rows.Remove(row);
}
}
table.AcceptChanges();
}
}
//Vérifie et corrige le type des colonnes
foreach (CColumnEQFromSource col in Columns)
{
DataColumn colDeTable = table.Columns[col.ColumnName];
if (colDeTable != null && col.DataType != colDeTable.DataType)
{
col.DataType = colDeTable.DataType;
}
}
}
}
if (!result)
{
result.EmpileErreur(I.T("Error on table @1|20002"));
}
return(result);
}
//-------------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CEasyQuery query = Query;
CResultAErreur result = CResultAErreur.True;
if (query == null || sources == null)
{
result.EmpileErreur(I.T("Table @1 needs a source to provide datas|20001", NomFinal));
return(result);
}
CEasyQuerySource source = sources.GetSourceFromId(TableDefinition.SourceId);
CDataHotelConnexion hotelConnexion = source != null ? source.Connexion as CDataHotelConnexion : null;
if (hotelConnexion == null)
{
result.EmpileErreur(I.T("No connection for table @1|20006", NomFinal));
return(result);
}
CTableDefinitionDataHotel tableHotel = m_definitionTable as CTableDefinitionDataHotel;
if (tableHotel == null)
{
result.EmpileErreur(I.T("Table @1 can not be calculated. A DataHotel table should be used as source|20002", NomFinal));
return(result);
}
DateTime?dateDebut = null;
DateTime?dateFin = null;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Query);
if (m_formuleDateDebut != null)
{
result = m_formuleDateDebut.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error on start date formula in table @1|20003", NomFinal));
}
else
{
dateDebut = result.Data as DateTime?;
}
}
if (m_formuleDateFin != null)
{
result = m_formuleDateFin.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error on end date formula in table @1|20004", NomFinal));
}
else
{
dateFin = result.Data as DateTime?;
}
}
if (dateDebut == null || dateFin == null)
{
result.EmpileErreur(I.T("Both start date and end date must be set for table @1|20005", NomFinal));
}
if (!result)
{
return(result);
}
List <string> lstIdsEntites = new List <string>();
if (SourceEntites != null)
{
lstIdsEntites.AddRange(SourceEntites.GetListeIdsEntites(Query));
}
ITestDataHotel test = null;
//Calcule le filtre
if (m_filtre != null)
{
test = m_filtre.GetTestFinal(Query);
}
CDataHotelQuery hotelQuery = new CDataHotelQuery();
hotelQuery.TableId = tableHotel.Id;
hotelQuery.DateDebut = dateDebut.Value;
hotelQuery.DateFin = dateFin.Value;
hotelQuery.EntitiesId.AddRange(lstIdsEntites);
hotelQuery.Filtre = test;
List <string> lstIdsColonnes = new List <string>();
List <IChampHotelCalcule> lstCalcs = new List <IChampHotelCalcule>();
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnEQFromSource colFromSource = col as CColumnEQFromSource;
if (colFromSource != null)
{
lstIdsColonnes.Add(colFromSource.IdColumnSource);
}
CColonneCalculeeDataHotel colCalc = col as CColonneCalculeeDataHotel;
if (colCalc != null)
{
if (colCalc.Calcul != null)
{
IChampHotelCalcule champHotelCalc = colCalc.Calcul.GetChampHotel(Query);
if (champHotelCalc != null)
{
champHotelCalc.NomChampFinal = colCalc.ColumnName;
lstCalcs.Add(champHotelCalc);
}
}
}
}
hotelQuery.ChampsId = lstIdsColonnes;
hotelQuery.ChampsCalcules = lstCalcs;
DataTable tableResult = hotelConnexion.GetData(tableHotel, hotelQuery);
if (tableResult != null)
{
Dictionary <string, IColumnDeEasyQuery> colNameSourceToDestCol = new Dictionary <string, IColumnDeEasyQuery>();
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnEQFromSource cs = col as CColumnEQFromSource;
if (cs != null)
{
IColumnDefinition def = tableHotel.GetColumn(cs.IdColumnSource);
if (def != null)
{
colNameSourceToDestCol[def.ColumnName] = col;
}
}
}
foreach (DataColumn col in tableResult.Columns)
{
IColumnDeEasyQuery colThis = null;
if (colNameSourceToDestCol.TryGetValue(col.ColumnName, out colThis))
{
col.ColumnName = colThis.ColumnName;
}
}
}
result.Data = tableResult;
return(result);
}
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20004"));
return;
}
m_tableFromBase.NomFinal = m_txtNomTable.Text;
m_tableFromBase.UseCache = m_chkUseCache.Checked;
List <IColumnDeEasyQuery> lst = new List <IColumnDeEasyQuery>();
foreach (ListViewItem item in m_wndListeColonnes.Items)
{
if (item.Checked)
{
IColumnDefinition colFromSource = item.Tag as IColumnDefinition;
IColumnDeEasyQuery newCol = m_tableFromBase.GetColonneFor(colFromSource);
if (newCol == null)
{
newCol = new CColumnEQFromSource(colFromSource);
}
newCol.ColumnName = item.Text;
lst.Add(newCol);
}
}
m_tableFromBase.SetColonnesOrCalculees(lst);
List <CColonneEQCalculee> colsCalc = new List <CColonneEQCalculee>();
foreach (CColonneEQCalculee col in m_ctrlFormulesNommees.GetFormules())
{
colsCalc.Add(col);
}
m_tableFromBase.ColonnesCalculees = colsCalc;
CResultAErreur result = CResultAErreur.True;
if (m_controleOptions != null)
{
result = m_controleOptions.MajChamps();
}
CResultAErreurType <CCAMLQuery> resCAML = m_panelCAML.MajChamps();
if (!resCAML)
{
result.EmpileErreur(resCAML.Erreur);
}
else
{
m_tableFromBase.CAMLQuery = resCAML.DataType;
}
if (result)
{
result = m_panelPostFilter.MajChamps();
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
Close();
}
//-------------------------------------------------------
/// <summary>
/// Retourne la colonne finale associé à une colonne de la base
/// </summary>
/// <param name="colonne"></param>
/// <returns></returns>
public IColumnDeEasyQuery GetColonneFinaleFor(IColumnDeEasyQuery colonne)
{
return(ColonnesFromSource.FirstOrDefault(c => c.IdColumnSource == colonne.Id));
}
//-----------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20004"));
return;
}
CResultAErreur result = CResultAErreur.True;
if (m_txtEditeFormule.Formule == null)
{
result = m_txtEditeFormule.ResultAnalyse;
if (result == null)
{
result = CResultAErreur.True;
}
result.EmpileErreur(I.T("Error in the formula|20011"));
CFormAfficheErreur.Show(result.Erreur);
return;
}
m_tableFiltre.NomFinal = m_txtNomTable.Text;
m_tableFiltre.UseCache = m_chkUseCache.Checked;
m_tableFiltre.Formule = m_txtEditeFormule.Formule;
m_tableFiltre.InclureToutesLesColonnesSource = m_chkInclureTout.Checked;
if (!m_tableFiltre.InclureToutesLesColonnesSource)
{
List <CColumnEQFromSource> lstColonnes = new List <CColumnEQFromSource>();
foreach (ListViewItem item in m_wndListeColonnesFromSource.Items)
{
if (item.Checked)
{
IColumnDeEasyQuery col = item.Tag as IColumnDeEasyQuery;
if (col != null)
{
bool bColExiste = false;
foreach (IColumnDeEasyQuery colEx in m_tableFiltre.ColonnesFromSource)
{
CColumnEQFromSource colExSrc = colEx as CColumnEQFromSource;
if (colExSrc != null && colExSrc.IdColumnSource == col.Id)
{
colEx.ColumnName = item.Text;
lstColonnes.Add(colExSrc);
bColExiste = true;
break;
}
}
if (!bColExiste)
{
CColumnEQFromSource newCol = new CColumnEQFromSource(col);
newCol.ColumnName = item.Text;
lstColonnes.Add(newCol);
}
}
}
}
m_tableFiltre.ColonnesFromSource = lstColonnes.AsReadOnly();
}
else
{
m_tableFiltre.ColonnesFromSource = null;
}
result = m_panelPostFilter.MajChamps();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
List <CColonneEQCalculee> lst = new List <CColonneEQCalculee>();
foreach (CColonneEQCalculee col in m_ctrlFormulesNommees.GetFormules())
{
lst.Add(col);
}
m_tableFiltre.ColonnesCalculeesFromSource = lst;
DialogResult = DialogResult.OK;
Close();
}
//-----------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20004"));
return;
}
List <CParametreJointure> lstParametres = new List <CParametreJointure>();
ArrayList lst = new ArrayList(m_panelJointure.Controls);
lst.Reverse();
foreach (Control ctrl in lst)
{
CEditeurParametreJointure editeur = ctrl as CEditeurParametreJointure;
if (editeur != null)
{
CResultAErreur result = editeur.MajChamps();
if (!result)
{
editeur.BackColor = Color.Red;
CFormAfficheErreur.Show(result.Erreur);
return;
}
editeur.BackColor = BackColor;
lstParametres.Add(editeur.Parametre);
}
}
List <IColumnDeEasyQuery> lstColonnes = new List <IColumnDeEasyQuery>();
foreach (ListViewItem item in m_wndListeColonnes1.Items)
{
if (item.Checked)
{
IColumnDeEasyQuery col = item.Tag as IColumnDeEasyQuery;
if (col != null)
{
bool bColExiste = false;
foreach (IColumnDeEasyQuery colEx in m_objetJointure.ColonnesSource)
{
CColumnEQFromSource colExSrc = colEx as CColumnEQFromSource;
if (colExSrc != null && colExSrc.IdColumnSource == col.Id)
{
colEx.ColumnName = item.Text;
lstColonnes.Add(colEx);
bColExiste = true;
break;
}
}
if (!bColExiste)
{
IColumnDeEasyQuery newCol = new CColumnEQFromSource(col);
newCol.ColumnName = item.Text;
lstColonnes.Add(newCol);
}
}
}
}
foreach (ListViewItem item in m_wndListeColonnes2.Items)
{
if (item.Checked)
{
IColumnDeEasyQuery col = item.Tag as IColumnDeEasyQuery;
if (col != null)
{
bool bColExiste = false;
foreach (IColumnDeEasyQuery colEx in m_objetJointure.ColonnesSource)
{
CColumnEQFromSource colExSrc = colEx as CColumnEQFromSource;
if (colExSrc != null && colExSrc.IdColumnSource == col.Id)
{
colEx.ColumnName = item.Text;
lstColonnes.Add(colEx);
bColExiste = true;
break;
}
}
if (!bColExiste)
{
IColumnDeEasyQuery newCol = new CColumnEQFromSource(col);
newCol.ColumnName = item.Text;
lstColonnes.Add(newCol);
}
}
}
}
m_objetJointure.UseCache = m_chkUseCache.Checked;
m_objetJointure.ModeJointure = (CODEQJointure.EModeJointure)m_cmbTypeJointure.SelectedIndex;
m_objetJointure.ColonnesSource = lstColonnes;
m_objetJointure.ParametresJointure = lstParametres;
m_objetJointure.NomFinal = m_txtNomTable.Text;
DialogResult = DialogResult.OK;
Close();
}
//---------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
DateTime dtChrono = DateTime.Now;
CResultAErreur result = CResultAErreur.True;
if (Table1 == null)
{
result.EmpileErreur(I.T("No source @1|20006", "1"));
return(result);
}
if (Table2 == null)
{
result.EmpileErreur(I.T("No source @2|20006", "2"));
return(result);
}
result = Table1.GetDatas(sources);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error in table @1 datas|20007", Table1.NomFinal));
return(result);
}
DataTable t1 = result.Data as DataTable;
result = Table2.GetDatas(sources);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error in table @1 datas|20007", Table2.NomFinal));
return(result);
}
DataTable t2 = result.Data as DataTable;
//Trouve toutes les lignes des la table 2 correspondant à la table 1
List <CMapRows> maps1To2 = new List <CMapRows>();
if (ParametresJointure.Count() == 0)
{
}
else
{
CParametreJointure param0 = m_listeParametresJointure[0];
Dictionary <object, List <DataRow> > dicValeursToRow1 = null;
//Première passe : on évalue toutes les expression sur tous les enregistrement de t1 et t2
List <DataRow> lst1 = new List <DataRow>();
foreach (DataRow row in t1.Rows)
{
lst1.Add(row);
}
result = CParametreJointure.GetDicValeurs(lst1, param0.FormuleTable1, ref dicValeursToRow1);
if (!result)
{
return(result);
}
Dictionary <object, List <DataRow> > dicValeursToRow2 = null;
List <DataRow> lst2 = new List <DataRow>();
foreach (DataRow row in t2.Rows)
{
lst2.Add(row);
}
result = CParametreJointure.GetDicValeurs(lst2, param0.FormuleTable2, ref dicValeursToRow2);
maps1To2 = GetMatches(dicValeursToRow1, dicValeursToRow2, param0.Operateur);
//Passe suivantes : on évalue pour chaque paire ce ceux qui matchent
for (int n = 1; n < m_listeParametresJointure.Count; n++)
{
CParametreJointure parametre = m_listeParametresJointure[n];
List <CMapRows> lstMaps = new List <CMapRows>();
foreach (CMapRows maps in maps1To2)
{
dicValeursToRow1 = null;
result = CParametreJointure.GetDicValeurs(maps.Rows1, parametre.FormuleTable1, ref dicValeursToRow1);
if (!result)
{
return(result);
}
dicValeursToRow2 = null;
result = CParametreJointure.GetDicValeurs(maps.Rows2, parametre.FormuleTable2, ref dicValeursToRow2);
lstMaps.AddRange(GetMatches(dicValeursToRow1, dicValeursToRow2, parametre.Operateur));
}
maps1To2 = lstMaps;
}
DataTable tableResult = new DataTable(NomFinal);
Dictionary <IColumnDeEasyQuery, IColumnDeEasyQuery> colsFromTable1 = new Dictionary <IColumnDeEasyQuery, IColumnDeEasyQuery>();
Dictionary <IColumnDeEasyQuery, IColumnDeEasyQuery> colsFromTable2 = new Dictionary <IColumnDeEasyQuery, IColumnDeEasyQuery>();
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnEQFromSource colFromSource = col as CColumnEQFromSource;
if (colFromSource != null)
{
IColumnDeEasyQuery colSource = Table1.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
if (colSource != null)
{
colsFromTable1[col] = colSource;
IColumnDeEasyQuery colSource2 = Table2.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
if (colSource2 != null)
{
colsFromTable2[col] = colSource2;
}
}
else
{
colSource = Table2.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
if (colSource != null)
{
colsFromTable2[col] = colSource;
}
}
if (colSource != null && !tableResult.Columns.Contains(col.ColumnName))
{
Type tp = col.DataType;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn dtCol = new DataColumn(col.ColumnName, tp);
dtCol.ExtendedProperties[CODEQBase.c_extPropColonneId] = col.Id;
tableResult.Columns.Add(dtCol);
}
}
}
foreach (CMapRows map in maps1To2)
{
lst1 = map.Rows1;
if (lst1.Count == 0)
{
lst1.Add(null);
}
lst2 = map.Rows2;
if (lst2.Count == 0)
{
lst2.Add(null);
}
foreach (DataRow row1 in lst1)
{
foreach (DataRow row2 in lst2)
{
if (row1 != null || row2 != null)
{
DataRow row = tableResult.NewRow();
if (row1 != null)
{
foreach (KeyValuePair <IColumnDeEasyQuery, IColumnDeEasyQuery> kv in colsFromTable1)
{
try
{
row[kv.Key.ColumnName] = row1[kv.Value.ColumnName];
}
catch { }
}
}
if (row2 != null)
{
foreach (KeyValuePair <IColumnDeEasyQuery, IColumnDeEasyQuery> kv in colsFromTable2)
{
try
{
row[kv.Key.ColumnName] = row2[kv.Value.ColumnName];
}
catch
{
}
}
}
tableResult.Rows.Add(row);
}
}
}
}
tableResult.AcceptChanges();
result.Data = tableResult;
}
TimeSpan sp = DateTime.Now - dtChrono;
Console.WriteLine("Join " + NomFinal + " : " + sp.TotalMilliseconds.ToString());
return(result);
}
//------------------------------------------------------------
public CResultAErreur OnRemplaceColSource(IColumnDeEasyQuery oldCol, IColumnDeEasyQuery newCol)
{
return(CResultAErreur.True);
}
//---------------------------------------------------
public virtual CResultAErreur SetSource(int nSource, IObjetDeEasyQuery nouvelleSource)
{
CResultAErreur result = CResultAErreur.True;
if (nouvelleSource == null || nSource > NbSourceRequired)
{
result.EmpileErreur(I.T("Invalid parameters to replace source|20019"));
return(result);
}
//On ne peut ajouter les sources que dans l'ordre
if (nSource > ElementsSource.Length)
{
result.EmpileErreur(I.T("You should add previous sources before this one|20021"));
return(result);
}
List <string> lstIds = new List <string>();
foreach (IObjetDeEasyQuery source in ElementsSource)
{
lstIds.Add(source.Id);
}
IObjetDeEasyQuery ancienneSource = ElementsSource.Length > nSource ? ElementsSource[nSource] : null;
if (nSource >= lstIds.Count())
{
lstIds.Add(nouvelleSource.Id);
}
else
{
lstIds[nSource] = nouvelleSource.Id;
}
if (ancienneSource != null)
{
//Vérifie que la nouvelle source est compatible
foreach (IColumnDeEasyQuery col in ancienneSource.Columns)
{
IColumnDeEasyQuery newCol = nouvelleSource.Columns.FirstOrDefault(c => c.ColumnName == col.ColumnName);
if (newCol == null)
{
result.EmpileErreur(I.T("The new source should contains the column @1|20018", col.ColumnName));
}
}
if (!result)
{
return(result);
}
for (int n = 0; n < m_lstObjetsSource.Count; n++)
{
if (m_lstObjetsSource[n] == ancienneSource.Id)
{
m_lstObjetsSource[n] = nouvelleSource.Id;
}
}
//Traite les CColumnEQFromSource
foreach (IColumnDeEasyQuery oldCol in ancienneSource.Columns)
{
IColumnDeEasyQuery newCol = nouvelleSource.Columns.FirstOrDefault(c => c.ColumnName == oldCol.ColumnName);
foreach (IColumnDeEasyQuery colDeThis in Columns)
{
result = colDeThis.OnRemplaceColSource(oldCol, newCol);
}
}
}
if (result)
{
m_lstObjetsSource = lstIds;
}
return(result);
}
//-------------------------------------------------------
/// <summary>
/// Retourne la colonne finale associé à une colonne de la base
/// </summary>
/// <param name="colonne"></param>
/// <returns></returns>
public IColumnDeEasyQuery GetColonneFinaleFor(IColumnDeEasyQuery colonne)
{
return(m_listeColonnes.FirstOrDefault(c => c is CColumnEQFromSource &&
((CColumnEQFromSource)c).IdColumnSource == colonne.Id));
}
//--------------------------------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20101"));
return;
}
m_tableFromFramework.FiltreDynamique = m_panelFiltre.FiltreDynamique;
m_tableFromFramework.ChampSource = m_champ;
m_tableFromFramework.NomFinal = m_txtNomTable.Text;
m_tableFromFramework.UseCache = m_chkUseCache.Checked;
List <IColumnDeEasyQuery> lst = new List <IColumnDeEasyQuery>();
foreach (ListViewItem item in m_wndListeColonnes.Items)
{
CColumnDeEasyQueryChampDeRequete col = item.Tag as CColumnDeEasyQueryChampDeRequete;
if (col != null)
{
lst.Add(col);
}
}
foreach (ListViewItem item in m_wndListeColonnesFromParent.Items)
{
if (item.Checked)
{
IColumnDeEasyQuery col = item.Tag as IColumnDeEasyQuery;
if (col != null)
{
bool bColExiste = false;
foreach (IColumnDeEasyQuery colEx in m_tableFromFramework.Columns)
{
CColumnEQFromSource colExSrc = colEx as CColumnEQFromSource;
if (colExSrc != null && colExSrc.IdColumnSource == col.Id)
{
colEx.ColumnName = item.Text;
lst.Add(colEx);
bColExiste = true;
break;
}
}
if (!bColExiste)
{
IColumnDeEasyQuery newCol = new CColumnEQFromSource(col);
newCol.ColumnName = item.Text;
lst.Add(newCol);
}
}
}
}
m_tableFromFramework.SetColonnesOrCalculees(lst);
List <CColonneEQCalculee> colsCalc = new List <CColonneEQCalculee>();
foreach (CColonneEQCalculee col in m_ctrlFormulesNommees.GetFormules())
{
colsCalc.Add(col);
}
m_tableFromFramework.ColonnesCalculees = colsCalc;
CResultAErreur result = CResultAErreur.True;
if (m_controleOptions != null)
{
result = m_controleOptions.MajChamps();
}
if (result)
{
result = m_panelPostFilter.MajChamps();
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
Close();
}
//--------------------------------------------------
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);
}
//-------------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CResultAErreur result = CResultAErreur.True;
if (sources == null)
{
result.EmpileErreur(I.T("Table @1 needs a source to provide datas|20001", NomFinal));
return(result);
}
CEasyQuerySource source = sources.GetSourceFromId(TableDefinition.SourceId);
CDataHotelConnexion hotelConnexion = source != null ? source.Connexion as CDataHotelConnexion : null;
if (hotelConnexion == null)
{
result.EmpileErreur(I.T("No connection for table @1|20006", NomFinal));
return(result);
}
CTableDefinitionEntitiesDataHotel tableHotel = m_definitionTable as CTableDefinitionEntitiesDataHotel;
if (tableHotel == null)
{
result.EmpileErreur(I.T("Table @1 can not be calculated. A DataHotel table should be used as source|20002", NomFinal));
return(result);
}
DateTime?dateDebut = null;
DateTime?dateFin = null;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Query);
if (m_formuleDateDebut != null)
{
result = m_formuleDateDebut.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error on start date formula in table @1|20003", NomFinal));
}
else
{
dateDebut = result.Data as DateTime?;
}
}
if (m_formuleDateFin != null)
{
result = m_formuleDateFin.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error on end date formula in table @1|20004", NomFinal));
}
else
{
dateFin = result.Data as DateTime?;
}
}
if (dateDebut == null || dateFin == null)
{
result.EmpileErreur(I.T("Both start date and end date must be set for table @1|20005", NomFinal));
}
if (!result)
{
return(result);
}
DataTable tableResult = hotelConnexion.GetData(tableHotel, dateDebut.Value, dateFin.Value);
if (tableResult != null)
{
Dictionary <string, IColumnDeEasyQuery> colNameSourceToDestCol = new Dictionary <string, IColumnDeEasyQuery>();
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnEQFromSource cs = col as CColumnEQFromSource;
if (cs != null)
{
IColumnDefinition def = tableHotel.GetColumn(cs.IdColumnSource);
if (def != null)
{
colNameSourceToDestCol[def.ColumnName] = col;
}
}
}
foreach (DataColumn col in tableResult.Columns)
{
IColumnDeEasyQuery colThis = null;
if (colNameSourceToDestCol.TryGetValue(col.ColumnName, out colThis))
{
col.ColumnName = colThis.ColumnName;
}
}
}
result.Data = tableResult;
return(result);
}
