Beispiel #1
0
        [ProducesResponseType(200)] // Ok
        public async Task <IActionResult> ChangeMotDePasse([FromBody] ChangeMotDePasseVue vue)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeEmail(vue.Email);

            if (await UtilisateurService.ChangeMotDePasse(user, vue.Ancien, vue.Nouveau))
            {
                return(Ok());
            }
            return(StatusCode(500, "Changement impossible"));
        }
Beispiel #2
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> Liste()
        {
            CarteUtilisateur carte = await CréeCarteAdministrateur();

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            return(Ok(await UtilisateurService.Lit()));
        }
Beispiel #3
0
        public async Task <IActionResult> OubliMotDePasse([FromBody] OubliMotDePasseVue vue)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeEmail(vue.Email);

            // n'envoie le mail que si la vue est valide
            if (user != null && user.EmailConfirmed && user.Email == vue.Email)
            {
                await UtilisateurService.EnvoieEmailRéinitialiseMotDePasse(user);
            }
            // retourne toujours Ok pour ne pas envoyer d'information
            return(Ok());
        }
Beispiel #4
0
        public async Task <IActionResult> Deconnecte()
        {
            CarteUtilisateur carte = await CréeCarteUtilisateur();

            if (carte.Erreur == null)
            {
                // ne déconnecte que si l'utilisateur est connecté à sa session en cours
                await UtilisateurService.Déconnecte(carte);
            }

            // dans tous les cas
            return(Ok());
        }
Beispiel #5
0
        [ProducesResponseType(400)] // Bad request
        public async Task <IActionResult> ChangeEmail([FromBody] ChangeEmailVue vue)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeEmail(vue.Email);

            if (user != null)
            {
                return(RésultatBadRequest("email", "nomPris"));
            }
            user = await UtilisateurService.UtilisateurDeId(vue.Id);

            await UtilisateurService.EnvoieEmailChangeEmail(user, vue.Email);

            return(Ok());
        }
Beispiel #6
0
        public async Task <IActionResult> Connecte([FromBody] ConnectionVue connection)
        {
            Utilisateur utilisateur = await UtilisateurService.UtilisateurVérifié(connection.Email, connection.Password);

            if (utilisateur == null)
            {
                return(RésultatBadRequest("Nom ou mot de passe invalide"));
            }
            if (!utilisateur.EmailConfirmed)
            {
                return(RésultatBadRequest("Vous devez confirmer votre adresse email en cliquant sur le lien qui vous a été envoyé."));
            }

            return(await Connecte(utilisateur));
        }
Beispiel #7
0
        [ProducesResponseType(200)] // Ok
        public async Task <IActionResult> ConfirmeChangeEmail([FromBody] ConfirmeChangeEmailVue vue)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeId(vue.Id);

            bool changé = false;

            if (user != null && vue.Email != null)
            {
                changé = await UtilisateurService.ChangeEmail(user, vue.Email, vue.Code);
            }
            if (changé)
            {
                return(Ok());
            }
            return(StatusCode(500, "Changement impossible"));
        }
Beispiel #8
0
        public async Task <IActionResult> ConfirmeEmail([FromBody] ConfirmeEmailVue confirme)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeId(confirme.Id);

            bool emailConfirmé = false;

            if (user != null)
            {
                emailConfirmé = await UtilisateurService.EmailConfirmé(user, confirme.Code);
            }
            if (!emailConfirmé)
            {
                return(RésultatBadRequest("Vous devez confirmer votre adresse email en cliquant sur le lien qui vous a été envoyé."));
            }
            return(Ok());
        }
Beispiel #9
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> Lit(string id)
        {
            CarteUtilisateur carte = await CréeCarteAdministrateur();

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            Utilisateur utilisateur = await UtilisateurService.UtilisateurDeId(id);

            if (utilisateur == null)
            {
                return(NotFound());
            }
            return(Ok(utilisateur));
        }
Beispiel #10
0
        public async Task <IActionResult> RéinitialiseMotDePasse([FromBody] RéinitialiseMotDePasseVue vue)
        {
            Utilisateur user = await UtilisateurService.UtilisateurDeId(vue.Id);

            bool réinitialisé = false;

            if (user != null)
            {
                réinitialisé = await UtilisateurService.RéinitialiseMotDePasse(user, vue.Code, vue.Password);
            }
            if (!réinitialisé)
            {
                return(BadRequest());
            }
            // retourne toujours Ok pour ne pas envoyer d'information
            return(Ok());
        }
Beispiel #11
0
        public async Task <IActionResult> Ajoute([FromBody] CréeCompteVue vue)
        {
            RetourDeService <Utilisateur> retour = await CréeUtilisateur(vue);

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            if (retour.Type != TypeRetourDeService.Ok)
            {
                return(SaveChangesActionResult(retour));
            }

            // envoie un mail contenant le lien de confirmation
            await UtilisateurService.EnvoieEmailConfirmeCompte(retour.Entité);

            return(Ok());
        }
Beispiel #12
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> Supprime(string id)
        {
            CarteUtilisateur carte = await CréeCarteAdministrateur();

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            Utilisateur utilisateur = await UtilisateurService.UtilisateurDeId(id);

            if (utilisateur == null)
            {
                return(NotFound());
            }
            var retour = await UtilisateurService.Supprime(utilisateur);

            return(SaveChangesActionResult(retour));
        }