Beispiel #1
0
        /// /////////////////////////////
        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;*/
                }
            }
        }
Beispiel #2
0
        //----------------------------------------------------------------------------

        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);
        }
        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();
                });
            }
        }
Beispiel #4
0
        //--------------------------------------------------------------------------------
        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;
                    }
                }
            }
        }
Beispiel #5
0
        //-------------------------------------------------------------------------
        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);
        }
        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;
                    }
                }
            }
        }
Beispiel #7
0
        /// /////////////////////////////////////////////
        protected override void MyInitValeurDefaut()
        {
            DateOuverture = DateTime.Now;
            // A la création du ticket la date de cloture est initialisée à une
            // valeur antérieur à la date d'ouverture car le ticket est Ouvert

            Auteur      = CUtilSession.GetUserForSession(this.ContexteDonnee);
            Responsable = Auteur;
            Numero      = GetNewTikcetNumber();

            // Le ticket est ouvert par défaut
            Row[c_champEtat] = false;
        }
Beispiel #8
0
        //-------------------------------------------------------------------------
        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;
            }
        }
        //-------------------------------------------------------------------
        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();
        }
 /// ///////////////////////////////////////
 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);
     }
 }
Beispiel #11
0
        private void m_lnkAjouterIntervention_LinkClicked(object sender, EventArgs e)
        {
            if (m_contexteDonnee == null || m_controlePlanning.ElementAInterventionSelectionne == null)
            {
                CFormAlerte.Afficher(I.T("Function not avaliable|30204"), EFormAlerteType.Exclamation);
                return;
            }
            CIntervention intervention = new CIntervention(m_contexteDonnee);

            intervention.CreateNew();
            intervention.ElementAIntervention  = (CObjetDonneeAIdNumerique)m_controlePlanning.ElementAInterventionSelectionne;
            intervention.DateDebutPrePlanifiee = m_controlePlanning.DateDebut;
            intervention.DateFinPrePlanifiee   = m_controlePlanning.DateFin;
            intervention.UserPreplanifieur     = CUtilSession.GetUserForSession(m_contexteDonnee);
            intervention.UserPlanifieur        = intervention.UserPlanifieur;
            EditeIntervention(intervention);
        }
        //----------------------------------------------------------------------------------
        public override CResultAErreur ExecuteAction(
            CTraitementReleveEquipement traitementExecutant,
            CEquipement equipementParent,
            CContexteDonnee ctxDonnee)
        {
            CResultAErreur         result      = CResultAErreur.True;
            CEquipement            eqpt        = (CEquipement)m_equipement.GetObjetInContexte(ctxDonnee);
            IEmplacementEquipement emplacement = m_emplacement;

            if (emplacement == null)
            {
                emplacement = CEmplacementEquipementsTrouves.StockPerduTrouve;
            }
            if (emplacement == null)
            {
                result.EmpileErreur(I.T("'lost & found' stock is not defined. Contact Timos Administrator|20216"));
                return(result);
            }
            string strSiteLabel = "";
            string strDate      = "";

            try
            {
                strSiteLabel = ReleveEquipement.ReleveSite.Site.Libelle;
                strDate      = ReleveEquipement.ReleveSite.DateReleve.ToShortDateString();
            }
            catch { }
            result = eqpt.DeplaceEquipementOptionPassage(
                I.T("Inventory on @1 (@2)|20245",
                    strSiteLabel, strDate),
                emplacement,
                equipementParent != null && equipementParent.Emplacement.Equals(emplacement) ? equipementParent : null,
                traitementExecutant.ReleveEquipement.Coordonnee,
                null,
                CUtilSession.GetUserForSession(ctxDonnee),
                DateTime.Now, "", false, true);
            if (result && emplacement.Equals(ReleveEquipement.ReleveSite.Site))
            {
                result = CActionModifierEquipement.MajEquipement(eqpt, traitementExecutant.ReleveEquipement);
            }
            return(result);
        }
Beispiel #13
0
        public CResultAErreur InitPanel(CTicket ticketEdité)
        {
            m_bIsInitialising = true;

            this.SuspendDrawing();

            if (ticketEdité == null)
            {
                return(CResultAErreur.False);
            }

            CResultAErreur result = CResultAErreur.True;

            m_ticketEdite = ticketEdité;
            m_utilisateur = CUtilSession.GetUserForSession(m_ticketEdite.ContexteDonnee);

            if (m_ticketEdite.IsNew())
            {
                m_bNouveau = true;
                m_ticketEdite.CreerHistorique(null, I.T("Ticket opening|675"));
            }
            else
            {
                m_bNouveau = false;
            }

            m_extLinkField.FillDialogFromObjet(m_ticketEdite);

            // Init panel Infos générales
            InitInfosGenerales();
            // Init Détail Ticket
            InitDetailTicket();
            InitOnglets();

            m_bIsInitialising = false;

            UpdateVisuEntete(m_bInfosEnteteAffiche);

            this.ResumeDrawing();

            return(result);
        }
Beispiel #14
0
        //---------------------------------------------------------------------------
        public void Init(CWorkflow workflowRacine)
        {
            if (workflowRacine == null)
            {
                Visible = false;
                return;
            }
            Visible          = true;
            m_stackWorkflows = new Stack <CWorkflow>();
            m_workflowRacine = workflowRacine;
            AfficheWorkflow(m_workflowRacine);

            //TESTDBKEYOK
            CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(workflowRacine.ContexteDonnee);

            m_bCanManage = user != null && (
                user.GetDonneeDroit(CDroitDeBase.c_droitBaseGestionWorkflows) != null ||
                user.DbKey == workflowRacine.KeyManager);
            Refresh();
        }
Beispiel #15
0
        //-------------------------------------------------------------------------
        protected override CResultAErreur MyInitChamps()
        {
            CResultAErreur result = base.MyInitChamps();

            AffecterTitre(I.T("Ticket number|666") + " :" + Ticket.Numero);


            // Si le ticket est clos il ne peut plus être édité
            if (Ticket.DateCloture != null ||
                Ticket.Responsable != CUtilSession.GetUserForSession(Ticket.ContexteDonnee))
            {
                this.ConsultationOnly = true;
            }
            else
            {
                this.ConsultationOnly = false;
            }


            if (Ticket.IsNew())
            {
                Ticket.CreerHistorique(null, I.T("Ticket opening|675"));
            }


            // Barre gauche
            m_barreGauche.Text = I.T("General information|10015");
            CPanelInfosGenerales panelInfos = new CPanelInfosGenerales();

            panelInfos.Dock = DockStyle.Fill;
            panelInfos.InitPanel(Ticket);
            m_barreGauche.Panel.Controls.Add(panelInfos);

            // Barre détail
            m_barreDetail.PostText = I.T("Ticket Number @1 |30260", Ticket.Numero.ToString());



            return(result);
        }
Beispiel #16
0
        public bool CanEdit()
        {
            if (TypePhase == null)
            {
                return(false);
            }
            if (TypePhase.ProfilResponsableTicket == null)
            {
                return(true);
            }

            if (this.Ticket != null)
            {
                CDonneesActeurUtilisateur userEnCours = CUtilSession.GetUserForSession(this.ContexteDonnee);
                if (TypePhase.ProfilResponsableTicket.IsInProfil(userEnCours, this))
                {
                    return(true);
                }
            }

            return(false);
        }
Beispiel #17
0
        public CResultAErreur CreerHistorique(CPhaseTicket phase, string info)
        {
            CResultAErreur result = CResultAErreur.True;

            CHistoriqueTicket histo = new CHistoriqueTicket(this.ContexteDonnee);

            histo.CreateNewInCurrentContexte();
            histo.Date   = DateTime.Now;
            histo.Ticket = this;
            if (phase != null)
            {
                histo.PhaseTicket = phase;
            }
            else
            {
                histo.PhaseTicket = PhaseEnCours;
            }
            histo.ActeurUtilisateur = CUtilSession.GetUserForSession(this.ContexteDonnee);
            histo.Info = info;

            return(result);
        }
Beispiel #18
0
        //-------------------------------------------------------------------------
        protected override CResultAErreur MyInitChamps()
        {
            CResultAErreur result = base.MyInitChamps();

            AffecterTitre(I.T("Ticket number|666") + " :" + Ticket.Numero);

            m_panelEditionTicket.InitPanel(Ticket);

            // Si le ticket est clos il ne peut plus être édité
            if (Ticket.DateCloture != null ||
                Ticket.Responsable != CUtilSession.GetUserForSession(Ticket.ContexteDonnee))
            {
                this.ConsultationOnly = true;
            }
            else
            {
                this.ConsultationOnly = false;
            }

            m_panelEditionTicket.Visible = true;

            return(result);
        }
 private void m_timerCheckEtapesEncours_Tick(object sender, EventArgs e)
 {
     try
     {
         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;
             }
         }
     }
     catch { }
 }
Beispiel #20
0
        //-------------------------------------------------------------------
        public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte)
        {
            CResultAErreur result = base.TraitementAvantSauvegarde(contexte);

            if (!result)
            {
                return(result);
            }

            DataTable table = contexte.Tables[GetNomTable()];

            if (table == null)
            {
                return(result);
            }

            ArrayList lst = new ArrayList(table.Rows);

            CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(contexte);

            if (user != null)
            {
                foreach (DataRow row in lst)
                {
                    if (row.RowState == DataRowState.Modified)
                    {
                        CPostIt pt = new CPostIt(row);
                        if (!pt.IsPublique && pt.Auteur != null &&
                            pt.Auteur.Id != user.Id)
                        {
                            row.RejectChanges();
                        }
                    }
                }
            }
            return(result);
        }
Beispiel #21
0
        //-------------------------------------------------------------
        public bool AddOperationALaFin()
        {
            if (LockEdition)
            {
                return(false);
            }
            //s'il y a des opérations sans type, on n'ajoute pas
            foreach (CItemOperation item in Items)
            {
                if (item.Operation == null || item.Operation.TypeOperation == null)
                {
                    CurrentItemIndex = item.Index;
                    return(false);
                }
            }
            //Regarde si le dernier item est vide
            if (!LockEdition && ElementAOperations != null)
            {
                CItemOperation item = null;

                COperation operation = new COperation(ElementAOperations.ContexteDonnee);
                operation.CreateNewInCurrentContexte();
                operation.ElementAOperationsRealisees = ElementAOperations;
                CItemOperation prec       = null;
                CItemOperation itemParent = null;
                if (Items.Count() > 0)
                {
                    prec = GetVisibleItemBefore(Items.Count()) as CItemOperation;
                    if (prec != null)
                    {
                        if (prec.Operation != null && prec.Operation.TypeOperation != null &&
                            prec.Operation.TypeOperation.TypesOperationsFilles.Count > 0)
                        {
                            operation.OperationParente = prec.Operation;
                            itemParent = prec;
                        }
                        else
                        {
                            operation.OperationParente = prec.Operation.OperationParente;
                            itemParent = prec.ItemParent as CItemOperation;
                        }
                        if (prec.Operation.DateHeureFin != null)
                        {
                            operation.DateDebut = prec.Operation.DateHeureFin;
                        }
                        else
                        {
                            operation.DateDebut = prec.Operation.DateDebut;
                        }

                        //Pour rester conforme au fonctionnement du contrôle
                        //avant sa réécriture
                        //c'est l'utilisateur en cours le bon acteur et non pas le précédent
                        //entre nov 2012 et Sept 2012, la ligne suivante a été active.
                        //operation.Acteur = prec.Operation.Acteur;
                    }
                }
                if (operation.Acteur == null)
                {
                    CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(operation.ContexteDonnee);
                    if (user != null)
                    {
                        operation.Acteur = user.Acteur;
                    }
                }
                if (operation.OperationParente != null)
                {
                    operation.Niveau = operation.OperationParente.Niveau + 1;
                }
                else
                {
                    operation.Niveau = 0;
                }
                item = new CItemOperation(operation, itemParent);
                AddItem(item, true);
                CurrentItemIndex = item.Index;
                if (AfterAddOperation != null)
                {
                    AfterAddOperation(this, null);
                }
                return(true);
            }
            return(false);
        }
Beispiel #22
0
 //-------------------------------------------------------------------
 protected override void MyInitValeurDefaut()
 {
     DateLivraisonEquipement = DateTime.Now;
     Createur = CUtilSession.GetUserForSession(ContexteDonnee);
 }
Beispiel #23
0
        static void Main()
        {
            //Test
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            CFinalCustomerInformations.Init();

            SystemEvents.SessionEnding += SystemEvents_SessionEnding;

            Thread thSplash = new Thread(new ThreadStart(SplashScreen));

            thSplash.Start();
            //new CFormPoissonAvril().ShowDialog();
#if DEBUG
            Thread.Sleep(10000);

            //CRecepteurNotification recepteur = new CRecepteurNotification(-1, typeof(CDonneeNotificationServeurStarted));
            //recepteur.OnReceiveNotification += new NotificationEventHandler(recepteur_OnReceiveNotification);
            //Application.Run();
#endif

            System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;
            CTraducteur.ReadFichier("timos.mes");

            //System.Threading.Thread.CurrentThread.ApartmentState = System.Threading.ApartmentState.STA;

            CServicePopupProgressionTimos serviceIndicateur = new CServicePopupProgressionTimos();
            IIndicateurProgression        indicateur        = null;/* = serviceIndicateur.GetNewIndicateurAndPopup();
                                                                    * indicateur.SetInfo("Démarrage");*/
#if DEBUG
#else
            try
            {
#endif

            AppDomain.CurrentDomain.Load("futurocom.win32.sig");
            AppDomain.CurrentDomain.Load("futurocom.win32.chart");
            AppDomain.CurrentDomain.Load("data.hotel.easyquery");
            AppDomain.CurrentDomain.Load("data.hotel.easyquery.win32");

            CTimosAppRegistre timosRegistre = new CTimosAppRegistre();
            CResultAErreur result           = timos.client.CInitialiseurClientTimos.InitClientTimos(timosRegistre, true, indicateur);

            /*GC.Collect();
             * GC.WaitForPendingFinalizers();
             * long nMemo = GC.GetTotalMemory(true);
             * DateTime dtChrono = DateTime.Now;
             * //for (int n = 0; n < 10000; n++)
             * {
             *  using (CContexteDonnee ctx = new CContexteDonnee(0, true, false))
             *  {
             *      for (int n = 0; n < 10000; n++)
             *      {
             *          using (CContexteDonnee ctx2 = ctx.GetContexteEdition())
             *          {
             *              CTypeAlarme tp = new CTypeAlarme(ctx2);
             *              tp.ReadIfExists(129);
             *          }
             *      }
             *  }
             * }
             * GC.Collect();
             * GC.WaitForPendingFinalizers();
             * long nMemo2 = GC.GetTotalMemory(true);
             * System.Threading.Thread.Sleep(10000);
             * TimeSpan sp = DateTime.Now - dtChrono;
             * Console.WriteLine("TEST : " + sp.TotalMilliseconds);*/


            //serviceIndicateur.EndIndicateur(indicateur);
            if (!result)
            {
                thSplash.Abort();
                result.EmpileErreur(I.T("Error while opening application|1219"));
                CFormAlerte.Afficher(result.Erreur, EFormAlerteBoutons.Ok, EFormAlerteType.Exclamation);
            }
            else
            {
                CSc2iWin32DataClient.Init(CFournisseurContexteDonnee.GetInstance());
                CReferenceObjetDonnee.SetFournisseurContexteDonnee(CFournisseurContexteDonnee.GetInstance());

                //Effet Fondu
                CEffetFonduPourFormManager.EffetActif = timosRegistre.OptionsGraphiques_FonduActif;
                if (AuthentifierUtilisateur(thSplash))
                {
                    string strVersionServeur = CTimosApp.SessionClient.SessionSurServeur.GetVersionServeur();
                    string strVersionClient  = Assembly.GetExecutingAssembly().GetName().Version.ToString();
                    if (strVersionClient != strVersionServeur)
                    {
                        result.EmpileErreur(I.T("Server (@2) and client (@1) version doesn't match. Please, update your Timos client version|20144",
                                                strVersionClient, strVersionServeur));
                        CFormAlerte.Afficher(result.Erreur);
                        CTimosApp.SessionClient.CloseSession();
                        return;
                    }
                    //Si le profil affecté n'est pas le même que le profil demandé
                    //pour l'utilisateur, affiche une boite de message indiquant
                    //la différence de profil
                    CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(CSc2iWin32DataClient.ContexteCourant);
                    if (user != null && user.IdProfilLicence.Length != 0)
                    {
                        CInfoLicenceUserProfil profil = (CInfoLicenceUserProfil)CTimosApp.SessionClient.GetPropriete(CInfoLicenceUserProfil.c_nomIdentification);
                        if (profil != null && profil.Id != user.IdProfilLicence)
                        {
                            CFormAlerte.Afficher(I.T("You are connected as @1|20023", profil.Nom), EFormAlerteType.Info);
                        }
                    }
                    bool bRestart = true;
                    foreach (Assembly ass in CGestionnaireAssemblies.GetAssemblies())
                    {
                        CGestionnaireExtendeurFormEditionStandard.RegisterExtendersInAssembly(ass);
                    }

                    C2iRegistre.InitRegistreApplication(new CTimosAppRegistre());
#if DEBUG
                    //ImporterChamps();

                    CRelationBesoin_Satisfaction.InitCachePourUnClientJamaisCotéServeur();

                    string str = "";
                    foreach (RelationTypeIdAttribute r in CContexteDonnee.RelationsTypeIds)
                    {
                        str += r.TableFille;
                        str += "\t";
                        str += r.ChampType;
                        str += Environment.NewLine;
                    }

                    Application.Run(new CFormMain());
#else
                    while (bRestart)
                    {
                        bRestart = false;

                        try
                        {
                            Application.Run(new CFormMain());
                        }
                        catch (Exception e)
                        {
                            result = CResultAErreur.True;
                            result.EmpileErreur(new CErreurException(e));
                            CFormAfficheErreur.Show(result.Erreur);
                            bRestart = true;
                        }
                    }
#endif
                }
            }
#if DEBUG
#else
        }

        catch (Exception ex)
        {
            StringBuilder bl = new StringBuilder();
            ReflectionTypeLoadException lex = ex as System.Reflection.ReflectionTypeLoadException;
            if (lex != null)
            {
                foreach (Exception ee in lex.LoaderExceptions)
                {
                    bl.Append(ee.Message.ToString());
                    bl.Append("\r\n");
                }
            }
            else
            {
                bl.Append(ex.Message.ToString( ));
            }
            CFormAlerte.Afficher(bl.ToString());
        }
#endif
        }
Beispiel #24
0
 //-------------------------------------------------------------------
 protected override void MyInitValeurDefaut()
 {
     DateCommande = DateTime.Now;
     Createur     = CUtilSession.GetUserForSession(ContexteDonnee);
 }
Beispiel #25
0
        private void m_btnActeur_Click(object sender, EventArgs e)
        {
            if (LockEdition || Operation == null)
            {
                return;
            }


            if (Operation.TypeOperation != null && Operation.TypeOperation.VerrouillerAuteur)
            {
                return;
            }

            ContextMenuStrip menu = new ContextMenuStrip();

            menu.ImageList = m_pictosActeur;

            if (ElementAOperations != null)
            {
                // Item par défaut : Acteur utilisateur en cours
                CActeur acteurEnCours = CUtilSession.GetUserForSession(Operation.ContexteDonnee).Acteur;

                ToolStripMenuItem itemParDefaut = new ToolStripMenuItem(acteurEnCours.IdentiteComplete);
                itemParDefaut.ImageIndex = 0;
                itemParDefaut.Tag        = acteurEnCours;
                itemParDefaut.Click     += new EventHandler(itemActeur_Click);
                menu.Items.Add(itemParDefaut);


                // ajoute les autres acteurs possibles
                CFractionIntervention fraction = ElementAOperations as CFractionIntervention;
                if (fraction != null)
                {
                    // On est sur une Intervention
                    // Les acteurs possibles sont pris parmis les intervenants définit comme ressource
                    CIntervention intervention = fraction.Intervention;

                    ArrayList listerelationsIntervenants = intervention.RelationsIntervenants.ToArrayList();
                    if (listerelationsIntervenants.Count > 0)
                    {
                        menu.Items.Add(new ToolStripSeparator());
                    }

                    foreach (CIntervention_Intervenant rel in listerelationsIntervenants)
                    {
                        CActeur           intervenant = rel.Intervenant;
                        ToolStripMenuItem item        = new ToolStripMenuItem(intervenant.IdentiteComplete);
                        item.Tag    = intervenant;
                        item.Click += new EventHandler(itemActeur_Click);
                        menu.Items.Add(item);
                    }
                }
                else
                {
                    // On est sur une Phase de Ticket
                }

                menu.Items.Add(new ToolStripSeparator());

                C2iTextBoxSelectionneForMenu selectActeurItem = new C2iTextBoxSelectionneForMenu();
                selectActeurItem.TextBoxSelection.InitForSelect(typeof(CActeur),
                                                                "IdentiteComplete",
                                                                false);
                selectActeurItem.AutoClose       = true;
                selectActeurItem.OnSelectObject += new ObjetDonneeEventHandler(selectActeurItem_OnSelectObject);
                menu.Items.Add(selectActeurItem);
            }

            menu.Show((Control)sender, new Point(0, m_btnActeur.Height));
        }
Beispiel #26
0
        //---------------------------- TAB CONTROL --------------------------
        private CResultAErreur m_gestionnaireTabControl_OnInitPage(object page)
        {
            CResultAErreur result = CResultAErreur.True;

            using (CWaitCursor waiter = new CWaitCursor())
            {
                if (page == tb_checklist)
                {
                    m_panelCheckList.InitChamps(m_intervention);
                }
                else if (page == tb_fiche)
                {
                    m_panelChampsCustom.ElementEdite = Intervention;
                }
                else if (page == tb_operations)
                {
                    int nb  = Intervention.RelationsListesOperations.CountNoLoad;
                    int nb2 = Intervention.RelationsListesOperations.Count;
                    m_gestionnaireEditionListeOp.ObjetEdite = Intervention.RelationsListesOperations;
                    InitSelectListeOperations();
                    InitOperationsPrev();

                    m_panelInfosListeOp.Visible = m_gestionnaireEditionListeOp.ObjetEnCours is CIntervention_ListeOperations;
                }
                else if (page == tb_planification)
                {
                    m_dtDebutPreplanifier.Value   = Intervention.DateDebutPrePlanifiee;
                    m_dtFinPreplanification.Value = Intervention.DateFinPrePlanifiee;
                    UpdateFractions();

                    CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(Intervention.ContexteDonnee);
                    if (Intervention.IsNew())
                    {
                        if (Intervention.UserPreplanifieur == null)
                        {
                            Intervention.UserPreplanifieur = user;
                        }
                        if (Intervention.UserPlanifieur == null)
                        {
                            Intervention.UserPlanifieur = user;
                        }
                    }

                    InitListesPlannifieurs(false);

                    if (Intervention.UserPreplanifieur != null)
                    {
                        m_txtSelectPreplanificateur.ElementSelectionne = Intervention.UserPreplanifieur.Acteur;
                    }
                    if (Intervention.UserPlanifieur != null)
                    {
                        m_txtSelectPlanificateur.ElementSelectionne = Intervention.UserPlanifieur.Acteur;
                    }

                    UpdateVisuForUser();

                    m_wndDureePrevue.UseValueFormat = false;
                    m_wndDureePrevue.DefaultFormat  = CGestionnaireUnites.GetUnite(CClasseUniteTemps.c_idH).LibelleCourt;
                    if (Intervention.DureePrevisionnelle != null)
                    {
                        m_wndDureePrevue.UnitValue = new CValeurUnite(Intervention.DureePrevisionnelle, CClasseUniteTemps.c_idH);
                    }

                    m_txtNbOperateursPrévus.IntValue = Intervention.NbOperateurSPrevus;

                    m_txtTauxHorairePrévu.InitAvecFiltreDeBase <CTypeConsommable>(
                        "Libelle",
                        new CFiltreData(CTypeConsommable.c_champClasseUniteString + "=@1",
                                        CClasseUniteTemps.c_idClasse),
                        false);
                    m_txtTauxHorairePrévu.ElementSelectionne = Intervention.TauxHorairePrevu;

                    m_panelFraction.Visible = m_editeurFraction.ObjetEnCours is CFractionIntervention;
                }
                else if (page == tb_realisation)
                {
                    InitCRs();
                    m_panelInfoGel.Init(Intervention);
                }
                else if (page == tb_ressources)
                {
                    InitIntervenants();
                    InitRessources();
                }
            }
            return(result);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void m_btnActions_Click(object sender, System.EventArgs e)
        {
            CListeObjetsDonnees listeCheckes = m_panelListe.GetElementsCheckes();

            if (listeCheckes.Count == 0)
            {
                CFormAlerte.Afficher(I.T("No element selected for action execution|1011"), EFormAlerteType.Exclamation);
                return;
            }

            CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(m_panelListe.ListeObjets.ContexteDonnee);
            bool bIsAdmin = user != null && user.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministrationSysteme) != null;

            Hashtable listeActions = new Hashtable();

            using (CWaitCursor curseur = new CWaitCursor())
            {
                bool bFirst = true;
                //Cherche les actions applicables à tous les éléments
                foreach (CObjetDonneeAIdNumerique objet in listeCheckes)
                {
                    IDeclencheurAction[] declencheurs = CRecuperateurDeclencheursActions.GetActionsManuelles(objet, false);
                    Hashtable            newTbl       = new Hashtable();
                    foreach (IDeclencheurAction declencheur in declencheurs)
                    {
                        if (bFirst || listeActions[declencheur] != null)
                        {
                            newTbl[declencheur] = true;
                        }
                    }
                    bFirst = false;
                    if (newTbl.Count == 0 && !bIsAdmin)
                    {
                        CFormAlerte.Afficher(I.T("There is no action to execute on the selected elements|1012"), EFormAlerteType.Exclamation);
                        return;
                    }
                    listeActions = newTbl;
                }
            }
            m_menuActions.MenuItems.Clear();
            foreach (IDeclencheurAction declencheur in listeActions.Keys)
            {
                string strMenu = "";
                if (declencheur is IDeclencheurActionManuelle)
                {
                    strMenu = ((IDeclencheurActionManuelle)declencheur).MenuManuel;
                }
                string[] strMenus = strMenu.Split('/');
                Menu.MenuItemCollection listeSousMenus = m_menuActions.MenuItems;
                if (strMenus.Length > 0)
                {
                    foreach (string strSousMenu in strMenus)
                    {
                        if (strSousMenu.Trim().Length > 0)
                        {
                            MenuItem sousMenu = null;
                            foreach (MenuItem item in listeSousMenus)
                            {
                                if (item.Text == strSousMenu)
                                {
                                    sousMenu = item;
                                    break;
                                }
                            }
                            if (sousMenu == null)
                            {
                                sousMenu = new MenuItem(strSousMenu);
                                listeSousMenus.Add(sousMenu);
                            }
                            listeSousMenus = sousMenu.MenuItems;
                        }
                    }
                }
                CMenuItemDeclencheur itemAction = new CMenuItemDeclencheur(declencheur);
                itemAction.Click += new EventHandler(MenuDeclencheurClick);
                listeSousMenus.Add(itemAction);
            }

            if (bIsAdmin)
            {
                m_menuActions.MenuItems.Add(new MenuItem());
                MenuItem itemApplyFormula = new MenuItem(I.T("Apply formula|20834"));
                m_menuActions.MenuItems.Add(itemApplyFormula);
                itemApplyFormula.Click += new EventHandler(itemApplyFormula_Click);
            }
            m_menuActions.Show(m_btnActions, new Point(0, m_btnActions.Height));
        }
Beispiel #28
0
        private void FillListeConnectes()
        {
            IGestionnaireSessions gestionnaire = (IGestionnaireSessions)C2iFactory.GetNewObject(typeof(IGestionnaireSessions));

            int[]  listeIdSessions    = gestionnaire.GetListeIdSessionsConnectees();
            string strNomGestionnaire = gestionnaire.GetType().ToString();

            m_listView.Items.Clear();
            foreach (int nId in listeIdSessions)
            {
                ListViewItem item = new ListViewItem();
                item.Tag = nId;
                while (item.SubItems.Count < m_listView.Columns.Count)
                {
                    item.SubItems.Add("");
                }
                item.SubItems[colIdSession.Index].Text = nId.ToString();
                IInfoSession session = gestionnaire.GetSessionClient(nId);
                try
                {
                    session.GetInfoUtilisateur();
                }
                catch
                {
                    session        = gestionnaire.GetSessionClientSurServeur(nId);
                    item.BackColor = Color.Red;
                    session        = gestionnaire.GetSessionClientSurServeur(nId);
                }
                if (session == null)
                {
                    item.BackColor = Color.Red;
                    session        = gestionnaire.GetSessionClientSurServeur(nId);
                    item.SubItems[colNom.Index].Text = "#ERREUR ACCES";
                }

                try
                {
                    item.SubItems[colNom.Index].Text   = session.GetInfoUtilisateur().NomUtilisateur;
                    item.SubItems[colAppli.Index].Text = session.DescriptionApplicationCliente;
                    item.SubItems[colType.Index].Text  = session.TypeApplicationCliente.ToString();
                    DateTime dt        = session.DateHeureConnexion;
                    TimeSpan span      = DateTime.Now - dt;
                    string   strChaine = "";
                    if (span.TotalDays > 1)
                    {
                        strChaine = ((int)span.TotalDays).ToString() + "j";
                    }
                    if (span.TotalHours > 0)
                    {
                        strChaine += ((int)(span.TotalHours % 24)).ToString() + "h";
                    }
                    strChaine += ((int)(span.TotalMinutes % 60)).ToString() + "m";
                    item.SubItems[colHeure.Index].Text = strChaine;


                    string strKeyUtilisateur = "";
                    if (session.GetInfoUtilisateur().KeyUtilisateur != null)
                    {
                        strKeyUtilisateur = session.GetInfoUtilisateur().KeyUtilisateur.StringValue;
                        item.SubItems[colIdUser.Index].Text = strKeyUtilisateur;

                        CContexteDonnee           ctx  = new CContexteDonnee(session.IdSession, true, false);
                        CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(ctx);
                        if (user != null)
                        {
                            CListeObjetsDonnees lstEtapesPourActeur = user.Acteur.GetEtapeWorkflowsEnCours();
                            int nbTodo = lstEtapesPourActeur.Count;
                            item.SubItems[colNbToDo.Index].Text = nbTodo.ToString();
                        }
                    }
                }
                catch
                {
                    if (nId == 0)
                    {
                        item.SubItems[colNom.Index].Text = "SERVEUR";
                    }
                    else
                    {
                        item.BackColor = Color.Red;
                        item.SubItems[colNom.Index].Text = "#ERREUR ACCES#";
                    }
                }
                if (nId == CSessionClient.GetSessionUnique().IdSession)
                {
                    item.BackColor = Color.LightGreen;
                }
                m_listView.Items.Add(item);
            }
        }
Beispiel #29
0
        //-------------------------------------------------------------------------
        private void CFormDeplacerEquipement_Load(object sender, EventArgs e)
        {
            m_initialise = false;

            sc2i.win32.common.CWin32Traducteur.Translate(this);
            m_selectSite.Init <CSite>(
                "Libelle",
                false);
            m_selectStock.Init <CStock>(
                "Libelle",
                false);
            m_selectActeur.Init <CActeur>(
                "IdentiteComplete",
                false);

            if (m_equipement.EmplacementSite != null)
            {
                m_radioSite.Checked = true;
                m_selectSite.Focus();
            }
            else if (m_equipement.EmplacementStock != null)
            {
                m_radioStock.Checked = true;
                m_selectStock.Focus();
            }
            else
            {
                m_radioActeur.Checked = true;
                m_selectActeur.Focus();
            }

            m_selectSite.ElementSelectionne   = m_equipement.EmplacementSite;
            m_selectStock.ElementSelectionne  = m_equipement.EmplacementStock;
            m_selectActeur.ElementSelectionne = m_equipement.EmplacementActeur;
            if (m_equipement.EmplacementSite != null)
            {
                m_cmbEquipement.ElementSelectionne = m_equipement.EquipementContenant;
            }
            else
            {
                m_cmbEquipement.ElementSelectionne = null;
            }
            if (m_equipement.EmplacementStock != null)
            {
                m_cmbEquipementStock.ElementSelectionne = m_equipement.EquipementContenant;
            }
            else
            {
                m_cmbEquipementStock.ElementSelectionne = null;
            }


            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, false);
            CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(m_equipement.ContexteDonnee);

            if (user != null)
            {
                m_selectUser.ElementSelectionne = user.Acteur;
            }

            InitComboEquipementParent(m_cmbEquipement);
            InitComboEquipementParent(m_cmbEquipementStock);

            m_initialise = true;

            ActualiserCoor();

            //S'il existe un mouvement en cours d'édition, remet l'info et la coordonnée
            foreach (CMouvementEquipement mvt in m_equipement.Mouvements)
            {
                if (mvt.IsNew() && mvt.MouvementSuivant == null)
                {
                    m_txtInfo.Text      = mvt.Info;
                    m_dtMouvement.Value = mvt.DateMouvement;
                }
            }
        }