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