Page 4 of 4

Checklist

Posted: Tue Oct 16, 2018 1:07 pm
by MariaIAF

Re: Ven a la U

Posted: Thu Oct 18, 2018 9:59 am
by MariaIAF
Sprint 10: 11-24 de Octubre
Avance 18 de Octubre

¿Qué hemos hecho?
Módulo de Administrador
  • Login por roles de Administrador Deportes y Administrador eventos
Módulo Perfil de Usuario
  • Implementación de las pantallas de Perfil de Usuario y Recordar/Cambiar contraseña
¿Qué vamos a hacer?
Continuar con las actividades del backlog:
  • Implementación de las funcionalidades de cambiar y recordar contraseña
  • Implementación de las interfaces y funcionalidades de administrador
¿Qué dificultades hemos tenido?
Ninguna

Burndown Chart
Image

Evidencias

Pántallas de Perfil, cambio de contraseña y recordar contraseña
Image

Login como Administrador de Eventos
Image

Login como Administrador de Deportes
Image

Re: Ven a la U

Posted: Mon Oct 22, 2018 10:05 pm
by Sergio Rodríguez
Sprint 10: 11-24 de Octubre
Avance 22 de Octubre

¿Qué hemos hecho?
  • Implementación de las funcionalidades de cambiar y recordar contraseña
  • Controladores Perfil de Usuario
¿Qué vamos a hacer?
Continuar con las actividades del backlog:
  • Implementación de diseño de interfaces de Administrador de Usuarios y Administrador de Eventos
¿Qué dificultades hemos tenido?
Ninguna

Burndown Chart
Image

Evidencias

Cambiar contraseña y Recordar Contraseña
Image

PersonasController.cs

Code: Select all

using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.Http.Description;
using VenALaU.API.Helpers;
using VenALaU.API.Models;
using VenALaU.Common.Models;
using VenALaU.Domain.Models;

namespace VenALaU.API.Controllers
{
    [RoutePrefix("api/Persona")]
    public class PersonasController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método que retorna todas las personas
        /// </summary>
        /// <returns>Retorna un mensaje satisfactorio y despliega toda la lista en caso
        /// de que se consulten todos los registros.
        /// Retorna un mensaje de error en caso de que no se logre consultar</returns>
        [HttpGet]
        [Route("findall")]
        public HttpResponseMessage findAll()
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Personas.Select(p => new { p.IdPersona, p.IdInstitucional, p.IdVinculo, p.Nombre, p.Apellido, p.Correo, p.CantidadMultas, p.Telefono }).ToList()));

                response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }

        /// <summary>
        /// Consulta por el id de la persona
        /// </summary>
        /// <param name="id">id de la persona a consultar</param>
        /// <returns>Retorna un mensaje satisfactorio y despliega toda la lista en caso
        /// de que se consulten todos los registros.
        /// Retorna un mensaje de error en caso de que no se logre consultar</returns>
        [HttpGet]
        [Route("find/{id}")]
        public HttpResponseMessage find(int id)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Personas.Select(p => new { p.IdPersona, p.IdInstitucional, p.IdVinculo, p.Nombre, p.Apellido, p.Correo, p.CantidadMultas, p.Telefono }).Where(p => p.IdVinculo == id)));

                response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }

        /// <summary>
        /// Consulta por el id de la persona
        /// </summary>
        /// <param name="id">id de la persona a consultar</param>
        /// <returns>Retorna un mensaje satisfactorio y despliega toda la lista en caso
        /// de que se consulten todos los registros.
        /// Retorna un mensaje de error en caso de que no se logre consultar</returns>
        [HttpGet]
        [Route("findIdInstitucional/{idInstitucional}")]
        public HttpResponseMessage findIdInstitucional(int idInstitucional)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Personas.Select(p => new { p.IdPersona, p.IdVinculo, p.Nombre, p.Apellido, p.Correo, p.CantidadMultas, p.Telefono, p.IdInstitucional }).Where(p => p.IdInstitucional == idInstitucional)));

                response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }


        [HttpPost]
        [Route("GetUserByEmail")]
        public async Task<IHttpActionResult> GetUserByEmail(JObject form)
        {
            var email = string.Empty;
            dynamic jsonObject = form;
            try
            {
                email = jsonObject.Correo.Value;
            }
            catch
            {
                return BadRequest("Missing parameter.");
            }

            var user = await db.Personas.
                Where(u => u.Correo.ToLower() == email.ToLower()).
                FirstOrDefaultAsync();
            if (user == null)
            {
                return NotFound();
            }

            return Ok(user);
        }

        /// <summary>
        /// Método para crear una persona
        /// </summary>
        /// <param name="persona">persona a crear</param>
        /// <returns>Retorna error en caso de que no se inserte, o correcto si se inserta</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(Persona persona)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.Personas.Add(new Persona
                {
                    IdPersona = persona.IdPersona,
                    IdVinculo = persona.IdVinculo,
                    Nombre = persona.Nombre,
                    Apellido = persona.Apellido,
                    Correo = persona.Correo,
                    CantidadMultas = persona.CantidadMultas,
                    Telefono = persona.Telefono,
                    IdInstitucional = persona.IdInstitucional


                });
                db.SaveChanges();
                return response;

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
        [HttpPut]
        [Route("update")]
        public HttpResponseMessage update(Persona persona)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                var personaActual = db.Personas.SingleOrDefault(p => p.IdInstitucional == persona.IdInstitucional);
                personaActual.Nombre =persona.Nombre;
                personaActual.Apellido = persona.Apellido;
                personaActual.Telefono = persona.Telefono;
                personaActual.IdVinculo = persona.IdVinculo;
                db.SaveChanges();

                return response;
            }
            catch
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }
        [HttpPost]
        [Route("ChangePassword")]
        public async Task<IHttpActionResult> ChangePassword(JObject form)
        {
            var email = string.Empty;
            var currentPassword = string.Empty;
            var newPassword = string.Empty;
            dynamic jsonObject = form;

            try
            {
                email = jsonObject.Email.Value;
                currentPassword = jsonObject.CurrentPassword.Value;
                newPassword = jsonObject.NewPassword.Value;
            }
            catch
            {
                return BadRequest("Incorrect call");
            }

            var userContext = new ApplicationDbContext();
            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(userContext));
            var userASP = userManager.FindByEmail(email);

            if (userASP == null)
            {
                return BadRequest("Incorrect call");
            }

            var response = await userManager.ChangePasswordAsync(userASP.Id, currentPassword, newPassword);
            if (!response.Succeeded)
            {
                return BadRequest(response.Errors.FirstOrDefault());
            }

            return Ok("ok");
        }

        [HttpPost]
        [Route("PasswordRecovery")]
        public async Task<IHttpActionResult> PasswordRecovery(JObject form)
        {
            try
            {
                var email = string.Empty;
                dynamic jsonObject = form;

                try
                {
                    email = jsonObject.Email.Value;
                }
                catch
                {
                    return BadRequest("Incorrect call.");
                }

                var customer = await db.Personas
                    .Where(u => u.Correo.ToLower() == email.ToLower())
                    .FirstOrDefaultAsync();
                if (customer == null)
                {
                    return NotFound();
                }

                var userContext = new ApplicationDbContext();
                var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(userContext));
                var userASP = userManager.FindByEmail(email);
                if (userASP == null)
                {
                    return NotFound();
                }

                var random = new Random();
                var newPassword = string.Format("{0}", random.Next(100000, 999999));
                var response1 = userManager.RemovePassword(userASP.Id);
                var response2 = await userManager.AddPasswordAsync(userASP.Id, newPassword);
                if (response2.Succeeded)
                {
                    var subject = "VenALaU - Recuperación de contraseña";
                    var body = string.Format(@"
                        <h1>VenALaU - Recuperación de contraseña</h1>
                        <p>Tu nueva contraseña es: <strong>{0}</strong></p>
                        <p>Por favor, Recuerda cambiar la contraseña por una que recuerdes fácilmente",
                        newPassword);

                    await MailHelper.SendMail(email, subject, body);
                    return Ok(true);
                }

                return BadRequest("The password can't be changed.");

            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

    }
}

Re: Ven a la U

Posted: Thu Oct 25, 2018 2:06 am
by Sergio Rodríguez
Sprint 10: 11-24 de Octubre
Velocidad Esperada: 12

¿Qué hemos hecho?
Damos por terminada la aplicación
Implementación de diseño de interfaces de Administrador de Usuarios y Administrador de Eventos

¿Qué vamos a hacer?
Se harán pequeños ajustes a la interfaz y a algunos Bugs todavía existen en la aplicación

¿Qué dificultades hemos tenido?
Ninguna

Burndown
Image


Evidencias
Información por rol
Image

Diseño interfaces
Image

Entrega Final - VenALaU

Posted: Thu Nov 08, 2018 10:20 am
by MariaIAF