//---------------------------------------------------------------
public object GetValeur(CVersionDonneesObjetOperation version)
{
IChampPourVersion champ = GetChamp(version);
if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
object valeur = version.GetValeurStd();
if (champCustom.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
Type tp = champCustom.TypeObjetDonnee;
if (tp != null && valeur is int)
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { version.ContexteDonnee });
if (objet != null && objet.ReadIfExists((int)valeur))
{
return(objet);
}
}
return(null);
}
return(valeur);
}
return(null);
}
//---------------------------------------------------------------------
public void SetValeur(object objet, object valeur)
{
if (objet != null && objet is IObjetDonneeAChamps)
{
if (valeur is int)
{
if ((int)valeur >= 0)
{
CContexteDonnee contexte = ((IObjetDonneeAChamps)objet).ContexteDonnee;
CChampCustom champ = new CChampCustom(contexte);
if (champ.ReadIfExists(IdChampCustom))
{
CObjetDonneeAIdNumerique objetDonne = (CObjetDonneeAIdNumerique)Activator.CreateInstance(champ.TypeObjetDonnee, new object[] { contexte });
if (objetDonne.ReadIfExists((int)valeur))
{
CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, objetDonne);
}
else
{
throw new Exception(I.T("Object @1 @2 doesn't exist|515",
DynamicClassAttribute.GetNomConvivial(champ.TypeObjetDonnee),
valeur.ToString()));
}
}
}
}
else
{
CUtilElementAChamps.SetValeurChamp((IObjetDonneeAChamps)objet, m_nIdChampCustom, null);
}
}
}
//----------------------------------------------------------
public CResultAErreur AnnuleModificationPrevisionnelle(CVersionDonneesObjet versionObjet)
{
CContexteDonnee contexte = versionObjet.ContexteDonnee;
CResultAErreur result = CResultAErreur.True;
int nIdObjet = versionObjet.IdElement;
Type typeObjet = versionObjet.TypeElement;
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
int nIdVersion = versionPrev.Id;
//Vérifie que l'utilisateur peut travailler avec cette version
result = versionPrev.EnregistreEvenement(CVersionDonnees.c_eventBeforeUtiliser, true);
if (!result)
{
return(result);
}
contexte.SetVersionDeTravail(-1, false);
//Suppression de l'objet associé
string strPrimKey = contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(typeObjet)).PrimaryKey[0].ColumnName;
CListeObjetsDonnees listeTmp = new CListeObjetsDonnees(contexte, typeObjet);
listeTmp.Filtre = new CFiltreData(
CSc2iDataConst.c_champIdVersion + "=@1 and " +
"(" + CSc2iDataConst.c_champOriginalId + "=@2 or " +
strPrimKey + "=@2)",
nIdVersion,
nIdObjet);
listeTmp.Filtre.IgnorerVersionDeContexte = true;
result = CObjetDonneeAIdNumerique.Delete(listeTmp);
if (!result)
{
return(result);
}
//Suppression de la version objet
result = versionObjet.Delete();
if (!result)
{
return(result);
}
//Force la modification de l'objet pour mettre à jour les versions suivantes
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(nIdObjet))
{
//Passe dans la version de l'objet
result = contexte.SetVersionDeTravail(objet.IdVersionDatabase, false);
if (!result)
{
return(result);
}
objet.Row.Row.SetModified();
}
return(result);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
macro.Libelle = version.Libelle;
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme();
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
variable.Nom = "CurrentElement";
variable.IdVariable = m_strIdVariableCurrentElement;
macro.AddVariable(variable);
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
if (!typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(vo.TypeElement) && vo.TypeElement.GetCustomAttributes(typeof(NoMacroAttribute), true).Length == 0)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
}
result.DataType = macro;
return(result);
}
}
//---------------------------------------------------------------------------
/// <summary>
/// Methode générique qui retourne une entité du jeux de test dans un contexte donné
/// </summary>
/// <typeparam name="TypeEntite"></typeparam>
/// <param name="nId"></param>
/// <param name="ctx"></param>
/// <returns></returns>
private CObjetDonneeAIdNumerique GetEntite(Type tp, int nId, CContexteDonnee ctx)
{
object obj = Activator.CreateInstance(tp, ctx);
CObjetDonneeAIdNumerique entite = obj as CObjetDonneeAIdNumerique;
if (entite != null && !entite.ReadIfExists(nId))
{
throw new Exception("L'entité: " + tp.ToString() + " avec l'ID " + nId.ToString() + " n'éxiste pas !");
}
return(entite);
}
public CObjetDonneeAIdNumerique GetObjetNomme()
{
Type tpObjet = TypeEntite;
object obj = Activator.CreateInstance(tpObjet, new object[] { ContexteDonnee });
CObjetDonneeAIdNumerique objAIdNum = obj as CObjetDonneeAIdNumerique;
if (objAIdNum != null && objAIdNum.ReadIfExists(CleEntite))
{
return(objAIdNum);
}
return(null);
}
private void ShowInfos(object obj)
{
if (obj == null)
{
m_panelInfo.Visible = false;
}
CRepertoire repertoire = obj as CRepertoire;
if (repertoire != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageDossier(repertoire)];
m_lblTitreErreur.Text = repertoire.Nom;
m_txtErreur.Text = repertoire.InfoImport;
}
CFichier fichier = obj as CFichier;
if (fichier != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageFichier(fichier)];
m_lblTitreErreur.Text = fichier.Nom;
if (fichier.KeyObjetAssocie != null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text = "Imported to ";
CObjetDonneeAIdNumerique objet = null;
if (CImportMyanmarConst.ContexteDonnee != null)
{
try
{
objet = Activator.CreateInstance(fichier.TypeObjetAssocie, new object[] { CImportMyanmarConst.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (obj != null && objet.ReadIfExists(fichier.KeyObjetAssocie))
{
m_txtErreur.Text += objet.DescriptionElement;
}
}
catch { }
}
if (objet == null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text += DynamicClassAttribute.GetNomConvivial(fichier.TypeObjetAssocie);
}
else
{
m_txtErreur.Text += " ? ";
}
}
else
{
m_txtErreur.Text = fichier.InfoImport;
}
}
}
//------------------------------------------------------------------------------------------
public CResultAErreur Execute(CContexteExecutionMacro contexteExecution)
{
CResultAErreur result = CResultAErreur.True;
//Initialise les valeurs des variables
foreach (KeyValuePair <string, CDbKey> kv in m_dicVariableToInitialId)
{
IVariableDynamique var = GetVariable(kv.Key);
if (var != null && kv.Value != null)
{
Type tpObjet = var.TypeDonnee.TypeDotNetNatif;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjet))
{
try
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(tpObjet, new object[] { contexteExecution.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (obj != null && obj.ReadIfExists(kv.Value))
{
SetValeurChamp(kv.Key, obj);
}
}
catch { }
}
}
}
IVariableDynamique variable = VariableCible;
if (variable == null)
{
result.EmpileErreur("#Macro target is not specified");
return(result);
}
if (contexteExecution.Cible != null && variable.TypeDonnee.TypeDotNetNatif != contexteExecution.Cible.GetType())
{
result.EmpileErreur("#Macro must be applied on " + DynamicClassAttribute.GetNomConvivial(variable.TypeDonnee.TypeDotNetNatif));
return(result);
}
SetValeurChamp(variable.IdVariable, contexteExecution.Cible);
if (Formulaire != null)
{
if (CFormFormulairePopup.EditeElement(Formulaire, this, "MACRO"))
{
foreach (CMacroObjet macObj in Objets)
{
macObj.Execute(contexteExecution);
}
}
}
return(result);
}
//----------------------------------
public CObjetDonneeAIdNumerique GetObjet(CContexteDonnee ctx)
{
if (IdObjet != null)
{
try
{
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(m_typeObjet, new object[] { ctx }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(IdObjet.Value))
{
return(objet);
}
}
catch { }
}
return(null);
}
//-------------------------------------------------------
public static CResultAErreurType <CMacro> FromVersion(CVersionDonnees version)
{
CResultAErreurType <CMacro> result = new CResultAErreurType <CMacro>();
using (CContexteDonnee contexte = new CContexteDonnee(version.ContexteDonnee.IdSession, true, false))
{
contexte.SetVersionDeTravail(version.Id, false);
CMacro macro = new CMacro();
macro.m_contexteDonnee = version.ContexteDonnee;
Dictionary <int, CMacroObjet> dicMacrosObjets = new Dictionary <int, CMacroObjet>();
Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacros = new Dictionary <CObjetDonneeAIdNumerique, CMacroObjet>();
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = new CMacroObjet(macro);
mo.TypeObjet = vo.TypeElement;
mo.IdObjet = vo.IdElement;
mo.TypeOperation = vo.TypeOperation;
macro.AddObjet(mo);
dicMacrosObjets[vo.Id] = mo;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexte }) as CObjetDonneeAIdNumerique;
if (objet.ReadIfExists(vo.IdElement))
{
dicObjetToMacros[objet] = mo;
}
mo.CreateVariable(objet);
}
foreach (CVersionDonneesObjet vo in version.VersionsObjets)
{
CMacroObjet mo = dicMacrosObjets[vo.Id];
CResultAErreur resMo = CResultAErreur.True;
resMo = mo.FillFromVersion(vo, contexte, dicObjetToMacros);
if (!resMo)
{
result.EmpileErreur(resMo.Erreur);
}
}
result.DataType = macro;
return(result);
}
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objetTypeId = objet as CObjetDonneeAIdNumerique;
if (objetTypeId == null)
{
return(result);
}
//trouve la relation correspondante à l'identifiant de la propriété
RelationTypeIdAttribute relation = null;
foreach (RelationTypeIdAttribute relTest in CContexteDonnee.RelationsTypeIds)
{
if (relTest.IdRelation == strPropriete)
{
relation = relTest;
break;
}
}
if (relation == null)
{
result.EmpileErreur(I.T("Relation @1 doesn't exists|20030", strPropriete));
return(result);
}
CObjetDonneeAIdNumerique objetParent = null;
//Récupère le type de l'objet parent
try
{
Type tp = CActivatorSurChaine.GetType((string)objetTypeId.Row[relation.ChampType], false);
objetParent = Activator.CreateInstance(tp, new object[] { objetTypeId.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (!objetParent.ReadIfExists((int)objetTypeId.Row[relation.ChampId]))
{
objetParent = null;
}
}
catch { }
result.Data = objetParent;
return(result);
}
/// //////////////////////////////////////////////////////////////////////////
public CResultAErreur DeclencheEvenementStatiques(Type typeObjet, CDbKey dbKeyObjet)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (!objet.ReadIfExists(dbKeyObjet))
{
result.EmpileErreur(I.T("The @1 object with id @2 doesn't exist|106", DynamicClassAttribute.GetNomConvivial(typeObjet), dbKeyObjet.StringValue));
return(result);
}
IDeclencheurAction[] declencheurs = CRecuperateurDeclencheursActions.GetDeclencheursAssocies(objet);
foreach (IDeclencheurAction declencheur in declencheurs)
{
if (declencheur is CEvenement)
{
CEvenement evt = (CEvenement)declencheur;
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess();
bool bShouldDeclenche = false;
if (!evt.DejaDeclenchePourEntite(objet))
{
bShouldDeclenche = evt.ParametreDeclencheur.ShouldDeclenche(
objet,
false,
true,
ref infoDeclencheur);
}
if (bShouldDeclenche)
{
evt.EnregistreDeclenchementEvenement(objet, infoDeclencheur);
}
if (!result)
{
return(result);
}
}
}
}
return(result);
}
/// ///////////////////////////////////////////
public object GetValeurParDefaut(CContexteDonnee contexte)
{
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(m_type.TypeDotNetNatif))
{
try
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(m_type.TypeDotNetNatif, new object[] { contexte });
// TESTDBKEYOK
if (m_dbKeyIdInitial != null && objet.ReadIfExists(m_dbKeyIdInitial))
{
return(objet);
}
}
catch { }
}
if (m_type.TypeDotNetNatif.GetCustomAttributes(typeof(VariableAutoAlloueeAttribute), true).Length > 0 && !m_type.IsArrayOfTypeNatif)
{
return(Activator.CreateInstance(m_type.TypeDotNetNatif, new object[0]));
}
return(null);
}
//------------------------------------------------------------------------------
public CDataPlanning(Type typeElement, int nIdElement, CContexteDonnee ctx)
{
m_typeElement = typeElement;
try
{
CObjetDonneeAIdNumerique element = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(typeElement, new object[] { ctx });
if (element.ReadIfExists(nIdElement))
{
m_element = (IElementDataDeTableauPlanning)element;
}
else
{
m_element = null;
}
}
catch
{
m_element = null;
}
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (!def.IsReadOnly && strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", def.Nom), true));
}
}
}
}
if (objet is CElementAChamp)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((CElementAChamp)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == rel.ChampCustom.Id);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
this.AddValeur(mv);
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", rel.ChampCustom.Nom), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == champCustom.Id);
}
}
if (def != null && !def.IsReadOnly)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (!FillMacroValeurWithValue(mv, valeur.GetValeur(), dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", valeur.NomChampConvivial), true));
}
else
{
AddValeur(mv);
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
/// <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);
}
private void m_arbreObjet_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
using (CWaitCursor waiter = new CWaitCursor())
{
if (e.Node.Nodes.Count != 1 || e.Node.Nodes[0].Tag != DBNull.Value)
{
return; //C'est un vrai noeud, on ne remplit pas
}
e.Node.Nodes.Clear();
if (e.Node.Tag is CObjetDonneeAIdNumerique)
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)e.Node.Tag;
CValeursHistorique valeursHistoriques = GetValeursHistorique(objet);
CStructureTable structure = CStructureTable.GetStructure(objet.GetType());
#region relations parentes
//traitement des relations parentes
foreach (CInfoRelation relation in structure.RelationsParentes)
{
Type tpParent = CContexteDonnee.GetTypeForTable(relation.TableParente);
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpParent) && relation.Propriete != "")
{
int nImage = c_nImageUnchanged;
object newValeur = objet.Row[relation.ChampsFille[0]];
if (newValeur == null) //Pour éviter les problèmes de null
{
newValeur = DBNull.Value;
}
object oldValeur = newValeur;
//Cherche si la valeur pour cette version a changé
CChampPourVersionInDb champ = new CChampPourVersionInDb(relation.ChampsFille[0], relation.ChampsFille[0]);
if (valeursHistoriques.ContainsKey(champ))
{
oldValeur = valeursHistoriques[champ];
if (!newValeur.Equals(oldValeur))
{
nImage = c_nImageEdit;
}
}
TreeNode node = new TreeNode(relation.NomConvivial);
node.Tag = relation;
node.ImageIndex = nImage;
node.SelectedImageIndex = nImage;
e.Node.Nodes.Add(node);
//Ajoute la valeur actuelle
CObjetDonneeAIdNumerique parent = (CObjetDonneeAIdNumerique)objet.GetParent(relation.ChampsFille[0], tpParent);
TreeNode nodeParent = CreateNodeObjet(node.Nodes, parent);
nodeParent.StateImageIndex = c_nImageActuel;
//Ajoute valeur historique
if (!newValeur.Equals(oldValeur))
{
parent = null;
nodeParent = null;
if (oldValeur is int)
{
//récupère l'ancien parent
parent = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpParent, new object[] { objet.ContexteDonnee });
if (!parent.ReadIfExists((int)oldValeur))
{
parent = null;
}
}
nodeParent = CreateNodeObjet(node.Nodes, parent);
nodeParent.StateImageIndex = c_nImageHistory;
}
}
}
#endregion
#region relations filles
foreach (CInfoRelation relationFille in structure.RelationsFilles)
{
if (relationFille.NomConvivial != "")
{
Type tpFille = CContexteDonnee.GetTypeForTable(relationFille.TableFille);
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFille))
{
int nImageNodeRelation = c_nImageUnchanged;
TreeNode nodeRelation = new TreeNode(relationFille.NomConvivial);
e.Node.Nodes.Add(nodeRelation);
Hashtable tableOldIds = new Hashtable();
foreach (int nId in m_version.GetIdsChildsHistoriques(objet, relationFille))
{
tableOldIds.Add(nId, true);
}
//Récupère la liste de tous les fils actuels
C2iRequeteAvancee requete = new C2iRequeteAvancee(-1);
requete.TableInterrogee = relationFille.TableFille;
C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID",
new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champDeRequete);
CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and " +
CSc2iDataConst.c_champIdVersion + " is null",
objet.Id);
filtre.IgnorerVersionDeContexte = true;
requete.FiltreAAppliquer = filtre;
Hashtable tableNewIds = new Hashtable();
CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession);
if (result)
{
foreach (DataRow row in ((DataTable)result.Data).Rows)
{
tableNewIds.Add(row[0], true);
}
}
//Ajoute les ids actuels
foreach (int nId in tableNewIds.Keys)
{
CObjetDonneeAIdNumerique fils = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpFille, new object[] { objet.ContexteDonnee });
if (fils.ReadIfExists(nId))
{
int nImage = -1;
if (!tableOldIds.ContainsKey(nId))
{
nImage = c_nImagePlus;
nImageNodeRelation = c_nImageEdit;
}
TreeNode nodeFille = CreateNodeObjet(nodeRelation.Nodes, fils);
if (nImage >= 0)
{
nodeFille.StateImageIndex = nImage;
}
}
}
//Ajoute les vieux ids
foreach (int nId in tableOldIds.Keys)
{
if (!tableNewIds.ContainsKey(nId))
{
CObjetDonneeAIdNumerique fils = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpFille, new object[] { objet.ContexteDonnee });
if (fils.ReadIfExists(nId))
{
int nImage = c_nImageMoins;
nImageNodeRelation = c_nImageEdit;
TreeNode nodeFille = CreateNodeObjet(nodeRelation.Nodes, fils);
nodeFille.StateImageIndex = nImage;
}
}
}
nodeRelation.ImageIndex = nImageNodeRelation;
nodeRelation.SelectedImageIndex = nImageNodeRelation;
}
}
}
#endregion
}
}
}
/// /////////////////////////////////////////////////////////
public static object StringToType(TypeDonnee type, string strTexte, CContexteDonnee contexteDonnee)
{
if (strTexte.ToUpper() == c_ConstanteNull)
{
return(null);
}
switch (type)
{
case TypeDonnee.tBool:
return(strTexte.ToString() == "1" || strTexte.ToUpper() == "TRUE");
case TypeDonnee.tDate:
try
{
return(Convert.ChangeType(strTexte, typeof(DateTime), null));
}
catch
{
//Tente le format sc2i de date chaine
try
{
return(CUtilDate.FromUniversalString(strTexte));
}
catch
{
return(null);
}
}
case TypeDonnee.tDouble:
try
{
return(CUtilDouble.DoubleFromString(strTexte));
}
catch
{
return(null);
}
case TypeDonnee.tEntier:
try
{
return(Convert.ChangeType(strTexte, typeof(int), null));
}
catch
{
return(null);
}
case TypeDonnee.tString:
return(strTexte);
case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
try
{
if (contexteDonnee == null)
{
return(null);
}
//Syntaxe : classe|id
int nPos = strTexte.LastIndexOf("|");
if (nPos < 0)
{
return(null);
}
string strClasse = strTexte.Substring(0, nPos);
int nId = Int32.Parse(strTexte.Substring(nPos + 1));
Type tp = CActivatorSurChaine.GetType(strClasse, true);
if (tp != null)
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { contexteDonnee });
if (objet.ReadIfExists(nId))
{
return(objet);
}
}
return(null);
}
catch
{
return(null);
}
}
return(null);
}
//------------------------------------
private CResultAErreur ImporteRow(DataRow row, CFiltreData filtreCle, CContexteDonnee contexteDestination)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <CDefinitionProprieteDynamique, object> dicValeurs = new Dictionary <CDefinitionProprieteDynamique, object>();
List <object> lstValeurs = new List <object>();
if (filtreCle != null)
{
filtreCle.Parametres.Clear();
}
foreach (CMappageChampImport mappage in Mappages)
{
object valeur = mappage.Origine.GetValeur(row);
if (mappage.IsCle && filtreCle != null)
{
if (valeur == null)
{
result.EmpileErreur("Can not import field @1 as key, because imported value is null|20045", mappage.ProprieteDestination.Nom);
return(result);
}
filtreCle.Parametres.Add(valeur);
}
dicValeurs[mappage.ProprieteDestination] = valeur;
}
CObjetDonnee objet = Activator.CreateInstance(m_typeCible, new object[] { contexteDestination }) as CObjetDonnee;
bool bCreate = true;
//Cherche si l'objet exite
if (filtreCle != null)
{
bCreate = !objet.ReadIfExists(filtreCle, !m_bChargerTouteLaCible);
}
if (bCreate && (OptionImport & EOptionImport.Create) != EOptionImport.Create)
{
return(result);
}
if (!bCreate && (OptionImport & EOptionImport.Update) != EOptionImport.Update)
{
return(result);
}
if (bCreate)
{
objet.CreateNewInCurrentContexte(null);
}
bool bUpdate = false;
foreach (KeyValuePair <CDefinitionProprieteDynamique, object> kv in dicValeurs)
{
object val = kv.Value;
if (kv.Value is int && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(kv.Key.TypeDonnee.TypeDotNetNatif))
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(kv.Key.TypeDonnee.TypeDotNetNatif, new object[] { contexteDestination }) as CObjetDonneeAIdNumerique;
if (!obj.ReadIfExists((int)kv.Value, !m_bChargerTouteLaCible))
{
obj = null;
}
val = obj;
}
result = CInterpreteurProprieteDynamique.GetValue(objet, kv.Key);
if (result)
{
object valeurOrigine = result.Data;
if ((val == null && valeurOrigine != null) ||
(valeurOrigine == null && val != null) ||
(val != null && valeurOrigine != null && !val.Equals(valeurOrigine)))
{
result = CInterpreteurProprieteDynamique.SetValue(objet, kv.Key, val);
if (!result)
{
return(result);
}
bUpdate = true;
}
}
}
if (bCreate)
{
m_nNbCreated++;
}
else if (bUpdate)
{
m_nNbUpdated++;
}
return(result);
}
//-------------------------------------------------------------------------------
public CResultAErreur FillFromSnmp(CEntiteSnmpPourSupervision entiteFromSnmp)
{
CResultAErreur result = CResultAErreur.True;
CTypeAgentSnmp typeAgent = AgentSnmp.TypeAgent;
CTypeEntiteSnmp[] typesEntites = (CTypeEntiteSnmp[])typeAgent.TypesEntites.ToArray(typeof(CTypeEntiteSnmp));
CTypeEntiteSnmp typeEntite = typesEntites.FirstOrDefault(t => t.Id.ToString() == entiteFromSnmp.TypeEntite.Id);
if (typeEntite == null)
{
result.EmpileErreur(I.T("Can not find Snmp entity type @1|20309", entiteFromSnmp.TypeEntite.Id));
return(result);
}
TypeEntiteSnmp = typeEntite;
Index = entiteFromSnmp.Index;
Libelle = entiteFromSnmp.Libelle;
//Affecte les champs
foreach (CChampEntiteFromQueryToChampCustom champ in typeEntite.ChampsFromQuery)
{
if (champ.IdChampCustom != null)
{
CChampCustom champCustom = new CChampCustom(ContexteDonnee);
if (champCustom.ReadIfExists(champ.IdChampCustom))
{
object valeur = entiteFromSnmp.GetValeurChamp(champ.Champ.Id);
if (valeur != null)
{
if (champCustom.TypeDonneeChamp.TypeDonnee == TypeDonnee.tObjetDonneeAIdNumeriqueAuto)
{
Type tp = champCustom.TypeObjetDonnee;
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(tp, new object[] { ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (valeur is int)
{
if (obj != null && obj.ReadIfExists((int)valeur, true))
{
SetValeurFromSnmp(champ.IdChampCustom.Value, obj);
}
}
else
{
SetValeurFromSnmp(champ.IdChampCustom.Value, null);
}
}
else
{
SetValeurFromSnmp(champ.IdChampCustom.Value, valeur);
}
}
}
}
}
//calcule le libellé
if (typeEntite.FormuleCalculLibelle != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this);
result = typeEntite.FormuleCalculLibelle.Eval(ctx);
if (result && result.Data != null)
{
Libelle = result.Data.ToString();
}
result = CResultAErreur.True;
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
string strVal = listeParametres[0].ToString();
Type tp = listeParametres[0] as Type;
if (tp == null)
{
tp = CActivatorSurChaine.GetType(strVal, true);
}
if (tp == null)
{
tp = CActivatorSurChaine.GetType(strVal, false);
}
if (tp == null)
{
result.EmpileErreur(I.T("The @1 type does not exist|221", strVal));
return(result);
}
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
result.EmpileErreur(I.T("The @1 type cannot be loaded by the 'GetEntite' function|222", strVal));
return(result);
}
try
{
CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
if (contexteDonnee == null)
{
contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
}
CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { contexteDonnee });
if (listeParametres[1] is int)
{
if (obj.ReadIfExists((int)listeParametres[1]))
{
result.Data = obj;
}
else
{
result.Data = null;
}
}
// YK 14/04/2011 Surcharge du deuxième paramètre en String Nom de l'entité nommée
else if (listeParametres[1] is string)
{
CNommageEntite nommage = new CNommageEntite(contexteDonnee);
if (nommage.ReadIfExists(new CFiltreData(
CNommageEntite.c_champTypeEntite + " = @1 AND " +
CNommageEntite.c_champNomFort + " = @2",
tp.ToString(),
(string)listeParametres[1])))
{
result.Data = nommage.GetObjetNomme();
}
else if (typeof(IObjetDonnee).IsAssignableFrom(tp))
{
IObjetDonnee objUniv = (IObjetDonnee)Activator.CreateInstance(tp, new object[] { contexteDonnee });
if (objUniv.ReadIfExistsUniversalId((string)listeParametres[1]))
{
result.Data = objUniv;
}
}
else
{
result.Data = null;
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
////////////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (result)
{
result = base.Serialize(serializer);
}
if (!result)
{
return(result);
}
bool bHasElement;
#region Version 0 : un seul élément
if (nVersion == 0)
{
CObjetDonneeAIdNumerique objet = null;
if (m_elementsAAgenda.Length > 0)
{
objet = m_elementsAAgenda[0];
}
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
bHasElement = objet != null;
serializer.TraiteBool(ref bHasElement);
if (bHasElement)
{
Type tp = objet.GetType();
serializer.TraiteType(ref tp);
int nId = objet.Id;
serializer.TraiteInt(ref nId);
}
break;
case ModeSerialisation.Lecture:
bHasElement = false;
serializer.TraiteBool(ref bHasElement);
if (!bHasElement)
{
objet = null;
}
else
{
Type tp = null;
serializer.TraiteType(ref tp);
objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { m_contexte });
int nId = 0;
serializer.TraiteInt(ref nId);
if (!objet.ReadIfExists(nId))
{
objet = null;
}
}
if (objet == null)
{
m_elementsAAgenda = new CObjetDonneeAIdNumerique[0];
}
else
{
m_elementsAAgenda = new CObjetDonneeAIdNumerique[] { objet }
};
break;
}
}
#endregion
return(result);
}
//-----------------------------------------------------------------------
private CResultAErreur TraiteModifiesFromSecondaire(CContexteDonnee ctxSecondaire)
{
CResultAErreur result = CResultAErreur.True;
CUtilSynchronisation utilSync = new CUtilSynchronisation(IdSession);
int nIdSyncSessionEnCours = utilSync.IdSyncSession;
ArrayList lstTables = ctxSecondaire.GetTablesOrderInsert();
DataTable tableLogsSynchroFromSecondaire = ctxSecondaire.Tables[CEntreeLogSynchronisation.c_nomTable];
if (tableLogsSynchroFromSecondaire == null)
{
result.EmpileErreur(I.T("Synchro table missing|20003"));
return(result);
}
foreach (DataTable tableSource in lstTables)
{
Type tpObjet = CContexteDonnee.GetTypeForTable(tableSource.TableName);
if (
tableSource.PrimaryKey.Length == 1 &&
m_mappeurTablesToClass.IsSynchronisable(tableSource.TableName) &&
tpObjet != null)
{
DataTable tableDest = GetTableSafe(tableSource.TableName);
string strPrimKey = tableDest.PrimaryKey[0].ColumnName;
ArrayList lstRows = new ArrayList(tableSource.Rows);
foreach (DataRow rowSource in lstRows)
{
//S'assure que la rowSource a bien été modifiée
if (rowSource.RowState == DataRowState.Modified)
{
DataRow rowDest = tableDest.Rows.Find(rowSource[strPrimKey]);
if (rowDest == null)
{
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(tpObjet, new object[] { this }) as CObjetDonneeAIdNumerique;
if (objet != null)
{
if (!objet.ReadIfExists((int)rowSource[strPrimKey]))
{
objet = null;
}
else
{
rowDest = objet.Row.Row;
}
}
}
else
{
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(tpObjet, new object[] { rowDest }) as CObjetDonneeAIdNumerique;
//S'assure de la lecture de la ligne
DataRow rowTmp = objet.Row.Row;
}
if (rowDest != null)//sinon, c'est bizarre, ça
//veut dire que la ligne aurait été supprimée dans la base principale
{
foreach (DataColumn col in tableSource.Columns)
{
if (rowDest.Table.Columns.Contains(col.ColumnName) &&
col.ColumnName != strPrimKey)
{
rowDest[col.ColumnName] = rowSource[col.ColumnName];
}
}
rowDest[CSc2iDataConst.c_champIdSynchro] = nIdSyncSessionEnCours;
}
}
}
}
}
return(result);
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
CStructureTable structure = CStructureTable.GetStructure(vo.TypeElement);
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut ForceSetOnMacro, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(strNom);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length != 0)
{
bAdd = true;
}
}
if (bAdd)
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", def.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
if (objet is IObjetDonneeAChamps)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((IObjetDonneeAChamps)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == rel.ChampCustom.DbKey);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", rel.ChampCustom.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
if (def == null)
{
CInfoRelation relation = structureObjet.RelationsParentes.FirstOrDefault(i => i.ChampsFille.Length == 1 && i.ChampsFille[0] == strNomChamp);
if (relation != null)
{
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == relation.Propriete);
}
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == champCustom.DbKey);
}
}
if (def != null)
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut TiagRelation, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(def.NomProprieteSansCleTypeChamp);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length > 0)
{
bAdd = true;
}
}
if (bAdd)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
object val = valeur.GetValeur();
if (val != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(def.TypeDonnee.TypeDotNetNatif) && valeur.TypeValeur == typeof(int))
{
CObjetDonneeAIdNumerique objetParent = Activator.CreateInstance(def.TypeDonnee.TypeDotNetNatif, new object[] { objet.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (objetParent.ReadIfExists((int)valeur.GetValeur()))
{
val = objetParent;
}
else
{
val = null;
}
}
if (!FillMacroValeurWithValue(mv, val, dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of @2 in macro", valeur.NomChampConvivial,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
else
{
AddValeur(mv);
}
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
IDataBaseCreator createur = connection.GetDataBaseCreator();
string strNomTableInContexte = CContexteDonnee.GetNomTableForType(m_type);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTableInContexte);
createur.CreationOuUpdateTableFromType(m_type);
string strChampIdObjet = m_strChampIdObjet;
if (m_strChampIdObjet.StartsWith("#SQL#"))
{
strChampIdObjet = m_strChampIdObjet.Substring("#SQL#".Length);
}
CObjetServeur.ClearCacheSchemas();
if (createur.ChampExists(strNomTableInDb, strChampIdObjet) &&
createur.ChampExists(strNomTableInDb, m_strChampDbKey))
{
using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strNomTableInDb;
CStructureTable structure = CStructureTable.GetStructure(m_type);
/*
* requete.ListeChamps.Add ( new C2iChampDeRequete (
* "ID",
* new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
* typeof(int),
* OperationsAgregation.None,
* true ));*/
requete.ListeChamps.Add(new C2iChampDeRequete(
"IDOBJET",
new CSourceDeChampDeRequete(m_strChampIdObjet),
typeof(int),
OperationsAgregation.None,
true));
if (m_typeObjetFixe == null)
{
requete.ListeChamps.Add(new C2iChampDeRequete(
"TYPEOBJET",
new CSourceDeChampDeRequete(m_strChampTypeObjet),
typeof(string),
OperationsAgregation.None,
true));
}
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
DataTable table = result.Data as DataTable;
Dictionary <int, int?> dicIdToIdObjet = new Dictionary <int, int?>();
string strFieldIdObjetInTable = m_strChampIdObjet.Replace("#SQL#", "");
foreach (DataRow row in table.Rows)
{
object val = row["IDOBJET"];
int? nValId = val == DBNull.Value?null:(int?)val;
if (nValId != null && nValId >= 0)
{
CDbKey key = null;
Type tp = m_typeObjetFixe;
if (tp == null)//Type non fixe
{
string strType = (string)row["TYPEOBJET"];
tp = CActivatorSurChaine.GetType(strType);
}
if (tp != null)
{
CObjetDonneeAIdNumerique objPointe = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, ctx);
if (objPointe.ReadIfExists(nValId.Value))
{
key = objPointe.DbKey;
}
}
if (key != null)
{
string strRequete = "Update " + strNomTableInDb + " set " +
m_strChampDbKey + "=" + connection.GetStringForRequete(key.StringValue) + " where " +
strFieldIdObjetInTable + "=" + nValId.Value;
if (m_typeObjetFixe == null)
{
strRequete += " and " + m_strChampTypeObjet + "='" +
row["TYPEOBJET"].ToString() + "'";
}
connection.RunStatement(strRequete);
}
}
}
}
//Supprime le champ
createur.DeleteChamp(strNomTableInDb, strChampIdObjet);
}
return(result);
}
//-------------------------------------------------------------------
public virtual object GetValeur(DataRowVersion version)
{
if (ChampCustom == null)
{
return("");
}
if (IsNull)
{
return(null);
}
try
{
switch (ChampCustom.TypeDonneeChamp.TypeDonnee)
{
case TypeDonnee.tBool:
return((bool)Row[c_champValeurBool, version]);
case TypeDonnee.tDate:
return((DateTime)Row[c_champValeurDate, version]);
case TypeDonnee.tDouble:
if (ChampCustom.ClasseUnite != null)
{
string strFormat = (string)Row[c_champValeurString, version];
if (strFormat == null || strFormat.Trim().Length == 0)
{
strFormat = ChampCustom.FormatAffichageUnite;
if (strFormat.Trim().Length == 0)
{
}
}
if (strFormat == null)
{
strFormat = "";
}
return(new CValeurUnite((double)Row[c_champValeurDouble],
ChampCustom.ClasseUnite.UniteBase,
strFormat));
}
return((double)Row[c_champValeurDouble, version]);
case TypeDonnee.tEntier:
return((int)Row[c_champValeurInt, version]);
case TypeDonnee.tString:
return((string)Row[c_champValeurString, version]);
case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
{
string strType = (string)Row[c_champValeurString, version];
int nId = (int)Row[c_champValeurInt, version];
Type tp = CActivatorSurChaine.GetType(strType, true);
if (tp != null)
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { ContexteDonnee });
if (objet.ReadIfExists(nId))
{
return(objet);
}
}
return(null);
}
}
}
catch
{
}
return(ChampCustom.TypeDonneeChamp.ObjectToType("", ContexteDonnee));
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
List <Type> lstTypesAVerifier = new List <Type>();
//Trouve tous les types héritant de CMappableTimos
foreach (Assembly ass in sc2i.common.CGestionnaireAssemblies.GetAssemblies())
{
foreach (Type tp in ass.GetTypes())
{
if (typeof(IObjetSPVAvecObjetTimos).IsAssignableFrom(tp))
{
lstTypesAVerifier.Add(tp);
}
}
}
List <string> lstTablesDansOrdre = new List <string>();
using (CContexteDonnee ctxTmp = new CContexteDonnee(contexte.IdSession, true, false))
{
foreach (Type tp in lstTypesAVerifier)
{
string strTable = CContexteDonnee.GetNomTableForType(tp);
if (strTable != null)
{
ctxTmp.GetTableSafe(strTable);
}
}
foreach (DataTable table in ctxTmp.GetTablesOrderInsert())
{
lstTablesDansOrdre.Add(table.TableName);
}
}
foreach (string strNomTable in lstTablesDansOrdre)
{
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
Type tpParent = tp;
Type[] generics = new Type[0];
while (tpParent != null && generics.Length == 0)
{
if (tpParent.IsGenericType && tpParent.GetGenericTypeDefinition() == typeof(CMappableAvecTimos <,>))
{
generics = tpParent.GetGenericArguments();
}
tpParent = tpParent.BaseType;
}
if (generics.Length == 0)
{
continue;
}
IObjetSPVAvecObjetTimos obj = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as IObjetSPVAvecObjetTimos;
Type typeTimos = obj.GetTypeObjetsTimos();
//Lit tous les objets TIMOS
CListeObjetsDonnees lstObjetsTimos = new CListeObjetsDonnees(contexte.ContexteDonnee, typeTimos);
lstObjetsTimos.AssureLectureFaite();
CListeObjetsDonnees lstObjetsSpv = new CListeObjetsDonnees(contexte.ContexteDonnee, obj.GetType());
lstObjetsSpv.AssureLectureFaite();
string strIdObjetTimosInObjetSpv = obj.GetChampIdObjetTimos();
Type tpMappable = typeof(CMappeurTimos <,>).MakeGenericType(generics);
IMappeurTimosNonGenerique mappeur = Activator.CreateInstance(tpMappable) as IMappeurTimosNonGenerique;
foreach (CObjetDonneeAIdNumerique objTimos in (CObjetDonneeAIdNumerique[])lstObjetsTimos.ToArray(typeof(CObjetDonneeAIdNumerique)))
{
CObjetDonneeAIdNumerique objSpv = Activator.CreateInstance(tp, new object[] { contexte.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (!objSpv.ReadIfExists(new CFiltreData(strIdObjetTimosInObjetSpv + "=@1",
objTimos.Id), false))
{
mappeur.GetObjetSpvFromObjetTimosAvecCreationSansGenerique(objTimos);
}
}
}
return(result);
}
