/// ////////////////////////////////////////////////////////
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>
/// 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);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
if (contexte.Branche.IsModeAsynchrone) //On est déjà en asynchrone
{
return(result);
}
//Ouvre une nouvelle session
CSessionProcessServeurSuivi session = new CSessionProcessServeurSuivi();
result = session.OpenSession(new CAuthentificationSessionProcess(),
I.T("Process @1|198", contexte.ProcessEnExecution.Libelle),
CSessionClient.GetSessionForIdSession(contexte.ContexteDonnee.IdSession));
if (!result)
{
result.EmpileErreur(I.T("Switch asynchronous mode failure|210"));
return(result);
}
//Change l'id de session du contexte de travail
contexte.ChangeIdSession(session.IdSession);
if (GetLiensSortantHorsErreur().Length == 1)
{
result.Data = GetLiensSortantHorsErreur()[0];
}
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);
}
/// <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);
}
private CFiltresSynchronisation GetFiltres(string strCodeGroupeSynchronisation)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session == null)
{
return(null);
}
IFournisseurServicePourSessionClient fournisseur = session.GetFournisseur(CSc2iDataConst.c_ServiceFiltresSynchronisation);
if (fournisseur == null)
{
return(null);
}
IServiceGetFiltresSynchronisation service = (IServiceGetFiltresSynchronisation)fournisseur.GetService(IdSession);
if (service != null)
{
CResultAErreur result = service.GetFiltresSynchronisation(strCodeGroupeSynchronisation);
if (result)
{
return(( CFiltresSynchronisation )result.Data);
}
throw new CExceptionErreur(result.Erreur);
}
return(null);
}
/// //////////////////////////////////////////
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 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 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 void CloseSession(int nIdSession)
{
CInfoSessionAspectize.OnCloseSession(nIdSession);
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session != null)
{
session.CloseSession();
}
}
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;
}
}
}
}
//---------------------------------------------------------
/// <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);
}
///////////////////////////////////////////
/// <summary>
/// Retourne l'id de la session qui gère les transaction pour cette session
/// </summary>
/// <param name="nIdSession"></param>
/// <returns></returns>
private int GetIdSessionForDb(int nIdSession)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
CSousSessionClient sousSession = session as CSousSessionClient;
if (sousSession != null)
{
return(sousSession.RootSession.IdSession);
}
return(nIdSession);
}
private void m_lnkFermer_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
if (MessageBox.Show("Fermer toutes les sessions sélectionnées ?", "Confirmation",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
ArrayList lstThreads = new ArrayList();
m_listeServicesToLaunch.Clear();
m_listeThreadsEnAttente.Clear();
ThreadStart funcStart = new ThreadStart(AskForClose);
foreach (ListViewItem item in m_listView.CheckedItems)
{
int nIdSession = (int)item.Tag;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
try
{
CServiceSurClientFermerApplication service = (CServiceSurClientFermerApplication)session.GetServiceSurClient(CServiceSurClientFermerApplication.c_idService);
if (service != null)
{
lock (m_listeServicesToLaunch)
{
m_listeServicesToLaunch.Add(service);
}
Thread th = new Thread(funcStart);
th.Start();
}
}
catch (Exception ex1)
{
result.EmpileErreur(ex1.Message);
try
{
if (session != null)
{
session.CloseSession();
}
}
catch (Exception ex2)
{
result.EmpileErreur(ex2.Message);
}
}
}
if (!result)
{
MessageBox.Show(result.MessageErreur);
}
}
//------------------------------------------------
public static CUtilTimosTiag GetUtilTiagForSession(int nIdSession)
{
CUtilTimosTiag util = null;
if (!m_tableUtilsParSession.TryGetValue(nIdSession, out util))
{
util = new CUtilTimosTiag(CSessionClient.GetSessionForIdSession(nIdSession));
m_tableUtilsParSession[nIdSession] = util;
}
return(util);
}
//-------------------------------------
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;
}
/// //////////////////////////////////////////////////
public CResultAErreur Purger(DateTime dt)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
try
{
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CProcessEnExecutionInDb));
liste.Filtre = new CFiltreData(CProcessEnExecutionInDb.c_champDateCreation + "<@1 and " +
"(" + CProcessEnExecutionInDb.c_champEtat + "=@2 or " +
CProcessEnExecutionInDb.c_champEtat + "=@3)",
dt,
(int)EtatProcess.Erreur,
(int)EtatProcess.Termine);
int nCount = liste.Count;
for (int nBloc = 0; nBloc < nCount; nBloc += 500)
{
StringBuilder bl = new StringBuilder();
int nMin = Math.Min(nBloc + 500, nCount);
for (int nCpt = nBloc; nCpt < nMin; nCpt++)
{
bl.Append(((CProcessEnExecutionInDb)liste[nCpt]).Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
using (CContexteDonnee ctxTmp = new CContexteDonnee(IdSession, true, false))
{
CListeObjetsDonnees petiteListe = new CListeObjetsDonnees(ctxTmp, typeof(CProcessEnExecutionInDb));
petiteListe.Filtre = new CFiltreData(
CProcessEnExecutionInDb.c_champId + " in (" +
bl.ToString() + ")");
result = CObjetDonneeAIdNumerique.Delete(petiteListe);
if (!result)
{
return(result);
}
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////
///Démarre une étape dans un thread séparé
public static void CalcElementsInThread(CElementsProjetARecalculer lstElements)
{
Thread th = new Thread(DoCalcInThread);
int nIdSession = lstElements.IdSession;
//Lance l'étape dans la session root, car la sousSEssion peut être fermée avant que
//L'étape ne soit lancée !
CSousSessionClient session = CSessionClient.GetSessionForIdSession(lstElements.IdSession) as CSousSessionClient;
if (session != null)
{
nIdSession = session.RootSession.IdSession;
}
th.Start(lstElements);
}
/// //////////////////////////////////////////////////
///Démarre une étape dans un thread séparé
public void RunEtapeInThread(int nIdEtape)
{
Thread th = new Thread(StartEtapeInThread);
int nIdSession = IdSession;
//Lance l'étape dans la session root, car la sousSEssion peut être fermée avant que
//L'étape ne soit lancée !
CSousSessionClient session = CSessionClient.GetSessionForIdSession(IdSession) as CSousSessionClient;
if (session != null)
{
nIdSession = session.RootSession.IdSession;
}
th.Start(new CParametresStartEtape(nIdSession, nIdEtape));
}
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);
}
/// ////////////////////////////////////////////////////////
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);
}
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());
}
//-------------------------------------------------------------------
public void OnEndProcess()
{
DoTraitementApresExecution();
if (m_bHasSessionPropre)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null)
{
try
{
session.CloseSession();
}
catch { }
}
}
}
//--------------------------------------------------------------------------------
/// <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);
}
//------------------------------------------------------------------------------
public static void CInitialiseurClientTimos_OnChangeVersionDeTravail(object sender, EventArgs e)
{
CContexteDonnee contexte = sender as CContexteDonnee;
if (contexte != null)
{
int nIdSession = contexte.IdSession;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
try
{
session.RefreshUtilisateur();
}
catch
{
}
}
}
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 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 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 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);
}