/// //////////////////////////////////////////
private void UpdateUtilisateurEnDur()
{
CResultAErreur result = GetExpressionUtilisateur();
if (!result)
{
m_lblUtilisateurEnDur.Visible = false;
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(null);
C2iExpression exp = (C2iExpression)result.Data;
if (exp != null)
{
result = exp.Eval(ctx);
if (result)
{
try
{
int nId = Convert.ToInt32(result.Data);
using (CContexteDonnee contexte = new CContexteDonnee(CTimosApp.SessionClient.IdSession, true, false))
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (user.ReadIfExists(nId))
{
m_lblUtilisateurEnDur.Text = user.Acteur.Nom;
m_lblUtilisateurEnDur.Visible = true;
return;
}
}
}
catch {}
}
}
m_lblUtilisateurEnDur.Visible = false;
}
//---------------------------------------------------------
private void ShowMessage(string strMessage, int nIdUserFrom)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant);
if (!user.ReadIfExists(nIdUserFrom))
{
return;
}
if (strMessage != null && nIdUserFrom != m_nIdUtilisateurAutre && Visible && m_nIdUtilisateurAutre >= 0)
{
CInfoMessage info = new CInfoMessage(strMessage, nIdUserFrom);
m_pileMessages.Push(info);
return;
}
bool bChangementUtilisateur = false;
if (nIdUserFrom >= 0)
{
if (nIdUserFrom != m_nIdUtilisateurAutre)
{
bChangementUtilisateur = true;
}
if (bChangementUtilisateur)
{
if (m_nIdUtilisateurAutre >= 0)
{
m_listeUserToMessage[m_nIdUtilisateurAutre] = m_txtMessage.Text;
}
if (m_listeUserToMessage.ContainsKey(nIdUserFrom))
{
m_txtMessage.Text = m_listeUserToMessage[nIdUserFrom];
}
else
{
m_txtMessage.Text = "";
}
m_nIdUtilisateurAutre = nIdUserFrom;
m_lblUser.Text = user.Acteur.IdentiteComplete;
}
}
foreach (ListViewItem item in new ArrayList(m_wndListeMessages.Items))
{
CInfoMessage info = (CInfoMessage)item.Tag;
if (info.IdUserEnvoyeur == nIdUserFrom)
{
AddMessage(info.Message, true);
m_wndListeMessages.Items.Remove(item);
}
}
if (m_wndListeMessages.Items.Count == 0)
{
m_wndListeMessages.Visible = false;
}
if (!bChangementUtilisateur || strMessage != null)
{
AddMessage(strMessage, true);
}
m_bRendVisible = !Visible;
}
public CResultAErreur IsUserValide(string strIdSupport)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (strIdSupport.Trim() != "")
{
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champIdSupportAmovible + "=@1",
strIdSupport)))
{
result.Data = donnees;
return(result);
}
else
{
result.EmpileErreur(I.T("Impossible to identify the storage device|30027"));
}
}
}
else
{
result.EmpileErreur("Invalid removable storage device|30028");
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Removable storage device identification error|30029"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
private void m_timerEmpile_Tick(object sender, EventArgs e)
{
while (m_pileMessages.Count > 0)
{
CInfoMessage info = m_pileMessages.Pop();
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant);
if (user.ReadIfExists(info.IdUserEnvoyeur))
{
ListViewItem item = m_wndListeMessages.Items.Add("");
string strText = user.Acteur.IdentificationCourte + " > " + info.Message;
item.Text = strText;
item.Tag = info;
m_wndListeMessages.Visible = true;
m_bRendVisible = true;
}
}
if (m_wndListeMessages.Items.Count > 0)
{
m_bFondColore = !m_bFondColore;
m_wndListeMessages.BackColor = m_bFondColore ? Color.White : BackColor;
}
else
{
m_wndListeMessages.BackColor = BackColor;
}
if (m_bRendVisible && !Visible)
{
Visible = true;
}
m_bRendVisible = false;
}
/// //////////////////////////////////////////
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 void TiagSetAuteurKeys(object[] lstCles)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(lstCles))
{
Auteur = user;
}
}
public void TiagSetResponsableKeys(object[] lstCles)
{
CDonneesActeurUtilisateur responsable = new CDonneesActeurUtilisateur(ContexteDonnee);
if (responsable.ReadIfExists(lstCles))
{
Responsable = responsable;
}
}
//-------------------------------------------------------------------------
protected override CResultAErreur MyInitChamps()
{
CResultAErreur result = base.MyInitChamps();
AffecterTitre(I.T("Workflow @1|20622", Workflow.Libelle));
m_panelStart.Visible = !Workflow.IsRunning || Workflow.Etapes.Count == 0;
CFiltreData filtre =
new CFiltreDataAvance(
CActeur.c_nomTable,
"HAs(" + CDonneesActeurUtilisateur.c_nomTable + "." + CDonneesActeurUtilisateur.c_champId + ")");
m_txtSelectManager.InitAvecFiltreDeBase <CActeur> (
"IdentiteComplete",
filtre,
false);
m_txtSelectTypeWorkflow.Init <CTypeWorkflow>(
"Libelle",
false);
m_txtSelectTypeWorkflow.ElementSelectionne = Workflow.TypeWorkflow;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(Workflow.ContexteDonnee);
CActeur acteur = null;
//TESTDBKEYOK
if (user.ReadIfExists(Workflow.KeyManager))
{
acteur = user.Acteur;
}
user = CUtilSession.GetUserForSession(Workflow.ContexteDonnee);
if (acteur == null && user != null)
{
acteur = user.Acteur;
}
m_txtSelectManager.ElementSelectionne = acteur;
if (Workflow.Etapes.Count > 0)
{
m_txtSelectTypeWorkflow.LockEdition = true;
m_gestionnaireModeEdition.SetModeEdition(m_txtSelectTypeWorkflow, TypeModeEdition.Autonome);
}
else
{
m_txtSelectTypeWorkflow.LockEdition = !m_gestionnaireModeEdition.ModeEdition;
m_gestionnaireModeEdition.SetModeEdition(m_txtSelectTypeWorkflow, TypeModeEdition.EnableSurEdition);
}
m_panelDessinWorkflow.Enabled = !ModeEdition;
return(result);
}
public CResultAErreur IsUserAdValide(string strIdAd)
{
CResultAErreur result = CResultAErreur.True;
try
{
string strNom;
if (strIdAd.Length > 0)
{
strNom = strIdAd;
//Supprime le domaine
int nPos = strNom.LastIndexOf('\\');
if (nPos > 0)
{
strNom = strNom.Substring(nPos + 1);
}
}
else
{
result.EmpileErreur(I.T("Invalid user name|6"));
return(result);
}
string[] strNoms = strNom.Split('/');
if (strNoms.Length < 1)
{
result.EmpileErreur(I.T("Unauthorized Windows user name|5"));
}
else
{
strNom = strNoms[strNoms.Length - 1];
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champNomWindows + "=@1", strNom)))
{
result.Data = donnees;
return(result);
}
else
{
result.EmpileErreur(I.T("Invalid user name|6"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////////////
public override string GetNomUtilisateurFromKeyUtilisateur(CDbKey keyUtilisateur)
{
//TESTDBKEYOK
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (user.ReadIfExists(keyUtilisateur))
{
return(user.Acteur.Nom);
}
}
return(I.T("Unknown|18"));
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
result = ExpressionUtilisateur.Eval(contexteEval);
if (!result)
{
return(result);
}
else
{
CDbKey keyUtilisateur = null;
try
{
//TESTDBKEYOK
int nId = Convert.ToInt32(result.Data);
keyUtilisateur = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId);
}
catch
{
//TESTDBKEYTODO
if (result.Data != null)
{
keyUtilisateur = CDbKey.CreateFromStringValue(result.Data.ToString());
}
else
{
result.EmpileErreur(I.T("The user expression doesn't return an integer number|381"));
return(result);
}
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte.ContexteDonnee);
if (!user.ReadIfExists(keyUtilisateur))
{
result.EmpileErreur(I.T("The user @1 doesn't exist|382", keyUtilisateur.StringValue));
return(result);
}
contexte.Branche.KeyUtilisateur = keyUtilisateur;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.ContexteDonnee.IdSession);
if (session != null)
{
session.ChangeUtilisateur(keyUtilisateur);
}
}
return(result);
}
//-------------------------------------------------------------------
protected override void MyInitValeurDefaut()
{
DateFin = DateTime.Now.AddMonths(1);
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session != null)
{
//TESTDBKEYOK
CDbKey keyUser = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(keyUser))
{
Auteur = user;
}
}
}
catch
{}
IsPublique = true;
}
public static CDonneesActeurUtilisateur GetUserForSession(CContexteDonnee contexte)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (session == null)
{
return(null);
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
try
{
//TESTDBKEYOK
if (user.ReadIfExists(session.GetInfoUtilisateur().KeyUtilisateur))
{
return(user);
}
}
catch {}
return(null);
}
//-------------------------------------------------------------------
protected override void MyInitValeurDefaut()
{
DateCreation = DateTime.Now;
NextSendDate = DateTime.Now;
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session != null)
{
//TESTDBKEYOK
CDbKey keyUser = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(keyUser))
{
Auteur = user;
}
}
}
catch
{}
NbEssais = 0;
}
protected CResultAErreur CanOpenSessionUserADMAC(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
try
{
CAuthentificationSessionUserADMAC auth = (CAuthentificationSessionUserADMAC)session.Authentification;
string[] strNoms = auth.UserId.Split('/');
string strNom;
if (strNoms.Length < 1)
{
result.EmpileErreur(I.T("Unauthorised Windows user name|5"));
}
else
{
strNom = strNoms[strNoms.Length - 1];
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champNomWindows + "=@1", strNom)))
{
return(InitialiserSessionCliente(session, donnees));
}
else
{
result.EmpileErreur(I.T("Invalid user name|6"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////////////
#region OLD
protected CResultAErreur CanOpenSessionLoginPasswordMAC(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
try
{
CAuthentificationSessionLoginPasswordMAC auth = (CAuthentificationSessionLoginPasswordMAC)session.Authentification;
if (auth.Login.Trim() == "" || auth.Password.Trim() == "")
{
result.EmpileErreur(I.T("Invalid user name or password |3"));
}
else
{
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
string strPassCrypte = C2iCrypto.Crypte(auth.Password);
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champLogin + "=@1 and " +
CDonneesActeurUtilisateur.c_champPassword + "=@2",
auth.Login, strPassCrypte)) && donnees.VerifiePassword(auth.Password))
{
return(InitialiserSessionCliente(session, donnees));
}
else
{
result.EmpileErreur(I.T("Invalid user name or password |3"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
public CResultAErreur IsUserValide(string strLogin, string strMdp)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (strLogin.Trim() == "" || strMdp.Trim() == "")
{
result.EmpileErreur(I.T("Invalid user name or password |3"));
}
else
{
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
string strPassCrypte = C2iCrypto.Crypte(strMdp);
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champLogin + "=@1 and " +
CDonneesActeurUtilisateur.c_champPassword + "=@2",
strLogin, strPassCrypte)) && donnees.VerifiePassword(strMdp))
{
result.Data = donnees;
return(result);
}
else
{
result.EmpileErreur(I.T("Login error |4"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//--------------------------------------------------------------------------------
/// <summary>
/// Complete les restrictions pour un objet donné
/// </summary>
/// <param name="restriction"></param>
public static void CompleteRestriction(IElementARestrictionsSpecifiques element, CRestrictionUtilisateurSurType restriction)
{
List <CRelationElement_RestrictionSpecifique> lst = GetRelationsRestrictions(element);
if (lst.Count == 0)
{
return;
}
CContexteDonnee contexte = element.ContexteDonnee;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
IInfoUtilisateur info = null;
//TESTDBKEYTODO
CDbKey keyUtilisateur = null;
if (session != null)
{
info = session.GetInfoUtilisateur();
if (info == null)
{
return;
}
if (info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null)
{
return;
}
keyUtilisateur = info.KeyUtilisateur;
}
//Application des restrictions qui s'appliquent à tout le monde
foreach (CRelationElement_RestrictionSpecifique rel in lst.ToArray())
{
if (rel.Applications.Count == 0)
{
CListeRestrictionsUtilisateurSurType liste = rel.GroupeRestriction.ListeRestrictions;
CRestrictionUtilisateurSurType resTmp = liste.GetRestriction(element.GetType());
restriction.Combine(resTmp);
lst.Remove(rel);
}
}
if (lst == null || lst.Count == 0 || info == null)
{
return;
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (user.ReadIfExists(keyUtilisateur))
{
CActeur acteur = user.Acteur;
while (acteur != null)
{
foreach (CRelationElement_RestrictionSpecifique rel in lst.ToArray())
{
CRelationElement_RestrictionSpecifique_Application app = rel.GetRelationFor(acteur);
if (app != null)
{
CListeRestrictionsUtilisateurSurType restrictions = rel.GroupeRestriction.ListeRestrictions;
CRestrictionUtilisateurSurType resTmp = restrictions.GetRestriction(element.GetType());
restriction.Combine(resTmp);
lst.Remove(rel);
}
}
acteur = acteur.ActeurParent;
}
acteur = user.Acteur;
if (lst.Count == 0)
{
return;
}
foreach (CGroupeActeur groupe in acteur.TousLesGroupesActeur)
{
foreach (CRelationElement_RestrictionSpecifique rel in lst.ToArray())
{
if (rel.GetRelationFor(groupe) != null)
{
CListeRestrictionsUtilisateurSurType restrictions = rel.GroupeRestriction.ListeRestrictions;
CRestrictionUtilisateurSurType resTmp = restrictions.GetRestriction(element.GetType());
restriction.Combine(resTmp);
lst.Remove(rel);
}
}
if (lst.Count == 0)
{
return;
}
}
foreach (CRelationUtilisateur_Profil relProfil in user.RelationsProfils)
{
foreach (CRelationElement_RestrictionSpecifique rel in lst.ToArray())
{
if (rel.GetRelationFor(relProfil.Profil) != null)
{
CListeRestrictionsUtilisateurSurType restrictions = rel.GroupeRestriction.ListeRestrictions;
CRestrictionUtilisateurSurType resTmp = restrictions.GetRestriction(element.GetType());
restriction.Combine(resTmp);
lst.Remove(rel);
if (lst.Count == 0)
{
return;
}
}
}
}
}
}
