Exemple #1
0
        /// <summary>
        /// Récupère le répertoire ARCHIVE dans la table SOCIETE
        /// </summary>
        /// <param name="codeLogiciel"></param>
        /// <returns></returns>
        public static String GetRepArchive(int codeSociete)
        {
            OracleTrans            o   = OracleTrans.getInstance;
            ExtendedReturnedScalar res = o.ExecuterSelectScalar(
                "SELECT BD_NET FROM SOCIETE WHERE CD_SOCIETE = :1", -1, codeSociete);

            if (res.Result == null || res.Result == null || res.Result == DBNull.Value)
            {
                return("");
            }
            else
            {
                return((String)res.Result);
            }
        }
Exemple #2
0
        /// <summary>
        /// Retourne l'équivalence de chemin réseau (UNC par exemple) associée à une lettre de lecteur réseau
        /// </summary>
        /// <param name="networkDrive">Lettre du lecteur</param>
        public static String NetworkDriveLetterToUNCPath(char networkDrive)
        {
            OracleTrans            o   = OracleTrans.getInstance;
            ExtendedReturnedScalar res = o.ExecuterSelectScalar(
                "SELECT path FROM ext_net_drive WHERE UPPER(drive) = :1 AND NVL(inactif, 0) = 0 ", -1, networkDrive.ToString().ToUpper());

            if (o.ErrCode > 0 || res.Result == null || res.Result == DBNull.Value)
            {
                return(null);
            }
            else
            {
                return((String)res.Result);
            }
        }
Exemple #3
0
        /// <summary>
        /// Récupère la version associée au logiciel
        /// </summary>
        /// <param name="codeLogiciel"></param>
        /// <returns></returns>
        public static String GetVersion(String nomLogiciel)
        {
            OracleTrans            o   = OracleTrans.getInstance;
            ExtendedReturnedScalar res = o.ExecuterSelectScalar(
                "SELECT n_version FROM VERSION WHERE CD_VERSION = :1", -1, nomLogiciel);

            if (res.Result == null || res.Result == null || res.Result == DBNull.Value)
            {
                return("");
            }
            else
            {
                return((String)res.Result);
            }
        }
Exemple #4
0
        /// <summary>
        /// Nombre de licence pour un logiciel
        /// </summary>
        /// <param name="codeLogiciel"></param>
        private static int NbLicCleLogiciel(int codeLogiciel, int transac)
        {
            OracleTrans            o   = OracleTrans.getInstance;
            ExtendedReturnedScalar res = o.ExecuterSelectScalar(
                "SELECT CELL.VALEUR FROM CELL, VERSION WHERE CELL.CD_CELL = VERSION.CD_CELL AND VERSION.CD_LOGICIEL = :1", transac, codeLogiciel);

            if (res.Result != null && res.Result != DBNull.Value)
            {
                String valeur = Crypte((String)res.Result, false);

                String codeCellule = valeur.Substring(6, 2);
                int    nbLicence   = int.Parse(valeur.Substring(16, 5));
                return(nbLicence);
            }
            else
            {
                return(0);
            }
        }
Exemple #5
0
        private static Boolean TestCle(int cdLogiciel, String sessionID, int dureeSecondes, int transac)
        {
            OracleTrans o = OracleTrans.getInstance;

            ExtendedReturnedScalar resultOpeCon = o.ExecuterSelectScalar(
                " SELECT COUNT(*) as NB_OPE_CON " +
                " FROM LOGICIEL_SESSIONS " +
                " WHERE CD_LOGICIEL = :1 " +
                " AND (SYSDATE - DATE_MAJ) < (:2 / 60 / 60 / 24) " +
                (sessionID != null && sessionID != "" ? " AND TRIM(SESSION_ID) <> '" + sessionID.Trim() + "'" : ""),
                transac, cdLogiciel, _DUREE_INACTIVITE);


            if (resultOpeCon.Result == null)
            {
                throw new Exception("Impossible de récupérer le nombre d'utilisateur connectés. " + (resultOpeCon.OracleException != null ? resultOpeCon.OracleException.Message : ""));
            }
            else
            {
                // - Comparaison avec la clé
                // - nombre de licences sur la clé
                // (si cd_logiciel = 10 et cd_ext_log_fct = 7, alors eCynaps pointage, test avec cd_logiciel = 5 (CAB) parceque pas de clé spécifique à eCynaps pointage pour le moment)
                int nbLicAuto = NbLicCleLogiciel(cdLogiciel, transac);
                // - nombre de licences majoré
                int nbLicPlus    = Convert.ToInt32(Math.Round(nbLicAuto * 0.10));
                int nbLicAutoMaj = nbLicAuto + Convert.ToInt32(Math.Round(nbLicAuto * 0.10));
                // - nombre de connectés
                int nbOpeCon = Convert.ToInt32(resultOpeCon.Result);
                // - comparaison nombre de connecté + tentative courante / nombre de licences sur clé + 10%
                ////////////////
                // TEST
                //nbLicAutoMaj = 2;
                ////////////////
                /// TODO: Ajouter contrôle sur licences clé
                // ERREUR LICENCE
                //if (nbOpeCon >= nbLicAutoMaj)
                //    throw new Exception(String.Format("Nombre de licences autorisé atteint ({0}/({1} + {2})). ", nbOpeCon, nbLicAuto, nbLicPlus));
                //else
                //    return true;
                return(true);
            }
        }
Exemple #6
0
        /// <summary>
        /// Teste si un module est activé ou non sur la clé (ne fonctionne qu'avec cd_logiciel = 40)
        /// </summary>
        /// <param name="cdLogiciel">code logiciel (helios / helios II = 40)</param>
        /// <param name="cdModule">code module</param>
        /// <returns>
        ///     "0" ou "1" si on cherche une activation de module
        ///     "" si erreur
        /// </returns>
        public static string TestCleModule(int cdLogiciel, int cdModule)
        {
            int cellAdd;
            int module = cdModule;


            switch (cdLogiciel)
            {
            case 51:        // HELIOS
                // Pour Hélios on a une cellule par module
                return("");

            case 40:        // HELIOS II
                if (cdModule >= 1 && cdModule <= 16)
                {
                    cellAdd = cdLogiciel + 7 + 1;
                }
                else if (cdModule >= 17 && cdModule <= 32)
                {
                    cellAdd = cdLogiciel + 7 + 2;
                    module  = cdModule - 16;
                }
                else if (cdModule >= 33 && cdModule <= 48)
                {
                    cellAdd = cdLogiciel + 7 + 3;
                    module  = cdModule - 32;
                }
                else if (cdModule >= 49 && cdModule <= 64)
                {
                    cellAdd = cdLogiciel + 7 + 4;
                    module  = cdModule - 48;
                }
                else if (cdModule >= 65 && cdModule <= 80)
                {
                    cellAdd = cdLogiciel + 7 + 5;
                    module  = cdModule - 64;
                }
                else if (cdModule >= 81 && cdModule <= 96)
                {
                    cellAdd = cdLogiciel + 7 + 6;
                    module  = cdModule - 80;
                }
                else if (cdModule >= 97 && cdModule <= 112)
                {
                    cellAdd = cdLogiciel + 7 + 7;
                    module  = cdModule - 96;
                }
                else
                {
                    cellAdd = 0;
                }
                break;

            default:
                return("");
            }

            if (module > 0)
            {
                //int cellCode = int32.Convert((cellAdd - 7).ToString().PadLeft(2, ' '));
                int cellCode = cellAdd - 7;

                String check = "";
                ExtendedReturnedScalar returnCheck = OracleTrans.getInstance.ExecuterSelectScalar("SELECT VALEUR FROM CELL WHERE CD_CELL = :1", -1, cellCode);
                if (returnCheck.Result != null && returnCheck.Result != DBNull.Value)
                {
                    check = Convert.ToString(returnCheck.Result);
                }

                if (check != "")
                {
                    check = Crypte(check, false);

                    String cdCell, valeur;
                    cdCell = check.Substring(6, 2);
                    valeur = check.Substring(16, 5);

                    try
                    {
                        if (Convert.ToInt32(cdCell) == cellCode)
                        {
                            int retour = Convert.ToInt32(valeur);
                            int reste  = 0;
                            for (int i = 1; i <= module; i++)
                            {
                                reste  = retour % 2;
                                retour = retour / 2;
                            }

                            return(reste.ToString());
                        }
                        else
                        {
                            return("");
                        }
                    }
                    catch (Exception)
                    {
                        return("");
                    }
                }
                else
                {
                    return("");
                }
            }
            else
            {
                return("");
            }
        }
Exemple #7
0
        /// <summary>
        /// Enregistrement d'une nouvelle session d'utilisation à un logiciel et vérification de la clé associée
        /// </summary>
        public static Boolean CreerNouvelleSessionCle(int cdLogiciel, string sessionId, string infos)
        {
            lock (LOCK)
            {
                if (DateTime.Now.Subtract(_dateDernierePurge).TotalSeconds > _FREQUENCE_PURGE)
                {
                    try
                    {
                        _dateDernierePurge = DateTime.Now;

                        // Purge des sessions existantes qui dépassent le délai d'inactivité
                        PurgerSessionsCle(cdLogiciel, _DUREE_INACTIVITE);
                    }
                    catch (Exception) { }
                }
            }

            OracleTrans o       = OracleTrans.getInstance;
            int         transac = o.DebutTransaction();
            Boolean     res     = true;

            try
            {
                // Test si session existe déjà
                Boolean existsSession = false;
                if (sessionId != "")
                {
                    ExtendedReturnedScalar resultSessionCourante = o.ExecuterSelectScalar(
                        " SELECT COUNT(*)" +
                        " FROM LOGICIEL_SESSIONS " +
                        " WHERE CD_LOGICIEL = :1 " +
                        " AND SESSION_ID = :2",
                        transac, cdLogiciel, sessionId);

                    if (Convert.ToInt32(resultSessionCourante.Result) > 0)
                    {
                        existsSession = true;
                        Boolean sessionAMAJ = false;

                        // SI DATE_MAJ session courante > DUREE_INACTIVITE => SESSION NON ACTIVE => test clé
                        ExtendedReturnedScalar resultSessionCouranteActive = o.ExecuterSelectScalar(
                            " SELECT CASE WHEN (SYSDATE - DATE_MAJ) < (:2 / 60 / 60 / 24) THEN 1 ELSE 0 END as SESSION_ACTIVE " +
                            " FROM LOGICIEL_SESSIONS " +
                            " WHERE CD_LOGICIEL = :1 " +
                            " AND SESSION_ID = :3",
                            transac, cdLogiciel, _DUREE_INACTIVITE, sessionId);

                        // Si session non active -> test clé
                        if (Convert.ToInt32(resultSessionCouranteActive.Result) == 0)
                        {
                            sessionAMAJ = TestCle(cdLogiciel, sessionId, _DUREE_INACTIVITE, transac);
                        }
                        else
                        {
                            // Sinon mise à jour activité session
                            sessionAMAJ = true;
                        }

                        if (sessionAMAJ)
                        {
                            //MajActiviteSessionCle(cdLogiciel, sessionId, transac);
                            ExtendedReturnedUpdate resultLogOpe = o.ExecuterUpdate(
                                " UPDATE LOGICIEL_SESSIONS SET " +
                                "   DATE_MAJ = SYSDATE, " +
                                "   DUREE_ACTIVITE = Round((DATE_MAJ - DATE_CREAT) * 24 * 60, 2) " +         // EN MINUTES
                                " WHERE CD_LOGICIEL = :1 " +
                                "   AND SESSION_ID = :2 ",
                                transac,
                                cdLogiciel, sessionId);

                            res = res && resultLogOpe.ErrCode == 0;

                            if (!res)
                            {
                                throw new Exception("Impossible de mettre à jour l'activité de la session d'utilisation. " + (resultLogOpe.OracleException != null ? resultLogOpe.OracleException.Message : ""));
                            }
                        }
                    }
                    else
                    {
                        existsSession = false;
                    }

                    if (!existsSession)
                    {
                        res = res && TestCle(cdLogiciel, null, _DUREE_INACTIVITE, transac);

                        if (res)
                        {
                            // - OK, nouvelle session
                            ExtendedReturnedUpdate resultLogOpe = o.ExecuterUpdate(
                                " INSERT INTO LOGICIEL_SESSIONS " +
                                "        (CD_LOGICIEL_SESSIONS, CD_LOGICIEL, SESSION_ID, INFOS, DATE_CREAT, DATE_MAJ, DUREE_ACTIVITE) " +
                                " VALUES (SEQ_LOGICIEL_SESSIONS.NEXTVAL, :1, :2, :3, SYSDATE, SYSDATE, 0)",
                                transac,
                                cdLogiciel, sessionId, infos);

                            res = res && resultLogOpe.ErrCode == 0;

                            if (!res)
                            {
                                throw new Exception("Impossible d'enregistrer la session d'utilisation. " + (resultLogOpe.OracleException != null ? resultLogOpe.OracleException.Message : ""));
                            }
                        }
                    }

                    if (res)
                    {
                        if (_COMMIT)
                        {
                            o.Commit(transac);
                        }
                        else
                        {
                            o.RollBack(transac);
                        }

                        return(res);
                    }
                    else
                    {
                        o.RollBack(transac);
                        return(false);
                    }
                }
                else
                {
                    o.RollBack(transac);
                    return(false);
                }
            }
            catch (Exception ex)
            {
                o.RollBack(transac);
                throw ex;
            }
        }