private void EditeElement() { CReferenceTypeForm refTypeForm = null; if (m_strCodeFormulaire != string.Empty) { refTypeForm = CFormFinder.GetRefFormToEdit(m_objetToEdit.GetType(), m_strCodeFormulaire); } else { refTypeForm = CFormFinder.GetRefFormToEdit(m_objetToEdit.GetType()); } if (refTypeForm == null) { m_resultEdit.EmpileErreur(I.T("The system is not able to edit elements from type @1|1076", m_objetToEdit.GetType().ToString())); return; } try { CFormEditionStandard form = refTypeForm.GetForm((CObjetDonneeAIdNumeriqueAuto)m_objetToEdit) as CFormEditionStandard; if (form != null) { CFormNavigateurPopup.Show(form); } } catch (Exception e) { m_resultEdit.EmpileErreur(new CErreurException(e)); } }
//---------------------------------------------------------------------------- public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet) { List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>(); if (objet == null) { return(lst); } if (!(objet is CObjetDonneeAIdNumerique)) { return(lst); } foreach (RelationTypeIdAttribute rt in CContexteDonnee.RelationsTypeIds) { if (rt.IsAppliqueToType(objet.GetType()) && objet.GetType().GetCustomAttribute <NoRelationTypeIdAttribute>() == null) { Type tpRelId = CContexteDonnee.GetTypeForTable(rt.TableFille); if (tpRelId != null && !manager.ConfigurationRecherche.IsIgnore(tpRelId)) { CListeObjetsDonnees lstRT = new CListeObjetsDonnees(objet.ContexteDonnee, tpRelId); lstRT.Filtre = new CFiltreData(rt.ChampType + "=@1 and " + rt.ChampId + "=@2", objet.GetType().ToString(), ((CObjetDonneeAIdNumerique)objet).Id); foreach (CObjetDonnee objetRT in lstRT) { lst.Add(new CReferenceObjetDependant(rt.NomConvivialPourParent, objetRT)); } } } } return(lst); }
private void FillNode(TreeNode node, CObjetDonnee objet) { string strLibelle = ""; if (objet.GetType() == typeof(CSpvFamilleMibmodule)) { strLibelle = ((CSpvFamilleMibmodule)objet).Libelle; node.Nodes.Add(""); node.BackColor = Color.LightGreen; } if (objet.GetType() == typeof(CSpvMibmodule)) { node.Nodes.Add(""); strLibelle = ((CSpvMibmodule)objet).NomModuleOfficiel; node.BackColor = Color.LightCyan; } if (objet.GetType() == typeof(CSpvMibTable)) { strLibelle = ((CSpvMibTable)objet).NomObjetOfficiel; node.Nodes.Add(""); node.BackColor = Color.LightGray; } if (objet.GetType() == typeof(CSpvMibVariable)) { CSpvMibVariable variable = objet as CSpvMibVariable; strLibelle = variable.NomObjetOfficiel; node.BackColor = Color.White; } node.Text = strLibelle; node.Tag = objet; }
public void SetEntite(string strCleFiltre, CObjetDonnee objet) { if (objet == null) { return; } CCacheEntitesDeType cache = null; if (!m_dicEntitesParType.TryGetValue(objet.GetType(), out cache)) { cache = new CCacheEntitesDeType(); m_dicEntitesParType[objet.GetType()] = cache; } cache[strCleFiltre] = objet; }
//----------------------------------------------------------- public void SetElementAjoute(CObjetDonnee objet) { if (objet == null) { return; } HashSet <CDbKey> set = null; if (!m_dicElementsAjoutes.TryGetValue(objet.GetType(), out set)) { set = new HashSet <CDbKey>(); m_dicElementsAjoutes[objet.GetType()] = set; } set.Add(objet.DbKey); }
//-------------------------------------------- public static bool SetParentViaPropriete(CAssociationTiag associationTiag, object obj, object[] valeursCles) { if (valeursCles.Length != 1) { return(false); } CObjetDonnee objet = obj as CObjetDonnee; if (objet == null) { return(false); } PropertyInfo info = objet.GetType().GetProperty(associationTiag.Propriete); if (info != null) { MethodInfo method = info.GetSetMethod(); if (method != null) { CObjetDonnee parent = Activator.CreateInstance(associationTiag.TypeParent, new object[] { objet.ContexteDonnee }) as CObjetDonnee; if (parent.ReadIfExists(valeursCles)) { method.Invoke(obj, new object[] { parent }); return(true); } } } return(false); }
/// <summary> /// /// /////////////////////////////////////// /// </summary> /// <param name="obj"></param> public CReferenceObjetDonnee(CObjetDonnee obj) { m_typeObjet = obj.GetType(); m_cles = obj.GetValeursCles(); if (obj.ManageIdUniversel) { m_keyObjet = obj.DbKey; } }
public CInfoAffectationDocumentToGed(string strNomFichier, CObjetDonnee elementSource) { m_strNomFichier = strNomFichier; m_elementSource = elementSource; if (elementSource != null) { m_typeSource = elementSource.GetType(); } }
//--------------------------------------------------------------- public CValeursProprietes(CObjetDonnee objet, bool bAvecValeursOriginales) { m_objetAssocie = objet; m_strLibelleObjet = objet.DescriptionElement; m_dbKeyObjet = objet.DbKey; m_typeObjet = objet.GetType(); m_bAvecValeursOriginales = bAvecValeursOriginales; m_versionObjetStocke = objet != null ? objet.VersionToReturn : DataRowVersion.Current; }
//--------------------------------------------------------------------------------- public void FillInventaireNonRecursif(object obj, CInventaire inventaire) { CObjetDonnee objetDonnee = obj as CObjetDonnee; if (objetDonnee != null) { CStructureTable structure = CStructureTable.GetStructure(objetDonnee.GetType()); if ((m_mode & EModeInventaireObjetDonneeLies.TousLesFils) != EModeInventaireObjetDonneeLies.Aucuns) { foreach (CInfoRelation relation in structure.RelationsFilles) { if (relation.Composition || (m_mode & EModeInventaireObjetDonneeLies.FilsCompositions) != EModeInventaireObjetDonneeLies.FilsCompositions) { CListeObjetsDonnees lst = objetDonnee.GetDependancesListe(relation.TableFille, relation.ChampsFille); foreach (CObjetDonnee fille in lst) { inventaire.AddObject(fille); } } } } if ((m_mode & EModeInventaireObjetDonneeLies.Parents) == EModeInventaireObjetDonneeLies.Parents) { foreach (CInfoRelation relation in structure.RelationsParentes) { CObjetDonnee parent = objetDonnee.GetParent(relation.ChampsFille, CContexteDonnee.GetTypeForTable(relation.TableParente)); if (parent != null) { inventaire.AddObject(parent); } } } foreach (IFournisseurInventaireObjetDonneeLies fournisseur in m_listeFournisseursSupplementaires) { fournisseur.FillInventaireNonRecursif(objetDonnee, inventaire, m_mode); } } else { if (obj is IUtilisateurObjetsDonnee) { CResultAErreur result = ((IUtilisateurObjetsDonnee)obj).GetObjetsUtilises(m_contexte); if (result) { foreach (CObjetDonnee objet in (CObjetDonnee[])result.Data) { inventaire.AddObject(objet); } } } } }
/// <summary> /// Vérifie qu'un objet respecte bien ses règles d'unicité /// </summary> /// <param name="objet"></param> /// <returns></returns> public static CResultAErreur VerifieUnicite(CObjetDonnee objet) { if (objet == null) { return(CResultAErreur.True); } CResultAErreur result = VerifieUnicite(objet.Row, GetFiltres(objet.GetType()), objet.GetType()); if (!result) { result.EmpileErreur(I.T("Unicity error on @1|20004", objet.DescriptionElement)); } return(result); }
//------------------------------------------------------ private void UpdateImage() { Image img = null; if (m_imageSpecifique != null) { m_picType.Image = m_imageSpecifique; } else { if (m_listeConfigs.Count == 1) { img = DynamicClassAttribute.GetImage(m_listeConfigs[0].TypeObjets); } else { if (SelectedObject != null) { img = DynamicClassAttribute.GetImage(SelectedObject.GetType()); } else { img = null; } } } m_picType.Image = img; switch (m_modeIcone) { case EModeAffichageImageTextBoxRapide.Never: m_picType.Visible = false; break; case EModeAffichageImageTextBoxRapide.Always: m_picType.Visible = img != null; break; case EModeAffichageImageTextBoxRapide.OnSelection: m_picType.Visible = img != null && SelectedObject != null; break; default: break; } }
//-------------------------------------------------------------- public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet) { objet.Refresh(); List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>(); if (objet == null) { return(lst); } Type tp = objet.GetType(); foreach (PropertyInfo info in tp.GetProperties()) { if (info.GetCustomAttribute <BlobDecoderAttribute>(true) != null) { try { DynamicFieldAttribute df = info.GetCustomAttribute <DynamicFieldAttribute>(); string strNomProp = df == null?info.Name:df.NomConvivial; MethodInfo methode = info.GetGetMethod(); List <CDbKey> lstKeys = new List <CDbKey>(); using (CDbKeyReaderTracker tracker = new CDbKeyReaderTracker()) { if (methode != null) { methode.Invoke(objet, new object[0]); } ; lstKeys.AddRange(tracker.TrackedKeys); } foreach (CDbKey key in lstKeys) { Type tpChild = manager.GetTypeForUniversalId(key.StringValue); if (tpChild != null && !manager.ConfigurationRecherche.IsIgnore(tpChild)) { lst.Add(new CReferenceObjetDependant(strNomProp, tpChild, key)); } } } catch { } } } return(lst); }
//---------------------------------------------------------------------- public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet) { List <CReferenceObjetDependant> lstRefs = new List <CReferenceObjetDependant>(); if (objet == null) { return(lstRefs); } Type tpObjet = objet.GetType(); List <MethodInfo> lstMethodes = new List <MethodInfo>(); foreach (MemberInfo member in from m in tpObjet.GetMembers() where m.GetCustomAttribute <DependanceObjetDonneeAttribute>(true) != null select m) { MethodInfo method = member as MethodInfo; if (method == null && member is PropertyInfo) { method = ((PropertyInfo)member).GetGetMethod(); } string strNom = member.Name; DynamicFieldAttribute fieldAtt = member.GetCustomAttribute <DynamicFieldAttribute>(true); if (fieldAtt != null) { strNom = fieldAtt.NomConvivial; } if (method != null) { try { CObjetDonnee dep = method.Invoke(objet, new object[0]) as CObjetDonnee; if (dep != null) { lstRefs.Add(new CReferenceObjetDependant(strNom, dep)); } } catch {} } } return(lstRefs); }
//------------------------------------------------ private CResultAErreurType <CValeursImportFixe> GetValeursFixesPourFilles(CObjetDonnee parent) { CResultAErreurType <CValeursImportFixe> resVals = new CResultAErreurType <CValeursImportFixe>(); if (Propriete is CDefinitionProprieteDynamiqueDotNet) { Type tp = MappagesEntitesFilles.ElementAt(0).ConfigMappage.TypeEntite; CDefinitionProprieteDynamique pDeFille = Propriete.GetDefinitionInverse(parent.GetType()); PropertyInfo info = tp.GetProperty(pDeFille.NomProprieteSansCleTypeChamp); if (info != null) { RelationAttribute relPar = info.GetCustomAttribute <RelationAttribute>(true); if (relPar != null) { CValeursImportFixe vals = new CValeursImportFixe(); for (int nChamp = 0; nChamp < relPar.ChampsFils.Length; nChamp++) { vals.SetValeur(relPar.ChampsFils[nChamp], parent.Row[relPar.ChampsParent[nChamp]]); } resVals.DataType = vals; return(resVals); } } } if (Propriete is CDefinitionProprieteDynamiqueRelationTypeId && parent is CObjetDonneeAIdNumerique) { RelationTypeIdAttribute att = ((CDefinitionProprieteDynamiqueRelationTypeId)Propriete).Relation; if (att != null) { CValeursImportFixe vals = new CValeursImportFixe(); vals.SetValeur(att.ChampType, parent.GetType().ToString()); vals.SetValeur(att.ChampId, ((CObjetDonneeAIdNumerique)parent).Id); resVals.DataType = vals; return(resVals); } } resVals.EmpileErreur(I.T("Can not define parent filter for property @1|20098", Propriete.Nom)); return(resVals); }
//------------------------------------------------- private void FillObjets(CSetupSmartImportItem item) { m_cmbObjet.BeginUpdate(); m_cmbObjet.Items.Clear(); m_cmbObjet.DisplayMember = "LibelleObjet"; m_cmbObjet.ValueMember = "IdMappage"; m_cmbObjet.Items.Add(new CCoupleObjetIdMappage(I.T("None|20230"), "")); if (item != null && item.Propriete != null && m_source != null) { CDefinitionProprieteDynamique def = item.Propriete; Type tp = def.TypeDonnee.TypeDotNetNatif; CSetupSmartImportItem itemTest = item.ItemParent as CSetupSmartImportItem; int nIndexSel = -1; while (itemTest != null) { CObjetDonnee objet = itemTest.ObjetExempleAssocie; if (objet != null && tp.IsAssignableFrom(objet.GetType())) { m_cmbObjet.Items.Add(new CCoupleObjetIdMappage( objet.DescriptionElement, itemTest.IdMappage )); if (itemTest.IdMappage == m_source.IdMappageReference) { nIndexSel = m_cmbObjet.Items.Count - 1; } } itemTest = itemTest.ItemParent as CSetupSmartImportItem; } if (nIndexSel != -1) { m_cmbObjet.SelectedIndex = nIndexSel; } else { m_cmbObjet.SelectedIndex = 0; } } m_cmbObjet.EndUpdate(); }
//---------------------------------------------------------------------------- public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet) { List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>(); if (objet == null) { return(lst); } CStructureTable structure = CStructureTable.GetStructure(objet.GetType()); foreach (CInfoRelation relation in structure.RelationsParentes) { Type tpParent = CContexteDonnee.GetTypeForTable(relation.TableParente); if (manager.ConfigurationRecherche.IsIgnore(tpParent)) { return(lst); } CObjetDonnee parent = objet.GetParent(relation.ChampsFille, tpParent); bool bHasUniversalId = tpParent.GetCustomAttribute <NoIdUniverselAttribute>(true) == null; string strNomProp = relation.NomConvivial; if (strNomProp.Length == 0) { strNomProp = DynamicClassAttribute.GetNomConvivial(tpParent); } if (parent != null) { if (bHasUniversalId) { lst.Add(new CReferenceObjetDependant(strNomProp, tpParent, parent.DbKey)); } else { lst.Add(new CReferenceObjetDependant(strNomProp, tpParent, parent.GetValeursCles())); } } } return(lst); }
public static void OnDemandeAffichageRecherche(CNoeudCheminResultatRechercheObjetAvecParents noeud) { //Trouve l'objet donnée le plus bas dans les noeuds CNoeudCheminResultatRechercheObjetAvecParents noeudLePlusBas = noeud; while (noeudLePlusBas.NoeudFils != null) { noeudLePlusBas = noeudLePlusBas.NoeudFils; } CNoeudRechercheObjet_ObjetDonnee noeudObjet = noeudLePlusBas.Noeud as CNoeudRechercheObjet_ObjetDonnee; while (noeudLePlusBas != null) { CNoeudRechercheObjet_ObjetDonnee noeudTest = noeudLePlusBas.Noeud as CNoeudRechercheObjet_ObjetDonnee; if (noeudTest != null) { noeudObjet = noeudTest; } if (noeudObjet != null) { CObjetDonnee objet = noeudObjet.GetObjet(CSc2iWin32DataClient.ContexteCourant); if (objet != null) { CReferenceTypeForm refType = CFormFinder.GetRefFormToEdit(objet.GetType()); if (refType != null) { IFormNavigable form = refType.GetForm(objet as CObjetDonneeAIdNumeriqueAuto) as IFormNavigable; if (form != null) { CTimosApp.Navigateur.AffichePage(form); return; } } } } noeudLePlusBas = noeudLePlusBas.NoeudParent; } MessageBox.Show(I.T("Cannot display this element|20143")); }
/// ///////////////////////////////////////////////////////////// public static CListeRestrictionsUtilisateurSurType GetDroits(CObjetDonnee objet) { CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType(); if (objet == null) { return(liste); } CListeObjetsDonnees lst = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDroitEditionType)); lst.Filtre = new CFiltreData(CDroitEditionType.c_champTypeElements + "=@1", objet.GetType().ToString()); foreach (CDroitEditionType droit in lst) { CParametreDroitEditionType parametre = droit.ParametreDroits; if (parametre != null) { CListeRestrictionsUtilisateurSurType lstTmp = parametre.GetRestrictions(objet); liste.Combine(lstTmp); } } return(liste); }
//////////////////////////////////////////////////////////// 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 bHasConteneur; serializer.TraiteString(ref m_strNomTableFille); int nNbChampsFille = m_strChampsFille.Length; serializer.TraiteInt(ref nNbChampsFille); switch (serializer.Mode) { case ModeSerialisation.Ecriture: foreach (string strChamp in m_strChampsFille) { string strTmp = strChamp; serializer.TraiteString(ref strTmp); } break; case ModeSerialisation.Lecture: m_strChampsFille = new string[nNbChampsFille]; for (int nChamp = 0; nChamp < nNbChampsFille; nChamp++) { string strTmp = ""; serializer.TraiteString(ref strTmp); m_strChampsFille[nChamp] = strTmp; } break; } switch (serializer.Mode) { case ModeSerialisation.Ecriture: bHasConteneur = m_objetConteneur != null; serializer.TraiteBool(ref bHasConteneur); if (bHasConteneur) { Type tp = m_objetConteneur.GetType(); serializer.TraiteType(ref tp); object[] lstValeurs = m_objetConteneur.GetValeursCles(); int nNbValeurs = lstValeurs.Length; serializer.TraiteInt(ref nNbValeurs); foreach (object obj in lstValeurs) { object obj_tmp = obj; serializer.TraiteObjetSimple(ref obj_tmp); } } break; case ModeSerialisation.Lecture: bHasConteneur = false; serializer.TraiteBool(ref bHasConteneur); if (!bHasConteneur) { m_objetConteneur = null; } else { Type tp = null; serializer.TraiteType(ref tp); #if PDA m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp); m_objetConteneur.ContexteDonnee = m_contexte; #else m_objetConteneur = (CObjetDonnee)Activator.CreateInstance(tp, new object[] { m_contexte }); #endif int nNbCles = 0; serializer.TraiteInt(ref nNbCles); object[] lst = new object[nNbCles]; for (int nCle = 0; nCle < nNbCles; nCle++) { serializer.TraiteObjetSimple(ref lst[nCle]); } m_objetConteneur.PointeSurLigne(lst); } break; } if (serializer.Mode == ModeSerialisation.Lecture) { Init(m_objetConteneur, m_strNomTableFille, m_strChampsFille, m_bAppliquerFiltreParDefaut); } return(result); }
//----------------------------------------------------------------------------------- private void FillNodeObjet(TreeNode node, CObjetDonnee objet) { node.ImageIndex = 1; node.Tag = objet; node.Text = objet.DescriptionElement; COptionRechercheType option = m_entitesManager.ConfigurationRecherche.GetOption(objet.GetType()); if (m_listeObjetsAnalyses.Contains(objet) || (option != null && option.RecursiveSearch)) { node.ImageIndex = 2; node.Checked = true; } else { node.Checked = false; } node.SelectedImageIndex = node.ImageIndex; }
//------------------------------------------------ private CResultAErreur UpdateObjet( DataRow row, CObjetDonnee objet, bool bIsNewObject, CContexteImportDonnee contexteImport, CValeursImportFixe valeursFixes) { CResultAErreur result = CResultAErreur.True; foreach (CMappageChampSimple mappage in MappagesChampsSimples) { if (mappage.Source != null && mappage.Source.ShouldImport(row, contexteImport)) { try { contexteImport.PushChamp(mappage.Propriete); result = mappage.GetValue(row, contexteImport); if (!result) { contexteImport.AddLog(new CLigneLogImport( ETypeLigneLogImport.Error, row, mappage.Source.LibelleSource, contexteImport, result.Erreur.ToString())); return(result); } try { CInterpreteurProprieteDynamique.SetValue(objet, mappage.Propriete, result.Data); //Stockage valeur témoin CSourceSmartImportField sourceField = mappage.Source as CSourceSmartImportField; if (sourceField != null) { result = CInterpreteurProprieteDynamique.GetValue(objet, mappage.Propriete); if (result) { contexteImport.SetValeurTemoin(sourceField.NomChampSource, result.Data); } result = CResultAErreur.True; } } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097", result.Data == null ? "null" : result.Data.ToString())); contexteImport.AddLog(new CLigneLogImport( ETypeLigneLogImport.Error, row, mappage.Source.LibelleSource, contexteImport, result.Erreur.ToString())); return(result); } } finally { contexteImport.PopChamp(); } } } foreach (CMappageEntiteParente mapParent in MappagesEntitesParentes) { if (mapParent.Source != null && mapParent.Source.ShouldImport(row, contexteImport)) { try { contexteImport.PushChamp(mapParent.Propriete); CResultAErreurType <CObjetDonnee> resObjet = mapParent.GetObjetAssocie(row, contexteImport, true); if (!resObjet) { contexteImport.AddLog(new CLigneLogImport( ETypeLigneLogImport.Error, row, mapParent.Source.LibelleSource, contexteImport, resObjet.MessageErreur)); } else { try { if (mapParent.AlternativeSetMethodInfo != null) { mapParent.AlternativeSetMethodInfo.Invoke(objet, new object[] { resObjet.DataType }); } else { result = CInterpreteurProprieteDynamique.SetValue(objet, mapParent.Propriete, resObjet.DataType); if (!result && mapParent.Propriete is CDefinitionProprieteDynamiqueDotNet) { //Tente affectation via fonction spécifique PropertyInfo info = objet.GetType().GetProperty(mapParent.Propriete.NomProprieteSansCleTypeChamp); if (info != null) { SpecificImportSetAttribute spec = info.GetCustomAttribute <SpecificImportSetAttribute>(true); if (spec != null) { MethodInfo method = objet.GetType().GetMethod(spec.NomMethodeSetSpecifique); if (method != null) { method.Invoke(objet, new object[] { resObjet.DataType }); } mapParent.AlternativeSetMethodInfo = method; } } } } } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097", result.Data == null ? "null" : result.Data.ToString())); contexteImport.AddLog(new CLigneLogImport( ETypeLigneLogImport.Error, row, mapParent.Source.LibelleSource, contexteImport, result.Erreur.ToString())); return(result); } } } finally { contexteImport.PopChamp(); } } } if (valeursFixes != null) { foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes) { objet.Row[kv.Key] = kv.Value == null ? DBNull.Value : kv.Value; } } foreach (CMappageEntitesFilles mapFille in m_listeMappagesFilles) { try { contexteImport.PushChamp(mapFille.Propriete); result = mapFille.ImportRow(row, contexteImport, objet); if (!result) { contexteImport.AddLog(new CLigneLogImport( ETypeLigneLogImport.Error, row, "", contexteImport, result.Erreur.ToString())); result = CResultAErreur.True; } } finally { contexteImport.PopChamp(); } } return(result); }
//--------------------------------------------------------------- private void CalculeValeurs( ) { CalculeValeurs(new CFournisseurGeneriqueProprietesDynamiques().GetDefinitionsChamps(m_objetAssocie.GetType())); }
private CResultAErreur EditeElementInterne(CObjetDonnee objet, bool bInNewOnglet, string strCodeFormEdition) { CResultAErreur result = CResultAErreur.True; CReferenceTypeForm refTypeForm = null; if (strCodeFormEdition != string.Empty) { refTypeForm = sc2i.win32.data.navigation.CFormFinder.GetRefFormToEdit(objet.GetType(), strCodeFormEdition); } else { refTypeForm = sc2i.win32.data.navigation.CFormFinder.GetRefFormToEdit(objet.GetType()); } if (refTypeForm == null) { result.EmpileErreur(I.T("The system is not able to edit elements of type '@1'|1076", objet.GetType().ToString())); return(result); } try { CFormEditionStandard form = refTypeForm.GetForm((CObjetDonneeAIdNumeriqueAuto)objet) as CFormEditionStandard; if (bInNewOnglet) { AffichePageDansNouvelOnglet(form); } else { AffichePage(form); } } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); } return(result); }
/// ////////////////////////////////////////// protected CResultAErreur GetFiltre( CContexteEvaluationExpression ctx, C2iExpression expressionAcces, C2iExpression expressionFiltre, params C2iExpression[] parametresFiltre) { CResultAErreur result = CResultAErreur.True; //Commence par créer le filtre qui permet d'accéder au type accedé (basé sur le premier paramètre /*Pour créer ce filtre, il faut remonter à l'envers depuis le type retourné * vers le type source de l'expression. * PAr exemple Classement.Lignes depuis lotproduit doit être inversé pour * indiquer le lot de produit du classement des lignes * (classement.LotProduitOrigine) * * */ string strFiltreToType = ""; C2iExpression parametre = expressionAcces; ArrayList lstPropsAccedees = new ArrayList(); /*if (!(ctx.ObjetSource is CObjetDonnee )) * { * result.EmpileErreur("La fonction SelectSql ne peut pas être appliquée ici "); * return result; * }*/ Type tp = ctx.ObjetSource.GetType(); CObjetDonnee objetRacine = (CObjetDonnee)ctx.ObjetSource; while (parametre != null) { string strTable = CContexteDonnee.GetNomTableForType(tp); if (strTable == null) { result.EmpileErreur(I.T("The SelectSql function cannot be applied on an element @1|210", DynamicClassAttribute.GetNomConvivial(tp))); return(result); } C2iExpressionChamp champ; if (parametre is C2iExpressionChamp) { champ = (C2iExpressionChamp)parametre; } else if (parametre is C2iExpressionObjet && parametre.Parametres2i[0] is C2iExpressionChamp) { champ = (C2iExpressionChamp)parametre.Parametres2i[0]; } else { result.EmpileErreur(I.T("Error in the SelectSql parameter|211")); return(result); } CDefinitionProprieteDynamique def = champ.DefinitionPropriete; PropertyInfo info = tp.GetProperty(def.NomProprieteSansCleTypeChamp); if (info == null) { result.EmpileErreur(I.T("The property @1 is not valid for SelectSql(*)|212", def.NomPropriete)); return(result); } //Il faut trouver la propriété de l'élément accedé utilisée pour atteindre le type précédent Type tpAccede = null; //Si la propriété a l'attribut relation fille, on va trouver l'info object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true); if (attribs.Length != 0) { RelationFilleAttribute attr = (RelationFilleAttribute)attribs[0]; strFiltreToType = attr.ProprieteFille + "." + strFiltreToType; tpAccede = attr.TypeFille; strTable = CContexteDonnee.GetNomTableForType(tpAccede); } else { //Pas une relation fille, est-ce une relation parente ? attribs = info.GetCustomAttributes(typeof(RelationAttribute), true); if (attribs.Length != 0) { if (objetRacine.IsNew()) { //L'objet racine est un nouvel objet, il n'est donc pas dans la base, //Donc la requête ne retournera rien !!!. Il faut donc utiliser //le prochain élément comme objetRacine objetRacine = (CObjetDonnee)info.GetGetMethod().Invoke(objetRacine, new object[0]); if (objetRacine != null) { tpAccede = objetRacine.GetType(); } } else { RelationAttribute attr = (RelationAttribute)attribs[0]; strFiltreToType = attr.GetInfoRelation(strTable).RelationKey + "." + strFiltreToType; tpAccede = info.PropertyType; strTable = CContexteDonnee.GetNomTableForType(tpAccede); } } else { // on est mal, impossible de savoir à quoi on fait référence ! result.EmpileErreur(I.T("The property @1 is not valid for a SelectSql operation|213", def.NomPropriete)); return(result); } } tp = tpAccede; if (parametre is C2iExpressionObjet) { parametre = parametre.Parametres2i[1]; } else { parametre = null; } } //Crée le filtre CObjetDonnee objetSource = objetRacine; CFiltreDataAvance filtre = new CFiltreDataAvance(CContexteDonnee.GetNomTableForType(tp), ""); int nCle = 1; foreach (string strCle in objetSource.GetChampsId()) { filtre.Filtre += strFiltreToType + strCle + "=@" + nCle.ToString(); nCle++; filtre.Parametres.Add(objetSource.Row[strCle]); } //Voila, on n'a plus qu'à combiner avec le filtre demandé //evaluation du paramètre 1 result = expressionFiltre.Eval(ctx); if (!result) { result.EmpileErreur(I.T("Error in SelectSql filter|214")); return(result); } if (result.Data.ToString().Trim() != "") { CFiltreDataAvance filtre2 = new CFiltreDataAvance(CContexteDonnee.GetNomTableForType(tp), result.Data.ToString()); //L'analyseur de filtre ne comprend pas la syntaxe [CHAMP].[Champ], mais comprend //[Champ.Champ], il faut donc remplacer tous les ].[ par des . filtre2.Filtre = filtre2.Filtre.Replace("].[", "."); foreach (C2iExpression expression in parametresFiltre) { result = expression.Eval(ctx); if (!result) { return(result); } filtre2.Parametres.Add(result.Data); } try { filtre = (CFiltreDataAvance)CFiltreData.GetAndFiltre(filtre, filtre2); } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); result.EmpileErreur(I.T("Error during the creation of a SelectSql filter|215")); return(result); } } result.Data = filtre; return(result); }
/// ///////////////////////////////////////////////////////// public static object GetValeur(CObjetDonnee objet, CDefinitionProprieteDynamique prop, DataRowVersion version) { if (prop is CDefinitionProprieteDynamiqueChampCustom) { //Evaluation d'un champ custom if (objet is CRelationElementAChamp_ChampCustom) { CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)objet; return(rel.GetValeur(version)); } if (objet is IElementAChamps) { return(((IElementAChamps)objet).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)prop).DbKeyChamp, version)); } } else { #region Evaluation d'un champ PropertyInfo info = objet.GetType().GetProperty(prop.NomProprieteSansCleTypeChamp); object[] attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true); if (attribs.Length != 0) { TableFieldPropertyAttribute attrTable = (TableFieldPropertyAttribute)attribs[0]; try { object val = objet.Row[attrTable.NomChamp, version]; if (val == DBNull.Value) { val = null; } return(val); } catch { return(null); } } else { attribs = info.GetCustomAttributes(typeof(RelationAttribute), true); if (attribs.Length != 0) { RelationAttribute attrRel = (RelationAttribute)attribs[0]; try { object val = objet.Row[attrRel.ChampsFils[0], version]; if (val == DBNull.Value) { val = null; } return(val); } catch { return(null); } } } #endregion } return(null); }
//---------------------------------------------------------------------------- public List <CReferenceObjetDependant> GetDependances(CEntitiesManager manager, CObjetDonnee objet) { List <CReferenceObjetDependant> lst = new List <CReferenceObjetDependant>(); if (objet == null) { return(lst); } CStructureTable structure = CStructureTable.GetStructure(objet.GetType()); foreach (CInfoRelation relation in structure.RelationsFilles) { Type tpFille = CContexteDonnee.GetTypeForTable(relation.TableFille); if (manager.ConfigurationRecherche.IsIgnore(tpFille)) { return(lst); } C2iRequeteAvancee requete = new C2iRequeteAvancee(); requete.FiltreAAppliquer = CFiltreData.CreateFiltreAndSurValeurs(relation.ChampsFille, objet.GetValeursCles()); requete.TableInterrogee = relation.TableFille; bool bHasUniversalId = tpFille.GetCustomAttribute <NoIdUniverselAttribute>(true) == null; if (bHasUniversalId) { requete.ListeChamps.Add(new C2iChampDeRequete(CObjetDonnee.c_champIdUniversel, new CSourceDeChampDeRequete(CObjetDonnee.c_champIdUniversel), typeof(string), OperationsAgregation.None, true)); } else { CStructureTable sFille = CStructureTable.GetStructure(tpFille); foreach (CInfoChampTable infoChamp in sFille.ChampsId) { requete.ListeChamps.Add(new C2iChampDeRequete(infoChamp.NomChamp, new CSourceDeChampDeRequete(infoChamp.NomChamp), infoChamp.TypeDonnee, OperationsAgregation.None, true)); } } string strNomProp = relation.NomConvivial; if (strNomProp.Length == 0) { strNomProp = "List of " + DynamicClassAttribute.GetNomConvivial(tpFille); } CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession); if (result && result.Data is DataTable) { DataTable table = result.Data as DataTable; foreach (DataRow row in table.Rows) { if (bHasUniversalId) { lst.Add(new CReferenceObjetDependant(strNomProp, tpFille, CDbKey.GetNewDbKeyOnUniversalIdANePasUtiliserEnDehorsDeCDbKeyAddOn((string)row[0]))); } else { lst.Add(new CReferenceObjetDependant(strNomProp, tpFille, row.ItemArray)); } } } } return(lst); }
//------------------------------------------------------------------ private void SynchroniseTextEtObjet() { if (m_selectedObject == null) { Text = TextNull; } else { foreach (CConfigTextBoxFiltreRapide config in m_listeConfigs) { if (config.TypeObjets != null && config.TypeObjets.IsAssignableFrom(m_selectedObject.GetType())) { Text = CInterpreteurTextePropriete.GetStringValue(m_selectedObject, config.ProprieteAffichee, ""); break; } } } m_strOldText = Text; UpdateImage(); }
/// ////////////////////////////////////////// public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres) { CResultAErreur result = CResultAErreur.True; try { if (!(listeParametres[0] is CObjetDonnee)) { result.EmpileErreur(I.T("The first argument does not return a valid object for this operation|230")); return(result); } string strChamp = listeParametres[1].ToString(); //Identifie le champ Type tp = listeParametres[0].GetType(); CObjetDonnee objet = (CObjetDonnee)listeParametres[0]; //Est-ce une propriété ? PropertyInfo propInteressante = tp.GetProperty(strChamp); string strUpper = strChamp.ToUpper();; if (propInteressante == null) { //Recherche sur DynamicField ou TableField; foreach (PropertyInfo info in tp.GetProperties()) { if (info.Name.ToUpper() == strUpper) { propInteressante = info; break; } object[] attribs = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true); if (attribs.Length > 0) { if (((DynamicFieldAttribute)(attribs[0])).NomConvivial.ToUpper() == strUpper) { propInteressante = info; break; } } attribs = info.GetCustomAttributes(typeof(TableFieldPropertyAttribute), true); if (attribs.Length > 0) { if (((TableFieldPropertyAttribute)attribs[0]).NomChamp.ToUpper() == strUpper) { propInteressante = info; break; } } } } if (propInteressante == null) { result.EmpileErreur(I.T("The property @1 isn't found in the @2 type|231", strChamp, objet.GetType().ToString())); return(result); } DataRowVersion oldVersion = objet.VersionToReturn; try { if (objet.Row.HasVersion(DataRowVersion.Original)) { objet.VersionToReturn = System.Data.DataRowVersion.Original; } result.Data = propInteressante.GetGetMethod(true).Invoke(objet, null); return(result); } catch { } finally { objet.VersionToReturn = oldVersion; } } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); return(result); } return(result); }
public CInfoElementImport(CObjetDonnee element) { TypeElement = element.GetType(); KeyElement = element.DbKey; }