//----------------------------------------------------------------------
public CResultAErreur SetParametres(Dictionary <string, object> dicParametres)
{
CResultAErreur result = CResultAErreur.True;
object obj = null;
if (dicParametres.TryGetValue(m_cParametreReportId, out obj))
{
if (obj is int)
{
m_rapport = new C2iRapportCrystal(CSc2iWin32DataClient.ContexteCourant);
if (!m_rapport.ReadIfExists((int)obj))
{
result.EmpileErreur(I.T("There is no Crystal Report Model corresponding to the Id: @1|10006", ((int)obj).ToString()));
}
}
else if (obj is string)
{
m_rapport = new C2iRapportCrystal(CSc2iWin32DataClient.ContexteCourant);
if (!m_rapport.ReadIfExists(CDbKey.CreateFromStringValue((string)obj)))
{
result.EmpileErreur(I.T("There is no Crystal Report Model corresponding to the Universal : @1", (string)obj));
}
}
else
{
result.EmpileErreur(I.T("The Report ID parameter must be an integer value|10007"));
}
}
return(result);
}
/// //////////////////////////////////////////
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);
}
//------------------------------------------------------------------------
private void m_lnkSelectFormulaires_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
C2iExpression formule = GetFormuleValideElementEdite(m_txtFormuleElementEdite);
if (formule != null)
{
Type tpEdite = formule.TypeDonnee.TypeDotNetNatif;
CFiltreData filtre = new CFiltreData(CFormulaire.c_champTypeElementEdite + "=@1",
tpEdite.ToString());
CRoleChampCustom role = CRoleChampCustom.GetRoleForType(tpEdite);
if (role != null)
{
filtre = CFiltreData.GetOrFiltre(filtre,
CFormulaire.GetFiltreFormulairesForRole(role.CodeRole));
}
CListeObjetDonneeGenerique <CFormulaire> listeFormulaires = new CListeObjetDonneeGenerique <CFormulaire>(
CSc2iWin32DataClient.ContexteCourant, filtre);
m_menuFormulaires.Items.Clear();
foreach (CFormulaire formulaire in listeFormulaires)
{
CDbKey nKeyForm = formulaire.DbKey;
ToolStripMenuItem itemForm = new ToolStripMenuItem(formulaire.Libelle);
itemForm.Tag = nKeyForm;
itemForm.Checked = m_listeDbKeysFormulaires.Contains(nKeyForm);
itemForm.Click += new EventHandler(itemForm_Click);
itemForm.Enabled = true;
m_menuFormulaires.Items.Add(itemForm);
}
m_menuFormulaires.Show(m_lnkSelectFormulaires, new Point(0, m_lnkSelectFormulaires.Height));
}
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteType(ref m_typeObjet);
if (nVersion >= 1)
{
serializer.TraiteDbKey(ref m_keyObjet);
}
//ArrayList lst = new ArrayList ( m_cles );
IList lst = (IList)m_cles;
serializer.TraiteListeObjetsSimples(ref lst);
m_cles = new object[lst.Count];
for (int nObjet = 0; nObjet < lst.Count; nObjet++)
{
m_cles[nObjet] = lst[nObjet];
}
if (nVersion < 1 && serializer.Mode == ModeSerialisation.Lecture)
{
if (m_cles.Length == 1 && m_cles[0] is int)
{
//Charge la DbKey
m_keyObjet = CDbKeyAddOn.GetDbKeyFromId(m_typeObjet, (int)m_cles[0]);
}
}
return(result);
}
/// <summary>
/// Retourne le filtre à appliquer aux listes qui sont filtrées pour l'affichage
/// </summary>
/// <param name="typeEntites"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public static CFiltreData GetFiltreAffichage(Type typeEntites, CContexteDonnee contexte)
{
AssureRecepteursNotifications(contexte.IdSession);
if (typeof(IElementAEO).IsAssignableFrom(typeEntites))
{
//TESTDBKEYOK
//Récupère l'id d'utilisateur lié au contexte
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
try
{
CDbKey keyUser = session.GetInfoUtilisateur().KeyUtilisateur;
string strFiltre = GetStringFiltreEOForUser(keyUser, contexte, typeEntites);
if (strFiltre != "")
{
return(new CFiltreData(strFiltre));
}
return(new CFiltreData(strFiltre));
}
catch (Exception e)
{
System.Console.WriteLine(e.ToString());
}
}
return(null);
}
//------------------------------------------------------------------------
public CResultAErreur Degeler(DateTime dateFin, string strInfoFinGel, CDbKey keyResponsableFinGel)
{
CResultAErreur result = CResultAErreur.True;
CGelEtapeWorkflow gelADegeler = null;
foreach (CGelEtapeWorkflow gel in Gels)
{
if (gel.DateFin == null)
{
gelADegeler = gel;
break;
}
}
if (gelADegeler == null)
{
result.EmpileErreur(I.T("Unfreezing impossible for an element not freezed|10005"));
return(result);
}
gelADegeler.BeginEdit();
gelADegeler.InfosFinGel = strInfoFinGel;
gelADegeler.DateFin = dateFin;
gelADegeler.KeyResponsabelFinGel = keyResponsableFinGel;
result = gelADegeler.CommitEdit();
return(result);
}
public bool HasInterventions(CDbKey keyUtilisateur)
{
if (keyUtilisateur == null)
{
return(false);
}
lock (typeof(CLockRechercheInterventions))
{
if (m_sessionPourRechercheInterventions == null)
{
m_sessionPourRechercheInterventions = CSessionClient.CreateInstance();
CResultAErreur result = m_sessionPourRechercheInterventions.OpenSession(new sc2i.multitiers.server.CAuthentificationSessionServer(),
I.T("Search for interventions|101"),
ETypeApplicationCliente.Service);
if (!result)
{
return(false);
}
}
using (CContexteDonnee contexte = new CContexteDonnee(m_sessionPourRechercheInterventions.IdSession, true, false))
{
CListeObjetsDonnees listeInterventions = new CListeObjetsDonnees(contexte, typeof(CBesoinInterventionProcess));
//TESTDBKEYTODO
listeInterventions.Filtre = new CFiltreData(
CBesoinInterventionProcess.c_champKeyUtilisateur + "=@1",
keyUtilisateur.StringValue);
return(listeInterventions.CountNoLoad > 0);
}
}
}
//---------------------------------------------------------------------
protected override void MyCreateControle(CCreateur2iFormulaireV2 createur, C2iWnd wnd, Control parent, IFournisseurProprietesDynamiques fournisseur)
{
C2iWndListeSpeedStandard listeStd = wnd as C2iWndListeSpeedStandard;
if (listeStd == null)
{
return;
}
CCreateur2iFormulaireV2.AffecteProprietesCommunes(wnd, m_panelListeSpeedStd);
m_fournisseurProprietes = fournisseur;
m_panelListeSpeedStd.BoutonAjouterVisible = listeStd.HasAddButton;
m_panelListeSpeedStd.BoutonSupprimerVisible = listeStd.HasDeleteButton;
m_panelListeSpeedStd.BoutonModifierVisible = listeStd.HasDetailButton;
m_panelListeSpeedStd.BoutonFiltrerVisible = listeStd.HasFilterButton;
m_panelListeSpeedStd.AllowCustomisation = listeStd.UserCustomizable;
m_panelListeSpeedStd.OnChangeSelection += new EventHandler(m_panelListeSpeedStd_OnChangeSelection);
m_panelListeSpeedStd.AffectationsPourNouveauxElements = listeStd.Affectations;
m_panelListeSpeedStd.ObjetReferencePourAffectationsInitiales = EditedElement;
if (listeStd.AlternativeEditedElement != null)
{
m_panelListeSpeedStd.TraiterModificationElement = TraiterEditionPanel;
}
// Initialisation des colonnes
foreach (C2iWndListeSpeedStandard.CColonneListeSpeedStd col in WndListeStandard.Columns)
{
if (col.InfoChampDynamique != null)
{
m_panelListeSpeedStd.AddColonne(col.Titre, col.InfoChampDynamique.NomPropriete, col.Width);
}
//string strCle = "";
//string strProp = "";
//if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(col.InfoChampDynamique.NomPropriete, ref strCle, ref strProp))
// strProp = col.InfoChampDynamique.Nom;
//if(col.InfoChampDynamique != null)
// m_panelListeSpeedStd.AddColonne(col.Titre, strProp, col.Width);
}
// Initialise le filtre
if (WndListeStandard.Filter != null)
{
CDbKey dbKeyFiltreStandard = WndListeStandard.Filter.DbKey;
CFiltreDynamiqueInDb filtre = new CFiltreDynamiqueInDb(CSc2iWin32DataClient.ContexteCourant);
if (filtre.ReadIfExists(dbKeyFiltreStandard))
{
m_panelListeSpeedStd.FiltrePrefere = filtre.Filtre;
}
}
// Initialise le nom du controle pour le registre des colonnes
string strNom = "CustomListeSpeedStandard_";
if (WndListeStandard.SourceFormula != null)
{
strNom += WndListeStandard.SourceFormula.TypeDonnee.TypeDotNetNatif.ToString();
}
m_panelListeSpeedStd.Name = strNom;
m_panelListeSpeedStd.UseCheckBoxes = WndListeStandard.UseCheckBoxes;
parent.Controls.Add(m_panelListeSpeedStd);
}
//---------------------------------------------------------------------------------------------
public CUserTimosWebApp(CSessionClient session, DataRow row, string strLogin)
{
if (session != null)
{
IInfoUtilisateur infosUser = session.GetInfoUtilisateur();
if (infosUser != null)
{
row[c_champUserName] = infosUser.NomUtilisateur;
row[c_champUserLogin] = strLogin;
row[c_champUserKey] = infosUser.KeyUtilisateur.StringValue;
row[c_champSessionId] = session.IdSession;
bool bIsAdministrator = false;
CDbKey keyGroupeAdminWeb = CTimosWebAppRegistre.WebAdminGroupKey;
if (keyGroupeAdminWeb != null && infosUser.ListeKeysGroupes.Contains(keyGroupeAdminWeb))
{
bIsAdministrator = true;
}
row[c_champIsAdministrator] = bIsAdministrator;
m_row = row;
m_dicoProperties = new Dictionary <string, object>();
m_dicoProperties[c_champUserName] = infosUser.NomUtilisateur;
m_dicoProperties[c_champUserLogin] = strLogin;
m_dicoProperties[c_champUserKey] = infosUser.KeyUtilisateur.StringValue;
m_dicoProperties[c_champSessionId] = session.IdSession;
m_dicoProperties[c_champIsAdministrator] = bIsAdministrator;
}
}
}
/// ////////////////////////////////////////
private void m_lnkNouvelleVariable_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
string strNom = "";
if (!(m_comboVariableListe.SelectedValue is CVariableDynamique))
{
CFormAlerte.Afficher(I.T("Select list variable first|30055"), EFormAlerteType.Exclamation);
return;
}
CVariableDynamique variable = (CVariableDynamique)m_comboVariableListe.SelectedValue;
CTypeResultatExpression type = variable.TypeDonnee.GetTypeElements();
CDbKey dbKey = null;
if (CFormEditNomVariable.EditeNomVariable(ref strNom, ref type, ref dbKey, false))
{
if (m_variableNew == null)
{
m_variableNew = new CVariableProcessTypeComplexe();
m_variableNew.SetTypeDonnee(type);
}
m_variableNew.Nom = strNom;
FillListeVariables();
m_comboVariable.SelectedValue = m_variableNew;
}
}
//----------------------------------------------------
public static int?GetIdFromUniverselId(Type typeElement, CDbKey key)
{
string strNomTable = CContexteDonnee.GetNomTableForType(typeElement);
CStructureTable structure = CStructureTable.GetStructure(typeElement);
C2iRequeteAvancee rq = new C2iRequeteAvancee();
rq.TableInterrogee = strNomTable;
rq.FiltreAAppliquer = new CFiltreData(
CObjetDonnee.c_champIdUniversel + "=@1", key.GetValeurInDb());
rq.ListeChamps.Add(new C2iChampDeRequete(
structure.ChampsId[0].NomChamp,
new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
typeof(string),
OperationsAgregation.None,
true));
CResultAErreur result = rq.ExecuteRequete(0);
if (result && result.Data is DataTable)
{
DataTable table = result.Data as DataTable;
if (table.Rows.Count > 0)
{
return((int)table.Rows[0][0]);
}
}
return(null);
}
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());
}
}
private void FillListe()
{
//TESTDBKEYOK
CDbKey keyMoi = CTimosApp.SessionClient.GetInfoUtilisateur().KeyUtilisateur;
IInfoUtilisateur[] infos = CSessionClient.GetUtilisateursConnecte();
List <IInfoUtilisateur> lst = new List <IInfoUtilisateur>(infos);
m_wndListeUsers.BeginUpdate();
m_wndListeUsers.Items.Clear();
Hashtable tableDejaFaits = new Hashtable();
tableDejaFaits[keyMoi] = true;
foreach (IInfoUtilisateur user in lst)
{
if (tableDejaFaits[user.KeyUtilisateur] == null)
{
tableDejaFaits[user.KeyUtilisateur] = true;
if (user.NomUtilisateur.Length > 0)
{
ListViewItem item = new ListViewItem(user.NomUtilisateur);
item.ImageIndex = 0;
item.Tag = user.KeyUtilisateur;
m_wndListeUsers.Items.Add(item);
}
}
}
m_wndListeUsers.EndUpdate();
}
public CResultAErreur DémarreWorkflow(CTypeEtapeWorkflow typeEtapeDebut, bool bStartImmediate)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info != null)
{
//TESTDBKEYOK
KeyManager = info.KeyUtilisateur;
}
CResultAErreur result = CResultAErreur.True;
if (EtapesEnCours.Count != 0)
{
result.EmpileErreur(I.T("Workflow was already started|20073"));
return(result);
}
if (typeEtapeDebut == null ||
typeEtapeDebut.Workflow != TypeWorkflow//cas pourri : l'étape de début n'est pas valide pour ce workflow ça ne doit pas arriver
)
{
if (TypeWorkflow == null)
{
result.EmpileErreur(I.T("Workflow type should be set before it starts|20077"));
return(result);
}
typeEtapeDebut = TypeWorkflow.EtapeDemarrageDefaut;
if (typeEtapeDebut == null)
{
result.EmpileErreur(I.T("Workflow type @1 doesn't have any start point|20074",
TypeWorkflow != null?TypeWorkflow.Libelle:"???"));
return(result);
}
}
using (CContexteDonnee ctx = new CContexteDonnee(ContexteDonnee.IdSession, true, false))
{
///Si bStartImmediate, travaille dans un contexte spécifique qui est sauvé tout de suite
CContexteDonnee contexteDeTravail = bStartImmediate ? ctx : ContexteDonnee;
CWorkflow wkf = GetObjetInContexte(contexteDeTravail) as CWorkflow;
typeEtapeDebut = typeEtapeDebut.GetObjetInContexte(contexteDeTravail) as CTypeEtapeWorkflow;
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtapeDebut);
if (resEtape)
{
CEtapeWorkflow etape = resEtape.DataType;
etape.DemandeDemarrageInCurrentContext(null);
}
else
{
result.EmpileErreur(resEtape.Erreur);
}
IsRunning = true;
RunGeneration++;
if (result && bStartImmediate)
{
result = ctx.SaveAll(true);
}
}
return(result);
}
/// //////////////////////////////////////////////////////
public CDefinitionProprieteDynamiqueDonneeCumulee(CTypeDonneeCumulee td, int nNumeroCle)
: base(td.Libelle.Replace(" ", "_"),
td.Id + "|" + nNumeroCle,
new CTypeResultatExpression(typeof(CDonneeCumulee), true), true, true)
{
m_dbKeyTypeDonneeCumulee = td.DbKey;
Rubrique = I.T("Cumulated data|163");
}
//-----------------------------------------------------------------------------------------
public CParametresStartEtapeInPile(int?nIdSessionMain, int nIdEtape, CDbKey keyUtilisateur)
{
IdSessionMain = nIdSessionMain;
IdEtape = nIdEtape;
//TESTDBKEYTODO
KeyUtilisateur = keyUtilisateur;
DateStart = DateTime.Now;
}
public static int GetIdUtilisateurFromKey(CDbKey key)
{
if (m_fournisseurInfos != null)
{
return(m_fournisseurInfos.GetIdUtilisateurFromKey(key));
}
return(-1);
}
//-----------------------------------------------------------
private CRuntimeConfigMapView GetRuntimeConfig(CDbKey keyConfig)
{
//TESTDBKEYOK
CRuntimeConfigMapView runtime = null;
m_dicRuntimes.TryGetValue(keyConfig, out runtime);
return(runtime);
}
/// //////////////////////////////////////////////////////
public CDefinitionProprieteDynamiqueChampCalcule(CChampCalcule champ)
: base(champ.Nom.Replace(" ", "_"), champ.DbKey.StringValue,
champ.Formule.TypeDonnee, false, true)
{
//TESTDBKEYOK
m_dbKeyChamp = champ.DbKey;
Rubrique = champ.Categorie;
}
public static bool HasInterventions(int nIdSession, CDbKey keyUtilisateur)
{
///TODO
///Problème VersionObjet
IBesoinInterventionProcessServeur serveur = (IBesoinInterventionProcessServeur)CContexteDonnee.GetTableLoader(CBesoinInterventionProcess.c_nomTable, null, nIdSession);
return(serveur.HasInterventions(keyUtilisateur));
}
public CInfoSessionAsDynamicClass[] GetInfosSessionsActives()
{
List <CInfoSessionAsDynamicClass> lst = new List <CInfoSessionAsDynamicClass>();
int[] listeIdSessions = GetListeIdSessionsConnectees();
foreach (int nId in listeIdSessions)
{
CInfoSessionAsDynamicClass infoSession = new CInfoSessionAsDynamicClass();
infoSession.IdSession = nId;
CDbKey keyUtilisateur = null;
IInfoSession session = GetSessionClient(nId);
try
{
session.GetInfoUtilisateur();
}
catch
{
session = GetSessionClientSurServeur(nId);
infoSession.Invalide = true;
session = GetSessionClientSurServeur(nId);
}
if (session == null)
{
infoSession.Invalide = true;
session = GetSessionClientSurServeur(nId);
infoSession.NomUtilisateur = I.T("ACCESS ERROR|20000");
}
try
{
infoSession.NomUtilisateur = session.GetInfoUtilisateur().NomUtilisateur;
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYOK
keyUtilisateur = info.KeyUtilisateur;
infoSession.KeyUtilisateur = info.KeyUtilisateur;
DateTime dt = session.DateHeureConnexion;
infoSession.DateDebutConnexion = dt;
infoSession.DateDerniereActivité = session.DateHeureDerniereActivite;
infoSession.LibelleSession = session.DescriptionApplicationCliente;
}
catch
{
if (nId == 0)
{
infoSession.NomUtilisateur = I.T("Server|20001");
}
else
{
infoSession.Invalide = true;
infoSession.NomUtilisateur = I.T("ACCESS ERROR|20000");
}
}
infoSession.IsSystem = keyUtilisateur == null;
lst.Add(infoSession);
}
return(lst.ToArray());
}
/// <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 CParametresStartEtapeInPile(
int?nIdSessionMain,
int nIdEtape,
CDbKey keyUtilisateur,
DateTime dtDemarrage)
: this(nIdSessionMain, nIdEtape, keyUtilisateur)
{
DateStart = dtDemarrage;
}
//---------------------------------------------------------------
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;
}
private void m_cmbStartStep_SelectionChangeCommitted(object sender, EventArgs e)
{
CTypeEtapeWorkflow typeEtape = m_cmbStartStep.ElementSelectionne as CTypeEtapeWorkflow;
if (typeEtape != null)
{
m_keyLastIdTypeEtapeSel = typeEtape.DbKey;
}
}
//-----------------------------------------------------
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 static object GetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp)
{
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(GetValeurChamp(objet, champ.Id, DataRowVersion.Default));
}
return(null);
}
//------------------------------------------------------------
public int GetIdUtilisateurFromKey(CDbKey key)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(CContexteDonneeSysteme.GetInstance());
if (user.ReadIfExists(key))
{
return(user.Id);
}
return(-1);
}
//----------------------------------------------------
public static CObjetDonnee GetObjet(this CDbKey key, CContexteDonnee contexte, Type typeObjet)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(key))
{
return(objet);
}
return(null);
}
//----------------------------------------------------
public static CDbKey GetDbKeyFromId(Type typeElement, int nId)
{
string strIdU = GetIdUniverselFromId(typeElement, nId);
if (strIdU.Length > 0)
{
return(CDbKey.GetNewDbKeyOnUniversalIdANePasUtiliserEnDehorsDeCDbKeyAddOn(strIdU));
}
return(null);
}
