public DataRow GetRowObjetPourDataVersionObject(DataRow row)
{
Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
return(null);
}
//Récupère l'objet associé
DataRowVersion rowVersion = DataRowVersion.Current;
if (row.RowState == DataRowState.Deleted)
{
if (row.HasVersion(DataRowVersion.Original))
{
rowVersion = DataRowVersion.Original;
}
else
{
return(null);
}
}
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { row });
rel.VersionToReturn = rowVersion;
try
{
IElementAChamps objet = rel.ElementAChamps;
return(((CObjetDonnee)objet).Row.Row);
}
catch
{
return(null);
}
}
//-------------------------------------------------------------------
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
{
CResultAErreur result = CResultAErreur.True;
DataTable table = contexte.Tables[GetNomTable()];
Type tpDonnees = CContexteDonnee.GetTypeForTable(GetNomTable());
ArrayList lst = new ArrayList(table.Rows);
foreach (DataRow row in lst)
{
//Interdit la création de doublons
if (row.RowState == DataRowState.Added)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, GetTypeObjets());
liste.Filtre = new CFiltreData(CActeur.c_champId + "=@1",
row[CActeur.c_champId]);
if (liste.CountNoLoad != 0)
{
//On supprime la ligne !!
row.Delete();
}
}
if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added)
{
CDonneesActeur objet = (CDonneesActeur)Activator.CreateInstance(tpDonnees, new object[] { row });
CResultAErreur resultVerif = VerifieDonnees(objet);
objet.IsDonneeActeurValide = VerifieDonnees(objet);
}
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public CFiltresDynamiquesForTables CalculeFiltresForTables()
{
CFiltresDynamiquesForTables filtres = new CFiltresDynamiquesForTables();
//Crée un filtre pour chaque les tables fullsnchro
foreach (string strNomTable in CContexteDonnee.MappeurTableToClass.GetListeTables())
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
{
CFiltreSynchronisation filtreTableFull = new CFiltreSynchronisation(strNomTable);
filtreTableFull.TouteLaTable = true;
filtreTableFull.IsAutoAdd = true;
filtreTableFull.CreateFiltreForAllParents();
filtreTableFull.CreateFiltreForAllCompositions();
filtreTableFull.FiltreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(tp);
filtres.AddFiltreSynchronisation(filtreTableFull);
}
}
foreach (CFiltreSynchronisation filtre in m_listefiltresSynchronisation)
{
filtre.CalculeFiltresForTables();
filtres.AddFiltreSynchronisation(filtre);
}
return(filtres);
}
////////////////////////////////////////////////////////////////////////
private void CreateFiltreForAllParents(Hashtable tableRelationsFaites)
{
CStructureTable structure = CStructureTable.GetStructure(CContexteDonnee.GetTypeForTable(NomTable));
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (tableRelationsFaites[relationParente.RelationKey] == null)
{
tableRelationsFaites[relationParente.RelationKey] = true;
CFiltreSynchronisation filtreFils = GetFilsForRelation(relationParente);
if (filtreFils == null)
{
filtreFils = new CFiltreSynchronisation(relationParente.TableParente);
filtreFils.m_bIsAutoAdd = true;
filtreFils.IsLienToFullTableParente = TouteLaTable;
AddFils(filtreFils, relationParente);
}
filtreFils.CreateFiltreForAllParents((Hashtable)tableRelationsFaites.Clone());
}
}
foreach (CFiltreSynchronisation filtreFils in m_listeFils)
{
if (tableRelationsFaites[filtreFils.RelationToParent.RelationKey] == null)
{
tableRelationsFaites[filtreFils.RelationToParent.RelationKey] = true;
if (filtreFils.NomTable == filtreFils.RelationToParent.TableFille)
{
filtreFils.CreateFiltreForAllParents((Hashtable)tableRelationsFaites.Clone());
}
}
}
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 2];
for (int nIndex = 2; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 2] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[1], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("SelectSql cannot be applied here|229"));
return(result);
}
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
CListeObjetsDonnees liste = new CListeObjetsDonnees(((CObjetDonnee)ctx.ObjetSource).ContexteDonnee,
CContexteDonnee.GetTypeForTable(filtre.TablePrincipale));
liste.Filtre = filtre;
result.Data = liste;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in SelectSql|228"));
}
return(result);
}
/// //////////////////////////////////////////
protected override void InitChamps()
{
m_wndListeTypes.BeginUpdate();
m_wndListeTypes.Items.Clear();
HashSet <Type> set = new HashSet <Type>();
foreach (Type tp in ActionNettoyageRelationsTypeId.TypesANettoyer)
{
set.Add(tp);
}
foreach (RelationTypeIdAttribute rel in CContexteDonnee.RelationsTypeIds)
{
string strNomTable = rel.TableFille;
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null)
{
ListViewItem item = new ListViewItem(DynamicClassAttribute.GetNomConvivial(tp));
item.Tag = tp;
item.Checked = set.Contains(tp);
m_wndListeTypes.Items.Add(item);
}
}
m_wndListeTypes.EndUpdate();
base.InitChamps();
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
if (!(objet is CObjetDonneeAIdNumerique))
{
return(lst);
}
foreach (RelationTypeIdAttribute rt in CContexteDonnee.RelationsTypeIds)
{
if (rt.IsAppliqueToType(objet.GetType()) && objet.GetType().GetCustomAttribute <NoRelationTypeIdAttribute>() == null)
{
Type tpRelId = CContexteDonnee.GetTypeForTable(rt.TableFille);
if (tpRelId != null && !manager.ConfigurationRecherche.IsIgnore(tpRelId))
{
CListeObjetsDonnees lstRT = new CListeObjetsDonnees(objet.ContexteDonnee, tpRelId);
lstRT.Filtre = new CFiltreData(rt.ChampType + "=@1 and " +
rt.ChampId + "=@2",
objet.GetType().ToString(),
((CObjetDonneeAIdNumerique)objet).Id);
foreach (CObjetDonnee objetRT in lstRT)
{
lst.Add(new CReferenceObjetDependant(rt.NomConvivialPourParent, objetRT));
}
}
}
}
return(lst);
}
//Journalise les données d'un élement
public CVersionDonneesObjet JournaliseDonnees(System.Data.DataRow row, CVersionDonnees version)
{
CVersionDonneesObjet versionObjet = null;
if (row.RowState != DataRowState.Added &&
row.RowState != DataRowState.Modified &&
row.RowState != DataRowState.Deleted)
{
return(null);
}
Type typeElement = CContexteDonnee.GetTypeForTable(row.Table.TableName);
versionObjet = version.GetVersionObjetAvecCreation(row);
if (versionObjet == null)
{
return(null);
}
if (row.HasVersion(DataRowVersion.Original))
{
CStructureTable structure = CStructureTable.GetStructure(typeElement);
foreach (CInfoChampTable info in structure.Champs)
{
if (info.m_bIsInDB)
{
new CJournaliseurChampDb().JournaliseDonneeInContexte(versionObjet, info.NomChamp, row);
}
}
}
return(versionObjet);
}
/////////////////////////////////////////////////////////////////////////////////////
public override int CountRecords(string strNomTableIndb, CFiltreData filtre)
{
filtre.SortOrder = "";
string strNomTableInContexte = GetNomTableInContexteFromNomTableInDb(strNomTableIndb);
Type tp = CContexteDonnee.GetTypeForTable(strNomTableInContexte);
string strRequete = "";
if (tp != null)
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure.ChampsId.Length == 1)
{
strRequete = "select count ( distinct " + strNomTableIndb + "." + structure.ChampsId[0].NomChamp + ") COMBIEN from " + strNomTableIndb;
}
}
if (strRequete == "")
{
strRequete = "select count (*) COMBIEN from " + strNomTableIndb;
}
IDataAdapter adapter = GetSimpleReadAdapter(strRequete, filtre);
DataSet ds = new DataSet();
FillAdapter(adapter, ds);
return(Convert.ToInt32(ds.Tables["Table"].Rows[0]["COMBIEN"]));
}
//----------------------------------------------------------
/// <summary>
/// Stock les anciens ids provisoire des éléments anciens
/// </summary>
/// <param name="table"></param>
/// <param name="tableParametres"></param>
/// <param name="result"></param>
public static void BeforeSaveExterneChampCustom(DataTable table, Hashtable tableParametres, ref CResultAErreur result)
{
if (!result)
{
return;
}
//stock la liste des ids nouveaux qu'il faut remapper après
CContexteDonnee contexte = (CContexteDonnee)table.DataSet;
Type tpObjetsSauves = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjetsSauves))
{
return;
}
Dictionary <DataRow, int> dicElementsNouveaux = new Dictionary <DataRow, int>();
if (table.PrimaryKey.Length > 0)
{
string strPrimKey = table.PrimaryKey[0].ColumnName;
foreach (DataRow row in table.Rows)
{
if (row.RowState == DataRowState.Added)
{
dicElementsNouveaux[row] = (int)row[strPrimKey];
}
}
tableParametres[typeof(CRelationElementAChamp_ChampCustomServeur).ToString()] = dicElementsNouveaux;
}
}
public Type GetTypeRetourne()
{
if (m_relation != null)
{
return(CContexteDonnee.GetTypeForTable(m_relation.TableFille));
}
return(null);
}
/// //////////////////////////////////////////////////////
private void InitBase()
{
m_strNomConvivial = m_relation.NomConvivialPourParent.Replace(" ", "_");
m_strNomPropriete = c_strCaractereStartCleType + CleType + c_strCaractereEndCleType + m_relation.IdRelation;
m_typeDonnee = new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(m_relation.TableFille), true);
m_bHasSubProprietes = true;
m_bIsReadOnly = true;
}
//----------------------------------------------------------------------------------
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 CListeObjetsDonneesContenus(
CObjetDonnee objetParent,
string strNomTableFille,
string strChampsFille,
bool bAppliquerFiltreParDefaut)
: base(objetParent.ContexteDonnee, CContexteDonnee.GetTypeForTable(strNomTableFille))
{
Init(objetParent, strNomTableFille, new String[] { strChampsFille }, bAppliquerFiltreParDefaut);
}
////////////////////////////////////////////////////////////
public CListeObjetsDonneesContenus(
CObjetDonnee objetParent,
string strNomTableFille,
string[] strChampsFille,
bool bAppliquerFiltreParDefaut,
bool bModeProgressif)
: base(objetParent.ContexteDonnee, CContexteDonnee.GetTypeForTable(strNomTableFille))
{
RemplissageProgressif = bModeProgressif;
Init(objetParent, strNomTableFille, strChampsFille, bAppliquerFiltreParDefaut);
}
public override bool ChampExists(string strTableName, string strChampName)
{
Type tp = CContexteDonnee.GetTypeForTable(strTableName);
if (tp == null)
{
return(true);
}
CStructureTable structure = CStructureTable.GetStructure(tp);
DataTable dt = GetDataTableForUpdateTable(structure);
return(dt.Columns.Contains(strChampName));
}
////////////////////////////////////////////////////////////////////////
public CFiltreDynamique GetFiltreDynamiqueForTable(string strNomTable, ref bool bShouldSynchroniseTable)
{
ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[strNomTable];
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
{
bShouldSynchroniseTable = true;
return(null);
}
if (lst == null || lst.Count == 0)
{
bShouldSynchroniseTable = false;
return(null);
}
bShouldSynchroniseTable = true;
CFiltreDynamique filtreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(strNomTable));
CComposantFiltreDynamiqueOu composantOu = new CComposantFiltreDynamiqueOu();
foreach (CFiltreSynchronisation filtreSynchro in lst)
{
if (filtreSynchro.TouteLaTable || filtreSynchro.FiltreDynamique == null)
{
return(null);
}
CFiltreDynamique filtreLocal = filtreSynchro.GetFiltreToElementPrincipal();
if (filtreLocal != null && filtreLocal.ComposantPrincipal != null)
{
composantOu.AddComposantFils(filtreLocal.ComposantPrincipal);
}
if (filtreLocal == null)
{
return(null);
}
}
if (composantOu.GetNbComposantsFils() == 0)
{
return(null);
}
if (composantOu.GetNbComposantsFils() == 1)
{
filtreDynamique.ComposantPrincipal = composantOu.ComposantsFils[0];
}
else
{
filtreDynamique.ComposantPrincipal = composantOu;
}
return(filtreDynamique);
}
//-------------------------------------------------------------------------
public static void CContexteDonnee_OnInvalideCacheRelation(DataRow row, DataRelation relation)
{
DataTable tableParente = relation.ParentTable;
if (tableParente != null && tableParente.Columns.Contains(c_champIdsChampsLus))
{
Type tp = CContexteDonnee.GetTypeForTable(relation.ChildTable.TableName);
if (tp != null && typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
//DataRow[] rows = tableParente.Select(c_champIdsChampsLus + " is not null");
//if (rows != null)
// foreach (DataRow row in rows)
CContexteDonnee.ChangeRowSansDetectionModification(row, c_champIdsChampsLus, DBNull.Value);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
public override int CountRecords(string strNomTableInDb, CFiltreData filtre)
{
filtre.SortOrder = "";
string strNomTableInContexte = GetNomTableInContexteFromNomTableInDb(strNomTableInDb);
Type tp = CContexteDonnee.GetTypeForTable(strNomTableInContexte);
string strRequete = "";
if (strRequete == "")
{
strRequete = "select count (*) as COMBIEN from " + GetNomTableForRequete(strNomTableInDb);
}
IDataAdapter adapter = GetSimpleReadAdapter(strRequete, filtre);
if (tp != null && adapter is IDbDataAdapter)
{
CStructureTable structure = CStructureTable.GetStructure(tp);
strRequete = ((IDbDataAdapter)adapter).SelectCommand.CommandText.Replace("distinct", "");
strRequete = "select count(*) as COMBIEN from (\n" +
strRequete + " group by \n";
foreach (CInfoChampTable info in structure.ChampsId)
{
strRequete += strNomTableInDb + "." + info.NomChamp + ",";
}
strRequete = strRequete.Substring(0, strRequete.Length - 1);
strRequete += ")";
((IDbDataAdapter)adapter).SelectCommand.CommandText = strRequete;
}
DataSet ds = new DataSet();
try
{
this.FillAdapter(adapter, ds);
}
catch (Exception e)
{
Console.WriteLine(I.T("Error in 'CountRecords' : @1|182", e.ToString()));
throw e;
}
finally
{
CUtilDataAdapter.DisposeAdapter(adapter);
}
return((int)ds.Tables["Table"].Rows[0]["COMBIEN"]);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 3];
for (int nIndex = 3; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 3] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[2], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("CalculSql cannot be applied here|204"));
return(result);
}
CObjetDonnee objet = (CObjetDonnee)ctx.ObjetSource;
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
Type tpInterroge = CContexteDonnee.GetTypeForTable(filtre.TablePrincipale);
result = Parametres2i[1].Eval(ctx);
if (!result)
{
return(result);
}
result = GetClauseSelect(result.Data.ToString(), tpInterroge);
IObjetServeur serveur = objet.ContexteDonnee.GetTableLoader(filtre.TablePrincipale);
result = serveur.ExecuteScalar((string)result.Data, filtre);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in calculSql|205"));
}
return(result);
}
//----------------------------------------------------------------
public static string GetIdTypeLimiteFromNomTable(string strTable)
{
string strIdType = null;
if (!m_dicNomTableToIdTypeLimite.TryGetValue(strTable, out strIdType))
{
Type tp = CContexteDonnee.GetTypeForTable(strTable);
if (tp != null)
{
object[] attribs = tp.GetCustomAttributes(typeof(LicenceCountAttribute), true);
if (attribs.Length > 0)
{
strIdType = ((LicenceCountAttribute)attribs[0]).CountTypeName;
}
m_dicNomTableToIdTypeLimite[strTable] = strIdType;
}
}
return(strIdType);
}
/////////////////////////////////////////////////////////////////////////////////////
public override int CountRecords(string strNomTableInDb, CFiltreData filtre)
{
filtre.SortOrder = "";
string strNomTableInContexte = GetNomTableInContexteFromNomTableInDb(strNomTableInDb);
Type tp = CContexteDonnee.GetTypeForTable(strNomTableInContexte);
string strRequete = "";
if (tp != null)
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure.ChampsId.Length == 1)
{
strRequete = "select count ( distinct " + strNomTableInDb + "." + structure.ChampsId[0].NomChamp + ") as COMBIEN from " + strNomTableInDb;
}
}
if (strRequete == "")
{
strRequete = "select count (*) as COMBIEN from " + strNomTableInDb;
}
IDataAdapter adapter = GetSimpleReadAdapter(strRequete, filtre);
DataSet ds = new DataSet();
try
{
/*SqlCommand cmd = ((SqlDataAdapter)adapter).SelectCommand;
* cmd.Connection = (SqlConnection)GetConnexion(true);
* cmd.Transaction = (SqlTransaction)Transaction;
* object val = ((SqlDataAdapter)adapter).SelectCommand.ExecuteScalar();*/
this.FillAdapter(adapter, ds);
}
catch (Exception e)
{
string strTmp = e.ToString();
return(0);
}
finally
{
CUtilDataAdapter.DisposeAdapter(adapter);
}
return((int)ds.Tables["Table"].Rows[0]["COMBIEN"]);
}
/// ////////////////////////////////////////////////
private void DisplayElement(DataRow row, DataGrid grid)
{
if (row == null)
{
grid.DataSource = null;
grid.Refresh();
return;
}
DataTable tablePresentation = new DataTable("Presentation");
tablePresentation.Columns.Add("NOM", typeof(string));
tablePresentation.Columns.Add("VALEUR", typeof(string));
Type tp = CContexteDonnee.GetTypeForTable(row.Table.TableName);
CStructureTable structure = CStructureTable.GetStructure(tp);
foreach (CInfoChampTable champ in structure.Champs)
{
DataRow rowPres = tablePresentation.NewRow();
rowPres["NOM"] = champ.NomConvivial;
object val = row[champ.NomChamp];
rowPres["VALEUR"] = val == null?"NULL":val.ToString();
tablePresentation.Rows.Add(rowPres);
}
grid.DataSource = tablePresentation;
DataGridTableStyle style = grid.TableStyles[tablePresentation.TableName];
if (style == null)
{
style = new DataGridTableStyle();
style.MappingName = tablePresentation.TableName;
DataGridColumnStyle col = new DataGridTextBoxColumn();
col.MappingName = "NOM";
col.Width = grid.Width / 3;
style.GridColumnStyles.Add(col);
col = new DataGridTextBoxColumn();
col.MappingName = "VALEUR";
col.Width = grid.Width * 2 / 3;
style.GridColumnStyles.Add(col);
grid.TableStyles.Add(style);
}
grid.Refresh();
}
public CFiltreDynamiqueParentTablePleine(string strTableConcernee, CInfoRelation relationToTableFille)
{
m_strNomTable = strTableConcernee;
m_relationToTableFille = relationToTableFille;
//Crée un filtre sur le parent pour qu'il ait un id > 0,
CComposantFiltreDynamiqueValeurChamp composant = new CComposantFiltreDynamiqueValeurChamp();
composant.IdOperateur = CComposantFiltreOperateur.c_IdOperateurSuperieurOuEgal;
composant.Champ = new CDefinitionProprieteDynamique(
relationToTableFille.ChampsParent[0],
relationToTableFille.ChampsParent[0],
new CTypeResultatExpression(typeof(int), false),
false,
true);
composant.ConditionApplication = new C2iExpressionVrai();
composant.ExpressionValeur = new C2iExpressionConstante(0);
ComposantPrincipal = composant;
TypeElements = CContexteDonnee.GetTypeForTable(strTableConcernee);
}
/// ////////////////////////////////////////////////////////////////
//Retourne le texte de la clause join à mettre dans SQL
public override string GetJoinClause(
string strAliasTableParente,
string strSuffixeParent,
string strAliasTableFille,
string strSuffixeFils)
{
//Identifie le type parent
Type tp = CContexteDonnee.GetTypeForTable(m_strTableParente);
if (!tp.IsSubclassOf(typeof(CObjetDonneeAIdNumerique)))
{
throw new Exception(I.T("Cumulated data link on a table which isn't managed by a numerical identifier|188"));
}
CStructureTable structure = CStructureTable.GetStructure(tp);
string strJoin = strAliasTableParente + "." + structure.ChampsId[0].NomChamp + strSuffixeParent + "=" +
strAliasTableFille + "." + CDonneeCumulee.c_baseChampCle + m_nNumeroCle.ToString() + strSuffixeFils + " and " +
strAliasTableFille + "." + CTypeDonneeCumulee.c_champId + strSuffixeFils + "=" +
m_nIdTypeDonneeCumulee.ToString();
return(strJoin);
}
//----------------------------------------------------------------------------
public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet)
{
List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>();
if (objet == null)
{
return(lst);
}
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
foreach (CInfoRelation relation in structure.RelationsParentes)
{
Type tpParent = CContexteDonnee.GetTypeForTable(relation.TableParente);
if (manager.ConfigurationRecherche.IsIgnore(tpParent))
{
return(lst);
}
CObjetDonnee parent = objet.GetParent(relation.ChampsFille, tpParent);
bool bHasUniversalId = tpParent.GetCustomAttribute <NoIdUniverselAttribute>(true) == null;
string strNomProp = relation.NomConvivial;
if (strNomProp.Length == 0)
{
strNomProp = DynamicClassAttribute.GetNomConvivial(tpParent);
}
if (parent != null)
{
if (bHasUniversalId)
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpParent, parent.DbKey));
}
else
{
lst.Add(new CReferenceObjetDependant(strNomProp, tpParent,
parent.GetValeursCles()));
}
}
}
return(lst);
}
//------------------------------------------------------------------------------------------------
public static CResultAErreur CreationOuUpdateTableFromType(Type tp, IDatabaseConnexion connexion, ArrayList strChampsAutorisesANull)
{
CResultAErreur result = CResultAErreur.True;
CStructureTable structure = CStructureTable.GetStructure(tp);
if (!result)
{
return(result);
}
//S'assure que toutes les tables parentes existent
foreach (CInfoRelation relation in structure.RelationsParentes)
{
if (relation.TableParente != structure.NomTable)
{
string strNomTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(relation.TableParente);
if (!CAccessTableCreatorOld.TableExists(strNomTableParenteInDb, connexion))
{
result = CreationOuUpdateTableFromType(CContexteDonnee.GetTypeForTable(relation.TableParente), connexion);
if (!result)
{
return(result);
}
}
}
}
if (CAccessTableCreatorOld.TableExists(structure.NomTableInDb, connexion))
{
result = CAccessTableCreatorOld.UpdateTable(structure, connexion, strChampsAutorisesANull);
}
else
{
result = CAccessTableCreatorOld.CreateTable(structure, connexion);
}
return(result);
}
//-------------------------------------------------------------------------
public void RepercuteModifsSurVersionFuture(
DataRow rowReference,
DataRow rowCopie,
Dictionary <int, Dictionary <CReferenceChampPourVersion, bool> > dicoDesChampsModifiesParId)
{
Type tp = CContexteDonnee.GetTypeForTable(rowReference.Table.TableName);
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp))
{
return;
}
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)Activator.CreateInstance(tp, new object[] { rowReference });
int nId = rel.ElementAChamps.Id;
Dictionary <CReferenceChampPourVersion, bool> dicoDesChampsModifies = null;
dicoDesChampsModifiesParId.TryGetValue(nId, out dicoDesChampsModifies);
if (dicoDesChampsModifies == null)
{
dicoDesChampsModifies = new Dictionary <CReferenceChampPourVersion, bool>();
}
CReferenceChampPourVersion refChamp = new CReferenceChampPourVersion(CChampCustomPourVersion.c_typeChamp, rel.Row[CChampCustom.c_champId].ToString());
if (!dicoDesChampsModifies.ContainsKey(refChamp))
{
string[] strChamps = new string[] {
CRelationElementAChamp_ChampCustom.c_champValeurBool,
CRelationElementAChamp_ChampCustom.c_champValeurDate,
CRelationElementAChamp_ChampCustom.c_champValeurDouble,
CRelationElementAChamp_ChampCustom.c_champValeurInt,
CRelationElementAChamp_ChampCustom.c_champValeurNull,
CRelationElementAChamp_ChampCustom.c_champValeurString
};
//Répercute la valeur
foreach (string strChamp in strChamps)
{
rowCopie[strChamp] = rowReference[strChamp];
}
}
}
/////////////////////////////////////////////
/// <summary>
/// Retourne tous les éléments liés par une relationTypeId
/// </summary>
/// <param name="strNomTableFille"></param>
/// <param name="strNomChampTypeSurTableFille"></param>
/// <param name="strNomChampIdSurTableFille"></param>
/// <returns></returns>
public CListeObjetsDonnees GetDependancesRelationTypeId(
string strNomTableFille,
string strNomChampTypeSurTableFille,
string strNomChampIdSurTableFille,
bool bProgressive,
bool bInterditLectureInDb)
{
string strColDep = RelationTypeIdAttribute.GetNomColDepLue(strNomTableFille);
DataColumn col = Table.Columns[strColDep];
if (col == null)
{
col = new DataColumn(strColDep, typeof(bool));
col.DefaultValue = false;
col.AllowDBNull = false;
Table.Columns.Add(col);
}
if ((bool)Row[strColDep] && !bProgressive)
{
bInterditLectureInDb = true;
}
Type typeFille = CContexteDonnee.GetTypeForTable(strNomTableFille);
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeFille, false);
liste.RemplissageProgressif = bProgressive;
liste.InterditLectureInDB = bInterditLectureInDb;
liste.PreserveChanges = true;
liste.Filtre = new CFiltreData(
strNomChampTypeSurTableFille + "=@1 and " +
strNomChampIdSurTableFille + "=@2",
GetType().ToString(),
Id);
if (!bProgressive)
{
CContexteDonnee.ChangeRowSansDetectionModification(Row, strColDep, true);
}
return(liste);
}
/// <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];
}
}
}
}
}