/// ///////////////////////////////////////////
///
/// ///////////////////////////////////////////
public void SetElementEdite(object element)
{
m_elementEdite = element;
IObjetDonneeAChamps elt = m_elementEdite as IObjetDonneeAChamps;
if (elt != null && m_wndSelectionValeurChamp.ChampCustom != null)
{
object valeur = elt.GetValeurChamp(m_wndSelectionValeurChamp.ChampCustom.Id);
if (valeur != null)
{
foreach (CValeurChampCustom value in m_wndSelectionValeurChamp.ChampCustom.Valeurs)
{
if (valeur.ToString() == value.Value.ToString())
{
m_valeurSelectionne = value;
}
}
}
else
{
m_valeurSelectionne = null;
}
}
UpdateVisuelFromSelection();
}
//-------------------------------------------------------------------
public static void SetTousChampsLus(IObjetDonneeAChamps obj)
{
Hashtable champsLus = new Hashtable();
//Lorsque champs lus contient -1, ça veut dire que tous les champs ont été lus
champsLus[-1] = true;
SetIdsChampsLus(obj, champsLus);
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp)
{
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(GetValeurChamp(objet, champ.Id, DataRowVersion.Default));
}
return(null);
}
//-------------------------------------------------------------------
/// <summary>
/// ids des champs qui ont été lus. Utilisés lorsqu'on lit partiellement les données
/// </summary>
protected static Hashtable GetIdsChampsLus(IObjetDonneeAChamps obj)
{
if (obj.ContexteDonnee.Tables[obj.GetNomTable()].Columns[c_champIdsChampsLus] == null)
{
return(null);
}
Hashtable hash = obj.Row[c_champIdsChampsLus] as Hashtable;
return(hash);
}
//-------------------------------------------------------------------
public static bool IsChampLu(IObjetDonneeAChamps obj, int nIdChamp)
{
Hashtable champsLus = GetIdsChampsLus(obj);
if (champsLus == null)
{
return(false);
}
return(champsLus.Contains(nIdChamp) || champsLus.Contains(-1));
}
/// ///////////////////////////////////////////
///
/// ///////////////////////////////////////////
public CResultAErreur MajChamps(bool bControlerLesValeursAvantValidation)
{
CResultAErreur result = CResultAErreur.False;
IObjetDonneeAChamps elt = m_elementEdite as IObjetDonneeAChamps;
if (elt != null && m_wndSelectionValeurChamp.ChampCustom != null)
{
result = elt.SetValeurChamp(m_wndSelectionValeurChamp.ChampCustom, m_valeurSelectionne == null ? null : m_valeurSelectionne.Value);
}
return(result);
}
public CTodoTimosWebApp(DataSet ds, CEtapeWorkflow etape)
{
m_etape = etape;
DataTable dt = ds.Tables[c_nomTable];
if (dt != null)
{
DataRow row = dt.NewRow();
string strInstrcution = GetInstructionsForTodo(etape);
string strTypeElementEdite = "";
int nIdElementEdite = -1;
string strElementDescription = "";
int nEtatTodo = etape.EtatCode;
CResultAErreur resObjet = GetElementEditePrincipal(etape);
CObjetDonneeAIdNumerique objEdite = resObjet.Data as CObjetDonneeAIdNumerique;
if (objEdite != null)
{
m_objetEdite = objEdite as IObjetDonneeAChamps;
strTypeElementEdite = objEdite.TypeString;
nIdElementEdite = objEdite.Id;
strElementDescription = objEdite.DescriptionElement;
}
resObjet = GetElementEditeSecondaire(etape);
objEdite = resObjet.Data as CObjetDonneeAIdNumerique;
if (objEdite != null)
{
m_objetEditeSecondaire = objEdite as IObjetDonneeAChamps;
}
row[c_champId] = etape.Id;
row[c_champDateDebut] = etape.DateDebut.Value;
row[c_champLibelle] = etape.Libelle;
row[c_champInstructions] = strInstrcution;
row[c_champTypeElementEdite] = strTypeElementEdite;
row[c_champIdElementEdite] = nIdElementEdite;
row[c_champElementDescription] = strElementDescription;
row[c_champEtatTodo] = nEtatTodo;
row[c_champDureeStandard] = DureeStandardTodo;
if (etape.DateFin == null)
{
row[c_champDateFin] = DBNull.Value;
}
else
{
row[c_champDateFin] = etape.DateFin.Value;
}
m_row = row;
dt.Rows.Add(row);
}
}
//---------------------------------------------------------------------------------
public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp, object valeur)
{
CResultAErreur result = CResultAErreur.True;
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(SetValeurChamp(objet, champ.Id, valeur));
}
result.EmpileErreur("Invalid Custom Field Id in SetValeurChamps (Line 179)");
return(result);
}
//-------------------------------------------------------------------
public static void SetChampsLus(IObjetDonneeAChamps obj, params int[] champs)
{
Hashtable champsLus = GetIdsChampsLus(obj);
if (champsLus == null)
{
champsLus = new Hashtable();
SetIdsChampsLus(obj, champsLus);
}
foreach (int nId in champs)
{
champsLus[nId] = true;
}
}
public static CResultAErreur VerifieDonnees(IObjetDonneeAChamps objet)
{
CResultAErreur result = CResultAErreur.True;
foreach (CRelationElementAChamp_ChampCustom rel in objet.RelationsChampsCustom)
{
CResultAErreur resTmp = CRelationElementAChamp_ChampCustomServeur.VerifieDonneesRelation(rel);
if (!resTmp)
{
result.Erreur.EmpileErreurs(resTmp.Erreur);
result.Result = false;
}
}
return(result);
}
//-------------------------------------------------------------------
public static CRelationElementAChamp_ChampCustom GetRelationToChamp(IObjetDonneeAChamps objet,
int nIdChamp)
{
string strTableValeurs = objet.GetNomTableRelationToChamps();
string strChampId = objet.GetChampId();
object dummy = null;
if (!objet.IsDependanceChargee(strTableValeurs, strChampId))
{
dummy = objet.RelationsChampsCustom;
}
DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
//Stef 20/07/2010 : si on fait un set avec version à -1, on modifie la version Referentiel.
//Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
//ce qui peut ramener plus d'1 élément, du coup, applique version fonctionne de manière aléatoire
//car parfois, on modifie bien la version référentiel, d'autres fois, on modifie
//autre chose (suivant ce qui est dans le contexte de données).
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
{
strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
CSc2iDataConst.c_champIsDeleted + "=0";
}
else
{
strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
}
}
DataRow[] rows = table.Select(strFiltre);
if (rows.Length > 0)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
rel.SetRow(rows[0]);
return(rel);
}
return(null);
}
//-------------------------------------------------------------------
protected static void SetIdsChampsLus(IObjetDonneeAChamps obj, Hashtable lst)
{
DataTable table = obj.ContexteDonnee.Tables[obj.GetNomTable()];
if (table.Columns[c_champIdsChampsLus] == null)
{
DataColumn col = new DataColumn(c_champIdsChampsLus);
table.RowChanged += new DataRowChangeEventHandler(OnChangeRowAvecChamps);
col.DataType = typeof(Hashtable);
table.Columns.Add(col);
}
object val = lst;
if (val == null)
{
val = DBNull.Value;
}
CContexteDonnee.ChangeRowSansDetectionModification(obj.Row, c_champIdsChampsLus, val);
}
//-------------------------------------------------------------------
//S'il n'y a pas de paramètres, lit tous les champs custom
public static void ReadChampsCustom(CListeObjetsDonnees lstObjets, params int[] idsChamps)
{
if (lstObjets.Count == 0)
{
return;
}
IObjetDonneeAChamps eltAChamps = lstObjets[0] as IObjetDonneeAChamps;
if (eltAChamps == null)
{
return;
}
if (idsChamps.Length == 0)
{
lstObjets.ReadDependances("RelationsChampsCustom");
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
SetTousChampsLus(eltAChamp);
}
return;
}
List <string> lstChamps = new List <string>();
foreach (int nIdChamp in idsChamps)
{
CChampCustom champ = new CChampCustom(eltAChamps.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
CDefinitionProprieteDynamiqueChampCustom def = new CDefinitionProprieteDynamiqueChampCustom(champ);
lstChamps.Add(def.NomPropriete);
}
}
lstObjets.ReadDependances(lstChamps.ToArray());
foreach (IObjetDonneeAChamps eltAChamp in lstObjets)
{
foreach (int nIdChamp in idsChamps)
{
SetChampsLus(eltAChamp, nIdChamp);
}
}
}
//-----------------------------------------------------------
private C2iRequeteAvancee GetRequeteChampCustom(CParametreInspirationProprieteDeType parametre)
{
CDefinitionProprieteDynamiqueChampCustom defChampCustom = parametre.Champ as CDefinitionProprieteDynamiqueChampCustom;
if (defChampCustom == null || parametre.Type == null || defChampCustom.DbKeyChamp == null)
{
return(null);
}
DataTable table = new DataTable();
DataRow row = table.NewRow();
IObjetDonneeAChamps objet = Activator.CreateInstance(parametre.Type, new object[] { row }) as IObjetDonneeAChamps;
if (objet != null)
{
string strTableValeurs = objet.GetNomTableRelationToChamps();
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strTableValeurs;
requete.ListeChamps.Add(new C2iChampDeRequete("LABEL",
new CSourceDeChampDeRequete(CRelationElementAChamp_ChampCustom.c_champValeurString),
typeof(string),
OperationsAgregation.None,
true));
int nIdChamp = -1;
//TESTDBKEYOK SC 31/03/2014
if (defChampCustom.DbKeyChamp.IsNumericalId())
{
nIdChamp = (int)defChampCustom.DbKeyChamp.GetValeurInDb();
}
else
{
nIdChamp = CChampCustom.GetIdFromDbKey(defChampCustom.DbKeyChamp);
}
requete.FiltreAAppliquer = new CFiltreData(CChampCustom.c_champId + "=@1", nIdChamp);
return(requete);
}
return(null);
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="table"></param>
/// <param name="result"></param>
///
private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
///Stef 22/07/08 : l'appel à shouldDeclenche peut
///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
///dans un contexte sans gestion par tables complètes, on est mal, parce que
///ça va génerer une requête par champ.
///Donc, on lit tous les champs custom avant de commencer
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés
listeChamps.AssureLectureFaite();
DateTime dt = DateTime.Now;
CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);
//Pour empêcher de regarder deux fois les évenements d'un même objet
//Type->Dictionnaire des ids vus
Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();
DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);
Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;
if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
{
listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >();
m_listeElementsARepasser[contexte] = listeElementsARepasser;
}
bool bFirstPasse = true;
int nLimiteurPasses = 0;
while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
{
nLimiteurPasses++;
foreach (DataTable table in lstTables)
{
if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
{
string strChampCle = table.PrimaryKey[0].ColumnName;
Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
{
continue;
}
Type typeOriginal = tpObjets;
//Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
//Mais le champ peut l'être
if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
{
int nLigne = 0;
bool bGoOut = false;
while (table.Rows.Count > nLigne && !bGoOut)
{
if (table.Rows[nLigne].RowState != DataRowState.Deleted)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
tpObjets = rel.ElementAChamps.GetType();
strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
bGoOut = true;
}
nLigne++;
}
}
//Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
{
continue;
}
ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);
//Id des éléments modifiés
List <int> listeIdsElementsAVerifierHandlers = new List <int>();
string strPrimaryKey = "";
if (table.PrimaryKey.Length == 1 &&
table.PrimaryKey[0].DataType == typeof(int))
{
strPrimaryKey = table.PrimaryKey[0].ColumnName;
}
Dictionary <int, bool> tableIdsVues = null;
if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
{
tableIdsVues = new Dictionary <int, bool>();
elementsVus[tpObjets] = tableIdsVues;
}
Dictionary <int, bool> listeARepasserPourTable = null;
if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
{
listeARepasserPourTable = null;
}
List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();
//Stef 16/11/2012 :
//Si c'est un élément à champs, il est consideré comme modifié
//si un de ses champs custom est modifiés
//Ca a été fait parce que les handlers d'évenement n'étaient
//Pas pris en compte sur modif de champ custom
//On n'enlève pas pour autant l'ancienne méthode qui consiste
//à considérer l'élément modifié losrqu'on passe sur la table des
//valeurs de champs custom
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
{
//Regarde s'il y a des relations
IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
string strTableChamps = objAChamp.GetNomTableRelationToChamps();
//Trouve la relation à la table
DataTable tableChamps = contexte.Tables[strTableChamps];
if (tableChamps != null)//Si la table champs n'est pas là, c'est
//qu'elle n'a pas été modifiée !! c'est logique çà
{
DataRelation rel = null;
foreach (DataRelation relTest in tableChamps.ParentRelations)
{
if (relTest.ParentTable.TableName == table.TableName)
{
rel = relTest;
break;
}
}
if (rel != null)//On peut vérifier !
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
{
DataRow[] rowsChamps = row.GetChildRows(rel);
foreach (DataRow rowChamp in rowsChamps)
{
if (rowChamp.RowState != DataRowState.Unchanged)
{
//Aloue l'objet pour s'assurer que la ligne est bien pleine
CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
objTmp.AssureData();
row.SetModified();
string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
if (strOldContexte.Length == 0)
{
row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
}
break;
}
}
}
}
}
}
}
foreach (DataRow row in new ArrayList(table.Rows))
{
CObjetDonneeAIdNumerique objet = null;
if (lstEvenements.Count > 0)
{
if (row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Deleted)
{
objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
{
lstObjetsAvecEvenementsSpecifiques.Add(objet);
}
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
{
CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
if (objet.Row.RowState == DataRowState.Unchanged)
{
objet.Row.Row.SetModified();
}
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (rel.ContexteDeModification.Length != 0 &&
objet.ContexteDeModification.Length == 0)
{
objet.ContexteDeModification = rel.ContexteDeModification;
}
}
if (!tableIdsVues.ContainsKey(objet.Id) || (
listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
{
tableIdsVues[objet.Id] = true;
foreach (CEvenement evt in lstEvenements)
{
if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
{
//Attention, si c'est une valeur de champ custom, envoie la valeur,
//c'est elle qui sera testée.
CInfoDeclencheurProcess infoDeclencheur = null;
if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
{
infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
infoDeclencheur.Info = evt.Libelle;
traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
}
}
}
}
}
}
//Regarde les handle d'évenement sur l'objet
if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
{
listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
}
}
if (listeARepasserPourTable != null)
{
listeARepasserPourTable.Clear();
}
if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
{
//traitement par paquet de 500
for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
{
int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
StringBuilder bl = new StringBuilder();
for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
{
bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
bl.Append(",");
}
string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
//Recherche tous les handlers d'évenement pour les objets concernés
CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
listeHandler.Filtre = new CFiltreData(
CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champTypeEvenement + "=@2",
tpObjets.ToString(),
(int)TypeEvenement.Modification);
listeHandler.PreserveChanges = true;
foreach (CHandlerEvenement handler in listeHandler)
{
if (handler.Row.RowState != DataRowState.Deleted)
{
CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
if (objetTmp.ReadIfExists(handler.IdElementCible))
{
CInfoDeclencheurProcess infoDeclencheur = null;
if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
{
if (infoDeclencheur != null && handler.EvenementLie != null)
{
infoDeclencheur.Info = handler.EvenementLie.Libelle;
}
traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
}
}
}
}
}
}
//Annule les évenements spécifiques, ils ont été traités !
foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
{
EvenementAttribute.ClearEvenements(objet);
}
}
}
//Execute ce qui peut être executé tout de suite
foreach (DataTable table in contexte.Tables)
{
table.RowChanged += handlerRedo;
}
listeElementsARepasser.Clear();
foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
{
if (couple.Objet is CObjetDonneeAIdNumerique &&
couple.PeutEtreExecuteSurLePosteClient)
{
result = couple.OnDeclencheSurClient();
if (!result)
{
return(result);
}
}
}
foreach (DataTable table in contexte.Tables)
{
table.RowChanged -= handlerRedo;
}
bFirstPasse = false;
}
if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
{
tableData[c_cleDonneeListeTraitements] = traitement;
}
m_listeElementsARepasser.Remove(contexte);
return(result);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete)
{
//Récupère l'objet à interroger
string strProp = propriete.NomPropriete;
object valeur = m_cache.GetValeurCache(objetInterroge, strProp);
if (valeur != null)
{
return(valeur);
}
CContexteDonnee contexteForObjets = ContexteDonneeCache;
if (objetInterroge is IObjetAContexteDonnee)
{
contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee;
}
if (contexteForObjets == null)
{
contexteForObjets = ContexteDonneeCache;
}
object objetFinal = objetInterroge;
int nPos = strProp.LastIndexOf('.');
if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustom) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustomFils) &&
!(propriete is CDefinitionProprieteDynamiqueFormule))
{
string strPropDebut;
strPropDebut = strProp.Substring(0, nPos);
strProp = strProp.Substring(nPos + 1);
objetFinal = m_cache.GetValeurCache(objetInterroge, strPropDebut);
if (objetFinal == null)
{
objetFinal = GetValue(objetInterroge, strPropDebut);
/*object objetAInterroger = null;
* MemberInfo membre = null;
* CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre );
* if ( membre != null )
* {
* objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre );
* }
* else
* {
* //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer
* //Le champ
* }*/
//objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal);
}
if (objetFinal == null)
{
return(null);
}
valeur = m_cache.GetValeurCache(objetFinal, strProp);
if (valeur != null)
{
return(valeur);
}
}
if (propriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(objetFinal is IElementAChamps))
{
valeur = null;
}
else
{
//TESTDBKEYTODO qui ne peut pas marche
valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default);
/*if (m_bValeurAfficheeDeChampsCustom)
* {
* CChampCustom champ = new CChampCustom(ContexteDonneeCache);
* if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp))
* {
* object valTmp = champ.DisplayFromValue(valeur);
* if (valTmp != null)
* valeur = valTmp;
* }
* }*/
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique)
{
CChampCustom champ = new CChampCustom(ContexteDonneeCache);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp))
{
Type tp = champ.Role.TypeAssocie;
try
{
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets });
CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp);
liste.Filtre = new CFiltreDataAvance(
elt.GetNomTable(),
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " +
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " +
rel.GetNomTable() + "." +
CChampCustom.c_champId + "=@3",
objetInterroge.GetType().ToString(),
((CObjetDonneeAIdNumerique)objetInterroge).Id,
champ.Id);
valeur = liste.ToArray(tp);
}
catch
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueListeEntites)
{
CListeEntites liste = new CListeEntites(contexteForObjets);
try
{
if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite))
{
CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge);
if (resultListe != null)
{
valeur = resultListe.ToArray(liste.TypeElements);
}
}
}
catch
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete;
return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId(
defRel.Relation.TableFille,
defRel.Relation.ChampType,
defRel.Relation.ChampId,
false));
}
}
else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete;
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal;
CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexteForObjets);
if (type.ReadIfExists(defType.DbKeyTypeDonnee))
{
valeur = type.GetDonneesCumuleesForObjet(objet);
}
else
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCalcule)
{
CChampCalcule champ = new CChampCalcule(contexteForObjets);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp))
{
valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true));
}
else
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueFormule)
{
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge);
contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets);
CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte);
if (result)
{
return(result.Data);
}
}
else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables)
{
valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
}
else
{
valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp);
}
m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur);
if (objetFinal != objetInterroge)
{
m_cache.StockeValeurEnCache(objetFinal, strProp, valeur);
}
return(valeur);
}
public CResultAErreur FillDataSet(DataSet ds, C2iWnd fenetre, IObjetDonneeAChamps objetEdite, CListeRestrictionsUtilisateurSurType lstRestrictions)
{
CResultAErreur result = CResultAErreur.True;
if (m_formulaire == null)
{
result.EmpileErreur("m_formulaire is null");
return(result);
}
if (fenetre != null)
{
try
{
ArrayList lst = fenetre.AllChilds();
bool bConserverCeGroupe = false;
CRestrictionUtilisateurSurType restrictionSurObjetEdite = lstRestrictions.GetRestriction(objetEdite.GetType());
foreach (object obj in lst)
{
if (obj is I2iWebControl)
{
I2iWebControl webControl = (I2iWebControl)obj;
if (webControl.WebLabel == "")
{
continue;
}
C2iWnd wndControl = webControl as C2iWnd;
if (wndControl != null)
{
// Traite la visibilité du champ
C2iExpression expVisible = wndControl.Visiblity;
if (expVisible != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetEdite);
CResultAErreur resVisible = expVisible.Eval(ctx);
if (resVisible && resVisible.Data != null)
{
if (resVisible.Data.ToString() == "0" || resVisible.Data.ToString().ToUpper() == "FALSE")
{
continue;
}
}
}
// Applique les restrictions
bool bIsEditable = true;
if (wndControl is C2iWndFormule || wndControl is C2iWndPanel || wndControl is C2iWndSlidingPanel)
{
bIsEditable = false;
}
else if ((bool)m_row[c_champIsInfosSecondaires])
{
// Si c'est un groupe d'infos secondaire, aucun champ n'est éditable
bIsEditable = false;
}
else if (wndControl is C2iWndChampCustom)
{
// Sinon on regarde les restrictions du champ
C2iWndChampCustom wndChamp = (C2iWndChampCustom)wndControl;
CChampCustom cc = wndChamp.ChampCustom;
if (restrictionSurObjetEdite != null)
{
ERestriction rest = restrictionSurObjetEdite.GetRestriction(cc.CleRestriction);
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
bIsEditable = false;
}
}
}
CChampTimosWebApp champWeb = new CChampTimosWebApp(ds, webControl, objetEdite, m_formulaire.Id, "-1", bIsEditable);
result = champWeb.FillDataSet(ds);
CTodoValeurChamp valeur = new CTodoValeurChamp(ds, objetEdite, champWeb, m_formulaire.Id, bIsEditable);
result = valeur.FillDataSet(ds);
bConserverCeGroupe = true;
}
}
// Traitement dans le cas d'un sous-formulaire
else if (obj is C2iWndConteneurSousFormulaire)
{
C2iWndConteneurSousFormulaire subForm = (C2iWndConteneurSousFormulaire)obj;
if (subForm != null && subForm.SubFormReference != null)
{
C2iWnd frm = sc2i.formulaire.subform.C2iWndProvider.GetForm(subForm.SubFormReference);
if (frm != null)
{
if (subForm.EditedElement != null)
{
C2iExpression expression = subForm.EditedElement;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetEdite);
CResultAErreur resEval = expression.Eval(ctx);
if (!resEval)
{
result += resEval;
return(result);
}
IObjetDonneeAChamps sousObjetEdite = resEval.Data as IObjetDonneeAChamps;
if (sousObjetEdite != null)
{
// Traite la visibilité du champ
var ctxSousObjet = new CContexteEvaluationExpression(sousObjetEdite);
C2iExpression expVisible = subForm.Visiblity;
if (expVisible != null)
{
CResultAErreur resVisible = expVisible.Eval(ctxSousObjet);
if (resVisible && resVisible.Data != null)
{
if (resVisible.Data.ToString() == "0" || resVisible.Data.ToString().ToUpper() == "FALSE")
{
continue;
}
}
}
bConserverCeGroupe = true;
FillDataSet(ds, frm, sousObjetEdite, lstRestrictions);
}
}
}
}
}
// Traitement dans le cas d'une Child Zone
else if (obj is C2iWndZoneMultiple)
{
C2iWndZoneMultiple childZone = (C2iWndZoneMultiple)obj;
C2iWndSousFormulaire sousFenetre = childZone.FormulaireFils;
bool bHasAddButton = childZone.HasAddButton;
bool bCanCreate = false;
if (childZone.SourceFormula != null)
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetEdite);
C2iExpression source = childZone.SourceFormula;
Type tp = source.TypeDonnee.TypeDotNetNatif;
if (tp != null)
{
// Gestion des restrictions
CRestrictionUtilisateurSurType restrictions = lstRestrictions.GetRestriction(tp);
if (restrictions != null)
{
bCanCreate = restrictions.CanCreateType();
}
}
CResultAErreur resEval = source.Eval(ctxEval);
if (!resEval)
{
result += resEval;
return(result);
}
object datas = resEval.Data;
if (datas != null)
{
bConserverCeGroupe = true;
IEnumerable collection = datas as IEnumerable;
if (collection != null)
{
// La source de données est une collection, il s'agit certainement de caractéristiques
// Mais c'est peut-être aussi un Workbook, un Site, un Projet... on ne sait pas car ça dépend du paramétrage
m_row[c_champTitreCaracteristiques] = childZone.WebLabel;
m_row[c_champCanAddCaracteristiques] = bHasAddButton && bCanCreate;
int nOrdre = 0;
foreach (var data in collection)
{
IObjetDonneeAChamps objEdite = data as IObjetDonneeAChamps;
if (objEdite != null)
{
CCaracteristique caracWeb = new CCaracteristique(
ds,
objEdite as IObjetDonneeAIdNumeriqueAuto,
tp,
objetEdite.GetType().ToString(),
((IObjetDonneeAIdNumeriqueAuto)objetEdite).Id,
nOrdre++,
m_formulaire.Id,
false);
caracWeb.FillDataSet(ds, sousFenetre, objEdite, lstRestrictions);
}
}
// Création d'un template
if (childZone.Affectations.Count > 0)
{
CAffectationsProprietes affectation = childZone.Affectations[0];
if (tp != null && affectation != null)
{
IAllocateurSupprimeurElements allocateur = objetEdite as IAllocateurSupprimeurElements;
object newObj = null;
try
{
if (allocateur != null)
{
result = allocateur.AlloueElement(tp);
if (result)
{
newObj = result.Data;
}
}
else
{
newObj = Activator.CreateInstance(tp);
}
}
catch (Exception ex)
{
result.EmpileErreur(new CErreurException(ex));
}
if (newObj == null | !result)
{
result.EmpileErreur(I.T("Error while allocating element|20003"));
}
result = affectation.AffecteProprietes(newObj, objetEdite, new CFournisseurPropDynStd(true));
if (!result)
{
result.EmpileErreur(I.T("Some values cannot be assigned|20004"));
}
CCaracteristique caracTemplate = new CCaracteristique(
ds,
newObj as IObjetDonneeAIdNumeriqueAuto,
tp,
objetEdite.GetType().ToString(),
((IObjetDonneeAIdNumeriqueAuto)objetEdite).Id,
nOrdre++,
m_formulaire.Id,
true);
caracTemplate.FillDataSet(ds, sousFenetre, newObj as IObjetDonneeAChamps, lstRestrictions);
}
}
}
else
{
// La source de donnée est un objet unique
IObjetDonneeAChamps objEdite = datas as IObjetDonneeAChamps;
if (objEdite != null)
{
FillDataSet(ds, sousFenetre, objEdite, lstRestrictions);
}
}
}
}
}
}
/*if (!bConserverCeGroupe)
* {
* DataTable dt = ds.Tables[c_nomTable];
* if (dt != null)
* dt.Rows.Remove(m_row);
* }*/
}
catch (Exception ex)
{
result.EmpileErreur(ex.Message);
return(result);
}
}
return(result);
}
//------------------------------------------------------------------------------------------------
public CResultAErreur FillDataSet(DataSet ds, C2iWnd fenetre, IObjetDonneeAChamps objetEdite, CListeRestrictionsUtilisateurSurType lstRestrictions)
{
CResultAErreur result = CResultAErreur.True;
string strIdCarac = (string)m_row[c_champId];
string strTypeElement = (string)m_row[c_champElementType];
if (fenetre != null)
{
ArrayList lst = fenetre.AllChilds();
foreach (object obj in lst)
{
if (obj is I2iWebControl)
{
I2iWebControl webControl = (I2iWebControl)obj;
if (webControl.WebLabel == "")
{
continue;
}
C2iWnd wndControl = webControl as C2iWnd;
if (wndControl != null)
{
// Traite la visibilité du champ
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetEdite);
C2iExpression expVisible = wndControl.Visiblity;
if (expVisible != null)
{
CResultAErreur resVisible = expVisible.Eval(ctx);
if (resVisible && resVisible.Data != null)
{
if (resVisible.Data.ToString() == "0" || resVisible.Data.ToString().ToUpper() == "FALSE")
{
continue;
}
}
}
// Applique les restrictions
bool bIsEditable = true;
if (wndControl is C2iWndFormule || wndControl is C2iWndPanel || wndControl is C2iWndSlidingPanel)
{
bIsEditable = false;
}
else if (wndControl is C2iWndChampCustom)
{
// Sinon on regarde les restrictions du champ
C2iWndChampCustom wndChamp = (C2iWndChampCustom)wndControl;
CChampCustom cc = wndChamp.ChampCustom;
CRestrictionUtilisateurSurType restrictionSurObjetEdite = lstRestrictions.GetRestriction(objetEdite.GetType());
if (restrictionSurObjetEdite != null)
{
ERestriction rest = restrictionSurObjetEdite.GetRestriction(cc.CleRestriction);
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
bIsEditable = false;
}
}
}
CChampTimosWebApp champWeb = new CChampTimosWebApp(ds, webControl, objetEdite, -1, strIdCarac, bIsEditable);
result = champWeb.FillDataSet(ds);
CCaracValeurChamp valeur = new CCaracValeurChamp(ds, objetEdite, champWeb, strTypeElement, strIdCarac, bIsEditable);
result = valeur.FillDataSet(ds);
}
}
// Traitement dans le cas d'un sous-formulaire
else if (obj is C2iWndConteneurSousFormulaire)
{
C2iWndConteneurSousFormulaire subForm = (C2iWndConteneurSousFormulaire)obj;
if (subForm != null && subForm.SubFormReference != null)
{
C2iWnd frm = sc2i.formulaire.subform.C2iWndProvider.GetForm(subForm.SubFormReference);
if (frm != null)
{
if (subForm.EditedElement != null)
{
C2iExpression expression = subForm.EditedElement;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetEdite);
CResultAErreur resEval = expression.Eval(ctx);
if (!resEval)
{
result += resEval;
return(result);
}
IObjetDonneeAChamps sousObjetEdite = resEval.Data as IObjetDonneeAChamps;
if (sousObjetEdite != null)
{
// Traite la visibilité du champ
ctx = new CContexteEvaluationExpression(sousObjetEdite);
C2iExpression expVisible = subForm.Visiblity;
if (expVisible != null)
{
CResultAErreur resVisible = expVisible.Eval(ctx);
if (resVisible && resVisible.Data != null)
{
if (resVisible.Data.ToString() == "0" || resVisible.Data.ToString().ToUpper() == "FALSE")
{
continue;
}
}
}
FillDataSet(ds, frm, sousObjetEdite, lstRestrictions);
}
}
}
}
}//*/
}
}
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur ExportSimple(int nIdSession, IEnumerable list, ref DataSet ds, IIndicateurProgression indicateur)
{
if (m_cacheValeurs == null)
{
m_cacheValeurs = new CCacheValeursProprietes();
}
DateTime dt = DateTime.Now;
CResultAErreur result = CResultAErreur.True;
if (list != null && !(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Impossible to use a simple export with something other than a Data Object list|102"));
return(result);
}
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
CContexteDonnee contexteDestination = new CContexteDonnee(nIdSession, true, false);
result = contexteDestination.SetVersionDeTravail(listeObjets.ContexteDonnee.IdVersionDeTravail, false);
if (!result)
{
return(result);
}
contexteDestination.EnforceConstraints = false; //Ca gagne un temps fou !!!
ds = contexteDestination;
//Crée la table principale
DataTable tablePrincipale = contexteDestination.GetTableSafe(CContexteDonnee.GetNomTableForType(m_typeSource));
if (tablePrincipale == null)
{
result.EmpileErreur(I.T("Error during the creation of the main table|103"));
return(result);
}
if (listeObjets != null)
{
//Exporte les objets dans la table principale
foreach (CObjetDonnee objet in listeObjets)
{
tablePrincipale.ImportRow(objet.Row.Row);
}
}
foreach (C2iChampExport champ in Table.Champs)
//Crée les colonnes calculées et champs custom
{
result = CreateChampInTable(champ, tablePrincipale);
if (!result)
{
result.EmpileErreur(I.T("Error during field @1 creation|104", champ.NomChamp));
return(result);
}
}
//Crée les autres tables
foreach (C2iTableExport tableFille in Table.TablesFilles)
{
CreateTableSimpleInDataset(tableFille, contexteDestination, m_typeSource);
}
foreach (DataTable table in contexteDestination.Tables)
{
ArrayList lstColsToDelete = new ArrayList();
foreach (DataColumn col in table.Columns)
{
if (col.DataType == typeof(CDonneeBinaireInRow))
{
lstColsToDelete.Add(col);
}
}
foreach (DataColumn col in lstColsToDelete)
{
table.Columns.Remove(col);
}
}
if (listeObjets == null)
{
AddTablesCalculees(contexteDestination, null);
}
if (listeObjets == null)
{
return(result);
}
CListeObjetsDonnees listeDestination = new CListeObjetsDonnees(contexteDestination, m_typeSource, false);
listeDestination.InterditLectureInDB = true;
//Lit les dépendances dans le contexte
//Récupère toutes les sous tables nécéssaires
string[] definitionsOrigines = GetDependancesDeTableSimple(listeObjets.ContexteDonnee);
Hashtable tableDependances = new Hashtable();
foreach (string def in definitionsOrigines)
{
tableDependances[def] = true;
}
string[] strDependances = new string[tableDependances.Count];
int nDependance = 0;
foreach (string strDependance in tableDependances.Keys)
{
strDependances[nDependance] = strDependance;
nDependance++;
}
listeDestination.ReadDependances(strDependances);
//Et voila, le tour est joué, toutes les données sont dans le dataset de destination
//Il manque juste les compositions des éléments nouveaux
if (listeObjets != null)
{
//Exporte les compositions des objets nouveaux
foreach (CObjetDonnee objet in listeObjets)
{
if (objet.IsNew()) //Si nouveau, charge directement toutes ses données
{
objet.ContexteDonnee.CopieRowTo(objet.Row.Row, contexteDestination, true, false, false);
}
}
}
//S'assure que toutes les données sont lues
foreach (DataTable table in contexteDestination.Tables)
{
DataView view = new DataView(table);
view.RowFilter = CContexteDonnee.c_colIsToRead + "=1";
foreach (DataRowView rowView in view)
{
contexteDestination.ReadRow(rowView.Row);
}
}
//Ramène les champs calculés
List <ITableExport> toutesLesTables = ToutesLesTables();
m_cacheValeurs.CacheEnabled = true;
int nNbTotalPrincipal = tablePrincipale.Rows.Count;
//Récupère les champs par ID
//Id->Nom du champ
Dictionary <int, CChampCustom> dicoChamps = new Dictionary <int, CChampCustom>();
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexteDestination, typeof(CChampCustom));
foreach (CChampCustom champ in listeChamps)
{
dicoChamps[champ.Id] = champ;
}
//Liste des tables à conserver au final
Hashtable tableTablesAConserver = new Hashtable();
foreach (C2iTableExport table in toutesLesTables)
{
string strNomTable = "";
DataTable tableDestination = tablePrincipale;
if (table.ChampOrigine != null)
{
strNomTable = CContexteDonnee.GetNomTableForType(table.ChampOrigine.TypeDonnee.TypeDotNetNatif);
tableDestination = contexteDestination.Tables[strNomTable];
}
if (tableDestination != null)
{
tableTablesAConserver[tableDestination.TableName] = true;
List <C2iChampExport> champsCalcules = new List <C2iChampExport>();
List <C2iChampExport> champsCustoms = new List <C2iChampExport>();
foreach (C2iChampExport champ in table.Champs)
{
if (champ.Origine is C2iOrigineChampExportExpression)
{
champsCalcules.Add(champ);
}
if (champ.Origine is C2iOrigineChampExportChampCustom)
{
champsCustoms.Add(champ);
}
}
if (champsCalcules.Count != 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
foreach (DataRow row in tableDestination.Rows)
{
#if PDA
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(tp);
objet.SetRow(row);
#else
object objet = Activator.CreateInstance(tp, new object[] { row });
#endif
foreach (C2iChampExport chp in champsCalcules)
{
if (chp.Origine is C2iOrigineChampExportExpression)
{
object valeur = chp.GetValeur(objet, m_cacheValeurs, null);
if (valeur == null)
{
valeur = DBNull.Value;
}
row[chp.NomChamp] = valeur;
}
}
m_cacheValeurs.ResetCache( );
}
}
if (champsCustoms.Count > 0)
{
Type tp = CContexteDonnee.GetTypeForTable(tableDestination.TableName);
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
IObjetDonneeAChamps element = (IObjetDonneeAChamps)Activator.CreateInstance(tp, contexteDestination);
string strTableValeursChamps = element.GetNomTableRelationToChamps();
Type tpValeursChamps = CContexteDonnee.GetTypeForTable(strTableValeursChamps);
//Travaille les valeurs de champs customs par paquet de 500;
int nTaillePaquet = 500;
int nMax = tableDestination.Rows.Count;
string strChampId = tableDestination.PrimaryKey[0].ColumnName;
for (int nPaquet = 0; nPaquet < nMax; nPaquet += nTaillePaquet)
{
StringBuilder bl = new StringBuilder();
int nFin = Math.Min(nMax, nPaquet + nTaillePaquet);
for (int nRow = nPaquet; nRow < nFin; nRow++)
{
bl.Append(tableDestination.Rows[nRow][strChampId]);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
string strIds = bl.ToString();
foreach (C2iChampExport champACustom in champsCustoms)
{
C2iOrigineChampExportChampCustom origineChamp = (C2iOrigineChampExportChampCustom)champACustom.Origine;
//C'est un élément à champ, donc, va requeter dans les champs customs pour avoir les
//valeurs
CListeObjetsDonnees listeValeurs = new CListeObjetsDonnees(contexteDestination, tpValeursChamps);
StringBuilder blIdsChamps = new StringBuilder();
foreach (int nId in origineChamp.IdsChampCustom)
{
blIdsChamps.Append(nId);
blIdsChamps.Append(',');
}
if (blIdsChamps.Length > 0)
{
blIdsChamps.Remove(blIdsChamps.Length - 1, 1);
listeValeurs.Filtre = new CFiltreData(
CChampCustom.c_champId + " in (" + blIdsChamps.ToString() + ") and " +
strChampId + " in (" + strIds + ")");
listeValeurs.AssureLectureFaite();
//On n'a plus qu'à rebasculer les valeurs dans la table
foreach (CRelationElementAChamp_ChampCustom valeur in listeValeurs)
{
try
{
DataRow rowAttachee = tableDestination.Rows.Find(valeur.Row[strChampId]);
if (rowAttachee != null)
{
object valTmp = valeur.Valeur;
if (valTmp == null)
{
valTmp = DBNull.Value;
}
rowAttachee[c_strPrefixeChampCustom + valeur.ChampCustom.Nom] = valTmp;
}
}
catch
{ }
}
}
}
}
}
}
}
}
}
m_cacheValeurs.ResetCache();
ArrayList lstTablesToDelete = new ArrayList();
foreach (DataTable table in contexteDestination.Tables)
{
if (tableTablesAConserver[table.TableName] == null)
{
lstTablesToDelete.Add(table);
}
}
foreach (DataTable table in lstTablesToDelete)
{
contexteDestination.SupprimeTableEtContraintes(table);
}
AddTablesCalculees(contexteDestination, null);
return(result);
}
public CTodoValeurChamp(DataSet ds, IObjetDonneeAChamps obj, CChampTimosWebApp champWeb, int nIdGroupeAssocie, bool bIsEditable)
{
DataTable dt = ds.Tables[c_nomTable];
if (dt == null)
{
return;
}
DataRow row = dt.NewRow();
int nIdChampWeb = champWeb.Id;
int nIdChampTimos = champWeb.IdTimos;
string strLibelleWeb = champWeb.WebLabel;
int nOrdreWeb = champWeb.WebNumOrder;
string strValeur = "";
string strElementType = "";
int nElementId = -1;
CChampCustom champ = champWeb.Champ;
bool bAutoComplete = champWeb.UseAutoComplete;
if (champ != null)
{
if (obj != null)
{
strElementType = obj.GetType().ToString();
nElementId = ((IObjetDonneeAIdNumerique)obj).Id;
m_valeur = CUtilElementAChamps.GetValeurChamp(obj, nIdChampTimos);
if (m_valeur != null)
{
if (champ.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
IObjetDonneeAIdNumerique objetValeur = m_valeur as IObjetDonneeAIdNumerique;
if (objetValeur != null)
{
try
{
if (bIsEditable && !bAutoComplete)
{
strValeur = objetValeur.Id.ToString();
}
else
{
strValeur = objetValeur.DescriptionElement;
}
}
catch
{
strValeur = "";
}
}
}
else if (champ.IsChoixParmis())
{
try
{
if (bIsEditable)
{
strValeur = m_valeur.ToString();
}
else
{
strValeur = champ.DisplayFromValue(m_valeur);
}
}
catch
{
strValeur = "";
}
}
else
{
try
{
strValeur = m_valeur.ToString();
}
catch
{
strValeur = "";
}
}
}
}
}
else
{
C2iExpression formule = champWeb.Formule;
if (formule != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(obj);
CResultAErreur resFormule = formule.Eval(ctx);
if (resFormule && resFormule.Data != null)
{
strValeur = resFormule.Data.ToString();
}
}
}
row[c_champId] = nIdChampWeb;
row[c_champLibelle] = strLibelleWeb;
row[c_champOrdreAffichage] = nOrdreWeb;
row[c_champValeur] = strValeur;
row[c_champElementType] = strElementType;
row[c_champElementId] = nElementId;
row[c_champIdGroupeChamps] = nIdGroupeAssocie;
row[c_champUseAutoComplete] = champWeb.UseAutoComplete;
m_row = row;
dt.Rows.Add(row);
}
//-------------------------------------------------------------------
public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, object valeur)
{
/*
* ///Stef 18052011, passage de la recherche de l'élément sous forme de fonction
*
* string strTableValeurs = objet.GetNomTableRelationToChamps();
* string strChampId = objet.GetChampId();
* object dummy = null;
* if (!objet.IsDependanceChargee(strTableValeurs, strChampId))
* dummy = objet.RelationsChampsCustom;
* DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
*
* string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
* strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
*
*
* //Stef 20/07/2010 : si on fait un set avec version à -1, on modifie la version Referentiel.
* //Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
* //ce qui peut ramener plus d'1 élément, du coup, applique version fonctionne de manière aléatoire
* //car parfois, on modifie bien la version référentiel, d'autres fois, on modifie
* //autre chose (suivant ce qui est dans le contexte de données).
* if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
* {
* strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
* CSc2iDataConst.c_champIsDeleted + "=0";
* }
* else
* {
* strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
* }
*
* DataRow[] rows = table.Select(strFiltre);
* if (rows.Length > 0)
* {
* CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
* rel.SetRow(rows[0]);
* rel.Valeur = valeur;
* return CResultAErreur.True;
* }*/
CRelationElementAChamp_ChampCustom rel = GetRelationToChamp(objet, nIdChamp);
if (rel != null)
{
rel.Valeur = valeur;
return(CResultAErreur.True);
}
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
CResultAErreur result = CResultAErreur.True;
if (champ.ReadIfExists(nIdChamp))
{
CRelationElementAChamp_ChampCustom relation = objet.GetNewRelationToChamp();
relation.CreateNewInCurrentContexte();
relation.ElementAChamps = objet;
relation.ChampCustom = champ;
relation.Valeur = valeur;
}
else
{
result.EmpileErreur(I.T("The field n°@1 doesn't exist|234", nIdChamp.ToString()));
}
return(result);
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp)
{
return(GetValeurChamp(objet, nIdChamp, DataRowVersion.Default));
}
public CResultAErreur Execute(int nIdSession, System.Collections.Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
session.BeginTrans();
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(nIdSession, typeof(CVersionDonneesObjetServeur));
//Supprime les versions
string strRequete = "delete from " + CVersionDonneesObjetOperation.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
strRequete = "delete from " + CVersionDonneesObjet.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(CVersionDonnees.c_nomTable))
{
if (info.TableParente == CVersionDonnees.c_nomTable)
{
strRequete = "update " + info.TableFille + " set " +
info.ChampsFille[0] + "=null where " +
info.ChampsFille[0] + " is not null";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
strRequete = "delete from " + CVersionDonnees.c_nomTable;
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Charge toutes les tables
List <Type> typesAChamps = new List <Type>();
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(tp))
{
typesAChamps.Add(tp);
}
}
/*Problème sur les champs custom : parfois (c'est rare, mais ça arrive
* les valeurs de champs ne sont pas supprimées alors que l'entité est bien
* supprimée. On ne sait pas pourquoi, mais les lignes suivantes
* règlent le problème*/
foreach (Type tp in typesAChamps)
{
string strNomTable = CContexteDonnee.GetNomTableForType(tp);
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexte });
string strTableValeurs = elt.GetNomTableRelationToChamps();
strRequete = "Update " + strTableValeurs + " set " +
CSc2iDataConst.c_champIsDeleted + "=1 where " +
elt.GetChampId() + " in (select " + elt.GetChampId() + " from " +
strNomTable + " where " + CSc2iDataConst.c_champIsDeleted + "=1)";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
ArrayList lstTables = CContexteDonnee.GetTableOrderDelete(contexte);
DataTable tableChampsCustomEnDernier = null;
foreach (DataTable table in lstTables)
{
/* J'ai un problème avec la table Champs Custom
* La requête suivante ne passe pas même directement dans SQL Server
* DELETE FROM CUSTOM_FIELD WHERE (SC2I_VERSION IS NOT NULL) OR (SC2I_DELETED = 1)
* Si je ne traite pas cette table, la purge se passe bien
* */
if (table.TableName == CChampCustom.c_nomTable)
{
tableChampsCustomEnDernier = table;
continue;
}
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
strRequete = "delete from " + table.TableName + " where " +
CSc2iDataConst.c_champIdVersion + " is not null or " +
CSc2iDataConst.c_champIsDeleted + "=1";
result = connexion.RunStatement(strRequete);
if (!result)
{
return(result);
}
}
}
//if (tableChampsCustomEnDernier != null)
//{
// if (tableChampsCustomEnDernier.Columns.Contains(CSc2iDataConst.c_champIdVersion))
// {
// strRequete = "delete from " + tableChampsCustomEnDernier.TableName + " where " +
// CSc2iDataConst.c_champIdVersion + " is not null or " +
// CSc2iDataConst.c_champIsDeleted + "=1";
// result = connexion.RunStatement(strRequete);
// if (!result)
// return result;
// }
//}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
if (!result)
{
session.RollbackTrans();
}
else
{
result = session.CommitTrans();
}
}
}
return(result);
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, int nIdChamp, DataRowVersion version)
{
string strTableValeurs = objet.GetNomTableRelationToChamps();
string strChampId = objet.GetChampId();
if (!objet.IsDependanceChargee(strTableValeurs, strChampId) && !IsChampLu(objet, nIdChamp))
{
object dummy;
dummy = objet.RelationsChampsCustom;
SetTousChampsLus(objet);
}
DataTable table = objet.ContexteDonnee.Tables[strTableValeurs];
string strFiltre = CChampCustom.c_champId + "=" + nIdChamp + " and " +
strChampId + "=" + ((IObjetDonneeAIdNumerique)objet).Id;
//Stef 20/07/2010 : si on fait un get avec version à -1, on récupère la version Referentiel.
//Le pb était que si on ne fait pas ça, on utilise CContexteDonnee.c_colIsHorsVersion = 0,
//ce qui peut ramener plus d'1 élément, du coup, GetValeur champ retourne
//n'importe quelle valeur, et pas forcement celle du référentiel
if (table.Columns.Contains(CSc2iDataConst.c_champIdVersion))
{
if (objet.ContexteDonnee.IdVersionDeTravail == null || objet.ContexteDonnee.IdVersionDeTravail == -1)
{
strFiltre += " and " + CSc2iDataConst.c_champIdVersion + " is null and " +
CSc2iDataConst.c_champIsDeleted + "=0";
}
else
{
strFiltre += " and " + CContexteDonnee.c_colIsHorsVersion + "=0";
}
}
DataRow[] rows = table.Select(strFiltre);
if (rows.Length > 0)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet.ContexteDonnee.GetNewObjetForTable(table);
DataRow row = rows[0];
if (row.HasVersion(version))
{
rel.SetRow(row);
rel.VersionToReturn = version;
return(rel.Valeur);
}
else
{
return(null);
}
}
/*CListeObjetsDonnees liste = GetRelationsToChamps(nIdChamp);
*
* if (liste.Count > 0)
* return ((CRelationElementAChamp_ChampCustom) liste[0]).Valeur;*/
//Changement le 12/10/03 :
/*Si l'objet n'a pas la relation du champ, mais qu'elle devrait (par ses groupes),
* retourne la valeur par défaut du champ
* si le champ ne doit pas apparaitre dans cet élément, retourne null
* */
// Lecture de la valeur par défaut du champ
/* le 3/2/04 pourquoi ? ça ralentit tout !!, annule cette modif*/
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(nIdChamp))
{
object valeurParDefaut = champ.ValeurParDefaut;
/*if ( valeurParDefaut == null )
* return null;
* //La valeur par défaut n'est pas null, regarde si cet élément doit avoir ce champ
* foreach ( CChampCustom champNormal in TousLesChamps )
* {
* if ( champNormal == champ )
* return valeurParDefaut;
* }*/
return(valeurParDefaut);
}
return(null);
}
//------------------------------------------------------------------------------------------
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
string strIdChamp = "";
string strPropriete = "";
string strCle = "";
if (listeSource.Count == 0)
{
return;
}
bool bFromEntiteToChamp = false;
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
return;
}
if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
{
//c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
//Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
listeSource.ReadDependances(arbre);
return;
}
//On a affaire à une liste source qui contient des valeurs qui sont pointées
//par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs
CChampCustom champ = new CChampCustom(listeSource.ContexteDonnee);
CDbKey dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);
if (!champ.ReadIfExists(dbKeyChamp))
{
return;
}
//Vérifie que la liste source est bien du type de données du champ custom
if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
{
return;
}
IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;
if (obj == null)
{
return;
}
string strChampId = obj.GetChampId();
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
}
//Trouve le type des éléments à champs
Type typeElementsFinaux = champ.Role.TypeAssocie;
//Trouve le type des relations aux elementAchamp_ChampCustom
IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;
if (elt == null)
{
return;
}
string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
Type tpRelToChamp = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);
if (tpRelToChamp == null)
{
return;
}
foreach (string strPaquet in lstPaquetsALire)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);
//TESTDBKEYTODO
string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;
lst.Filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(typeElementsFinaux),
strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
strPaquet,
dbKeyChamp.GetValeurInDb());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
