Ejemplo n.º 1
0
        /// <summary>
        /// Démarre une action
        /// </summary>
        /// <param name="process"></param>
        /// <param name="nIdSession"></param>
        /// <returns></returns>
        public static CResultAErreur RunEvent(IDeclencheurAction declencheur, CObjetDonneeAIdNumerique objetCible, bool bHideProgress)
        {
            CFormExecuteProcess form = new CFormExecuteProcess();

            form.Top  = 0;
            form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
            if (declencheur is IDeclencheurActionManuelle)
            {
                bHideProgress |= ((IDeclencheurActionManuelle)declencheur).HideProgress;
            }
            if (bHideProgress)
            {
                CInfoDeclencheurProcess      infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
                CAppelleurFonctionAsynchrone appeleur        = new CAppelleurFonctionAsynchrone();
                CResultAErreur resultDefault = CResultAErreur.True;
                resultDefault.EmpileErreur(I.T("Asynchronous call error @1|20149", "RunEvent"));
                return(appeleur.StartFonctionAndWaitAvecCallback(declencheur.GetType(), declencheur,
                                                                 "RunEvent", "", resultDefault, objetCible, infoDeclencheur, null) as CResultAErreur);
                //return declencheur.RunEvent(objetCible, infoDeclencheur, null);
            }
            else
            {
                IAsyncResult res = form.m_runEvent.BeginInvoke(declencheur, objetCible,
                                                               new AsyncCallback(form.OnEndProcess), null);
                form.ShowDialog();                //Bloque le code ici !
                CResultAErreur result = form.m_runEvent.EndInvoke(res);
                return(result);
            }
        }
Ejemplo n.º 2
0
        /// /////////////////////////////////////////////////////////////
        public static CResultAErreur StartProcessMultiples(CProcess process,
                                                           CInfoDeclencheurProcess infoDeclencheur,
                                                           CReferenceObjetDonnee[] refsCible,
                                                           int nIdSession,
                                                           int?nIdVersion,
                                                           IIndicateurProgression indicateur)
        {
            process.InfoDeclencheur = infoDeclencheur;
            ///TODO
            ///Problème VersionObjet
            IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);

            using (C2iSponsor sponsor = new C2iSponsor())
            {
                sponsor.Register(processServeur);
                CAppelleurFonctionAsynchrone appelleur = new CAppelleurFonctionAsynchrone();
                CResultAErreur defaultResult           = CResultAErreur.True;
                defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "StartProcessMultiples"));
                return(appelleur.StartFonctionAndWaitAvecCallback(
                           typeof(IProcessEnExecutionInDbServeur),
                           processServeur,
                           "StartProcessMultiples",
                           "",
                           defaultResult,
                           new CValise2iSerializable(process),
                           refsCible,
                           nIdVersion,
                           indicateur) as CResultAErreur);
            }
        }
Ejemplo n.º 3
0
        //------------------------------------------------------------
        public CResultAErreur DoOperation(IOperationSynchronisation operation, int nIdSession)
        {
            CResultAErreur result = CResultAErreur.True;

            CAppelleurFonctionAsynchrone ap = new CAppelleurFonctionAsynchrone();

            CAppeleurFonctionAvecDelai.CallFonctionAvecDelai(
                GetConnexion(),
                "NotifyProxyNecessiteMAJ", 1,
                Int32.Parse(operation.IdElementASynchroniser), false, true);

            return(CResultAErreur.True);
        }
Ejemplo n.º 4
0
 public static void Autoexec()
 {
     CAppelleurFonctionAsynchrone.SetTypeMultiThreader(typeof(CFormWaitingThread));
 }
Ejemplo n.º 5
0
        public static CResultAErreur StartProcessClient(
            CProcess leProcessAExecuter,
            object objetCible,
            CContexteDonnee contexte,
            IIndicateurProgression indicateur)
        {
            System.Console.WriteLine("Démarrage process" + leProcessAExecuter.Libelle);
            leProcessAExecuter.ContexteDonnee = contexte;
            //Fin Stef 2/4/08
            CResultAErreur result = CResultAErreur.True;

            if (!leProcessAExecuter.PeutEtreExecuteSurLePosteClient)
            {
                result.EmpileErreur(I.T("Cannot start this process in client mode|20004"));
                return(result);
            }
            CProcessEnExecutionInDb processEnExec = new CProcessEnExecutionInDb(contexte);

            processEnExec.CreateNewInCurrentContexte();
            if (objetCible is CObjetDonneeAIdNumerique)
            {
                processEnExec.ElementLie = (CObjetDonneeAIdNumerique)objetCible;
            }
            else
            {
                processEnExec.ElementLie = null;
            }
            processEnExec.Libelle = leProcessAExecuter.Libelle;
            processEnExec.DbKeyEvennementDeclencheur = leProcessAExecuter.InfoDeclencheur.DbKeyEvenementDeclencheur;
            processEnExec.IdVersionExecution         = contexte.IdVersionDeTravail;

            CBrancheProcess branche = new CBrancheProcess(leProcessAExecuter);

            branche.IsModeAsynchrone           = false;
            branche.ExecutionSurContexteClient = true;
            CSessionClient sessionSource = CSessionClient.GetSessionForIdSession(contexte.IdSession);

            //TESTDBKEYTODO
            branche.KeyUtilisateur          = sessionSource.GetInfoUtilisateur().KeyUtilisateur;
            branche.ConfigurationImpression = sessionSource.ConfigurationsImpression;

            CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
                processEnExec,
                branche,
                objetCible,
                contexte,
                indicateur);
            string strOldContextuel = contexte.IdModificationContextuelle;

            contexteExecution.SauvegardeContexteExterne = true;
            processEnExec.BrancheEnCours = branche;

            CAppelleurFonctionAsynchrone appeleur = new CAppelleurFonctionAsynchrone();
            CResultAErreur defaultResult          = CResultAErreur.True;

            defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "ExecuteAction"));
            result = appeleur.StartFonctionAndWaitAvecCallback(branche.GetType(),
                                                               branche,
                                                               "ExecuteAction",
                                                               "",
                                                               defaultResult,
                                                               leProcessAExecuter.GetActionDebut(), contexteExecution, true) as CResultAErreur;



            //result = branche.ExecuteAction ( leProcessAExecuter.GetActionDebut(), contexteExecution, true );
            if (leProcessAExecuter.VariableDeRetour != null)
            {
                result.Data = leProcessAExecuter.GetValeurChamp(leProcessAExecuter.VariableDeRetour.IdVariable);
            }
            contexte.IdModificationContextuelle = strOldContextuel;
            return(result);
        }