//----------------------------------------------------------------------------
public CResultAErreur InitPanel(CTicket ticketEdité)
{
this.SuspendDrawing();
if (ticketEdité == null)
{
return(CResultAErreur.False);
}
CResultAErreur result = CResultAErreur.True;
m_ticketEdite = ticketEdité;
m_utilisateur = CUtilSession.GetUserForSession(m_ticketEdite.ContexteDonnee);
m_extLinkField.FillDialogFromObjet(m_ticketEdite);
// Init panel Infos générales
InitInfosGenerales();
// Init Détail Ticket
this.ResumeDrawing();
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);
}
public bool Acknowledge()
{
CResultAErreur result = CResultAErreur.True;
if (DateAcquittement != null)
{
return(false);
}
BeginEdit();
CDonneesActeurUtilisateur utilisateurEnCours =
CDonneesActeurUtilisateur.GetUserForSession(ContexteDonnee.IdSession, ContexteDonnee);
if (utilisateurEnCours != null)
{
ResponsableAcquittement = utilisateurEnCours.Acteur;
DateAcquittement = DateTime.Now;
// Acquitte les alarmes filles en cascade
foreach (CAlarme alarmeFille in AlarmesFilles)
{
alarmeFille.Acknowledge();
}
}
result = CommitEdit();
return(result.Result);
}
/// //////////////////////////////////////////
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 CPanelNotificationUtilisateur_Load(object sender, System.EventArgs e)
{
if (!DesignMode)
{
m_recepteurInterventions = new CRecepteurNotification(CTimosApp.SessionClient.IdSession, typeof(CDonneeNotificationBesoinIntervention));
m_recepteurInterventions.OnReceiveNotification += new NotificationEventHandler(OnNotification);
m_recepteurWorkflow = new CRecepteurNotification(CTimosApp.SessionClient.IdSession, typeof(CDonneeNotificationWorkflow));
m_recepteurWorkflow.OnReceiveNotification += new NotificationEventHandler(m_recepteurWorkflow_OnReceiveNotification);
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(CSc2iWin32DataClient.ContexteCourant);
if (user != null)
{
CListeObjetsDonnees lstPourActeur = user.Acteur.GetEtapeWorkflowsEnCours();
m_nNbEtapesEnCours = lstPourActeur.Count;
if (m_nNbEtapesEnCours > 0)
{
m_lblNbToDo.Text = m_nNbEtapesEnCours.ToString();
m_lblNbToDo.Visible = true;
}
else
{
m_lblNbToDo.Text = "0";
m_lblNbToDo.Visible = false;
}
}
BeginInvoke((MethodInvoker) delegate
{
UpdateInterventions();
});
}
}
//--------------------------------------------------------------------------------
private void UpdateVisuForUser()
{
if (m_gestionnaireModeEdition.ModeEdition)
{
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(Intervention.ContexteDonnee);
if (user != null)
{
if (!user.Acteur.Equals(m_txtSelectPreplanificateur.ElementSelectionne))
{
m_panelPreplanification.LockEdition = true;
}
else
{
m_panelPreplanification.LockEdition = false;
}
if (!user.Acteur.Equals(m_txtSelectPlanificateur.ElementSelectionne))
{
m_panelPlanification.LockEdition = true;
}
else
{
m_panelPlanification.LockEdition = 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);
}
//-------------------------------------------------------------------------------------------------
public CResultAErreur GetUserProfil(CDonneesActeurUtilisateur donnees)
{
CResultAErreur result = CResultAErreur.True;
if (TimosServeur.LicenceLogiciel.ProfilsUtilisateurs.Count == 0)
{
result.EmpileErreur(I.T("Error : there is no profile in the license|14"));
return(result);
}
CUserProfilPrtct prof = TimosServeur.LicenceLogiciel.GetProfil(donnees.IdProfilLicence);
if (prof == null)
{
//Tente de récuperer des licences perdues
RecalculeAffectationLicencesEtProfils();
prof = TimosServeur.LicenceLogiciel.GetProfil(donnees.IdProfilLicence);
}
if (prof == null)
{
result.EmpileErreur(I.T("Error : no more free profile for the license|15"));
}
result.Data = prof;
return(result);
}
/// /////////////////////////////
public void SetElementsAAgenda(CObjetDonneeAIdNumerique[] elements)
{
m_elementsAAgenda = elements;
if (m_controlAffichage != null)
{
((IControlAgenda)m_controlAffichage).SetElementsAAgenda(m_elementsAAgenda);
}
if (m_elementsAAgenda.Length > 1)
{
m_lnkAjouter.Visible = false;
return;
}
//Si l'élément est un acteur, possible de créer une entrée si
//c'est soi-même ou si c'est un acteur dont on gère l'agenda
if (elements.Length == 1 && elements[0] is CActeur)
{
CActeur part = (CActeur)elements[0];
m_lnkAjouter.Visible = false;
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(elements[0].ContexteDonnee);
if (user.Acteur.Equals(part))
{
m_lnkAjouter.Visible = true;
}
else
{
/*foreach ( CRelationUtilisateur_AgendasGeres rel in user.RelationsUtilisateursAgendaGeres )
* if ( rel.UtilisateurGere.Acteur.Equals ( part ) )
* m_lnkAjouter.Visible = true;*/
}
}
}
//-------------------------------------------------------------------
private CResultAErreur InitialiserSessionCliente(CSessionClient session, CDonneesActeurUtilisateur donneesUser)
{
CResultAErreur result = VerifInitialisationsTimosServeur();
if (!result)
{
return(result);
}
//Recupération de la licence
result = GetUserLicence(session, donneesUser);
if (!result)
{
return(result);
}
CUserLicencePrtct licence = (CUserLicencePrtct)result.Data;
//Recuperation d'un profil
result = GetUserProfil(donneesUser);
if (!result)
{
return(result);
}
CUserProfilPrtct profil = (CUserProfilPrtct)result.Data;
//Enregistrement des infos de session
CInfoSessionTimos info = new CInfoSessionTimos(donneesUser, licence, profil);
result.Data = info;
return(result);
}
/// ///////////////////////////////////////////////////
public CListeRestrictionsUtilisateurSurType GetListeRestrictions(int?nIdVersion)
{
CListeRestrictionsUtilisateurSurType liste = new CListeRestrictionsUtilisateurSurType();
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
CDonneesActeurUtilisateur user = Utilisateur;
//C'est pas une session système
if (user != null)
{
liste.Combine(user.GetRestrictions(nIdVersion));
}
liste.Combine(GetListeRestrictionsModulesClient());
CConfigurationRestrictions.AppliqueRestrictions(CTimosServeur.c_keyRestrictionAllUsers, liste);
if (UserLicence != null && UserLicence.IsReadOnly)
{
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CRestrictionUtilisateurSurType rest = liste.GetRestriction(tp);
CRestrictionUtilisateurSurType restRO = new CRestrictionUtilisateurSurType(tp);
restRO.RestrictionSysteme = ERestriction.ReadOnly;
rest.Combine(restRO);
liste.AddRestriction(rest);
}
}
return(liste);
}
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 void TiagSetResponsableKeys(object[] lstCles)
{
CDonneesActeurUtilisateur responsable = new CDonneesActeurUtilisateur(ContexteDonnee);
if (responsable.ReadIfExists(lstCles))
{
Responsable = responsable;
}
}
public void TiagSetAuteurKeys(object[] lstCles)
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(lstCles))
{
Auteur = user;
}
}
public CInfoSessionTimos(
CDonneesActeurUtilisateur donneesUtilisateur,
CUserLicencePrtct userLicence,
CUserProfilPrtct userProfil)
{
m_donneesUtilisateur = donneesUtilisateur;
m_userLicence = userLicence;
m_userProfil = userProfil;
}
/// ///////////////////////////////////////////////////
public IDonneeDroitUtilisateur GetDonneeDroit(string strCode)
{
CDonneesActeurUtilisateur user = Utilisateur;
if (user == null)//C'est une session système
{
return(new CDonneeDroitSysteme(strCode));
}
return(user.GetDonneeDroit(strCode));
}
//-------------------------------------------------------------------------
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);
}
void m_recepteurWorkflow_OnReceiveNotification(IDonneeNotification donnee)
{
CDonneeNotificationWorkflow dw = donnee as CDonneeNotificationWorkflow;
if (dw == null)
{
return;
}
string[] strCodesInteressants = CUtilSession.GetCodesAffectationsEtapeConcernant(CSc2iWin32DataClient.ContexteCourant);
bool bPourMoi = false;
foreach (string strCode in strCodesInteressants)
{
if (dw.CodesAffectations.Contains("~" + strCode + "~"))
{
bPourMoi = true;
break;
}
}
if (bPourMoi)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(dw.IdSessionEnvoyeur);
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
session = sousSession.RootSession;
}
if (session != null &&
session.IdSession == CTimosApp.SessionClient.IdSession &&
dw.ExecutionAutomatique
)
{
m_nIdEtapeToLaunch = dw.IdEtapeSource;
}
m_nNbClignotementsWorkflowsRestant += c_nNbClignotementsWorkflow;
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(CSc2iWin32DataClient.ContexteCourant);
if (user != null)
{
CListeObjetsDonnees lstPourActeur = user.Acteur.GetEtapeWorkflowsEnCours();
m_nNbEtapesEnCours = lstPourActeur.Count;
if (m_nNbEtapesEnCours > 0)
{
m_lblNbToDo.Text = m_nNbEtapesEnCours.ToString();
m_lblNbToDo.Visible = true;
}
else
{
m_lblNbToDo.Text = "0";
m_lblNbToDo.Visible = false;
}
}
}
}
public static string[] GetCodesAffectationsEtapeConcernant(CContexteDonnee contexteDonnee)
{
CDonneesActeurUtilisateur user = GetUserForSession(contexteDonnee);
List <string> strCodes = new List <string>();
if (user != null)
{
CActeur acteur = user.Acteur;
strCodes.AddRange(acteur.GetListeCodesAffectationEtape());
}
return(strCodes.ToArray());
}
/// ////////////////////////////////////////////////////
private bool ShouldAffiche(CMenuCustom menu)
{
bool bAfficheGroupes = false;
bool bAfficheProfils = false;
bool bAffiche = true;
CDbKey[] keysGroupes = menu.KeysGroupes;
if (keysGroupes != null && keysGroupes.Length > 0)
{
bAffiche = false;
//TESTDBKEYOK
CDbKey[] lstGroupesSession = CTimosApp.SessionClient.GetInfoUtilisateur().ListeKeysGroupes;
foreach (CDbKey keyVoyant in keysGroupes)
{
foreach (CDbKey key in lstGroupesSession)
{
if (keyVoyant == key)
{
bAfficheGroupes = true;
}
}
}
}
//TESTDBKEYOK
CDbKey[] keysProfils = menu.KeysProfils;
if (keysProfils != null && keysProfils.Length > 0)
{
bAffiche = false;
CDonneesActeurUtilisateur user = CDonneesActeurUtilisateur.GetUserForSession(
CTimosApp.SessionClient.IdSession,
m_menuCustom.ContexteDonnee);
foreach (CDbKey keyVoyant in keysProfils)
{
CProfilUtilisateur profilVoyant = new CProfilUtilisateur(m_menuCustom.ContexteDonnee);
if (profilVoyant.ReadIfExists(keyVoyant))
{
if (user.IsInProfil(profilVoyant))
{
bAfficheGroupes = true;
}
}
}
}
if (!bAffiche)
{
return(bAfficheGroupes || bAfficheProfils);
}
return(bAffiche);
}
/// ///////////////////////////////////////////////////
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"));
}
/// //////////////////////////////////////////
private void m_btnSelectionnerUtilisateur_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CDonneesActeurUtilisateur user = (CDonneesActeurUtilisateur)CFormSelectUnObjetDonnee.SelectObjetDonnee(
I.T("Select an application user|20739"),
typeof(CDonneesActeurUtilisateur),
null,
"NomDestinataireMessage");
if (user != null)
{
m_txtFormule.Text = user.Id.ToString();;
}
}
//-------------------------------------------------------------------------
private void CFormDeplacerRessource_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
m_selectSite.Init <CSite>(
"Libelle",
false);
m_selectActeur.Init <CActeur>(
"IdentiteComplete",
false);
if (m_ressource.TypeRessource != null)
{
m_radioSite.Enabled = m_ressource.TypeRessource.EmplacementSitePossible;
m_selectSite.LockEdition = !m_ressource.TypeRessource.EmplacementSitePossible;
m_radioActeur.Enabled = m_ressource.TypeRessource.EmplacementActeurPossible;
m_selectActeur.LockEdition = !m_ressource.TypeRessource.EmplacementActeurPossible;
}
if (m_ressource.EmplacementSite != null)
{
m_radioSite.Checked = true;
m_selectSite.Focus();
}
else
{
m_radioActeur.Checked = true;
m_selectActeur.Focus();
}
m_selectSite.ElementSelectionne = m_ressource.EmplacementSite;
m_selectActeur.ElementSelectionne = m_ressource.EmplacementActeur;
m_dtMouvement.Value = DateTime.Now;
CFiltreData filtre = new CFiltreDataAvance(CActeur.c_nomTable,
"Has(" + CDonneesActeurUtilisateur.c_nomTable + "." +
CDonneesActeurUtilisateur.c_champId + ")");
m_selectUser.InitAvecFiltreDeBase <CActeur>("IdentiteComplete", filtre, true);
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(m_ressource.ContexteDonnee);
if (user != null)
{
m_selectUser.ElementSelectionne = user.Acteur;
}
}
private void m_arbre_AfterCheck(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
if (!e.Node.Checked || m_elementADroits == null || m_bIsInitialising)
{
return;
}
// Utilistauer connecté
CDonneesActeurUtilisateur userConnecte = null;
CObjetDonnee objet = m_elementADroits as CObjetDonnee;
if (objet != null)
{
userConnecte = CDonneesActeurUtilisateur.GetUserForSession(objet.ContexteDonnee.IdSession, objet.ContexteDonnee);
}
CDroitNode node = (CDroitNode)e.Node;
if (userConnecte != null)
{
// Verifie que l'utilisateur tente d'affecter un droit qu'il n'a pas !
if (userConnecte.GetDonneeDroit(node.Droit.Code) == null)
{
node.Checked = false;
CFormAlerte.Afficher(I.T("You don't have right to affect this system Right : @1|10010", node.Droit.Libelle));
return;
}
}
if (node.Relation == null)
{
CRelationElement_Droit relation = m_elementADroits.GetNewObjetRelationDroit();
relation.Droit = (CDroitUtilisateur)node.Droit;
relation.ElementDefinisseur = m_elementADroits;
node.Relation = relation;
}
m_arbre.SelectedNode = node;
if (node.Checked && !m_bLockEdition)
{
m_listeExtensions.Enabled = true;
m_wndListeOptions.Enabled = true;
}
else
{
m_listeExtensions.Enabled = false;
m_wndListeOptions.Enabled = false;
}
}
/// ////////////////////////////////////////////////////////
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 InitPanel()
{
CFormMain.GetInstance().CancelEtapePermanente();
CFiltreData filtre = null;
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(m_listeObjets.ContexteDonnee);
if (user != null)
{
CListeObjetsDonnees lstPourActeur = user.Acteur.GetEtapeWorkflowsEnCours();
filtre = lstPourActeur.FiltrePrincipal;
}
else
{
filtre = new CFiltreData(CEtapeWorkflow.c_champEtat + "=@1", (int)EEtatEtapeWorkflow.Démarrée);
}
/*
* string[] strCodes = CUtilSession.GetCodesAffectationsEtapeConcernant(m_listeObjets.ContexteDonnee);
* CFiltreData filtreAss = new CFiltreData( );
* foreach (string strCode in strCodes)
* {
* filtreAss.Filtre += CEtapeWorkflow.c_champAffectations + " like @" +
* (filtreAss.Parametres.Count + 1) + " or ";
* filtreAss.Parametres.Add("%~" + strCode + "~%");
* }
* if (filtreAss.Filtre.Length > 0)
* {
* filtreAss.Filtre = filtreAss.Filtre.Remove(filtreAss.Filtre.Length - 4, 4);
* filtre = CFiltreData.GetAndFiltre(filtre, filtreAss);
* }
*/
//m_listeObjets.Filtre = filtre;
m_panelListe.FiltreDeBase = filtre;
m_panelListe.InitFromListeObjets(
m_listeObjets,
typeof(CEtapeWorkflow),
null, "");
m_panelListe.BoutonAjouterVisible = false;
m_panelListe.BoutonSupprimerVisible = false;
m_panelListe.BoutonModifierVisible = false;
m_panelListe.RemplirGrille();
}
//-------------------------------------------------------------------------------------------------
public CResultAErreur GetUserLicence(CSessionClient session, CDonneesActeurUtilisateur donnees)
{
CResultAErreur result = CResultAErreur.True;
if (session != null && session.Authentification is CAuthentificationSessionTimos)
{
CParametresLicence param = ((CAuthentificationSessionTimos)session.Authentification).ParametresIdentificationLicence;
param.UserID = donnees.Id.ToString();
param.GroupeID = donnees.Acteur.TousLesIdsDeGroupes;
return(GetUserLicence(param));
}
result.EmpileErreur(I.T("Error while licence recovery : the user session cannot be identified|13"));
return(result);
}
/// ///////////////////////////////////////
private void m_btnAgenda_Click(object sender, System.EventArgs e)
{
try
{
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(CSc2iWin32DataClient.ContexteCourant);
if (user != null)
{
CTimosApp.Navigateur.AffichePage(new CFormAgenda(user.Acteur));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
CFormAlerte.Afficher(I.T("Impossible to reach the agenda|30116"), EFormAlerteType.Erreur);
}
}
