///<sumary>
///El metodo agregarTipoBeca recibe los parámetros necesarios para poder crear la instancia tipo beca
///Este envía los parámetros para poder crear un tipo de beca y recibe una instancia
///Envía el objeto nuevo al repositorio para agregarlo a la lista del repositorio respectiva.
///El objeto es enviado para ser agregado en la base de datos
///En caso de algún error se atrapa la excepción
///</sumary>
///<author>María Jesús Gutiérrez</author>
///<param name="descripcion">Esta es la descripción del tipo de beca</param>
///<param name="estado">Este es el estado en el que se encuentra el tipo de beca</param>
///<param name="nombre"> Este es el nombre del tipo de beca</param>
public TipoBeca agregarTipoBeca(string nombre, string estado, string descripcion)
{
try
{
TipoBeca objTipoBeca = new TipoBeca(nombre, estado, descripcion);
if (objTipoBeca.IsValid)
{
TipoBecaRepository.Instance.Insert(objTipoBeca);
return(objTipoBeca);
}
else
{
StringBuilder sb = new StringBuilder();
foreach (RuleViolation rv in objTipoBeca.GetRuleViolations())
{
sb.AppendLine(rv.ErrorMessage);
}
throw new ApplicationException(sb.ToString());
}
}
catch (Exception ex)
{
throw ex;
}
}
private static PlanPago CrearPlanPago(SMPorresEntities db, int idAlumno, int idCurso,
short porcentajeBeca, int modalidad, TipoBeca tipoBeca)
{
var curso = CursosRepository.ObtenerCursoPorId(idCurso);
var plan = new PlanPago
{
Id = db.PlanesPago.Any() ? db.PlanesPago.Max(c1 => c1.Id) + 1 : 1,
IdAlumno = idAlumno,
IdCurso = idCurso,
//Curso = curso,
CantidadCuotas = CursosRepository.ObtieneMaxCuota(modalidad), //Configuration.MaxCuotas,
NroCuota = CursosRepository.ObtieneMinCuota(modalidad), //1,
ImporteCuota = curso.ImporteCuota,
PorcentajeBeca = porcentajeBeca,
TipoBeca = (byte)tipoBeca,
Estado = (short)EstadoPlanPago.Vigente,
IdUsuarioEstado = Session.CurrentUser.Id,
FechaGrabacion = Configuration.CurrentDate,
IdUsuario = Session.CurrentUser.Id,
Modalidad = modalidad //curso.Modalidad
};
db.PlanesPago.Add(plan);
db.SaveChanges();
return(plan);
}
public void asignarBeneficio(TipoBeca objTipoBeca)
{
using (TransactionScope scope = new TransactionScope())
{
try
{
if (_insertItems.Count > 0)
{
foreach (Beneficio objBeneficio in _insertItems)
{
asignarBeneficioTipoBeca(objBeneficio, objTipoBeca);
}
}
scope.Complete();
}
catch (TransactionAbortedException ex)
{
throw ex;
}
catch (ApplicationException ex)
{
throw ex;
}
finally
{
Clear();
}
}
}
public static PlanPago Insertar(int idAlumno, int idCurso, short porcentajeBeca, int modalidad,
TipoBeca tipoBeca)
{
using (var db = new SMPorresEntities())
{
if (db.PlanesPago.Any(pp => pp.IdAlumno == idAlumno && pp.IdCurso == idCurso & pp.Estado == (short)EstadoPlanPago.Vigente))
{
throw new Exception("El alumno ya tiene un plan de pago vigente en el curso seleccionado.");
}
db.Database.Log = s => _log.Debug(s);
using (var trx = db.Database.BeginTransaction())
{
try
{
var plan = CrearPlanPago(db, idAlumno, idCurso, porcentajeBeca, modalidad, tipoBeca);
PagosRepository.CrearMatrícula(db, plan);
PagosRepository.CrearCuotas(db, plan, modalidad);
trx.Commit();
return(plan);
}
catch (Exception ex)
{
_log.Error(ex);
trx.Rollback();
throw;
}
}
}
}
/// <summary>
/// Trae un DataSet de la base de datos.
/// Por cada DataRow en el DataSet, instancia un beneficio.
/// </summary>
/// <author>Mathias Muller</author>
/// <returns>Una lista de beneficios</returns>
public IEnumerable <Beneficio> GetLista(TipoBeca objTipoBeca)
{
List <Beneficio> pbeneficio = null;
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(new SqlParameter("@Nombre", objTipoBeca.nombre));
DataSet ds = DBAccess.ExecuteSPWithDS(ref cmd, "Sp_consultarTipoBecaBeneficios");
if (ds.Tables[0].Rows.Count > 0)
{
pbeneficio = new List <Beneficio>();
foreach (DataRow dr in ds.Tables[0].Rows)
{
pbeneficio.Add(new Beneficio
{
Id = Convert.ToInt32(dr["idBeneficio"]),
Nombre = dr["Nombre"].ToString(),
Porcentaje = Convert.ToDouble(dr["Porcentaje"]),
Aplicacion = dr["Aplicabilidad"].ToString()
});
}
}
return(pbeneficio);
}
public static PlanPago Actualizar(int planDePagoId, short porcentajeBeca, TipoBeca tipoBeca)
{
using (var db = new SMPorresEntities())
{
var p = db.PlanesPago.Find(planDePagoId);
p.PorcentajeBeca = porcentajeBeca;
p.TipoBeca = (byte)tipoBeca;
db.SaveChanges();
return(p);
}
}
/// <summary>
/// Método que elimina un tipo de beca por medio de un nombre en específico.
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="pnombre">nombre de un tipo de beca que se envía por parámetro para eliminar un tipo de beca en específico</param>
public void eliminarTipoBeca(String pnombre)
{
try
{
TipoBeca objTipoBeca = ContenedorMantenimiento.Instance.crearTipoBeca(pnombre);
TipoBecaRepository.Instance.Delete(objTipoBeca);
}
catch (Exception ex)
{
throw ex;
}
}
//Crear TipoBeca
public async Task Create(TipoBeca TipoBeca)
{
try
{
_ctx.TipoBeca.Add(TipoBeca);
await _ctx.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
/// <summary>
/// Método que busca un tipo de beca por su nombre y trae el id que se relaciona a ese nombre del tipo de beca
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="pnombre">nombre del tipo de beca que es enviado por parámetro</param>
/// <returns>Retorna el id del tipo de beca de acuerdo al nombre enviado</returns>
public int idTipoBeca(string pnombre)
{
try
{
TipoBeca tmpTipo = buscarUnTipoBeca(pnombre);
return(tmpTipo.Id);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Método que modifica los beneficios asociados a un tipo de beca
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="listaBeneficios">envía por parámetro la lista de beneficios</param>
/// <param name="objTipoBeca">envíapor parámetro un objeto de tipo beca</param>
public void modificarBeneficios(List <Beneficio> listaBeneficios, TipoBeca objTipoBeca)
{
try {
BeneficioRepository.objTipoBeca = objTipoBeca;
foreach (Beneficio objBeneficio in listaBeneficios)
{
BeneficioRepository.Instance.Insert(objBeneficio);
}
BeneficioRepository.Instance.asignarBeneficio();
}
catch (Exception ex) {
throw ex;
}
}
/// <summary>
/// Método que modifica los requisitos asociados a un tipo de beca
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="listaRequisitos">lista de requisitos asociados a un tipo de beca en específico</param>
/// <param name="objTipoBeca">objeto de tipo de beca</param>
public void modificarRequisitos(List <Requisito> listaRequisitos, TipoBeca objTipoBeca)
{
try {
RequisitoRepository.objTipoBeca = objTipoBeca;
foreach (Requisito objRequisito in listaRequisitos)
{
RequisitoRepository.Instance.Update(objRequisito);
}
RequisitoRepository.Instance.asignarRequisito();
}
catch (Exception ex) {
throw ex;
}
}
/// <summary>
/// Método que inserta un alista de requisitos para asignarlos a un tipo de beca
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="listaRequisitos">lista de requisitos que es enviada por parámetro para asignar a un tipo de beca</param>
/// <param name="objTipoBeca">objeto de tipo de beca</param>
public void asignarRequisitoTipoBeca(List <Requisito> listaRequisitos, TipoBeca objTipoBeca)
{
try {
RequisitoRepository.objTipoBeca = objTipoBeca;
foreach (Requisito objRequisito in listaRequisitos)
{
RequisitoRepository.Instance.Insert(objRequisito);
}
RequisitoRepository.Instance.asignarRequisito(objTipoBeca);
}
catch (Exception ex) {
throw ex;
}
}
public IEnumerable <Requisito> mostrarRequisitoTB(TipoBeca ptipoBeca)
{
try {
if (RequisitoRepository.Instance.GetLista(ptipoBeca) == null)
{
throw new ApplicationException("El tipo de beca seleccionado no tiene requisitos asignados");
}
else
{
return(RequisitoRepository.Instance.GetLista(ptipoBeca));
}
}
catch (Exception ex) {
throw ex;
}
}
public void asignarBeneficioTipoBeca(Beneficio objBeneficio, TipoBeca objTipoBeca)
{
try
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(new SqlParameter("@idBeneficio", objBeneficio.Id));
cmd.Parameters.Add(new SqlParameter("@idTipoBeca", objTipoBeca.nombre));
DataSet ds = DBAccess.ExecuteSPWithDS(ref cmd, "Sp_insertarBeneficiosTiposBeca");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
throw ex;
}
}
//Actualizar TipoBeca
public async Task UpdateEstado(TipoBeca TipoBeca)
{
try
{
var _TipoBeca = await _ctx.TipoBeca.FirstOrDefaultAsync(e => e.TipoBecaId == TipoBeca.TipoBecaId);
if (_TipoBeca != null)
{
_TipoBeca.Estado = TipoBeca.Estado;
await _ctx.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
/// <summary>
/// Método que modifica los datos de un tipo de beca, busca los beneficios y requisitos que están asociados a un tipo de beca
/// vuelve a asignar a un tipo de beca los beneficios y requisitos marcados.
/// </summary>
/// <author>María Jesús Gutiérrez Calvo</author>
/// <param name="idTipoBeca">id tipo de beca a modificar</param>
/// <param name="pnombre">nombre del tipo de beca que se desea modificar</param>
/// <param name="pestado">estado a modificar en que se encuentra la beca (activo o inactivo)</param>
/// <param name="pdescripcion">descripción del tipo de beca que se desea modificar</param>
/// <param name="plistaBeneficios">lista de beneficios associados a un tipo de beca en específico</param>
/// <param name="plistaRequisitos">lista de requisitos asociados a un tipo de beca en específico</param>
public void modificarTipoBeca(int idTipoBeca, string pnombre, string pestado, string pdescripcion, List <int> plistaBeneficios, List <int> plistaRequisitos)
{
try
{
TipoBeca objTipoBeca = ContenedorMantenimiento.Instance.crearTipoBeca(idTipoBeca, pnombre, pestado, pdescripcion);
List <Beneficio> listaBeneficios = new List <Beneficio>();
List <Requisito> listaRequisitos = new List <Requisito>();
if (objTipoBeca.IsValid)
{
TipoBecaRepository.Instance.Update(objTipoBeca);
eliminarBeneficiosTipoBeca(idTipoBeca);
eliminarRequisitoTipoBeca(idTipoBeca);
foreach (int idBeneficio in plistaBeneficios)
{
Beneficio beneficio = new Beneficio(idBeneficio);
listaBeneficios.Add(beneficio);
}
foreach (int idRequisito in plistaRequisitos)
{
Requisito requisito = new Requisito(idRequisito);
listaRequisitos.Add(requisito);
}
asignarBeneficioTipoBeca(listaBeneficios, objTipoBeca);
asignarRequisitoTipoBeca(listaRequisitos, objTipoBeca);
}
else
{
StringBuilder sb = new StringBuilder();
foreach (RuleViolation rv in objTipoBeca.GetRuleViolations())
{
sb.AppendLine(rv.ErrorMessage);
}
throw new ApplicationException(sb.ToString());
}
}
catch (Exception ex)
{
throw ex;
}
}
public IEnumerable <Requisito> GetLista(TipoBeca objTipoBeca)
{
try {
List <Requisito> prequisito = null;
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(new SqlParameter("@Nombre", objTipoBeca.nombre));
DataSet ds = DBAccess.ExecuteSPWithDS(ref cmd, "Sp_consultarTipoBecaRequisito");
if (ds.Tables[0].Rows.Count > 0)
{
prequisito = new List <Requisito>();
foreach (DataRow dr in ds.Tables[0].Rows)
{
prequisito.Add(new Requisito
(
dr["Nombre"].ToString(),
dr["Descripcion"].ToString(),
Convert.ToInt32(dr["idRequisito"])
));
}
}
return(prequisito);
}
catch (SqlException ex)
{
numero = ex.Number;
mensaje = exceptions.validarExcepcion(numero);
throw new CustomExceptions.DataAccessException(mensaje, ex);
}
catch (Exception ex)
{
throw ex;
}
}
public void asignarRequisitoTipoBeca(Requisito objRequisito, TipoBeca objTipoBeca)
{
try
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(new SqlParameter("@idRequisito", objRequisito.Id));
cmd.Parameters.Add(new SqlParameter("@Nombre", objTipoBeca.nombre));
DataSet ds = DBAccess.ExecuteSPWithDS(ref cmd, "Sp_insertarRequisitoTipoBeca");
}
catch (SqlException ex)
{
numero = ex.Number;
mensaje = exceptions.validarExcepcion(numero);
throw new CustomExceptions.DataAccessException(mensaje, ex);
}
catch (Exception ex)
{
throw ex;
}
}
public TipoBeca crearTipoBeca(string pnombre)
{
TipoBeca objTipoBeca = new TipoBeca(pnombre);
return(objTipoBeca);
}
//crear TipoBeca
[HttpPost][Authorize] public async Task <IHttpActionResult> Create(TipoBeca TipoBeca)
{
try { log.Info(new MDCSet(this.ControllerContext.RouteData));
await _TipoBecaRepo.Create(TipoBeca);
return(Ok("Registro creado correctamente!")); }
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
public async Task <IHttpActionResult> UpdateEstado(TipoBeca TipoBeca)
{
try { log.Info(new MDCSet(this.ControllerContext.RouteData));
await _TipoBecaRepo.UpdateEstado(TipoBeca);
return(Ok()); }
catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e)); }
}
