/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
//TESTDBKEYOK
CContexteDonnee contexte = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
CDbKey key = null;
if (contexte != null)
{
key = CSessionClient.GetSessionForIdSession(contexte.IdSession).GetInfoUtilisateur().KeyUtilisateur;
}
else
{
key = CSessionClient.GetSessionUnique().GetInfoUtilisateur().KeyUtilisateur;
}
result.Data = null;
if (key != null)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());
if (user.ReadIfExists(key))
{
result.Data = user.Id;
}
}
}
catch
{
result.Data = -1;
}
return(result);
}
/// ////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 1)
{
//TESTDBKEYOK
serializer.ReadDbKeyFromOldId(ref m_dbKeyChamp, typeof(CChampCustom));
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(m_dbKeyChamp))
{
//Convertit le nom de propriété avec les DbKey
//ne pas appeller SetNomProprieteSansCleTypeChamp(GetKeyChamp()) car pour les filtres,
//le nom de propriété peut contenir un chemin
ConvertNomProprieteFromIdToDbKey();
}
}
else
{
//TESTDBKEYOK
serializer.TraiteDbKey(ref m_dbKeyChamp);
}
return(result);
}
//----------------------------------------------------------------------------------
public static CReferenceTypeForm[] GetReferencesTypeToEdit(Type tpElement)
{
List <CReferenceTypeForm> lstRefs = new List <CReferenceTypeForm>();
if (tpElement == null)
{
return(lstRefs.ToArray());
}
foreach (Type tp in GetListeTypeFormToEdit(tpElement))
{
lstRefs.Add(new CReferenceTypeFormBuiltIn(tp));
}
//Charge les formulaires
CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CFormulaire));
listeFormulaires.Filtre = new CFiltreData(
CFormulaire.c_champTypeElementEdite + " = @1 AND " +
CFormulaire.c_champCodeRole + " is null",
tpElement.ToString());
foreach (CFormulaire formulaire in listeFormulaires)
{
lstRefs.Add(new CReferenceTypeFormDynamic(formulaire));
}
return(lstRefs.ToArray());
}
public void AddProprietesAccedees(
CArbreDefinitionsDynamiques arbre,
Type typeSource,
string strPropriete)
{
//TESTDBKEYOK
CDbKey key = CDbKey.CreateFromStringValue(strPropriete);
/*int nIdChamp = -1;
* try
* {
* nIdChamp = Int32.Parse ( strPropriete );
* }
* catch
* {
* }*/
CChampCalcule champCalcule = new CChampCalcule(CContexteDonneeSysteme.GetInstance());
C2iExpression formule = null;
if (champCalcule.ReadIfExists(key))
{
formule = champCalcule.Formule;
formule.GetArbreProprietesAccedees(arbre);
CDefinitionProprieteDynamiqueChampCalcule.DetailleSousArbres(arbre, CContexteDonneeSysteme.GetInstance());
}
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
if (!C2iFactory.IsInit())
{
return(lstProps.ToArray());
}
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CSmartField));
liste.Filtre = new CFiltreData(CSmartField.c_champTypeCible + "=@1", tp.ToString());
foreach (CSmartField champ in liste)
{
CDefinitionProprieteDynamiqueSmartField def = new CDefinitionProprieteDynamiqueSmartField(champ);
def.HasSubProperties = CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(def.TypeDonnee.TypeDotNetNatif);
def.Rubrique = champ.Categorie;
lstProps.Add(def);
}
return(lstProps.ToArray());
}
//--------------------------------------------------------------
private void CFormEditeUniteInDb_Load(object sender, EventArgs e)
{
CWin32Traducteur.Translate(this);
if (m_unite == null)
{
m_unite = new CUniteInDb(CContexteDonneeSysteme.GetInstance());
m_unite.CreateNew();
m_bIsNewUnite = true;
}
else
{
m_unite.BeginEdit();
m_bIsNewUnite = false;
}
m_cmbClasse.ListDonnees = CGestionnaireUnites.Classes;
m_cmbClasse.ProprieteAffichee = "Libelle";
m_cmbClasse.SelectedValue = m_unite.Classe;
m_txtIdUnite.Text = m_unite.GlobalId;
m_txtLibellCourtUnite.Text = m_unite.Libelle;
m_txtLibelleLongUnite.Text = m_unite.LibelleLong;
m_txtFacteurConversion.DoubleValue = m_unite.FacteurVersBase;
m_txtOffsetConversion.DoubleValue = m_unite.OffsetVersBase;
RefreshFormule();
}
//-------------------------------------------------------
private void InitChamps()
{
CFiltreData filtre = new CFiltreData(CProcessInDb.c_champTypeCible + "=@1",
typeof(CEtapeWorkflow).ToString());
m_txtSelectProcess.Init(typeof(CProcessInDb),
filtre,
"Libelle",
true);
if (m_blocProcess.DbKeyProcess != null)
{
CProcessInDb process = new CProcessInDb(CContexteDonneeSysteme.GetInstance());
if (process.ReadIfExists(m_blocProcess.DbKeyProcess))
{
m_txtSelectProcess.ElementSelectionne = process;
}
}
m_process = m_blocProcess.Process;
m_txtInstructions.Text = m_blocProcess.Instructions;
m_chkManualStart.Checked = m_blocProcess.DemarrageManuel;
CParametresInitialisationEtape parametres = m_blocProcess.TypeEtape != null ? m_blocProcess.TypeEtape.ParametresInitialisation : new CParametresInitialisationEtape();
m_panelAffectations.Init(parametres);
m_chkUtiliserSortieProcessCommeCodeRetour.Checked = m_blocProcess.UtiliserLaValeurDeSortieDeProcessCommeCodeRetour;
UpdateVisuProcess();
}
private void CControlActionReleve_Load(object sender, EventArgs e)
{
//Cherche les champs relevé
CListeObjetsDonnees lst = CChampCustom.GetListeChampsForRole(CContexteDonneeSysteme.GetInstance(), CReleveEquipement.c_roleChampCustom);
if (lst.Count == 0)
{
m_panelReleve.Height = m_lblSerialReleve.Height;
m_panelOriginal.Height = m_lblSerialDB.Height;
Height = m_panelReleve.Height + m_panelOriginal.Height;
m_panelChampsOriginaux.Visible = false;
m_panelChampsReleve.Visible = false;
}
else
{
foreach (CChampCustom champ in lst)
{
CControleForCustomFieldReleve ctrl = new CControleForCustomFieldReleve();
ctrl.Init(champ);
m_panelChampsReleve.Controls.Add(ctrl);
ctrl.Dock = DockStyle.Left;
ctrl.LockEdition = true;
ctrl.OnValueChanged += new EventHandler(ctrlCustom_OnValueChanged);
ctrl = new CControleForCustomFieldReleve();
ctrl.Init(champ);
m_panelChampsOriginaux.Controls.Add(ctrl);
ctrl.Dock = DockStyle.Left;
ctrl.LockEdition = true;
}
m_panelChampsOriginaux.Visible = true;
m_panelChampsReleve.Visible = true;
}
}
public void Init(CProcess process, Type typeObjet, CActionImportFromTableRow.CMappageColonne mappage)
{
m_mappage = mappage;
CColonneTableParametrable col = new CColonneTableParametrable(CContexteDonneeSysteme.GetInstance());
col.ReadIfExists(mappage.IdColonne);
m_lblColonne.Text = col.Libelle;
Type tp = col.TypeDonneeChamp.TypeDotNetAssocie;
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>();
foreach (CDefinitionProprieteDynamique def in new CFournisseurPropDynStd(false).GetDefinitionsChamps(typeObjet))
{
Type defType = def.TypeDonnee.TypeDotNetNatif;
if (defType.IsGenericType && defType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
defType = defType.GetGenericArguments()[0];
}
if (defType == tp && !def.TypeDonnee.IsArrayOfTypeNatif)
{
lst.Add(def);
}
}
m_cmbChamp.ListDonnees = lst;
m_cmbChamp.ProprieteAffichee = "Nom";
m_cmbChamp.SelectedValue = mappage.ProprieteCible;
m_txtFormuleCondition.Init(process, typeof(CProcess));
m_txtFormuleCondition.Formule = mappage.FormuleCondition;
}
//-----------------------------------------------------------------------------
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
CContexteDonnee ctxDonnee = null;
if (ctx.ObjetSource is IObjetAContexteDonnee)
{
ctxDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
}
if (ctxDonnee == null)
{
ctxDonnee = ctx.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
}
if (ctxDonnee == null)
{
ctxDonnee = CContexteDonneeSysteme.GetInstance();
}
CNommageEntite nommage = new CNommageEntite(ctxDonnee);
//TESTDBKEYOK
if (nommage.ReadIfExists(m_keyNommageEntite)) //&& nommage.NomFort == m_strNom)
{
result.Data = nommage.GetObjetNomme();
}
else if (nommage.ReadIfExists(new CFiltreData(CNommageEntite.c_champNomFort + "=@1",
m_strNom)))
{
result.Data = nommage.GetObjetNomme();
}
return(result);
}
//----------------------------------------------
public void ChercheObjet(object objetCherche, CResultatRequeteRechercheObjet resultat)
{
if (objetCherche is CDefinitionProprieteDynamique)
{
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetDonneeGenerique <CFormulaire> lstFormulaires = new CListeObjetDonneeGenerique <CFormulaire>(contexte);
foreach (CFormulaire form in lstFormulaires)
{
C2iWnd wnd = form.Formulaire;
try
{
if (wnd != null)
{
resultat.PushChemin(new CNoeudRechercheObjet_ObjetDonnee(form));
wnd.ChercheObjet(objetCherche, resultat);
resultat.PopChemin();
}
}
catch
{
System.Console.WriteLine("Erreur recherche formulaire " + form.Libelle);
}
}
}
}
//----------------------------------------------------
public void ChercheObjet(object objetCherche, CResultatRequeteRechercheObjet resultat)
{
CContexteDonnee ctx = CContexteDonneeSysteme.GetInstance();
CListeObjetDonneeGenerique <CProcessInDb> lstProcess = new CListeObjetDonneeGenerique <CProcessInDb>(ctx);
foreach (CProcessInDb processInDb in lstProcess)
{
try
{
processInDb.RechercheObjet(objetCherche, resultat);
}
catch { }
}
CListeObjetDonneeGenerique <CEvenement> lstEvents = new CListeObjetDonneeGenerique <CEvenement>(ctx);
foreach (CEvenement evt in lstEvents)
{
try
{
evt.RechercheObjet(objetCherche, resultat);
}
catch
{
}
}
}
public CDefinitionProprieteDynamique[] GetDefinitionsChamps(CObjetPourSousProprietes objet, CDefinitionProprieteDynamique defParente)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
if (!C2iFactory.IsInit())
{
return(lstProps.ToArray());
}
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees listeEntites = new CListeObjetsDonnees(contexte, typeof(CListeEntites));
listeEntites.Filtre = new CFiltreData(
CListeEntites.c_champTypeElementSourceDeRecherche + "=@1",
tp.ToString());
foreach (CListeEntites liste in listeEntites)
{
CDefinitionProprieteDynamiqueListeEntites def = new CDefinitionProprieteDynamiqueListeEntites(liste);
def.Rubrique = I.T("Lists|60");
lstProps.Add(def);
}
return(lstProps.ToArray());
}
//---------------------------------------
private void InitFiltres()
{
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());
if (typeDonnee == null)
{
m_listeFiltresDeBase.Clear();
m_listeFiltresUser.Clear();
return;
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null)
{
CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
if (filtre != null)
{
dicToDelete[filtre.ChampAssocie] = false;
}
if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
}
}
foreach (KeyValuePair <string, bool> kv in dicToDelete)
{
if (kv.Value)
{
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresUser.Remove(filtre);
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresDeBase.Remove(filtre);
}
}
}
}
//---------------------------------------------------------------------
private void Init(
CConfigWndMapView config,
CObjetPourSousProprietes objetEdite,
IFournisseurProprietesDynamiques fournisseurProprietes)
{
m_configEditee = config;
m_fournisseurProprietes = fournisseurProprietes;
m_objetEdite = objetEdite;
m_txtFormuleLatitude.Init(FournisseurProprietes, ObjetEdite);
m_txtFormuleLongitude.Init(FournisseurProprietes, ObjetEdite);
m_txtFormuleZoom.Init(FournisseurProprietes, ObjetEdite);
m_txtFormuleKeepState.Init(FournisseurProprietes, ObjetEdite);
m_txtFormuleLatitude.Formule = m_configEditee.FormuleLatitude;
m_txtFormuleLongitude.Formule = m_configEditee.FormuleLongitude;
m_txtFormuleZoom.Formule = m_configEditee.FormuleZoomFactor;
m_txtFormuleKeepState.Formule = m_configEditee.FormulePreserveStateKey;
m_chkPreserveCenter.Checked = m_configEditee.PreserveCenter;
m_chkPreserveLayers.Checked = m_configEditee.PreserveLayers;
m_chkPreserveMapMode.Checked = m_configEditee.PreserveMapMode;
m_chkPreserveZoom.Checked = m_configEditee.PreserveZoom;
m_rbtnViewMap.Checked = config.MapMode == EWndMapMode.Map;
m_rbtnAerial.Checked = config.MapMode == EWndMapMode.Aerial;
m_rbtnHybride.Checked = config.MapMode == EWndMapMode.Hybrid;
CListeObjetDonneeGenerique <CConfigMapDatabase> lstConfigs = CConfigMapDatabase.GetConfigsFor(
CContexteDonneeSysteme.GetInstance(),
objetEdite);
m_wndListeCalques.BeginUpdate();
foreach (CConfigMapDatabase configDB in lstConfigs)
{
bool bIsChecked = false;
//TESTDBKEYOK
CConfigCalqueMap configCalque = m_configEditee.GetConfigForCalque(configDB.DbKey);
if (configCalque == null)
{
configCalque = new CConfigCalqueMap();
//TESTDBKEYOK
configCalque.KeyConfigMapDatabase = configDB.DbKey;
}
else
{
bIsChecked = true;
}
configCalque.generator = configDB.MapGenerator;
ListViewItem item = new ListViewItem(configDB.Libelle);
item.Tag = configCalque;
item.Checked = bIsChecked;
m_wndListeCalques.Items.Add(item);
}
m_wndListeCalques.EndUpdate();
}
//-----------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
//TESTDBKEYTODO : remplacer IdChamp par DbKey
CDbKey dbKeyChampWrite = ChampCustom != null ? ChampCustom.DbKey : null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyChampWrite, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref dbKeyChampWrite);
}
break;
case ModeSerialisation.Lecture:
CContexteDonnee contexte = serializer.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
if (contexte == null)
{
contexte = CContexteDonneeSysteme.GetInstance();
}
//TESTDBKEYTODO : remplacer IdChamp par DbKey
CDbKey dbKeyChampRead = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyChampRead, typeof(CChampCustom));
}
else
{
serializer.TraiteDbKey(ref dbKeyChampRead);
}
if (dbKeyChampRead == null)
{
m_champ = null;
}
else
{
m_champ = new CChampCustom(contexte);
if (!m_champ.ReadIfExists(dbKeyChampRead))
{
m_champ = null;
}
}
break;
}
return(result);
}
public CFonctionDynamique GetFonctionSupplementaire(string strIdFonction)
{
CFonctionDynamiqueInDb f = new CFonctionDynamiqueInDb(CContexteDonneeSysteme.GetInstance());
if (f.ReadIfExistsUniversalId(strIdFonction))
{
return(f.Fonction);
}
return(null);
}
//------------------------------------------------------------
public int GetIdUtilisateurFromKey(CDbKey key)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());
if (user.ReadIfExists(key))
{
return(user.Id);
}
return(-1);
}
//------------------------------------------------------------
public CDbKey GetKeyUtilisateurFromId(int nId)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());
if (user.ReadIfExists(nId))
{
return(user.DbKey);
}
return(null);
}
public static int GetIdFromDbKey(CDbKey dbKey)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(dbKey))
{
return(champ.Id);
}
return(-1);
}
//-------------------------------------------------------------------------
private void FillListeChamps(CRestrictionUtilisateurSurType restriction)
{
m_wndListeChamps.BeginUpdate();
m_wndListeChamps.Items.Clear();
CInfoStructureDynamique info = CInfoStructureDynamique.GetStructure(restriction.TypeAssocie, 0);
List <ListViewItem> lstItems = new List <ListViewItem>();
foreach (CInfoChampDynamique champ in info.Champs)
{
string strTmp = "";
CDefinitionProprieteDynamique def = CConvertisseurInfoStructureDynamiqueToDefinitionChamp.GetDefinitionProprieteDynamique(champ.NomPropriete, ref strTmp);
//Uniquement les propriétés "classiques"
//voir CTimosApp.GetStructure
if (def != null && typeof(CDefinitionProprieteDynamiqueDotNet).IsAssignableFrom(def.GetType()))
{
ListViewItem item = new ListViewItem();
item.Text = champ.NomChamp;
item.Tag = def.NomProprieteSansCleTypeChamp;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(def.NomProprieteSansCleTypeChamp));
lstItems.Add(item);
}
}
lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));
if (typeof(IElementAChamps).IsAssignableFrom(restriction.TypeAssocie))
{
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(restriction.TypeAssocie);
if (role != null)
{
CListeObjetsDonnees listeChampsCustom = CChampCustom.GetListeChampsForRole(CContexteDonneeSysteme.GetInstance(), role.CodeRole);
foreach (CChampCustom champ in listeChampsCustom)
{
ListViewItem item = new ListViewItem();
item.Text = champ.Nom;
item.Tag = champ.CleRestriction;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(champ.CleRestriction));
lstItems.Add(item);
}
lstItems.Sort((x, y) => x.Text.CompareTo(y.Text));
CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(CContexteDonneeSysteme.GetInstance(), typeof(CFormulaire));
listeFormulaires.Filtre = CFormulaire.GetFiltreFormulairesForRole(role.CodeRole);
foreach (CFormulaire formulaire in listeFormulaires)
{
ListViewItem item = new ListViewItem();
item.Text = "{" + formulaire.Libelle + "}";
item.Tag = formulaire.CleRestriction;
item.ImageIndex = GetIndexImage(restriction.GetRestriction(formulaire.CleRestriction));
lstItems.Add(item);
}
}
}
m_wndListeChamps.Items.AddRange(lstItems.ToArray());
m_wndListeChamps.EndUpdate();
}
///////////////////////////////////////////////////////////////
/// <summary>
/// récupère un paramètre système
/// </summary>
/// <param name="strParametre"></param>
/// <returns></returns>
public static string GetParametreSysteme(string strParametre)
{
CSpvParamSysteme parametre = new CSpvParamSysteme(CContexteDonneeSysteme.GetInstance());
if (parametre.ReadIfExists(new CFiltreData(c_champPARAM_VALEUR + " like @1",
strParametre + "=%")))
{
return(parametre.Valeur);
}
return("");
}
public static object GetValeurChamp(this IElementAChamps elt, CDbKey key, DataRowVersion version)
{
if (key != null)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(key))
{
return(elt.GetValeurChamp(champ.Id, version));
}
}
return(null);
}
//------------------------------------------------------------
public override CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
result.Data = null;
string strIdChamp = null;
bool bEntiteToChamp = false;
if (
/*Pour compatibilité, avant modifs de décembre 2015, le nom du champ était en fait le même qu'une propriété champ custom.
* En décembre 2015, ajout de la possiblité de retourner les valeurs display de champ custom dans les requêtes,
* ce qui a changé le nom de la propriétés
* */
CInfoRelationEntiteToValeurChampCustom.DecomposeNomPropriete(strPropriete, ref strIdChamp) ||
/*fin pour compatiblité*/
CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bEntiteToChamp))
{
IElementAChamps eltAChamps = objet as IElementAChamps;
if (eltAChamps == null)
{
return(result);
}
result.Data = eltAChamps.GetValeurChamp(strIdChamp);
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (result.Data != null && champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
if (!champ.IsChoixParmis())
{
result.Data = result.Data.ToString();
}
else
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
if (valeur.Value.Equals(result.Data))
{
result.Data = valeur.Display;
return(result);
}
}
}
}
}
else if (CInfoRelationEValeurChampCustomToDisplay.DecomposeNomPropriete(strPropriete, ref strIdChamp))
{
//Rien de spécial, il s'agit de la navigation vers la valeur du champ qui a déjà été reprise par le composant filtre to champ entité
//car la propriété complète d'un definitionDisplayValue est donnée par GetKeyChamp qui ajoute un composant Element->ValeurChamp + ValeurChamp->Display value
result.Data = objet;
}
return(result);
}
private void AssureRecepteurs()
{
if (m_recepteurAjout == null)
{
m_recepteurAjout = new CRecepteurNotification(CContexteDonneeSysteme.GetInstance().IdSession, typeof(CDonneeNotificationAjoutEnregistrement));
m_recepteurAjout.OnReceiveNotification += new NotificationEventHandler(m_recepteurAjout_OnReceiveNotification);
}
if (m_recepteurModification == null)
{
m_recepteurModification = new CRecepteurNotification(CContexteDonneeSysteme.GetInstance().IdSession, typeof(CDonneeNotificationModificationContexteDonnee));
m_recepteurModification.OnReceiveNotification += new NotificationEventHandler(m_recepteurModification_OnReceiveNotification);
}
}
//-----------------------------------------------------------------------
public static CPreferenceFiltreRapide GetPreferenceForType(Type typeElements)
{
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CPreferenceFiltreRapide prefFiltre = new CPreferenceFiltreRapide(contexte);
if (prefFiltre.ReadIfExists(new CFiltreData(
CPreferenceFiltreRapide.c_champTypeObjets + "=@1",
typeElements.ToString())))
{
return(prefFiltre);
}
return(null);
}
//-------------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CEasyQuery query = Query;
CResultAErreur result = CResultAErreur.True;
if (result && TypeSource == null)
{
result.EmpileErreur(I.T("###Table object must be specified |"));
}
if (query == null || sources == null)
{
result.EmpileErreur(I.T("###Query needs a source to provide datas|"));
}
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(TypeSource);
result = FiltreDynamique.GetFiltreData();
if (!result)
{
return(result);
}
if (result.Data is CFiltreData)
{
requete.FiltreAAppliquer = result.Data as CFiltreData;
}
foreach (IColumnDeEasyQuery col in Columns)
{
CColumnDeEasyQueryChampDeRequete colR = col as CColumnDeEasyQueryChampDeRequete;
requete.ListeChamps.Add(colR);
}
DataTable table = null;
if (requete.ListeChamps.Count > 0)
{
result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
if (!result)
{
result.EmpileErreur(I.T("###Error on table @1|"));
return(result);
}
table = result.Data as DataTable;
}
else
{
table = new DataTable();
}
table.TableName = NomFinal;
return(result);
}
//---------------------------------------------------------
private CFormulaire GetFormulaire(C2iWndReference info)
{
try
{
int nId = Int32.Parse(info.WndKey);
CFormulaire form = new CFormulaire(CContexteDonneeSysteme.GetInstance());
if (form.ReadIfExists(nId))
{
return(form);
}
}
catch { }
return(null);
}
/// ///////////////////////////////////////////////////////////
private static void UpdateTableDonneesCumulees()
{
int nIdSession = 0;
try
{
nIdSession = CSessionClient.GetSessionUnique().IdSession;
}
catch
{ }
if (m_recepteurNotificationModifTypeDonneeCumulee == null)
{
m_recepteurNotificationModifTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationModificationContexteDonnee));
m_recepteurNotificationModifTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
}
if (m_recepteurNotificationAjoutTypeDonneeCumulee == null)
{
m_recepteurNotificationAjoutTypeDonneeCumulee = new CRecepteurNotification(nIdSession, typeof(CDonneeNotificationAjoutEnregistrement));
m_recepteurNotificationAjoutTypeDonneeCumulee.OnReceiveNotification += new NotificationEventHandler(m_recepteurNotificationTypeDonneeCumulee_OnReceiveNotification);
}
if (m_tableTypeToDonneesCumulees != null)
{
m_tableTypeToDonneesCumulees.Clear();
}
else
{
m_tableTypeToDonneesCumulees = new Dictionary <Type, List <CTypeDonneeCumulee> >();
}
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CTypeDonneeCumulee));
foreach (CTypeDonneeCumulee type in liste)
{
CParametreDonneeCumulee parametre = type.Parametre;
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null)
{
List <CTypeDonneeCumulee> lst = null;
if (!m_tableTypeToDonneesCumulees.TryGetValue(cle.TypeLie, out lst))
{
lst = new List <CTypeDonneeCumulee>();
m_tableTypeToDonneesCumulees[cle.TypeLie] = lst;
}
lst.Add(type);
}
}
}
}
public COptimiseurProprieteDynamiqueChampCustomDisplayValue(CDbKey keyChamp)
{
m_dbKeyChamp = keyChamp;
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(keyChamp))
{
if (champ.IsChoixParmis())
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
m_dicValeurs[valeur.Value] = valeur.Display;
}
}
}
}