//-------------------------------------
protected override void MyInitValeurDefaut()
{
CodeTypeVersion = (int)CTypeVersion.TypeVersion.Archive;
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session != null && session.GetInfoUtilisateur() != null)
{
DbKeyUtilisateur = session.GetInfoUtilisateur().KeyUtilisateur;
}
Date = DateTime.Now;
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientMessageBox);
if (service != null)
{
sponsor.Register(service);
//Calcule le message
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
m_strMessageCache = FormuleMessage.GetString();
}
else
{
m_strMessageCache = result.Data == null ? "" : result.Data.ToString();
}
result = service.RunService(this);
if (!result)
{
return(result);
}
E2iDialogResult dResult = (E2iDialogResult)result.Data;
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// <summary>
/// Indique si l'utilisateur d'une session a le droit d'executer une tache.
/// Le paramètre tableGroupesUtilisateurs est alloué si nécéssaire (pour cache)
/// </summary>
/// <param name="nIdSession"></param>
/// <param name="parametre"></param>
/// <param name="tableGroupesUtilisateur"></param>
/// <returns></returns>
private static bool CanUserDeclenche(int nIdSession, CDbKey[] listeKeysGroupesEvenement, HashSet <CDbKey> tableGroupesUtilisateur)
{
if (listeKeysGroupesEvenement.Length == 0)
{
return(true);
}
if (tableGroupesUtilisateur == null)
{
try
{
tableGroupesUtilisateur = new HashSet <CDbKey>();
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
foreach (CDbKey keyGroupe in session.GetInfoUtilisateur().ListeKeysGroupes)
{
//TESTDBKEYOK les groupes pour exécution manuelle ne sont plus exploités (Avril 2014)
if (keyGroupe != null)
{
tableGroupesUtilisateur.Add(keyGroupe);
}
}
}
catch
{
}
}
foreach (CDbKey keyGroupe in listeKeysGroupesEvenement)
{
if (keyGroupe != null && tableGroupesUtilisateur.Contains(keyGroupe))
{
return(true);
}
}
return(false);
}
//---------------------------------------------------------------------------------------------
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;
}
}
}
//------------------------------------------------------
public static void AppliqueToForm(Form racine)
{
if (racine == null)
{
return;
}
racine.KeyPreview = true;
racine.KeyDown -= m_handlerKey;
CSessionClient session = CSessionClient.GetSessionUnique();
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
bool bIsAdmin = false;
if (info != null)
{
if (info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitInterface) != null)
{
bIsAdmin = true;
racine.KeyDown += m_handlerKey;
}
}
CSetupVisibiliteControles setup = GetSetupForWindow(session, racine);
if (setup != null && (
!bIsAdmin ||
(GetKeyState(0x10) & 0xF000) != 0xF000 || //SHIFT
(GetKeyState(0x12) & 0xF000) != 0xF000)) //ALT
{
setup.Apply(racine, false);
}
}
/// <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);
}
//------------------------------------------------------
static void racine_KeyDown(object sender, KeyEventArgs e)
{
if (e.Alt && e.Shift && e.KeyCode == Keys.F7)
{
CSessionClient session = CSessionClient.GetSessionUnique();
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info != null)
{
if (info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitInterface) != null)
{
CSetupVisibiliteControles setup = new CSetupVisibiliteControles();
Control ctrl = sender as Control;
if (ctrl != null)
{
Form frm = ctrl.FindForm();
if (frm != null)
{
setup = GetSetupForWindow(session, frm);
CFormSetupFenetreDynamique.ShowArbre(frm, setup);
SetSetupForWindow(session, frm, setup);
setup.Apply(frm, false);
}
}
}
}
}
}
//------------------------------------------------------------
public CResultAErreur PurgeEntites(Type typeObjets, int[] lstIds)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info == null)
{
result.EmpileErreur(I.T("Invalid session in Purge entities|20014"));
return(result);
}
if (info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministrationSysteme) == null)
{
result.EmpileErreur(I.T("Purge entity is allowed to administrators only|20015"));
return(result);
}
result = session.BeginTrans();
if (!result)
{
return(result);
}
CDonneeNotificationModificationContexteDonnee dataModif = new CDonneeNotificationModificationContexteDonnee(IdSession);
result = PurgeEntites(typeObjets, lstIds, dataModif);
if (result)
{
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { dataModif });
result = session.CommitTrans();
}
else
{
session.RollbackTrans();
}
return(result);
}
//------------------------------------------------------------------------------------------------------
public CResultAErreur GetSession(int nIdSession)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session == null)
{
result.EmpileErreur("La session Timos N° " + nIdSession + " a expiré");
return(result);
}
CInfoSessionAspectize.RenouvelleSession(nIdSession);
try
{
result.Data = session.GetInfoUtilisateur().KeyUtilisateur.StringValue;
}
catch (Exception)
{
result.EmpileErreur("La session Timos N° " + nIdSession + " a expiré");
return(result);
}
return(result);
}
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 static void ShowPostIt(Control parent, CPostIt postIt, bool bForceDraw)
{
CWndPostit wndPostIt = new CWndPostit();
wndPostIt.Left = 0;
wndPostIt.Top = 0;
wndPostIt.Width = 270;
wndPostIt.Height = 230;
wndPostIt.Parent = parent;
wndPostIt.LockEdition = true;
wndPostIt.CreateControl();
wndPostIt.Show();
wndPostIt.m_postIt = postIt;
wndPostIt.Left = parent.ClientRectangle.Width / 2 - wndPostIt.Width / 2;
wndPostIt.Top = parent.ClientRectangle.Height / 2 - wndPostIt.Height / 2;
parent.SizeChanged += new EventHandler(wndPostIt.OnParentSizeChanged);
if (postIt.IsNew())
{
wndPostIt.LockEdition = false;
wndPostIt.m_bCanEdit = true;
}
else
{
wndPostIt.LockEdition = true;
wndPostIt.m_bCanEdit = false;
try
{
if (postIt.IsPublique)
{
wndPostIt.m_bCanEdit = true;
}
CSessionClient session = CTimosApp.SessionClient;
//TESTDBKEYOK
if (session.GetInfoUtilisateur().KeyUtilisateur == postIt.Auteur.DbKey)
{
wndPostIt.m_bCanEdit = true;
}
}
catch
{
}
}
wndPostIt.ReadFromRegistre();
if (!wndPostIt.m_bVisible && !bForceDraw)
{
wndPostIt.Visible = false;
wndPostIt.Close();
}
else
{
wndPostIt.FillDialogWithObjet();
wndPostIt.BringToFront();
wndPostIt.Visible = true;
wndPostIt.m_bVisible = true;
wndPostIt.SaveIntoRegistre();
wndPostIt.UpdateVisibiliteBouton();
}
}
public CPanelNotificationUtilisateur()
{
// Cet appel est requis par le Concepteur de formulaires Windows.Forms.
InitializeComponent();
// TODO : ajoutez les initialisations après l'appel à InitializeComponent
//Vérifie le droit sur les worfklows
CSessionClient session = CTimosApp.SessionClient;
if (session != null && session.GetInfoUtilisateur() != null)
{
CRestrictionUtilisateurSurType rest = session.GetInfoUtilisateur().GetRestrictionsSur(typeof(CWorkflow), null);
if ((rest.RestrictionGlobale & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
m_panelWorkflow.Visible = false;
}
}
}
//---------------------------------------------------------
/// <summary>
/// Stocke les informations de fin d'étape dans l'étape
/// <BR></BR>Cette méthode ne doit pas être utilisée en dehors d'un appel par l'objet serveur
/// </summary>
/// <returns></returns>
public CResultAErreur InternalSetInfosTerminéeInCurrentContexte(EEtatEtapeWorkflow etat)
{
DateFin = DateTime.Now;
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
//TESTDBKEYOK
KeyTermineur = info != null ? info.KeyUtilisateur : null;
EtatCode = (int)etat;
return(CResultAErreur.True);
}
//-----------------------------------------------------------
private void CFormAffectationEntitesOrganisationnelles_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
m_lblEntite.Text = m_objet.DescriptionElement;
m_extModeEdition.ModeEdition = false;
m_btnOk.Visible = false;
CSessionClient session = CSessionClient.GetSessionForIdSession(CTimosApp.SessionClient.IdSession);
CRestrictionUtilisateurSurType rest = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_objet, m_objet.ContexteDonnee.IdVersionDeTravail);
if (rest.CanModifyType() && !m_objet.ContexteDonnee.IsEnEdition)
{
rest = session.GetInfoUtilisateur().GetRestrictionsSur(typeof(CRelationElement_EO), m_objet.ContexteDonnee.IdVersionDeTravail);
m_lnkAjouter.Visible = rest.CanCreateType();
m_lnkSupprimer.Visible = rest.CanDeleteType();
m_btnOk.Visible = m_lnkAjouter.Visible || m_lnkSupprimer.Visible;
m_extModeEdition.ModeEdition = m_btnOk.Visible;
m_objet.BeginEdit();
m_bStopEditionSurSortie = true;
}
m_wndListeEos.ListeSource = CRelationElement_EO.GetListeRelationsForElement(m_objet);
}
public static bool UtilisateurConnecteIsUserManager(CContexteDonnee ctx)
{
IDonneeDroitUtilisateur data = null;
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
if (session != null)
{
IInfoUtilisateur infoUser = session.GetInfoUtilisateur();
if (infoUser != null)
{
data = infoUser.GetDonneeDroit(CDroitDeBase.c_droitBaseGestionUtilisateurs);
}
}
return(data != null);
}
public CResultAErreur AcquitterNow()
{
BeginEdit();
Acquittee = true;
AcquitteeDate = CDivers.GetSysdateNotNull();//DateTime.Now;
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
AcquitteePar = session.GetInfoUtilisateur().NomUtilisateur;
CSpvMessalrm spvMessalrm = new CSpvMessalrm(ContexteDonnee);
spvMessalrm.CreateNewInCurrentContexte();
spvMessalrm.MessageAcquittementAlarmeIndividuelle(this.EvenementDebut.Id);
return(CommitEdit());
}
//--------------------------------------------------------------------------------
/// <summary>
/// Complete les restrictions pour un objet donné
/// </summary>
/// <param name="restriction"></param>
public static void CompleteRestriction(IElementAEO element, CRestrictionUtilisateurSurType restriction)
{
CRestrictionUtilisateurSurType restCache = CCacheRestrictions.GetRestriction(element);
if (restCache != null)
{
restriction.Combine(restCache);
return;
}
CContexteDonnee contexte = ((CObjetDonneeAIdNumerique)element).ContexteDonnee;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (session != null)
{
//TESTDBKEYOK
CDbKey keyUtilisateur = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (user.ReadIfExists(keyUtilisateur))
{
foreach (CRelationUtilisateur_Profil rel in user.RelationsProfils)
{
rel.CompleteRestriction(element, restriction);
}
}
}
//Vérifie qu'on a le droit de voir l'élément
try
{
if (!(element is CObjetDonneeAIdNumerique) ||
!((CObjetDonneeAIdNumerique)element).IsDeleted)
{
if (!((CObjetDonnee)element).IsNew())//On ne peut pas appliquer la restriction sur un élément nouveau !
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(element.ContexteDonnee, element.GetType());
lst.Filtre = new CFiltreData(element.GetChampId() + "=@1", element.Id);
lst.AppliquerFiltreAffichage = true;
lst.PreserveChanges = true;
if (lst.Count == 0)
{
restriction.RestrictionUtilisateur = ERestriction.Hide;
}
}
}
}
catch { }
CCacheRestrictions.SetRestriction(element, restriction);
}
private void CFormFormulaireCustom_Load(object sender, System.EventArgs e)
{
m_extModeEdition.ModeEdition = false;
if (m_formulaire != null)
{
if (m_objetEdite is CObjetDonnee)
{
m_createur = new CCreateur2iFormulaireObjetDonnee(((CObjetDonnee)m_objetEdite).ContexteDonnee.IdSession);
}
else if (m_objetEdite is CObjetDonnee[])
{
m_createur = new CCreateur2iFormulaireV2();
}
else
{
m_objetEdite = CSc2iWin32DataClient.ContexteCourant;
m_createur = new CCreateur2iFormulaireV2();
}
m_createur.CreateControlePrincipalEtChilds(m_panelFormulaire, m_formulaire.Formulaire, new CFournisseurPropDynStd(true));
m_createur.LockEdition = !m_extModeEdition.ModeEdition;
CSessionClient session = CSessionClient.GetSessionForIdSession(CTimosApp.SessionClient.IdSession);
CListeRestrictionsUtilisateurSurType restrictions = session.GetInfoUtilisateur().GetListeRestrictions(null).Clone() as CListeRestrictionsUtilisateurSurType;
m_createur.ElementEdite = m_objetEdite;
m_createur.AppliqueRestrictions(restrictions, m_gestionnaireReadOnly);
m_panelEdition.Visible = m_formulaire.AllowEditMode;
CTimosApp.Titre = m_formulaire.Formulaire.Text;
}
else
{
CTimosApp.Titre = "";
}
if (CTimosApp.SessionClient.GetInfoUtilisateur().GetDonneeDroit(
CDroitDeBase.c_droitBasePersonnalisation) != null)
{
this.ContextMenuStrip = m_menuCustomizer;
}
else
{
this.ContextMenuStrip = null;
}
}
/// //////////////////////////////////////////////////
protected override void MyInitValeurDefaut()
{
DateCreation = DateTime.Now;
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
//TESTDBKEYOK
if (info != null)
{
KeyManager = info.KeyUtilisateur;
}
else
{
KeyManager = null;
}
IsRunning = false;
RunGeneration = 0;
}
/// //////////////////////////////////////////////////
public override CResultAErreur TraitementApresSauvegarde(sc2i.data.CContexteDonnee contexte, bool bOperationReussie)
{
CResultAErreur result = CResultAErreur.True;
result = base.TraitementApresSauvegarde(contexte, bOperationReussie);
if (!result)
{
return(result);
}
DataTable table = contexte.Tables[GetNomTable()];
List <DataRow> lstRowsEtapesADemarrer = table == null ? null : table.ExtendedProperties[c_constEtapesADemarre] as List <DataRow>;
if (lstRowsEtapesADemarrer != null && lstRowsEtapesADemarrer.Count > 0)
{
int? nIdSessionMain = IdSession;
CDbKey keyUtilisateur = null;
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYOK
if (info != null)
{
keyUtilisateur = info.KeyUtilisateur;
}
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
nIdSessionMain = sousSession.RootSession.IdSession;
}
}
List <CParametresStartEtapeInPile> lstToStart = new List <CParametresStartEtapeInPile>();
foreach (DataRow row in lstRowsEtapesADemarrer)
{
//Ancien mode, avant 13/9/2013
//RunEtapeInThread ( (int)row[CEtapeWorkflow.c_champId]);
//TESTDBKEYOK
lstToStart.Add(new CParametresStartEtapeInPile(
nIdSessionMain, (int)row[CEtapeWorkflow.c_champId], keyUtilisateur));
}
CPileExecutionEtapes.AddEtapesADemarrer(lstToStart.ToArray());
}
return(result);
}
public static void AddToMenuParent(ToolStripMenuItem menu, string strContexte, object objet)
{
if (objet == null)
{
return;
}
CModeleTexte modeleSel = CTimosAppRegistre.GetModeleTexteForType(strContexte, objet.GetType());
CListeObjetsDonnees liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CModeleTexte));
liste.Filtre = new CFiltreData(CModeleTexte.c_champTypeAssocie + "=@1",
objet.GetType().ToString());
foreach (CModeleTexte modele in liste)
{
CMenuModeleTexte menuModele = new CMenuModeleTexte(modele, strContexte, objet);
if (modeleSel != null && modele.Id == modeleSel.Id)
{
menuModele.Checked = true;
}
menuModele.MouseUp += new MouseEventHandler(menuModele.menuModele_MouseUp);
menu.DropDownItems.Add(menuModele);
}
CSessionClient session = CSessionClient.GetSessionForIdSession(CSc2iWin32DataClient.ContexteCourant.IdSession);
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null && info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null)
{
menu.DropDownItems.Add(new ToolStripSeparator());
CMenuModeleTexte menuModeleAdd = new CMenuModeleTexte(null, strContexte, objet);
menuModeleAdd.Text = I.T("Add|124");
menuModeleAdd.Click += new EventHandler(menuModeleAdd.itemAddMenu_Click);
menu.DropDownItems.Add(menuModeleAdd);
}
}
if (menu.DropDownItems.Count == 0)
{
menu.Visible = false;
}
}
//------------------------------------------------------
public void InitForObjet(CObjetDonneeAIdNumerique objet, CVersionDonnees version)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(objet.ContexteDonnee.IdSession);
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null)
{
m_bCanRestore = info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null;
}
m_bCanRestore &= version != null && version.TypeVersion.Code == CTypeVersion.TypeVersion.Archive;
m_panelRestore.Visible = m_bCanRestore;
if (m_contexteDonnees != null)
{
m_contexteDonnees.Dispose();
}
m_tableValeurs.Clear();
m_objetDepart = null;
m_version = null;
m_arbreObjet.Nodes.Clear();
if (objet == null || version == null)
{
return;
}
m_contexteDonnees = new CContexteDonnee(objet.ContexteDonnee.IdSession, true, false);
m_contexteDonnees.SetVersionDeTravail(-1, false); //Travaille sur toutes les versions
m_objetDepart = (CObjetDonneeAIdNumerique)m_contexteDonnees.GetObjetInThisContexte(objet);
m_version = (CVersionDonnees)m_contexteDonnees.GetObjetInThisContexte(version);
List <int> lstIds = new List <int>();
if (m_version.TypeVersion.Code == CTypeVersion.TypeVersion.Previsionnelle)
{
CVersionDonnees verTmp = m_version.VersionParente;
while (verTmp != null)
{
lstIds.Add(verTmp.Id);
verTmp = verTmp.VersionParente;
}
}
m_nIdsVersionsSuccessives = lstIds.ToArray();
CreateNodeObjet(m_arbreObjet.Nodes, m_objetDepart);
}
public static CActeur UtilisateurActuel(CContexteDonnee ctx)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
if (session != null)
{
IInfoUtilisateur infoUser = session.GetInfoUtilisateur();
if (infoUser != null)
{
CDonneesActeurUtilisateur data = new CDonneesActeurUtilisateur(ctx);
//TESTDBKEYOK
if (data.ReadIfExists(infoUser.KeyUtilisateur))
{
return(data.Acteur);
}
}
}
return(null);
}
/// ///////////////////////////////////////////////////
public CResultAErreur ReconnecteSession(CSessionClient sessionSurClient)
{
CResultAErreur result = CResultAErreur.True;
ISessionClientSurServeur sessionSurServeur = GetSessionClientSurServeur(sessionSurClient.IdSession);
if (sessionSurServeur != null)
{
sessionSurClient.SessionSurServeur = sessionSurServeur;
return(result);
}
result = CanOpenSession(sessionSurClient);
if (result)
{
sessionSurServeur = GetNewSessionSurServeur(sessionSurClient, result.Data);
result.Data = null;
if (sessionSurServeur == null)
{
result.EmpileErreur(I.T("Server session allocation impossible|105"));
}
else
{
sessionSurClient.SessionSurServeur = sessionSurServeur;
lock (typeof(CLockerListeSessions))
{
m_listeSessions[sessionSurClient.IdSession] = sessionSurServeur;
}
string strMessage = I.T("Session Reconnection n°|111") + sessionSurClient.IdSession +
"\r\n" + I.T("Type|107") + sessionSurClient.TypeApplicationCliente.ToString();
strMessage += I.T("\r\n|108") + sessionSurServeur.DescriptionApplicationCliente;
try
{
strMessage += I.T("\r\n|108") + sessionSurClient.GetInfoUtilisateur().NomUtilisateur;
}
catch
{ }
C2iEventLog.WriteInfo(strMessage, NiveauBavardage.VraiPiplette);
CDonneeNotificationConnection donnee = new CDonneeNotificationConnection(sessionSurClient.IdSession, true);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { donnee });
}
}
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);
}
public static IDonneeDroitUtilisateur GetDonneeDroitForSession(int nIdSession, string strCodeDroit)
{
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session == null)
{
return(null);
}
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info == null)
{
return(null);
}
return(info.GetDonneeDroit(strCodeDroit));
}
catch
{
}
return(null);
}
//---------------------------------------------------------
/// <summary>
/// Stocke les différentes informations pour le démarrage d'une étape
/// (date de début, date de fin à null, idDémarreur et IdTermineur à null)
/// <BR></BR>Cette méthode ne doit pas être utilisée en dehors d'un appel par l'objet serveur
/// </summary>
/// <returns></returns>
public CResultAErreur InternalSetInfosDemarrageInCurrentContext()
{
if (DateDebut != null && DateFin != null)
{
//Historise l'étape
CEtapeWorkflowHistorique h = new CEtapeWorkflowHistorique(ContexteDonnee);
h.CreateNewInCurrentContexte();
h.DateDebut = DateDebut.Value;
h.DateFin = DateFin.Value;
//TESTDBKEYOK
h.KeyDémarreur = KeyDémarreur;
h.KeyTermineur = KeyTermineur;
h.CodesRetourString = CodesRetourString;
h.EtatCode = EtatCode;
h.EtapeAppelante = EtapeAppelante;
h.Etape = this;
h.RunGeneration = RunGeneration;
}
DateDebut = DateTime.Now;
RunGeneration = Workflow.RunGeneration;
DateFin = null;
CodesRetour = new string[0];
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session is CSousSessionClient)
{
session = ((CSousSessionClient)session).RootSession;
}
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
KeyDémarreur = info != null ? info.KeyUtilisateur : null;
KeyTermineur = null;
EtatCode = (int)EEtatEtapeWorkflow.ADemarrer;
if (Workflow.EtapeAppelante != null && Workflow.EtapeAppelante.Etat.Code != EEtatEtapeWorkflow.Démarrée)
{
Workflow.EtapeAppelante.OnDemarrageDepuisSousWorkflow();
}
Workflow.IsRunning = true;
return(CResultAErreur.True);
}
//-------------------------------------------------------------------
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;
}
//-------------------------------------------------------------------
public static CDonneesActeurUtilisateur GetUserForSession(int nIdSession, CContexteDonnee contexte)
{
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session == null)
{
return(null);
}
//TESTDBKEYOK
CDbKey keyUtilisateur = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (!user.ReadIfExists(keyUtilisateur))
{
return(null);
}
return(user);
}
catch
{
}
return(null);
}