示例#1
0
        public async Task <HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            string date;

            req.GetQueryParameterDictionary().TryGetValue("date", out date);


            string retour = "";

            try
            {
                retour = new CompteDAO(sqlManager).GetAllAccountPositionAtDate(date);
            }
            catch (Exception e)
            {
                return(new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError)
                {
                    Content = new StringContent(e.Message)
                });
            }


            return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
            {
                Content = new StringContent(retour, Encoding.UTF8, "application/json")
            });
        }
        public async Task <HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
            ILogger log)
        {
            string date_debut;
            string date_fin;
            string mode;
            string compte;

            req.GetQueryParameterDictionary().TryGetValue("date_debut", out date_debut);
            req.GetQueryParameterDictionary().TryGetValue("date_fin", out date_fin);
            req.GetQueryParameterDictionary().TryGetValue("mode", out mode);
            req.GetQueryParameterDictionary().TryGetValue("compte", out compte);

            string retour = "";

            try
            {
                retour = new CompteDAO(sqlManager).GetTotalPositionAtInterval(date_debut, date_fin, mode, compte);
            }
            catch (Exception e)
            {
                return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
                {
                    Content = new StringContent(e.Message, Encoding.UTF8, "application/json")
                });
            }
            return(new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(retour)
            });
        }
示例#3
0
        public static void IsTokenValid(String Token)
        {
            if (string.IsNullOrEmpty(Token) | (Token == "undefined"))
            {
                throw new TokenInvalidException("Le token est invalide");
            }

            string key = Encoding.UTF8.GetString(Convert.FromBase64String(Token));

            string[] parts = key.Split(new char[] { ':' });
            if (parts.Length > 3 | parts.Length < 3)
            {
                throw new TokenInvalidException("Le token est invalide");
            }

            string   hash      = parts[0];
            string   username  = parts[1];
            long     ticks     = long.Parse(parts[2]);
            DateTime timeStamp = new DateTime(ticks);
            // Ensure the timestamp is valid.
            bool expired = Math.Abs((DateTime.UtcNow - timeStamp).TotalMinutes) > _expirationMinutes;

            if (expired)
            {
                throw new TokenExpireException("Le token est expiré");
            }

            CompteDAO comptedao = new CompteDAO();

            string[] Keybdd = Encoding.UTF8.GetString(Convert.FromBase64String(comptedao.GetToken(username))).Split(new char[] { ':' });
            if (Keybdd[0] != hash)
            {
                throw new TokenInvalidException("Le token est invalide");
            }
        }
示例#4
0
        internal double GetTotalPosition(CompteDAO compteDAO)
        {
            string retour         = compteDAO.GetAllAccountPositionAtDate("31/12/2019");
            var    resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionDate> >(retour);
            double total          = 0;

            foreach (var item in resultPosition)
            {
                total += double.Parse((item.position ?? "0").Replace('.', ','));
            }
            return(total);
        }
        // -- Recharger les données dans le auto complete -- //
        public override object Recharger_EasyAutocomplete(string id_page, string id_vue)
        {
            List <object> donnee = new List <object>();

            try
            {
                #region ConfigurationBudget-ParametreBudgetRevenu
                if (id_page == GB_Enum_Menu.ConfigurationBudget_ParametreBudgetRevenu)
                {
                    // -- Si la vue est pour le compte -- //
                    #region comptes
                    if (id_vue == "compte")
                    {
                        // -- Mise à jour de la liste en session -- //
                        this.con.donnee.comptes = CompteDAO.Lister_Cle();
                    }
                    #endregion
                }
                #endregion

                #region ConfigurationBudget-ParametreBudgetFrais
                if (id_page == GB_Enum_Menu.ConfigurationBudget_ParametreBudgetFrais)
                {
                    // -- Si la vue est pour le compte -- //
                    #region comptes
                    if (id_vue == "compte")
                    {
                        // -- Mise à jour de la liste en session -- //
                        this.con.donnee.comptes = CompteDAO.Lister_Cle();
                    }
                    #endregion
                }
                #endregion
            }
            #region catch & finally
            catch (Exception ex)
            {
                // -- Vérifier la nature de l'exception -- //
                if (!GBException.Est_GBexception(ex))
                {
                    // -- Log -- //
                    GBClass.Log.Error(ex);
                }
            }
            #endregion

            // -- Retoure le résultat en objet JSON -- //
            return(GBConvert.To_JSONString(donnee));
        }
示例#6
0
        /// <summary>
        /// transcription du Token en objet Compte avec cryptage du mot de passe
        /// </summary>
        /// <param name="Token"></param>
        /// <returns></returns>
        public static Compte GetCompteSecurite(string Token)
        {
            string key = Encoding.UTF8.GetString(Convert.FromBase64String(Token));

            using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(key)))
            {
                DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(Compte));
                Compte         compte      = (Compte)deserializer.ReadObject(ms);
                UtilisateurWeb utilisateur = new UtilisateurWeb()
                {
                    Identifiant = compte.Identifiant, Token = compte.Token
                };


                if (key == null)
                {
                    throw new AutentificationIncorrecteException("Les information de login / mot de passe sont incorrecte");
                }
                if (String.IsNullOrEmpty(compte.Identifiant))
                {
                    throw new AutentificationIncorrecteException("Le login est nul ou vide");
                }
                if (String.IsNullOrEmpty(compte.MotDePass))
                {
                    throw new AutentificationIncorrecteException("Le mot de passe est nul ou vide");
                }
                if (String.IsNullOrEmpty(compte.Token))
                {
                    throw new TokenInvalidException(utilisateur, "Le token est nul ou vide");
                }
                if (compte.Token != _CleeBasic)
                {
                    throw new TokenInvalidException(utilisateur, "Le token est invalide");
                }
                compte.MotDePass = HashMotDePass(compte.MotDePass);

                string retourMotDePass = new CompteDAO().GetMotDePass(compte.Identifiant);
                if (retourMotDePass == "" | compte.MotDePass != retourMotDePass)
                {
                    throw new AutentificationIncorrecteException(compte.Identifiant, "Identifiant ou mot de passe incorrecte");
                }

                return(compte);
            }
        }
示例#7
0
        public void GetAllAccountPositionAtDate()
        {
            var decaissementDAO   = new DecaissementDAO(sqlManager);
            var encaissementDAO   = new EncaissementDAO(sqlManager);
            var compteDAO         = new CompteDAO(sqlManager);
            var classificationDAO = new ClassificationDAO(sqlManager);

            var resultPosition = GetTotalPosition(compteDAO);

            //on s'assure qu'au début, la position est à zero
            Assert.AreEqual(0, resultPosition);
            string retour = encaissementDAO.SaveEncaissement(new EncaissementDTO()
            {
                banque         = "BNP",
                compte         = "compte 2 BNP",
                total_ttc      = "12",
                date_reglement = "02/06/2019"
            });

            resultPosition = GetTotalPosition(compteDAO);
            Assert.AreEqual(12, resultPosition);

            //on fait un deuxieme encaissement dans un autre compte
            retour = encaissementDAO.SaveEncaissement(new EncaissementDTO()
            {
                banque         = "HSBC",
                total_ttc      = "13",
                date_reglement = "02/06/2019"
            });
            resultPosition = GetTotalPosition(compteDAO);

            Assert.AreEqual(25, resultPosition);
            //on fait un troisieme encaissement, mais en 2020 pour etre sur qu'il n'est pas comptabilisé
            retour = encaissementDAO.SaveEncaissement(new EncaissementDTO()
            {
                banque         = "BPOP",
                total_ttc      = "11",
                date_reglement = "01/01/2020"
            });
            resultPosition = GetTotalPosition(compteDAO);
            Assert.AreEqual(25, resultPosition);


            string retour1 = decaissementDAO.SaveDraftDecaissement(new DecaissementDTO()
            {
                operation       = "test",
                banque          = "BNP",
                montant_ttc     = "9.5",
                date_operation  = "05/06/2019",
                date_compta     = "05/06/2019",
                date_valeur     = "05/06/2019",
                facture_verifie = "1"//ne devrai pas etre pris en compte
            });

            retour = JsonConvert.DeserializeObject <List <ExpectedReturn> >(retour1)[0].retour;
            //on s'assure qu'un decaissement non validé n'est pas pris en compte
            resultPosition = GetTotalPosition(compteDAO);
            Assert.AreEqual(25, resultPosition);


            string idSousCLass = "";
            var    dicoRetour  = JsonConvert.DeserializeObject
                                 <Dictionary <string, List <SousClassificationDTO> > >(
                classificationDAO.GetClassification());

            foreach (var item in dicoRetour)
            {
                idSousCLass = item.Value[0].id;
                break;
            }


            Assert.AreEqual(25, resultPosition);
            var retour2 = decaissementDAO.ValidateDecaissement(new DecaissementDTO()
            {
                id = retour,
                id_sous_classification = idSousCLass,
                mois_valeur            = "6"
            });
            var resultValidated = JsonConvert.DeserializeObject <List <DecaissementDTO> >(decaissementDAO.GetValidatedDecaissements());

            Assert.IsTrue(resultValidated.Count == 1);

            resultPosition = GetTotalPosition(compteDAO);

            Assert.AreEqual(15.5, resultPosition);
        }
示例#8
0
        public void GetPositionPeriode()
        {
            var decaissementDAO = new DecaissementDAO(sqlManager);
            var encaissementDAO = new EncaissementDAO(sqlManager);
            var compteDAO       = new CompteDAO(sqlManager);

            //on s'assure qu'au début, la position est à zero
            string retour         = compteDAO.GetTotalPositionAtInterval(DateTime.Now.ToString("dd/MM/yyyy"), DateTime.Now.ToString("dd/MM/yyyy"), "annee");
            var    resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);

            Assert.AreEqual(0, double.Parse(resultPosition[0].position.Replace('.', ',')));

            //on enregistre un decaissement non validé
            var decaissement1 = new DecaissementDTO()
            {
                banque         = "BNP",
                date_compta    = "20/02/2019",
                date_valeur    = "20/02/2019",
                date_operation = "20/02/2019",
                mode_paiement  = "CHQ",
                operation      = "unitTestDec1",
                montant_ttc    = "12.2"
            };

            decaissementDAO.SaveDraftDecaissement(decaissement1);
            retour = decaissementDAO.GetDraftDecaissement();
            var resultDecaissement = JsonConvert.DeserializeObject <List <DecaissementDTO> >(
                decaissementDAO.GetDraftDecaissement());

            decaissement1.id = resultDecaissement[0].id;
            var listClassif = JsonConvert.DeserializeObject <Dictionary <string, List <SousClassificationDTO> > >(
                new ClassificationDAO(sqlManager).GetClassification());

            decaissement1.id_sous_classification = listClassif["ADMINISTRATIF"][1].id;
            decaissement1.mois_valeur            = "2";
            //on valide le decaissement
            decaissementDAO.ValidateDecaissement(decaissement1);
            retour         = compteDAO.GetTotalPositionAtInterval("07/06/2019", "07/06/2019", "jours");
            resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);
            //on s'assure que la postition après le decaissement as bien changé
            Assert.AreEqual(-12.2, double.Parse(resultPosition[0].position.Replace('.', ',')));
            retour         = compteDAO.GetTotalPositionAtInterval("13/01/2019", "13/01/2019", "jours");
            resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);
            //on s'assure que la position AVANT le decaissement reste inchangé
            Assert.AreEqual(0, double.Parse(resultPosition[0].position.Replace('.', ',')));
            var encaissement = new EncaissementDTO()
            {
                banque         = "HSBC",
                compte         = "compte 1 HSBC",
                mode_paiement  = "CHQ",
                total_ttc      = "20",
                societe        = "UNO",
                date_reglement = "14/05/2019"
            };

            encaissementDAO.SaveEncaissement(encaissement);
            retour         = compteDAO.GetTotalPositionAtInterval("07/06/2019", "07/06/2019", "jours");
            resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);
            //on s'assure que la position prend en compte les encaissement et decaissement meme sur différentes banque/compte
            Assert.AreEqual(7.8, double.Parse(resultPosition[0].position.Replace('.', ',')));


            encaissement = new EncaissementDTO()
            {
                banque         = "HSBC",
                compte         = "compte 1 HSBC",
                mode_paiement  = "CHQ",
                total_ttc      = "20",
                societe        = "UNO",
                date_reglement = "14/05/2017"
            };
            encaissementDAO.SaveEncaissement(encaissement);
            retour         = compteDAO.GetTotalPositionAtInterval("07/06/2018", "07/06/2018", "jours");
            resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);
            //on s'assure que la position prend en compte l'encaissement en 2018 et ignore les mouvements ulterieurs
            Assert.AreEqual(20, double.Parse(resultPosition[0].position.Replace('.', ',')));

            retour         = compteDAO.GetTotalPositionAtInterval("07/06/2019", "07/06/2019", "jours");
            resultPosition = JsonConvert.DeserializeObject <List <ExpectedPositionInterval> >(retour);
            //on s'assure que la position prend en compte tout les mouvements, peut importe le compte ou l'année
            Assert.AreEqual(27.8, double.Parse(resultPosition[0].position.Replace('.', ',')));
        }
        // -- Charger les données dans le auto complete -- //
        public override object Charger_EasyAutocomplete(string id_page, string id_vue)
        {
            List <object> donnee = new List <object>();

            try
            {
                #region ConfigurationBudget-ParametreBudgetRevenu
                if (id_page == GB_Enum_Menu.ConfigurationBudget_ParametreBudgetRevenu)
                {
                    // -- Si la vue n'est pas retourné -- //
                    #region comptes
                    if (string.IsNullOrEmpty(id_vue))
                    {
                        // -- Si la liste des comptes en session est vide, la mettre à jour -- //
                        if ((this.con.donnee.comptes as List <Compte>).Count == 0)
                        {
                            this.con.donnee.comptes = CompteDAO.Lister_Cle();
                        }

                        // -- Charger la liste des résultats -- //
                        foreach (var val in (this.con.donnee.comptes as List <Compte>))
                        {
                            donnee.Add(
                                new
                            {
                                id      = val.id,
                                code    = val.code,
                                libelle = val.libelle
                            }
                                );
                        }
                    }
                    #endregion
                }
                #endregion

                #region ConfigurationBudget-ParametreBudgetFrais
                else if (id_page == GB_Enum_Menu.ConfigurationBudget_ParametreBudgetFrais)
                {
                    // -- Si la vue n'est pas retourné -- //
                    #region comptes
                    if (string.IsNullOrEmpty(id_vue))
                    {
                        // -- Si la liste des comptes en session est vide, la mettre à jour -- //
                        if ((this.con.donnee.comptes as List <Compte>).Count == 0)
                        {
                            this.con.donnee.comptes = CompteDAO.Lister_Cle();
                        }

                        // -- Charger la liste des résultats -- //
                        foreach (var val in (this.con.donnee.comptes as List <Compte>))
                        {
                            donnee.Add(
                                new
                            {
                                id      = val.id,
                                code    = val.code,
                                libelle = val.libelle
                            }
                                );
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #region catch & finally
            catch (Exception ex)
            {
                // -- Vérifier la nature de l'exception -- //
                if (!GBException.Est_GBexception(ex))
                {
                    // -- Log -- //
                    GBClass.Log.Error(ex);
                }
            }
            #endregion

            // -- Retoure le résultat en objet JSON -- //
            return(GBConvert.To_JSONString(donnee));
        }
示例#10
0
 public CompteBLL()
 {
     daoCpt = new CompteDAO();
 }