/// ///////////////////////////////////// //////////////////////////////////
public CContexteDonnee CreateStructureFromTypes(params Type[] lesTypes)
{
ArrayList lstStructures = new ArrayList();
foreach (Type tp in lesTypes)
{
CStructureTable structure = CStructureTable.GetStructure(tp);
lstStructures.Add(structure);
}
//Création des tables
foreach (CStructureTable structure in lstStructures)
{
DataTable table = new DataTable(structure.NomTable);
foreach (CInfoChampTable champ in structure.Champs)
{
DataColumn col = new DataColumn(champ.NomChamp);
col.DataType = champ.TypeDonnee;
if (champ.Longueur > 0)
{
col.MaxLength = champ.Longueur;
}
table.Columns.Add(col);
}
DataColumn[] cols = new DataColumn[structure.ChampsId.Length];
for (int nChamp = 0; nChamp < structure.ChampsId.Length; nChamp++)
{
cols[nChamp] = table.Columns[structure.ChampsId[nChamp].NomChamp];
}
table.PrimaryKey = cols;
m_contexte.Tables.Add(table);
}
//Les relations se créent toutes seules par le contexte de données
return(m_contexte);
}
//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 static string GetIdUniverselFromId(Type typeElement, int nId)
{
string strNomTable = CContexteDonnee.GetNomTableForType(typeElement);
CStructureTable structure = CStructureTable.GetStructure(typeElement);
C2iRequeteAvancee rq = new C2iRequeteAvancee();
rq.TableInterrogee = strNomTable;
rq.FiltreAAppliquer = new CFiltreData(
structure.ChampsId[0].NomChamp + "=@1", nId);
rq.ListeChamps.Add(new C2iChampDeRequete(
"UniversalId",
new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel),
typeof(string),
OperationsAgregation.None,
true));
CResultAErreur result = rq.ExecuteRequete(0);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
if (table.Rows.Count > 0)
{
return((string)table.Rows[0][0]);
}
}
return("");
}
public static List <CInfoTypeElementInDb> GetInfosInDatabase(int nIdSession)
{
List <CInfoTypeElementInDb> lst = new List <CInfoTypeElementInDb>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(tp);
requete.ListeChamps.Add(new C2iChampDeRequete("NBELEMENTS", new CSourceDeChampDeRequete(structure.Champs[0].NomChamp),
typeof(int), OperationsAgregation.Number, false));
CInfoTypeElementInDb info = new CInfoTypeElementInDb(tp);
CResultAErreur result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElements = (int)((DataTable)result.Data).Rows[0][0];
}
if (!typeof(IObjetSansVersion).IsAssignableFrom(tp))
{
requete.FiltreAAppliquer = new CFiltreData(CSc2iDataConst.c_champIdVersion + " is not null and " +
CSc2iDataConst.c_champIsDeleted + "=@1", false);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElementsPrevisionnels = (int)((DataTable)result.Data).Rows[0][0];
}
requete.FiltreAAppliquer = new CFiltreData(CSc2iDataConst.c_champIsDeleted + "=@1", true);
requete.FiltreAAppliquer.IgnorerVersionDeContexte = true;
result = requete.ExecuteRequete(nIdSession);
if (result && result.Data is DataTable)
{
info.NbElementsSupprimes = (int)((DataTable)result.Data).Rows[0][0];
}
}
lst.Add(info);
}
return(lst);
}
public List <IChampPourVersion> GetChampsJournalisables(CObjetDonneeAIdNumerique objet)
{
List <IChampPourVersion> champs = null;
if (!m_dicTypeToChamps.TryGetValue(objet.GetType(), out champs))
{
champs = new List <IChampPourVersion>();
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
CInfoChampTable[] allchamps = structure.Champs;
List <string> lstChampsSys = CSc2iDataConst.GetNomsChampsSysteme();
foreach (CInfoChampTable c in allchamps)
{
if (c.m_bIsInDB && !lstChampsSys.Contains(c.NomChamp))
{
champs.Add(new CChampPourVersionInDb(c.NomChamp, c.NomConvivial));
}
}
m_dicTypeToChamps[objet.GetType()] = champs;
}
return(champs);
}
//-----------------------------------------------------------------
public void AddFiltreSynchroPourTable(string strTable, IFiltreSynchronisation filtre, bool bAvecCompositions)
{
List <IFiltreSynchronisation> lstFiltres = null;
if (!m_dicTableToFiltre.TryGetValue(strTable, out lstFiltres))
{
lstFiltres = new List <IFiltreSynchronisation>();
m_dicTableToFiltre[strTable] = lstFiltres;
}
lstFiltres.Add(filtre);
if (bAvecCompositions)
{
//trouve les compositions de la table et les filtre !
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure != null)
{
foreach (CInfoRelation relParente in structure.RelationsParentes)
{
Type tpFils = CContexteDonnee.GetTypeForTable(relParente.TableFille);
if (tpFils == null || tpFils.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length == 0)
{
if (relParente.Composition && relParente.TableParente == strTable && relParente.TableFille != strTable)
{
AddFiltreSynchroPourTable(structure.NomTable, new CFiltreSynchronisationFilsCompositions(structure.NomTable, strTable), true);
}
else if (relParente.TableFille == strTable && relParente.TableParente == strTable)
{
AddFiltreSynchroPourTable(structure.NomTable, new CFiltreSynchroFilsAutoreference(relParente.ChampsFille[0]), false);
}
}
}
}
}
}
}
public void ReadArbre(
CListeObjetsDonnees listeSource,
CListeObjetsDonnees.CArbreProps arbre,
List <string> lstPaquetsALire)
{
string strCle = "";
string strPropriete = "";
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
strPropriete = arbre.ProprietePrincipale;//Mode sans DefinitionProprieteDynamique
}
Type typeObjets = listeSource.TypeObjets;
Hashtable sousArbresToRemove = new Hashtable();
PropertyInfo info = typeObjets.GetProperty(strPropriete);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(OptimiseReadDependanceAttribute), true);
if (attribs.Length != 0)
{
string strProp = ((OptimiseReadDependanceAttribute)attribs[0]).ProprieteALire;
if (strProp.IndexOf('.') > 0)
{
string strSuite = strProp.Substring(strProp.IndexOf('.') + 1);
strProp = strProp.Substring(0, strProp.IndexOf('.'));
arbre.GetArbreSousProp(strSuite, true);
}
strPropriete = strProp;
}
}
CStructureTable structure = CStructureTable.GetStructure(typeObjets);
//Cherche la relation liée à la propriete
bool bRelationTrouvee = false;
foreach (CInfoRelation relation in structure.RelationsFilles)
{
if (relation.Propriete == strPropriete)
{
ReadDependanceFille(
strPropriete,
listeSource,
arbre,
relation,
lstPaquetsALire);
lstPaquetsALire = null;
bRelationTrouvee = true; break;
}
}
if (!bRelationTrouvee)
{
foreach (CInfoRelation relation in structure.RelationsParentes)
{
if (relation.Propriete == strPropriete)
{
ReadDependanceParente(strPropriete, listeSource, arbre, relation);
bRelationTrouvee = true;
}
}
}
if (!bRelationTrouvee)
{
sousArbresToRemove[arbre] = true;
}
foreach (CListeObjetsDonnees.CArbreProps arbreTmp in sousArbresToRemove.Keys)
{
arbre.SousArbres.Remove(arbreTmp);
}
}
