//--------------------------------------------------------------- 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); }