Ven a la U

En esta sección se atenderán las dudas relacionadas con sistemas de gestión de la calidad, procedimientos, buenas prácticas, normas y todo lo relacionado con aseguramiento de la calidad

Moderator: julianmartinez16

User avatar
xacarana
Site Admin
Posts: 1028
Joined: Fri Jan 15, 2016 6:13 pm

Re: Ven a la U

Post by xacarana » Tue Aug 28, 2018 5:15 pm

Image

Muy bien, recuerden seguir publicando los diagramas y los cheklist de cada componente.
Andrés Bedoya Tobón
Profesor
"I only smile in the dark, I only smile when it's complicated" Raybiez

User avatar
Sergio Rodríguez
Posts: 18
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by Sergio Rodríguez » Thu Aug 30, 2018 12:25 pm

Sprint 5: Agosto 23-30
Velocidad del Sprint: 9

¿Qué hemos hecho?
  • Se creó y diseñó las interfaz de la pantalla Login 1/9
  • Se creó y diseñó las interfaz de la pantalla Registro 1/9
  • Implementación funcionalidades de Inicio de Sesión: 2/9
  • Implementaación de funcionalidad Recuerdame: 1/9
  • Implementación de cerrar sesión: 1/9
¿Qué vamos a hacer?
Continuar con las actividades del Backlog, que incluye la implementación del menú de opciones y la implementación del módulo de eventos
Planear el Sprint 7 correspondiente a la semana del 6 de septiembre al 13 de Septiembre

¿Qué dificultades tuvimos?
Debido a problemas con Visual Studio y a alta carga académica no se logró implementar la funcionalidades en la Pantalla registro. A esta dificultad se le dará solución en el siguiente Sprint.

Burndown Chart
Image

Diagramas

Diagrama de casos de uso
Image

Diagrama de clases
Image

Diagrama de secuencias
Image

Diagrama ER
Image

CheckList de diseño y código
https://docs.google.com/spreadsheets/d/ ... sp=sharing

Evidencias

Login
Image

Logout
Image

Rememberme
Image
Gestión de Calidad de Software
Sergio Andrés Rodríguez Galeano
sergio.rodriguezg@upb.edu.co

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Sat Sep 01, 2018 6:57 pm

Sprint 6: 30 de Agosto-6 de Septiembre
Novedades 1 de Septiembre :!:
Tuve que ingresar mi computador a servicio técnico, por lo que la planeación que se tenía para el sprint tuvo que reducirse. Quitamos de este el módulo de eventos, teniendo presupuestado para hacer únicamente lo faltante del sprint pasado (Registro) y el menú principal.

Sprint Planning
  • Implementación de registro de usuarios: 3 (Sprint pasado)
Menú de opciones
  • Menú principal: 2/5
  • Acceso a menú de eventos: 1/5
  • Acceso a menú de reservas: 1/5
  • Acceso a menú de información deportiva: 1/5
Velocidad esperada: 8
Last edited by MariaIAF on Wed Sep 05, 2018 8:57 pm, edited 1 time in total.
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Mon Sep 03, 2018 2:13 pm

Sprint 6: 30 de Agosto - 6 de Septiembre
Avances 3 de Septiembre

Velocidad del sprint: 8

¿Qué hemos hecho?
Se completó el faltante del sprint pasado, correspondiente al registro de usuarios.

¿Qué vamos a hacer?
  • Continuar con las actividades del backlog: Menú principal


¿Qué dificultades hemos tenido?
Al tener mi computador en servicio técnico se ha frenado un poco el ritmo de trabajo que teníamos.

Burndown Chart
Image

Evidencias

Funcionamiento de registro
Image

Image

Image
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Wed Sep 05, 2018 8:56 pm

Sprint 6: 30 de Agosto - 6 de Septiembre

Velocidad del sprint: 8

¿Qué hemos hecho?
  • Registro (Faltante del sprint pasado)
  • Menú principal
¿Qué vamos a hacer?
Continuar con las actividades del backlog. Módulo de eventos y estado de cuenta

¿Qué dificultades hemos tenido?
Al tener mi computador en servicio técnico se ha frenado un poco el ritmo de trabajo que teníamos.

Burndown Chart
Image

Evidencias

Menú Principal
Image

Navegación general
Image

Navegación a Deportes
Image

Navegación a Eventos
Image

Navegación a Estado de Cuenta
Image
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

User avatar
Sergio Rodríguez
Posts: 18
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by Sergio Rodríguez » Tue Sep 11, 2018 11:20 am

Sprint 7: 6 de Septiembre- 20 de Septiembre

Sprint Planning

Implementación del módulo de Deportes
  • Menú de acceso a las funcionalidades correspondientes: implementos, horarios de cursos promocionales y piscina: 1/7
  • Crear modelos y controladores para módulo de deportes 2/7
  • Lista de implementos deportivos con cantidad (Sólo consultar disponibilidad): 2/7
  • Lista de horarios y detalle de cursos promocionales: 1/7
  • Lista de horarios de acceso libre a la piscina: 1/7
Implementación del módulo eventos
  • Crear modelos y controladores para módulo de Eventos 2/8
  • Creación de pantalla de eventos y detalle de eventos: 1/8
  • Cargar eventos a la lista con el API: 1/8
  • Fitro por categorías: 2/8
  • Pantalla de detalle evento seleccionado: 2/8
Velocidad esperada: 15

¿ Qué hemos hecho?
  • Menú de acceso a las funcionalidades correspondientes: implementos, horarios de cursos promocionales y piscina: 2/8
¿ Qué vamos a hacer?
Continuar con el sprint planeado

¿Qué dificultades hemos tenido?
Se presentó un problema con el servicio y la base de datos al cuál se le está dando solución

Burndown chart
Image

Evidencias

Navgación
Image

Diagramas:

Entidad relación
Image

Casos de uso:
Image

Error
Image
Last edited by Sergio Rodríguez on Sat Sep 15, 2018 11:21 am, edited 1 time in total.
Gestión de Calidad de Software
Sergio Andrés Rodríguez Galeano
sergio.rodriguezg@upb.edu.co

User avatar
Sergio Rodríguez
Posts: 18
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by Sergio Rodríguez » Thu Sep 13, 2018 11:03 am

Sprint 7: 6 de Septiembre- 20 de Septiembre

¿ Qué hemos hecho?
  • Se dio solución al error que se nos presentaba al momento de consultar el servicio
  • Se diseñó el modelo para listar cursos promocionales y piscina
¿ Qué vamos a hacer?
Continuar con el sprint planeado

¿Qué dificultades hemos tenido?
La única dificultad fue buscar solución al error, lo cuál nos impedía avanzar con el sprint

Evidencias
Burndown
Image

Vinculo
Image

TipoImplemento
Image

TipoEvento
Image

Dia
Image

Instructor
Image

EspacioCurso
Image

TipoEspacio
Image

Evidencias creación modelos

CursoPromocional.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class CursoPromocional
    {
        [Key]
        public int Id { get; set; }
        public string Nombre { get; set; }
        public int IdDia { get; set; }
        public string Hora { get; set; }
        public int IdEspacioCurso { get; set; }
        public int IdInstructor { get; set; }

        [ForeignKey("IdDia")]
        public virtual Dia Dia { get; set; }
        [ForeignKey("IdEspacioCurso")]
        public virtual EspacioCurso EspacioCurso { get; set; }
        [ForeignKey("IdInstructor")]
        public virtual Instructor Instructor { get; set; }
    }
}
Dia.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class Dia
    {
        [Key]
        public int IdDia { get; set; }
        public string Dia1 { get; set; }
    }
}
EspacioCurso.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class EspacioCurso
    {
        [Key]
        public int IdEspacioCurso { get; set; }
        public string EspacioCurso1 { get; set; }
    }
Instructor.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class Instructor
    {
        [Key]
        public int IdInstructor { get; set; }
        public string Nombre { get; set; }
    }
}
Piscina.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class Piscina
    {
        [Key]
        public int Id { get; set; }
        public int IdDia { get; set; }
        public string Hora { get; set; }
        public int EspacioDispoible { get; set; }
        public string Observacion { get; set; }
        [ForeignKey("IdDia")]
        public virtual Dia Dia { get; set; }
    }
}
Evento.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class Evento
    {
        [Key]
        public int Id { get; set; }
        public int IdTipoEvento { get; set; }
        public System.DateTime FechaEvento { get; set; }
        public string Lugar { get; set; }
        public string DetalleEvento { get; set; }
        public string Nombre { get; set; }
        public string URLImagen { get; set; }
        public string PublicoDirigido { get; set; }

    }
}
Implemento.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class Implemento
    {
        [Key]
        public int IdImplemento { get; set; }
        public int IdTipoImplemento { get; set; }
        public string Nombre { get; set; }
        public int Cantidad { get; set; }

    }
}
TipoEvento.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class TipoEvento
    {
        [Key]
        public int IdTipoEvento { get; set; }
        public string TipoEvento1 { get; set; }
    }
}
TipoImplemento.cs

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace VenALaU.Service.Models
{
    public class TipoImplemento
    {
        [Key]
        public int IdTipoImplemento { get; set; }
        public string TipoImplemento1 { get; set; }
    }
}
Last edited by Sergio Rodríguez on Tue Sep 18, 2018 5:13 pm, edited 1 time in total.
Gestión de Calidad de Software
Sergio Andrés Rodríguez Galeano
sergio.rodriguezg@upb.edu.co

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Tue Sep 18, 2018 12:26 pm

Sprint 7: 6-19 de Septiembre
Avance 18 de Septiembre
Velocidad del Sprint: 15

¿Qué hemos hecho?
Módulo de deportes
  • Diagramas
  • Creación de modelos y controladores del módulo de deportes: 2/7
  • Lista de cursos promocionales: 1/7
  • Lista de implementos deportivos con cantidad:2/7
Módulo de Eventos
  • Diagramas
  • Creación de modelos y controladores del módulo de eventos: 2/8
  • Creación de la pantalla de eventos y detalle eventos: 1/8
  • Cargar eventos a la lista desde el API: 1/8
  • Filtro por categoría de eventos: 2/8
¿Qué vamos a hacer?
Continuar con las actividades del backlog:
  • Lista de horarios de piscina
  • Lista de implementos deportivos
  • Detalle de eventos
  • Detalle de cursos promocionales
¿Qué dificultades hemos tenido?
Ninguna

Burndown Chart
Image

Check-list Diseño
Image

Check-list Código
Image

Diagramas
Diagrama Entidad-Relación Módulo de deportes
Image
Diagrama Entidad-Relación Módulo de Eventos
Image
Diagrama de casos de uso Deportes
Image
Diagrama de Casos de uso Eventos
Image
Diagrama de Flujo Deportes
Image
Diagrama de Flujo Eventos
Image
Diagrama de Secuencias Eventos
Image
Diagrama de Secuencias Deportes
Image

Evidencias
Funcionamiento Eventos
Image
Funcionamiento Cursos Promocionales
Image
Funcionamiento implementos deportivos
Image


Código-Web API
Controlador Curso Promocional

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/CursoPromocional")]
    public class CursoPromocionalController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método que encuentra todos los cursos
        /// </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.CursoPromocionals.Select(p => new { p.Id,p.Nombre,p.IdInstructor,p.IdDia,p.Hora,p.IdEspacioCurso }).ToList()));

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


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

        /// <summary>
        /// Método para consultar por id del curso
        /// </summary>
        /// <param name="id">id del curso a consultar</param>
        /// <returns>Mensaje de satisfacción y el evento respectivo si logra consultarlo
        /// Mensaje de error si no logra 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.CursoPromocionals.Select(p => new { p.Id, p.Nombre, p.IdInstructor, p.IdDia, p.Hora, p.IdEspacioCurso }).Where(p => p.Id == id)));

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


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }
        /// <summary>
        /// Obtener un curso por el tipo de día
        /// </summary>
        /// <param name="idDia">id del tipo dia</param>
        /// <returns>Mensaje satisfactorio con lo datos si logra obtenerlos
        /// Mensaje de error si no logra obtenerlos</returns>
        [HttpGet]
        [Route("findByDay/{idDia}")]
        public HttpResponseMessage findByDay(int idDia)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.CursoPromocionals.Select(p => new { p.Id, p.Nombre, p.IdInstructor, p.IdDia, p.Hora, p.IdEspacioCurso }).Where(p => p.IdDia == idDia)));

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


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }
        /// <summary>
        /// Método para crear un curso
        /// </summary>
        /// <param name="curso">curso 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(CursoPromocional curso)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.CursoPromocionals.Add(new CursoPromocional
                {
                    Id = curso.Id,
                    Nombre=curso.Nombre,
                    IdEspacioCurso = curso.IdEspacioCurso,
                    IdInstructor = curso.IdInstructor,
                    IdDia = curso.IdDia,
                    Hora = curso.Hora,
                     
                });
                db.SaveChanges();
                return response;

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }

    
}
}
Controlador Dia

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/Dia")]
    public class DiaController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método para consultar todos los días
        /// </summary>
        /// <returns>Mensaje satisfactorio y todos los tipos de días en caso de que logre
        /// consultar todos los Tipos de día
        /// Mensaje de error en caso de que no logre consultar todos los tipos de día</returns>
        [HttpGet]
        [Route("findall")]
        public HttpResponseMessage findAll()
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Dias.Select(p => new { p.IdDia, p.Dia1 }).ToList()));

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


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

        /// <summary>
        /// Método para consultar un tipo de evento específico
        /// </summary>
        /// <param name="id">ID del tipo de evento</param>
        /// <returns>Mensaje satisfactorio y todos los tipos de eventos en caso de que logre
        /// consultar un Tipo de Evento.
        /// Mensaje de error en caso de que no logre consultar un tipo de evento</returns>
        [HttpGet]
        [Route("find/{id}")]
        public HttpResponseMessage find(int id)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Dias.Select(p => new { p.IdDia, p.Dia1 }).Where(p => p.IdDia == id)));

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


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

        /// <summary>
        /// Método para crear un tipo de día
        /// </summary>
        /// <param name="tipoEvento">Dia del modelo</param>
        /// <returns>Retorna mensaje positivo si logra insertar el modelo.
        /// Mensaje negativo si no lo lora insertar</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(Dia tipoDia)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.Dias.Add(new Dia
                {
                    IdDia = tipoDia.IdDia,
                    Dia1 = tipoDia.Dia1


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

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
    }
}
Controlador Evento

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/Evento")]
    public class EventoController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método para crear un evento
        /// </summary>
        /// <param name="evento">Evento del modelo de la base de datos</param>
        /// <returns>Retorna error en caso de que no se inserte, o correcto si se inserta</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(Evento evento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.Eventoes.Add(new Evento
                {
                    Id = evento.Id,
                    IdTipoEvento = evento.IdTipoEvento,
                    Nombre = evento.Nombre,
                    FechaEvento = evento.FechaEvento,
                    Lugar = evento.Lugar,
                    DetalleEvento = evento.DetalleEvento,
                    URLImagen = evento.URLImagen,
                    PublicoDirigido = evento.PublicoDirigido

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

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
        /// <summary>
        /// Método que encuentra todos los eventos
        /// </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.Eventoes.Select(p => new { p.Id, p.Nombre, p.IdTipoEvento, p.Lugar, p.FechaEvento, p.DetalleEvento,p.URLImagen,p.PublicoDirigido }).ToList()));

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


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

        /// <summary>
        /// Método para consultar por ID del evento
        /// </summary>
        /// <param name="id">ID del evento a consultar</param>
        /// <returns>Mensaje de satisfacción y el evento respectivo si logra consultarlo
        /// Mensaje de error si no logra 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.Eventoes.Select(p => new { p.Id, p.Nombre, p.IdTipoEvento, p.Lugar, p.FechaEvento, p.DetalleEvento, p.URLImagen, p.PublicoDirigido }).Where(p => p.Id == id)));

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


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

        /// <summary>
        /// Obtener un evento por tipo de evento
        /// </summary>
        /// <param name="idTipoEvento">ID del tipo de evento</param>
        /// <returns>Mensaje satisfactorio con lo datos si logra obtenerlos
        /// Mensaje de error si no logra obtenerlos</returns>
        [HttpGet]
        [Route("findByType/{idTipoEvento}")]
        public HttpResponseMessage findByType(int idTipoEvento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Eventoes.Select(p => new { p.Id, p.Nombre, p.IdTipoEvento, p.Lugar, p.FechaEvento, p.DetalleEvento, p.URLImagen, p.PublicoDirigido }).Where(p => p.IdTipoEvento == idTipoEvento)));

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


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


    }
}
Controlador Implemento

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/Implemento")]
    public class ImplementoController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método que encuentra todos los Implementos
        /// </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.Implementoes.Select(p => new { p.IdImplemento, p.IdTipoImplemento, p.Nombre, p.Cantidad }).ToList()));

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


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

        /// <summary>
        /// Método para consultar por id del implemento
        /// </summary>
        /// <param name="id">id del implemento a consultar</param>
        /// <returns>Mensaje de satisfacción y el evento respectivo si logra consultarlo
        /// Mensaje de error si no logra 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.Implementoes.Select(p => new { p.IdImplemento, p.IdTipoImplemento, p.Nombre, p.Cantidad }).Where(p => p.IdImplemento == id)));

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


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }
        /// <summary>
        /// Obtener un curso por el tipo de implemento
        /// </summary>
        /// <param name="idTipoImplemento">id del tipo implemento</param>
        /// <returns>Mensaje satisfactorio con lo datos si logra obtenerlos
        /// Mensaje de error si no logra obtenerlos</returns>
        [HttpGet]
        [Route("findByType/{idTipoImplemento}")]
        public HttpResponseMessage findByType(int idTipoImplemento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Implementoes.Select(p => new { p.IdImplemento, p.IdTipoImplemento, p.Nombre, p.Cantidad }).Where(p => p.IdTipoImplemento == idTipoImplemento)));

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


                return response;
            }
            catch (Exception)
            {
                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }
        }
        /// <summary>
        /// Método para crear un implemento
        /// </summary>
        /// <param name="implemento">implemento 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(Implemento imlpemento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.Implementoes.Add(new Implemento
                {
                    IdImplemento = imlpemento.IdImplemento,
                    IdTipoImplemento = imlpemento.IdTipoImplemento,
                    Nombre = imlpemento.Nombre,
                    Cantidad = imlpemento.Cantidad,

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

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
    }
}
Controlador Piscina

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/Piscina")]
    public class PiscinaController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método para crear un Horario y Piscina
        /// </summary>
        /// <param name="piscina">Evento del modelo de la base de datos</param>
        /// <returns>Retorna error en caso de que no se inserte, o correcto si se inserta</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(Piscina piscina)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.Piscinas.Add(new Piscina
                {
                    Id = piscina.Id,
                    IdDia = piscina.IdDia,
                    Hora = piscina.Hora,
                    EspacioDispoible=piscina.EspacioDispoible,
                    Observacion=piscina.Observacion
                    
                });
                db.SaveChanges();
                return response;

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
        /// <summary>
        /// Método que encuentra todos los horarios de piscina
        /// </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.Piscinas.Select(p => new { p.Id, p.IdDia,p.Hora,p.EspacioDispoible,p.Observacion }).ToList()));

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


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

        /// <summary>
        /// Método para consultar por Día
        /// </summary>
        /// <param name="id">ID del horario a consultar</param>
        /// <returns>Mensaje de satisfacción y el evento respectivo si logra consultarlo
        /// Mensaje de error si no logra 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.Piscinas.Select(p => new { p.Id, p.IdDia, p.Hora, p.EspacioDispoible, p.Observacion }).Where(p => p.Id == id)));

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


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

        /// <summary>
        /// Método para consultar los horarios por día
        /// </summary>
        /// <param name="idDia">ID del día</param>
        /// <returns>Retorna la lista de los horarios en caso de que la consulta se relice de
        /// forma satisfactoria. Mensaje de error en caso de que no logre consultar</returns>
        [HttpGet]
        [Route("findByDay/{idDia}")]
        public HttpResponseMessage findByDay(int idDia)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.Piscinas.Select(p => new { p.Id, p.IdDia, p.Hora, p.EspacioDispoible, p.Observacion }).Where(p => p.IdDia== idDia)));

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


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

    }
}
Controlador Tipo Evento

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/TipoEvento")]

    public class TipoEventoController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método para consultar todos los tipos de evento
        /// </summary>
        /// <returns>Mensaje satisfactorio y todos los tipos de eventos en caso de que logre
        /// consultar todos los Tipos de Evento.
        /// Mensaje de error en caso de que no logre consultar todos los tipos de eventos</returns>
        [HttpGet]
        [Route("findall")]
        public HttpResponseMessage findAll()
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.TipoEventoes.Select(p => new { p.IdTipoEvento, p.TipoEvento1}).ToList()));

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


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

        /// <summary>
        /// Método para consultar un tipo de evento específico
        /// </summary>
        /// <param name="id">ID del tipo de evento</param>
        /// <returns>Mensaje satisfactorio y todos los tipos de eventos en caso de que logre
        /// consultar un Tipo de Evento.
        /// Mensaje de error en caso de que no logre consultar un tipo de evento</returns>
        [HttpGet]
        [Route("find/{id}")]
        public HttpResponseMessage find(int id)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.TipoEventoes.Select(p => new { p.IdTipoEvento, p.TipoEvento1}).Where(p => p.IdTipoEvento == id)));

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


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

        /// <summary>
        /// Método para crear un tipo de evento
        /// </summary>
        /// <param name="tipoEvento">Evento del modelo</param>
        /// <returns>Retorna mensaje positivo si logra insertar el modelo.
        /// Mensaje negativo si no lo lora insertar</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(TipoEvento tipoEvento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.TipoEventoes.Add(new TipoEvento
                {
                    IdTipoEvento = tipoEvento.IdTipoEvento,
                    TipoEvento1 = tipoEvento.TipoEvento1
                    

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

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
    }
}
Controlador Tipo Implemento

Code: Select all

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using VenALaU.Service.Models;

namespace VenALaU.Service.Controllers
{
    [RoutePrefix("api/TipoImplemento")]
    public class TipoImplementoController : ApiController
    {
        private DataContext db = new DataContext();

        /// <summary>
        /// Método para consultar todos los tipos de implemento
        /// </summary>
        /// <returns>Mensaje satisfactorio y todos los tipos de implemento en caso de que logre
        /// consultar todos los Tipos de implemento
        /// Mensaje de error en caso de que no logre consultar todos los tipos de implemento</returns>
        [HttpGet]
        [Route("findall")]
        public HttpResponseMessage findAll()
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.TipoImplementoes.Select(p => new { p.IdTipoImplemento, p.TipoImplemento1 }).ToList()));

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


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

        /// <summary>
        /// Método para consultar un tipo de implemento específico
        /// </summary>
        /// <param name="id">id del tipo de implemento</param>
        /// <returns>Mensaje satisfactorio y todos los tipos de implementos en caso de que logre
        /// consultar un Tipo de Implemento.
        /// Mensaje de error en caso de que no logre consultar un tipo de implemento</returns>
        [HttpGet]
        [Route("find/{id}")]
        public HttpResponseMessage find(int id)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(db.TipoImplementoes.Select(p => new { p.IdTipoImplemento, p.TipoImplemento1 }).Where(p => p.IdTipoImplemento == id)));

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


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

        /// <summary>
        /// Método para crear un tipo de implemento
        /// </summary>
        /// <param name="tipoImplemento">Tipo de Implemento del modelo</param>
        /// <returns>Retorna mensaje positivo si logra insertar el modelo.
        /// Mensaje negativo si no lo lora insertar</returns>
        [HttpPost]
        [Route("create")]
        public HttpResponseMessage create(TipoImplemento tipoImplemento)
        {
            try
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK);
                db.TipoImplementoes.Add(new TipoImplemento
                {
                    IdTipoImplemento = tipoImplemento.IdTipoImplemento,
                    TipoImplemento1 = tipoImplemento.TipoImplemento1


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

            }
            catch
            {

                return new HttpResponseMessage(HttpStatusCode.BadGateway);
            }

        }
    }
}
Continuación de Evidencias en el siguiente Post
Last edited by MariaIAF on Thu Sep 20, 2018 9:41 am, edited 1 time in total.
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Tue Sep 18, 2018 2:29 pm

Sprint 7: 6-19 de Septiembre
Continuación del post anterior :!:

Código-Aplicación Móvil
Vista Cursos Promocionales

Code: Select all

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="VenALaU.Views.CursosPage"
             Title="Cursos Promocionales"
             BindingContext="{Binding Main,Source={StaticResource Locator}}">
    <ContentPage.Content>
        <StackLayout
            BindingContext="{Binding NewCourse}">
            <Picker  
                ItemsSource="{Binding DayTypes}"
                ItemDisplayBinding="{Binding Day1}"
                Grid.Row="3"
                Grid.Column="1"
                SelectedIndex="{Binding SelectedDayType}"
                Title="Seleccione Dia...">
            </Picker>
            
            <ListView 
                BackgroundColor="Silver"
                HasUnevenRows="true" 
                IsPullToRefreshEnabled="true"
                ItemsSource="{Binding Courses}"
                SeparatorVisibility="None"
                IsRefreshing="{Binding IsRefreshing, Mode=TwoWay}"
                RefreshCommand="{Binding RefreshCommand}"
                >
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <ViewCell>
                            <Frame
                                CornerRadius="20"
                                HasShadow="true"
                                Margin="5">
                                <Frame.GestureRecognizers>
                                    <TapGestureRecognizer Command="{Binding SelectEventCommand}"/>
                                </Frame.GestureRecognizers>
                                <Grid>
                                    <Grid.ColumnDefinitions>
                                        <ColumnDefinition Width="Auto"/>
                                        <ColumnDefinition Width="*"/>
                                        <ColumnDefinition Width="Auto"/>
                                    </Grid.ColumnDefinitions>
                                    <StackLayout 
                                        Grid.Column="1"
                                        VerticalOptions="Center">
                                        <Label 
                                            FontAttributes="Bold"
                                            FontSize="Medium" 
                                            Text="{Binding Name}"
                                            TextColor="Black"
                                            FontFamily="{StaticResource NormalFont}">
                                        </Label>
                                        <Label 
                                            FontAttributes="Bold"
                                            FontSize="Medium" 
                                            Text="{Binding Hour}"
                                            TextColor="Black"
                                            FontFamily="{StaticResource NormalFont}">
                                        </Label>

                                    </StackLayout>
                                    <Image 
                                        Grid.Column="2"
                                        HorizontalOptions="End" 
                                        Source="chevron">
                                    </Image>
                                </Grid>
                            </Frame>
                        </ViewCell>
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>

        </StackLayout>
    </ContentPage.Content>
</ContentPage>
ViewModel Cursos

Code: Select all

using GalaSoft.MvvmLight.Command;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Windows.Input;
using VenALaU.Models;
using VenALaU.Services;
using Xamarin.Forms;

namespace VenALaU.ViewModels
{
    public class CoursesViewModel : BaseViewModel
    {
        #region Services
        private ApiService apiService;
        #endregion

        #region Attributes
        private ObservableCollection<CourseItemViewModel> courses;
        private ObservableCollection<DayTypeItemViewModel> dayTypes;
        private DialogService dialogService;
        private int dayId;
        private string day1;

        private string name;
        private int courseId;
        private int dayId1;
        private string hour; 
        private int spaceCourseId;
        private int instructorId;
        private bool isRefreshing;

        private int selectedDayType;
        #endregion

        #region Events
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        #region Properties
        public ObservableCollection<CourseItemViewModel> Courses
        {
            get { return this.courses; }
            set { SetValue(ref this.courses, value); }
        }
        public ObservableCollection<DayTypeItemViewModel> DayTypes
        {
            get;
            set;
        }
        public bool IsRefreshing
        {
            get { return this.isRefreshing; }
            set { SetValue(ref this.isRefreshing, value); }
        }


        public int DayId
        {
            set
            {
                if (dayId != value)
                {
                    dayId = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("DayId"));
                }
            }
            get
            {
                return dayId;
            }
        }
        public String Name
        {
            set
            {
                if (name != value)
                {
                    name = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
                }
            }
            get
            {
                return name;
            }
        }
        public String Hour
        {
            set
            {
                if (hour != value)
                {
                    hour = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Hour"));
                }
            }
            get
            {
                return hour;
            }
        }

        public int SelectedDayType
        {
            set
            {
                if (selectedDayType != value)
                {
                    selectedDayType = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SelectedDayType"));
                    LoadCourseByDay(selectedDayType +1);
                }
                else
                {
                    LoadCourseByDay(selectedDayType + 1);
                }
            }
            get
            {
                return (selectedDayType+1);
            }
        }


        #endregion

        #region Constructors
        /// <summary>
        /// Constructor de la clase CoursesViewModel
        /// Instancia las ObservableCollection que servirán para mostrar los cursos
        /// en la ListView de la vista. 
        /// Se llaman a los métodos para cargar los días al Picker y los cursos al
        /// ListView
        /// </summary>
        public CoursesViewModel()
        {
            this.apiService = new ApiService();
            DayTypes = new ObservableCollection<DayTypeItemViewModel>();
            Courses = new ObservableCollection<CourseItemViewModel>();
            dialogService = new DialogService();
            LoadDay();
            LoadCourse();
            

        }
        #endregion

        #region Methods

        /// <summary>
        /// Realiza la consulta al servicio y verifica si hay conexión para consultar los dias
        /// </summary>
        private async void LoadDay()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var dia = await apiService.Get<Day>(apiVenALaU, "/api", "/Dia/findall");
            if (!dia.IsSuccess)
            {
                await dialogService.ShowMessage("Error", dia.Message);
                return;
            }
            ReloadDay((List<Day>)dia.Result);
        }

        /// <summary>
        /// Método que recibe una lista de días y selecciona los datos necesarios para añadirlos a la 
        /// ObservableCollection DayTypes, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="dia">Lista con los días</param>
        private void ReloadDay(List<Day> dia)
        {
            DayTypes.Clear();
            foreach (var dias in dia)
            {

                DayTypes.Add(new DayTypeItemViewModel
                {
                    Day1 = dias.Day1
                });
            }
        }

        /// <summary>
        /// Realiza la consulta al servicio y verifica si hay conexión para consultar los cursos
        /// </summary>
        private async void LoadCourse()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var course = await apiService.Get<Courses>(apiVenALaU, "/api/CursoPromocional", "/findall");
            this.IsRefreshing = false;
            if (!course.IsSuccess)
            {
                await dialogService.ShowMessage("Error", course.Message);
                return;
            }
            ReloadCourse((List<Courses>)course.Result);
        }

        /// <summary>
        /// Método que recibe una lista de cursos y selecciona los datos necesarios para añadirlos a la 
        /// ObservableCollection Courses, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="course">Lista con los cursos</param>
        private void ReloadCourse(List<Courses> course)
        {
            Courses.Clear();
            foreach (var courses in course.OrderBy(c => c.Name))
            {

                Courses.Add(new CourseItemViewModel
                {
                    Name = courses.Name,
                    Hour = courses.Hour
                });
            }
            this.IsRefreshing = false;
        }

        /// <summary>
        /// Método que recibe un tipo de día y realiza la consulta al servicio de los cursos por
        /// un día determinado
        /// </summary>
        /// <param name="param">dia seleccionado en el picker</param>
        private async void LoadCourseByDay(int param)
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var course = await apiService.Get<Courses>(apiVenALaU, "/api/CursoPromocional", "/findByDay/"+(param));
            if (!course.IsSuccess)
            {
                this.IsRefreshing = false;
                await dialogService.ShowMessage("Error", course.Message);
                return;
            }
            ReloadCourseByDay((List<Courses>)course.Result);
        }

        /// <summary>
        /// Método que recibe una lista de cursos por tipo y selecciona los datos 
        /// necesarios añadirlos a la ObservableCollection Courses, que posteriormente los 
        /// añadirá al control asociado en la Vista
        /// </summary>
        /// <param name="course">Lista de cursos por tipo</param>
        private void ReloadCourseByDay(List<Courses> course)
        {
            this.IsRefreshing = true;
            Courses.Clear();
            foreach (var courses in course.OrderBy(c => c.Name))
            {

                Courses.Add(new CourseItemViewModel
                {
                    Name = courses.Name,
                    Hour = courses.Hour
                });
            }
            this.IsRefreshing = false;
        }
        #endregion
        #region Commands
        /// <summary>
        /// Comando para refrescar la lista
        /// </summary>
        public ICommand RefreshCommand
        {
            get
            {
                return new RelayCommand(LoadCourse);
            }
        }
        #endregion

    }
}

Vista Eventos

Code: Select all

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="VenALaU.Views.EventsPage"
             Title="Eventos"
             BindingContext="{Binding Main,Source={StaticResource Locator}}">
    <ContentPage.Content>
        <StackLayout
            BindingContext="{Binding NewEvents}">
            <Picker  
                ItemsSource="{Binding EventTypes}"
                ItemDisplayBinding="{Binding EventType1}"
                Grid.Row="3"
                Grid.Column="1"
                SelectedIndex="{Binding SelectedEventType}"
                Title="Seleccione Tipo de Evento...">
            </Picker>
            
            <ListView 
                BackgroundColor="Silver"
                HasUnevenRows="true" 
                IsPullToRefreshEnabled="true"
                ItemsSource="{Binding Events}"
                SeparatorVisibility="None"
                IsRefreshing="{Binding IsRefreshing, Mode=TwoWay}"
                RefreshCommand="{Binding RefreshCommand}"
                >
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <ViewCell>
                            <Frame
                                CornerRadius="20"
                                HasShadow="true"
                                Margin="5"
                                BorderColor="Orange">
                                <Frame.GestureRecognizers>
                                    <TapGestureRecognizer Command="{Binding SelectEventCommand}"/>
                                </Frame.GestureRecognizers>
                                <Grid>
                                    <Grid.ColumnDefinitions>
                                        <ColumnDefinition Width="Auto"/>
                                        <ColumnDefinition Width="*"/>
                                        <ColumnDefinition Width="Auto"/>
                                    </Grid.ColumnDefinitions>

                                    <StackLayout 
                                        Grid.Column="1"
                                        VerticalOptions="Center">
                                        <Label 
                                            FontAttributes="Bold"
                                            FontSize="Medium" 
                                            Text="{Binding Name}"
                                            TextColor="Black"
                                            FontFamily="{StaticResource NormalFont}">
                                        </Label>

                                    </StackLayout>
                                    <Image 
                                        Grid.Column="2"
                                        HorizontalOptions="End" 
                                        Source="chevron">
                                    </Image>
                                </Grid>
                            </Frame>
                        </ViewCell>
                    </DataTemplate>
                </ListView.ItemTemplate>
             </ListView>
        </StackLayout>
    </ContentPage.Content>
</ContentPage>
ViewModel Eventos

Code: Select all

using GalaSoft.MvvmLight.Command;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Text;
using System.Windows.Input;
using VenALaU.Models;
using VenALaU.Services;
using Xamarin.Forms;

namespace VenALaU.ViewModels
{
    public class EventsViewModel : BaseViewModel
    {
        #region Services
        private ApiService apiService;
        #endregion
        #region Attributes
        private ObservableCollection<EventItemViewModel> events;
        private ObservableCollection<EventTypeItemViewModel> eventTypes;
        private DialogService dialogService;
        private int id;
        private string name;
        private int idEventType;
        private string place;
        private DateTime eventDate;
        private string eventDetail;
        private string imageURL;
        private string publicDirected;
        private bool isRefreshing;
        private int typeEventID;
        private string eventType1;
        private int selectedEventType;
        #region Events
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion
        #endregion

        #region Properties

        public ObservableCollection<EventItemViewModel> Events
        {
            get { return this.events; }
            set { SetValue(ref this.events, value); }
        }
        public ObservableCollection<EventTypeItemViewModel> EventTypes
        {
            get { return this.eventTypes; }
            set { SetValue(ref this.eventTypes, value); }
        }
        public bool IsRefreshing
        {
            get { return this.isRefreshing; }
            set { SetValue(ref this.isRefreshing, value); }
        }


        public int Id
        {
            set
            {
                if (id != value)
                {
                    id = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Id"));
                }
            }
            get
            {
                return id;
            }
        }
        public String Name
        {
            set
            {
                if (name != value)
                {
                    name = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
                }
            }
            get
            {
                return name;
            }
        }
        public int IdEventType
        {
            set
            {
                if (idEventType != value)
                {
                    idEventType = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IdEventType"));
                }
            }
            get
            {
                return idEventType;
            }
        }
        public string Place
        {
            set
            {
                if (place != value)
                {
                    place = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Place"));
                }
            }
            get
            {
                return place;
            }
        }
        public DateTime EventDate
        {
            set
            {
                if (eventDate != value)
                {
                    eventDate = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EventDate"));
                }
            }
            get
            {
                return eventDate;
            }
        }
        public string EventDetail
        {
            set
            {
                if (eventDetail != value)
                {
                    eventDetail = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EventDetail"));
                }
            }
            get
            {
                return eventDetail;
            }
        }
        public string ImageURL
        {
            set
            {
                if (imageURL != value)
                {
                    imageURL = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("ImageURL"));
                }
            }
            get
            {
                return imageURL;
            }
        }
        public string PublicDirected
        {
            set
            {
                if (publicDirected != value)
                {
                    publicDirected = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("PublicDirected"));
                }
            }
            get
            {
                return publicDirected;
            }
        }

        public int TypeEventID
        {
            set
            {
                if (typeEventID != value)
                {
                    typeEventID = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TypeEventID"));
                }
            }
            get
            {
                return typeEventID;
            }
        }
        public string EventType1
        {
            set
            {
                if (eventType1 != value)
                {
                    eventType1 = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EventType1"));
                }
            }
            get
            {
                return eventType1;
            }
        }

        public int SelectedEventType
        {
            set
            {
                if (selectedEventType != value)
                {
                    selectedEventType = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SelectedEventType"));
                    LoadEventByType(selectedEventType + 1);
                }
                else
                {
                    LoadEventByType(selectedEventType + 1);
                }

            }
            get
            {
                return (selectedEventType + 1);
            }
        }




        #endregion

        #region Constructors

        /// <summary>
        /// Constructor de la clase EventsViewModel
        /// Instancia las ObservableCollection que servirán para mostrar los eventos
        /// en la ListView de la vista. 
        /// Se llaman a los métodos para cargar los tipos de eventos al Picker y los eventos al
        /// ListView
        /// </summary>
        public EventsViewModel()
        {
            this.apiService = new ApiService();
            EventTypes = new ObservableCollection<EventTypeItemViewModel>();
            Events = new ObservableCollection<EventItemViewModel>();

            dialogService = new DialogService();
            LoadEventType();
            LoadEvent();

        }



        #endregion

        #region Methods

        /// <summary>
        /// Realiza la consulta al servicio y verifica si hay conexión para consultar los eventos
        /// </summary>
        private async void LoadEvent()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var response = await apiService.Get<Event>(apiVenALaU, "api/Evento", "/findall");
            if (!response.IsSuccess)
            {
                await dialogService.ShowMessage(
                    "Error",
                    response.Message);
                return;
            }
            ReloadEvent((List<Event>)response.Result);
        }

        /// <summary>
        /// Método que recibe una lista de eventos y selecciona los datos necesarios añadirlos a la 
        /// ObservableCollection Events, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="theEvent">Lista con eventos</param>
        private void ReloadEvent(List<Event> theEvent)
        {
            Events.Clear();
            foreach (var evt in theEvent)
            {

                Events.Add(new EventItemViewModel
                {
                    Name = evt.Name,
                    ImageURL = evt.ImageURL,
                    EventDetail = evt.EventDetail,
                    PublicDirected = evt.PublicDirected,
                    EventDate = evt.EventDate
                });
            }
            this.IsRefreshing = false;

        }

        /// <summary>
        /// Verifica si hay conexión y realiza la consulta al servicio de los tipos de eventos
        /// </summary>
        private async void LoadEventType()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var response = await apiService.Get<EventType>(apiVenALaU, "api/TipoEvento", "/findall");
            if (!response.IsSuccess)
            {
                await dialogService.ShowMessage(
                    "Error",
                    response.Message);
                return;
            }
            ReloadEventType((List<EventType>)response.Result);
        }

        /// <summary>
        ///Método que recibe una lista de eventos y selecciona los datos necesarios añadirlos a la 
        /// ObservableCollection EventTypes, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="theEventType">Lista de tipos de evento</param>
        private void ReloadEventType(List<EventType> theEventType)
        {
            EventTypes.Clear();
            foreach (var evtype in theEventType)
            {

                EventTypes.Add(new EventTypeItemViewModel
                {
                    EventType1 = evtype.EventType1
                });
            }

        }

        /// <summary>
        /// Método que recibe un tipo de evento y realiza la consulta al servicio de los eventos por
        /// un tipo determinado de eventos
        /// </summary>
        /// <param name="eventType">Índice del picker para realizar la consulta por tipo</param>
        private async void LoadEventByType(int eventType)
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var response = await apiService.Get<Event>(apiVenALaU, "api/Evento", "/findByType/" + eventType);
            if (!response.IsSuccess)
            {
                await dialogService.ShowMessage(
                    "Error",
                    response.Message);
                return;
            }
            ReloadEventByType((List<Event>)response.Result);

        }

        /// <summary>
        /// Método que recibe una lista de eventos por tipo y selecciona los datos 
        /// necesarios añadirlos a la ObservableCollection Events, que posteriormente los 
        /// añadirá al control asociado en la Vista
        /// </summary>
        /// <param name="eventByType">Lista de eventos por tipo</param>
        private void ReloadEventByType(List<Event> eventByType)
        {
            this.IsRefreshing = true;

            Events.Clear();
            foreach (var evt in eventByType)
            {

                Events.Add(new EventItemViewModel
                {
                    //Id=evt.Id
                    Name = evt.Name,
                    ImageURL = evt.ImageURL,
                    EventDetail = evt.EventDetail,
                    PublicDirected = evt.PublicDirected,
                    EventDate = evt.EventDate
                });
            }
            this.IsRefreshing = false;

        }
        
        #endregion
        #region Commands

        /// <summary>
        /// Comando para refrescar la lista
        /// </summary>
        public ICommand RefreshCommand
        {
            get
            {
                return new RelayCommand(LoadEvent);
            }
        }
        #endregion
    }
}

Vista Implementos

Code: Select all

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="VenALaU.Views.ImplementosPage"
             Title="Implementos"
             BindingContext="{Binding Main,Source={StaticResource Locator}}">
    <ContentPage.Content>
        <StackLayout
            BindingContext="{Binding NewImplement}">
            <Picker  
                ItemsSource="{Binding ImplementTypes}"
                ItemDisplayBinding="{Binding ImplementType1}"
                Grid.Row="3"
                Grid.Column="1"
                SelectedIndex="{Binding SelectedImplementType}"
                Title="Seleccione Implemento...">
            </Picker>

            <ListView 
                BackgroundColor="Silver"
                HasUnevenRows="true" 
                IsPullToRefreshEnabled="true"
                ItemsSource="{Binding Implements}"
                SeparatorVisibility="None"
                IsRefreshing="{Binding IsRefreshing, Mode=TwoWay}"
                RefreshCommand="{Binding RefreshCommand}"
                >
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <ViewCell>
                            <Frame
                                CornerRadius="20"
                                HasShadow="true"
                                Margin="5">
                                <Frame.GestureRecognizers>
                                    <TapGestureRecognizer Command="{Binding SelectEventCommand}"/>
                                </Frame.GestureRecognizers>
                                <Grid>
                                    <Grid.ColumnDefinitions>
                                        <ColumnDefinition Width="Auto"/>
                                        <ColumnDefinition Width="*"/>
                                        <ColumnDefinition Width="Auto"/>
                                    </Grid.ColumnDefinitions>
                                    <StackLayout 
                                        Grid.Column="1"
                                        VerticalOptions="Center">
                                        <Label 
                                            FontAttributes="Bold"
                                            FontSize="Medium" 
                                            Text="{Binding Name}"
                                            TextColor="Black"
                                            FontFamily="{StaticResource NormalFont}">
                                        </Label>
                                        <Label 
                                            FontAttributes="Bold"
                                            FontSize="Medium" 
                                            Text="{Binding Quantity}"
                                            TextColor="Black"
                                            FontFamily="{StaticResource NormalFont}">
                                        </Label>

                                    </StackLayout>
                                </Grid>
                            </Frame>
                        </ViewCell>
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>

        </StackLayout>
    </ContentPage.Content>
</ContentPage>
ViewModel Implementos

Code: Select all

using GalaSoft.MvvmLight.Command;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Windows.Input;
using VenALaU.Models;
using VenALaU.Services;
using Xamarin.Forms;

namespace VenALaU.ViewModels
{
    public class ImplementViewModel : BaseViewModel
    {
        #region Services
        private ApiService apiService;
        #endregion

        #region Attributes
        private ObservableCollection<ImplementItemViewModel> implements;
        private ObservableCollection<ImplementTypeItemViewModel> impementsType;
        private DialogService dialogService;
        private int typeImplementId;
        private string implementType1;

        private string name;
        private int implementId;
        private int idImplementType;
        private string quantity;

        private int selectedDayType;

        private bool isRefreshing;
        private int selectedImplementType;
        #endregion

        #region Events
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        #region Properties
        public ObservableCollection<ImplementItemViewModel> Implements
        {
            get { return this.implements; }
            set { SetValue(ref this.implements, value); }
        }
        public ObservableCollection<ImplementTypeItemViewModel> ImplementTypes
        {
            get;
            set;
        }
        public bool IsRefreshing
        {
            get { return this.isRefreshing; }
            set { SetValue(ref this.isRefreshing, value); }
        }


        public string Quantity
        {
            set
            {
                if (quantity != value)
                {
                    quantity = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Quantity"));
                }
            }
            get
            {
                return quantity;
            }
        }
        public String Name
        {
            set
            {
                if (name != value)
                {
                    name = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Name"));
                }
            }
            get
            {
                return name;
            }
        }
        public int SelectedImplementType
        {
            set
            {
                if (selectedImplementType != value)
                {
                    selectedImplementType = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SelectedImplementType"));
                    LoadCourseByImplement(selectedImplementType + 1);
                }
                else
                {
                    LoadCourseByImplement(selectedImplementType + 1);
                }
            }
            get
            {
                return (selectedImplementType + 1);
            }
        }


        #endregion

        #region Constructors
        /// <summary>
        /// Constructor de la clase ImplementViewModel
        /// Instancia las ObservableCollection que servirán para mostrar los implementos
        /// en la ListView de la vista. 
        /// Se llaman a los métodos para cargar los tipos de implemento al Picker y los implementos al
        /// ListView
        /// </summary>
        public ImplementViewModel()
        {
            this.apiService = new ApiService();
            ImplementTypes = new ObservableCollection<ImplementTypeItemViewModel>();
            Implements = new ObservableCollection<ImplementItemViewModel>();
            dialogService = new DialogService();
            LoadImplementType();
            LoadImplement();


        }
        #endregion

        #region Methods

        /// <summary>
        /// Realiza la consulta al servicio y verifica si hay conexión para consultar los tipos de implemento
        /// </summary>
        private async void LoadImplementType()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var implementType = await apiService.Get<ImplementType>(apiVenALaU, "/api", "/TipoImplemento/findall");
            if (!implementType.IsSuccess)
            {
                await dialogService.ShowMessage("Error", implementType.Message);
                return;
            }
            ReloadImplementType((List<ImplementType>)implementType.Result);
        }

        /// <summary>
        /// Método que recibe una lista de tipos de implemento y selecciona los datos necesarios para añadirlos a la 
        /// ObservableCollection ImplementTypes, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="implementType">Lista con los tipos de implemento</param>
        private void ReloadImplementType(List<ImplementType> implementType)
        {
            ImplementTypes.Clear();
            foreach (var implements in implementType)
            {

                ImplementTypes.Add(new ImplementTypeItemViewModel
                {
                    ImplementType1 = implements.ImplementType1
                });
            }
        }

        /// <summary>
        /// Realiza la consulta al servicio y verifica si hay conexión para consultar los implementos
        /// </summary>
        private async void LoadImplement()
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var implement = await apiService.Get<Implement>(apiVenALaU, "/api/Implemento", "/findall");
            this.IsRefreshing = false;
            if (!implement.IsSuccess)
            {
                await dialogService.ShowMessage("Error", implement.Message);
                return;
            }
            ReloadImplement((List<Implement>)implement.Result);
        }

        /// <summary>
        /// Método que recibe una lista de implementos y selecciona los datos necesarios para añadirlos a la 
        /// ObservableCollection Implements, que posteriormente los añadirá al control asociado
        /// en la Vista
        /// </summary>
        /// <param name="course">Lista con los cursos</param>
        private void ReloadImplement(List<Implement> implement)
        {
            var cantidad = "";
            Implements.Clear();
            foreach (var implements in implement.OrderBy(c => c.Name))
            {
                if (implements.Quantity.Equals("0"))
                {
                    cantidad = "No disponible";
                }
                else
                {
                    cantidad = implements.Quantity;
                }
                Implements.Add(new ImplementItemViewModel
                {
                    Name = implements.Name,
                    Quantity = cantidad
                    
                });
            }
            this.IsRefreshing = false;
        }

        /// <summary>
        /// Método que recibe un tipo de implemento y realiza la consulta al servicio de los cursos por
        /// un implemento determinado
        /// </summary>
        /// <param name="param">implemento seleccionado en el picker</param>
        private async void LoadCourseByImplement(int param)
        {
            var connection = await this.apiService.CheckConnection();

            if (!connection.IsSuccess)
            {
                this.IsRefreshing = false;
                await Application.Current.MainPage.DisplayAlert(
                    "Error",
                    connection.Message,
                    "Ok");
                return;
            }
            this.IsRefreshing = true;
            var apiVenALaU = Application.Current.Resources["ServiceVenALaU"].ToString();
            var implement = await apiService.Get<Implement>(apiVenALaU, "/api/Implemento", "/findByType/" + (param));
            if (!implement.IsSuccess)
            {
                this.IsRefreshing = false;
                await dialogService.ShowMessage("Error", implement.Message);
                return;
            }
            ReloadImplementByType((List<Implement>)implement.Result);
        }

        /// <summary>
        /// Método que recibe una lista de implmentos por tipo y selecciona los datos 
        /// necesarios añadirlos a la ObservableCollection Implements, que posteriormente los 
        /// añadirá al control asociado en la Vista
        /// </summary>
        /// <param name="implement">Lista de implementos por tipo</param>
        private void ReloadImplementByType(List<Implement> implement)
        {
            var cantidad = "";
            this.IsRefreshing = true;
            Implements.Clear();
            foreach (var implementsType in implement.OrderBy(c => c.Name))
            {
                if (implementsType.Quantity.Equals("0"))
                {
                    cantidad = "No disponible";
                }
                else
                {
                    cantidad = implementsType.Quantity;
                }
                Implements.Add(new ImplementItemViewModel
                {
                    Name = implementsType.Name,
                    Quantity = cantidad
                });
            }
            this.IsRefreshing = false;
        }
        #endregion
        #region Commands
        /// <summary>
        /// Comando para refrescar la lista
        /// </summary>
        public ICommand RefreshCommand
        {
            get
            {
                return new RelayCommand(LoadImplement);
            }
        }
        #endregion

    }
}

Last edited by MariaIAF on Thu Sep 20, 2018 9:40 am, edited 1 time in total.
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

User avatar
MariaIAF
Posts: 25
Joined: Thu Jul 26, 2018 12:12 pm

Re: Ven a la U

Post by MariaIAF » Thu Sep 20, 2018 10:57 am

Sprint 7: 6-19 de Septiembre
Avance 19 de Septiembre

¿Qué hicimos
  • Lista de horarios de piscina
  • Lista de cursos promocionales
  • Lista de implementos deportivos
  • Detalle de eventos
¿Qué vamos a hacer?
Completar un faltante de este sprint
  • Detalle de cursos promocionales
¿Qué dificultades hemos tenido?
Falta de tiempo por carga académica, por lo que tuvimos que dejar un faltante

Burndown Chart
Image

Evidencias
Lista de horarios de piscina
Image

Lista de implementos deportivos con cantidad
Image

Lista de cursos promocionales
Image
Detalle de Eventos
Image
Maria Isabel Arcila Franco
maria.arcilaf@upb.edu.co

Gestión de Calidad de Software
Aplicaciones Móviles

Post Reply