public async Task <WrapperSimpleTypesDTO> EliminarPlan(Planes planParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaEliminar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
bool esPlanDefault = await planRepository.BuscarSiPlanEsDefault(planParaEliminar);
if (esPlanDefault)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoPlanNuevo = planParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnPlan(notificacion);
PlanesContenidos planContenido = new PlanesContenidos
{
CodigoPlan = planParaEliminar.Consecutivo
};
planRepository.EliminarMultiplesPlanesContenidos(planContenido);
planRepository.EliminarPlan(planParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = planParaEliminar.CodigoArchivo
};
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarPlan = new WrapperSimpleTypesDTO();
wrapperEliminarPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlan.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlan.Exitoso = true;
}
return(wrapperEliminarPlan);
}
}
public async Task <WrapperSimpleTypesDTO> DesasignarPlanDefault(Planes planParaDesasignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaDesasignar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
Planes planExistente = await planRepository.DesasignarPlanDefault(planParaDesasignar);
WrapperSimpleTypesDTO wrapperDesasignarPlanDefault = new WrapperSimpleTypesDTO();
wrapperDesasignarPlanDefault.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperDesasignarPlanDefault.NumeroRegistrosAfectados > 0)
{
wrapperDesasignarPlanDefault.Exitoso = true;
}
return(wrapperDesasignarPlanDefault);
}
}
public void AddDeletePlane_Returns_CreatedResult_And_Plane_ShoudBe_AddedTo_Database_And_Then_ShouldBe_Deleted()
{
// Arrange
MSSQLContext context = new MSSQLContext();
PlaneTypesRepository planeTypesRepository = new PlaneTypesRepository();
PlanesRepository planesRepository = new PlanesRepository();
AircraftUnitOfWork uow = new AircraftUnitOfWork(planesRepository, planeTypesRepository, context);
AircraftService service = new AircraftService(uow);
PlanesController controller = new PlanesController(mapper.GetDefaultMapper(), service);
// add act
var newPlaneDTO = new PlaneDTO()
{
Lifetime = new TimeSpan(200, 0, 0, 0, 0),
Name = "Bf-109g",
ReleaseDate = new DateTime(1941, 1, 1, 0, 0, 0),
FlightHours = 560,
LastHeavyMaintenance = DateTime.Now,
PlaneTypeId = 1
};
var addResult = controller.AddPlane(newPlaneDTO);
// add assert
Assert.IsInstanceOf <CreatedResult>(addResult);
Assert.IsInstanceOf <PlaneDTO>((addResult as CreatedResult).Value);
// delete act
var addedPlaneDTO = (addResult as CreatedResult).Value as PlaneDTO;
var deleteResult = controller.DeletePlane(addedPlaneDTO.Id);
// delete assert
Assert.IsInstanceOf <OkResult>(deleteResult);
Assert.IsInstanceOf <NotFoundObjectResult>(controller.GetPlane(addedPlaneDTO.Id));
}
public void AddDeletePlaneType_Returns_CreatedResult_And_PlaneType_ShoudBe_AddedTo_Database_And_Then_ShouldBe_Deleted()
{
// Arrange
MSSQLContext context = new MSSQLContext();
PlaneTypesRepository planeTypesRepository = new PlaneTypesRepository();
PlanesRepository planesRepository = new PlanesRepository();
AircraftUnitOfWork uow = new AircraftUnitOfWork(planesRepository, planeTypesRepository, context);
AircraftService service = new AircraftService(uow);
PlaneTypesController controller = new PlaneTypesController(mapper.GetDefaultMapper(), service);
// add act
var newPlaneTypeDTO = new PlaneTypeDTO()
{
Capacity = 100,
CargoCapacity = 5000,
Model = "Hurricane"
};
var addResult = controller.AddPlaneType(newPlaneTypeDTO);
// add assert
Assert.IsInstanceOf <CreatedResult>(addResult);
Assert.IsInstanceOf <PlaneTypeDTO>((addResult as CreatedResult).Value);
// delete act
var addedPlaneTypeDTO = (addResult as CreatedResult).Value as PlaneTypeDTO;
var deleteResult = controller.DeletePlaneType(addedPlaneTypeDTO.Id);
// delete assert
Assert.IsInstanceOf <OkResult>(deleteResult);
Assert.IsInstanceOf <NotFoundObjectResult>(controller.GetPlaneType(addedPlaneTypeDTO.Id));
}
public async Task <List <PlanesContenidos> > ListarContenidoDeUnPlan(PlanesContenidos planContenidoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
List <PlanesContenidos> listaPlanes = await planesRepo.ListarContenidoDeUnPlan(planContenidoParaListar);
return(listaPlanes);
}
}
public async Task <PlanesContenidos> BuscarPlanContenido(PlanesContenidos planContenidoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
PlanesContenidos planContenidoBuscado = await planesRepo.BuscarPlanContenido(planContenidoParaBuscar);
return(planContenidoBuscado);
}
}
public async Task <List <PlanesDTO> > ListarPlanesAdministrador(Planes planParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
List <PlanesDTO> listaPlanes = await planRepository.ListarPlanesPorIdioma(planParaListar);
return(listaPlanes);
}
}
public async Task <Planes> BuscarPlanDefaultDeUnPerfil(Planes planParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
Planes planExistente = await planRepository.BuscarPlanDefaultDeUnPerfil(planParaBuscar);
return(planExistente);
}
}
public PlanesService()
{
_airportPlanesRepository = new PlanesRepository();
var mapperConfig = new MapperConfiguration(cfg =>
{
cfg.CreateMap <PlaneModel, Plane>();
cfg.CreateMap <PlaneModel, Plane>().ReverseMap();
});
_mapper = new Mapper(mapperConfig);
}
public void SheduleDeleteDeparture_When_All_Args_IsOk_When_Should_Return_CreatedResult_And_Add_Departure_To_dB_And_Then_Delete()
{
// Arrange
#region ControllerInit
MSSQLContext context = new MSSQLContext();
PlaneTypesRepository planeTypesRepository = new PlaneTypesRepository();
PlanesRepository planesRepository = new PlanesRepository();
AircraftUnitOfWork uow = new AircraftUnitOfWork(planesRepository, planeTypesRepository, context);
AircraftService service = new AircraftService(uow);
CrewsRepository crewsRepository = new CrewsRepository();
PilotsRepository pilotsRepository = new PilotsRepository();
StewardessesRepository stewardessesRepository = new StewardessesRepository();
CrewingUnitOfWork cuow = new CrewingUnitOfWork(crewsRepository, pilotsRepository, stewardessesRepository, context);
CrewingService crewingService = new CrewingService(cuow);
FlightsRepository flightRepository = new FlightsRepository();
DeparturesRepository departuresRepository = new DeparturesRepository();
TicketsRepository ticketsRepository = new TicketsRepository();
FlightOperationsUnitOfWork flightOpUow = new FlightOperationsUnitOfWork(flightRepository, ticketsRepository, departuresRepository, context);
FlightOperationsService flightOpeService = new FlightOperationsService(flightOpUow);
AiroportService airportService = new AiroportService(service, crewingService, flightOpeService);
AirportController controller = new AirportController(mapper.GetDefaultMapper(), airportService);
#endregion
var departureDto = new DepartureDTO()
{
CrewId = crewId,
DepartureTime = new DateTime(2018, 8, 10, 11, 0, 0),
PlaneId = 2,
FlightId = 1
};
var addResult = controller.SheduleDeparture(departureDto);
// add assert
Assert.IsInstanceOf <CreatedResult>(addResult);
Assert.IsInstanceOf <DepartureDTO>((addResult as CreatedResult).Value);
// delete act
var addedDepartureDTO = (addResult as CreatedResult).Value as DepartureDTO;
var deleteResult = controller.DeleteDeparture(addedDepartureDTO.Id);
// delete assert
Assert.IsInstanceOf <OkResult>(deleteResult);
Assert.IsNull(departuresRepository.Get(addedDepartureDTO.Id));
}
public async Task <WrapperSimpleTypesDTO> VerificarSiPlanSoportaLaOperacion(PlanesUsuarios planUsuarioParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
bool esPosible = await planRepository.VerificarSiPlanSoportaLaOperacion(planUsuarioParaBuscar, planUsuarioParaBuscar.TipoOperacionBase);
WrapperSimpleTypesDTO wrapperVerificarPlanOperacion = new WrapperSimpleTypesDTO
{
EsPosible = esPosible
};
return(wrapperVerificarPlanOperacion);
}
}
public async Task <WrapperSimpleTypesDTO> CrearHistorialPagoPersona(HistorialPagosPersonas historialPagoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
bool existePagoEnTramite = await pagosRepo.VerificarQueNoExistaUnPagoEnTramite(historialPagoParaCrear);
if (existePagoEnTramite)
{
throw new InvalidOperationException("Ya existe un pago en tramite, espera por la aprobacion o cancelalo si esta en pendiente!.");
}
historialPagoParaCrear.FechaPago = DateTime.Now;
historialPagoParaCrear.EstadoDelPago = EstadoDeLosPagos.EsperaPago;
Monedas monedaDelPais = await pagosRepo.BuscarMonedaDeUnPais(historialPagoParaCrear.CodigoPais);
historialPagoParaCrear.CodigoMoneda = monedaDelPais.Consecutivo;
PlanesRepository planRepo = new PlanesRepository(context);
decimal? precioDelPlan = await planRepo.BuscarPrecioDeUnPlan(historialPagoParaCrear.CodigoPlan);
historialPagoParaCrear.Precio = precioDelPlan.Value;
historialPagoParaCrear.Paises = null;
historialPagoParaCrear.Monedas = null;
historialPagoParaCrear.Personas = null;
historialPagoParaCrear.Planes = null;
historialPagoParaCrear.EstadoPago = null;
pagosRepo.CrearHistorialPagoPersona(historialPagoParaCrear);
WrapperSimpleTypesDTO wrapperCrearHistorialPagoPersona = new WrapperSimpleTypesDTO();
wrapperCrearHistorialPagoPersona.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearHistorialPagoPersona.NumeroRegistrosAfectados > 0)
{
wrapperCrearHistorialPagoPersona.Exitoso = true;
wrapperCrearHistorialPagoPersona.ConsecutivoCreado = historialPagoParaCrear.Consecutivo;
}
return(wrapperCrearHistorialPagoPersona);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoriaCandidato(CategoriasCandidatos categoriaCandidatoParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
HabilidadesCandidatos habilidadParaBorrar = new HabilidadesCandidatos
{
CodigoCategoriaCandidato = categoriaCandidatoParaBorrar.Consecutivo
};
habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
int?codigoCandidato = await categoriasRepo.BuscarCodigoCandidatoDeUnaCategoriaCandidato(categoriaCandidatoParaBorrar.Consecutivo);
if (!codigoCandidato.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo del candidato para borrar la categoria y modificar el plan!.");
}
categoriasRepo.EliminarCategoriaCandidato(categoriaCandidatoParaBorrar);
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanExistente = await planRepo.BuscarCodigoPlanUsuarioPorCodigoCandidato(codigoCandidato.Value);
if (!codigoPlanExistente.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el plan del candidato para crear la categoria para el!.");
}
// Se "BAJA" el contador de categorias 1
PlanesUsuarios planUsuarioExistente = await planRepo.ModificarNumeroCategoriasUsadas(codigoPlanExistente.Value, -1);
WrapperSimpleTypesDTO wrapperEliminarCategoriaCandidato = new WrapperSimpleTypesDTO();
wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoriaCandidato.Exitoso = true;
}
return(wrapperEliminarCategoriaCandidato);
}
}
public async Task <WrapperSimpleTypesDTO> CrearPlan(Planes planParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
planParaCrear.Archivos.CodigoTipoArchivo = (int)TipoArchivo.Imagen;
planRepository.CrearPlan(planParaCrear);
WrapperSimpleTypesDTO wrapperCrearPlan = new WrapperSimpleTypesDTO();
wrapperCrearPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearPlan.NumeroRegistrosAfectados > 0)
{
wrapperCrearPlan.Exitoso = true;
wrapperCrearPlan.ConsecutivoCreado = planParaCrear.Consecutivo;
if (planParaCrear.PlanDefault == (int)SiNoEnum.Si)
{
await planRepository.DesasignarPlanDefaultDeUnPerfilMenosActual(planParaCrear.Consecutivo, planParaCrear.CodigoTipoPerfil);
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.NuevoPlan,
CodigoPlanNuevo = planParaCrear.Consecutivo,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
wrapperCrearPlan.NumeroRegistrosAfectados += await context.SaveChangesAsync();
//if (notificacion.Consecutivo > 0)
//{
// TimeLineNotificaciones timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
//}
}
return(wrapperCrearPlan);
}
}
public async Task <WrapperSimpleTypesDTO> CrearPlanesContenidos(List <PlanesContenidos> planesContenidosParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
planesRepo.CrearPlanesContenidos(planesContenidosParaCrear);
WrapperSimpleTypesDTO wrapperCrearPlanesContenidos = new WrapperSimpleTypesDTO();
wrapperCrearPlanesContenidos.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearPlanesContenidos.NumeroRegistrosAfectados > 0)
{
wrapperCrearPlanesContenidos.Exitoso = true;
}
return(wrapperCrearPlanesContenidos);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarPlanContenido(PlanesContenidos planContenidoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
planesRepo.EliminarPlanContenido(planContenidoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarPlanContenido = new WrapperSimpleTypesDTO();
wrapperEliminarPlanContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlanContenido.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlanContenido.Exitoso = true;
}
return(wrapperEliminarPlanContenido);
}
}
public async Task <List <PlanesDTO> > ListarPlanesPorIdioma(Planes planParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
List <PlanesDTO> listaPlanes = await planRepository.ListarPlanesPorIdioma(planParaListar);
PagosRepository pagosRepo = new PagosRepository(context);
Monedas monedaDeLaPersona = await pagosRepo.BuscarMonedaDeUnPais(planParaListar.CodigoPaisParaBuscarMoneda);
if (monedaDeLaPersona.MonedaEnum != MonedasEnum.PesosColombianos)
{
Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();
QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, monedaDeLaPersona.AbreviaturaMoneda);
Monedas monedaBuscada = await pagosRepo.BuscarMoneda(monedaDeLaPersona.MonedaEnum);
if (exchangeEntity != null)
{
monedaBuscada.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
}
foreach (PlanesDTO planes in listaPlanes)
{
planes.Precio *= monedaBuscada.CambioMoneda;
}
}
try
{
// No es obligatorio para el paso que actualize el cambio de moneda
await context.SaveChangesAsync();
}
catch (Exception)
{
}
return(listaPlanes);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarPlanDefault(Planes planParaAsignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
Planes planExistente = await planRepository.AsignarPlanDefault(planParaAsignar);
// Para dejar el plan existente como el unico default
await planRepository.DesasignarPlanDefaultDeUnPerfilMenosActual(planExistente.Consecutivo, planExistente.CodigoTipoPerfil);
WrapperSimpleTypesDTO wrapperAsignarPlanDefault = new WrapperSimpleTypesDTO();
wrapperAsignarPlanDefault.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarPlanDefault.NumeroRegistrosAfectados > 0)
{
wrapperAsignarPlanDefault.Exitoso = true;
}
return(wrapperAsignarPlanDefault);
}
}
public async Task <PlanesUsuariosDTO> BuscarPlanUsuario(PlanesUsuarios planUsuarioParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
PlanesUsuariosDTO planUsuarioExistente = await planRepository.BuscarPlanUsuario(planUsuarioParaBuscar);
int?codigoUsuario = await planRepository.BuscarCodigoUsuarioPorCodigoPlanUsuario(planUsuarioExistente.Consecutivo);
PagosRepository pagosRepo = new PagosRepository(context);
Monedas monedaDelUsuario = await pagosRepo.BuscarMonedaDeUnUsuario(codigoUsuario.Value);
if (monedaDelUsuario.MonedaEnum != MonedasEnum.PesosColombianos)
{
Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();
QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, monedaDelUsuario.AbreviaturaMoneda);
if (exchangeEntity != null)
{
monedaDelUsuario.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
}
planUsuarioExistente.Planes.Precio *= monedaDelUsuario.CambioMoneda;
}
try
{
// No es obligatorio para el paso que actualize el cambio de moneda
await context.SaveChangesAsync();
}
catch (Exception)
{
}
return(planUsuarioExistente);
}
}
public async Task <WrapperSimpleTypesDTO> CrearCategoriaCandidatos(CategoriasCandidatos categoriaCandidatoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanExistente = await planRepo.BuscarCodigoPlanUsuarioPorCodigoCandidato(categoriaCandidatoParaCrear.CodigoCandidato);
if (!codigoPlanExistente.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el plan del candidato para crear la categoria para el!.");
}
// Se "SUBE" el contador de categorias 1
PlanesUsuarios planUsuarioExistente = await planRepo.ModificarNumeroCategoriasUsadas(codigoPlanExistente.Value, 1);
if (categoriaCandidatoParaCrear.HabilidadesCandidatos != null && categoriaCandidatoParaCrear.HabilidadesCandidatos.Count > 0)
{
categoriaCandidatoParaCrear.HabilidadesCandidatos = categoriaCandidatoParaCrear.HabilidadesCandidatos.Where(x => x.NumeroEstrellas > 0).ToList();
}
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
categoriasRepo.CrearCategoriaCandidatos(categoriaCandidatoParaCrear);
WrapperSimpleTypesDTO wrapperCrearCategoriaCandidato = new WrapperSimpleTypesDTO();
wrapperCrearCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearCategoriaCandidato.NumeroRegistrosAfectados > 0)
{
wrapperCrearCategoriaCandidato.Exitoso = true;
wrapperCrearCategoriaCandidato.ConsecutivoCreado = categoriaCandidatoParaCrear.Consecutivo;
}
return(wrapperCrearCategoriaCandidato);
}
}
public async Task <WrapperSimpleTypesDTO> CambiarDePlanUsuario(PlanesUsuarios planParaCambiar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
DateTime fechaVencimientoPlan = await planRepository.CalcularFechaVencimientoPlanUsuario(planParaCambiar);
planParaCambiar.Vencimiento = fechaVencimientoPlan;
PlanesUsuarios planUsuarioExistente = await planRepository.CambiarDePlanUsuario(planParaCambiar);
WrapperSimpleTypesDTO wrapperCambiarDePlanUsuario = new WrapperSimpleTypesDTO();
wrapperCambiarDePlanUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCambiarDePlanUsuario.NumeroRegistrosAfectados > 0)
{
wrapperCambiarDePlanUsuario.Exitoso = true;
wrapperCambiarDePlanUsuario.Vencimiento = fechaVencimientoPlan;
}
return(wrapperCambiarDePlanUsuario);
}
}
internal async Task <WrapperSimpleTypesDTO> CambiarPlanUsuarioADefaultPerfilPorVencimiento(PlanesUsuariosDTO planesUsuariosVencidoParaCambiar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
Planes planParaBuscar = new Planes
{
Consecutivo = planesUsuariosVencidoParaCambiar.CodigoPlan
};
int?codigoPerfil = await planesRepo.BuscarCodigoTipoPerfilDeUnPlan(planParaBuscar);
if (!codigoPerfil.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo de perfil!. BUUUUG");
}
TipoPerfil tipoPerfil = codigoPerfil.Value.ToEnum <TipoPerfil>();
int? codigoPlanDefault = await planesRepo.BuscarCodigoPlanDefault(tipoPerfil);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo del plan default para este perfil!. BUUUUG");
}
PlanesUsuarios planParaCambiar = new PlanesUsuarios
{
Consecutivo = planesUsuariosVencidoParaCambiar.Consecutivo,
CodigoPlanDeseado = codigoPlanDefault.Value
};
WrapperSimpleTypesDTO wrapper = await CambiarDePlanUsuario(planParaCambiar);
return(wrapper);
}
}
public async Task <WrapperSimpleTypesDTO> CrearCandidato(Candidatos candidatoParaCrear, string urlLogo, string urlBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanDefault = await planRepo.BuscarCodigoPlanDefault(TipoPerfil.Candidato);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No existe un plan default para los candidatos!.");
}
PlanesUsuarios planUsuarioDefault = new PlanesUsuarios
{
CodigoPlan = codigoPlanDefault.Value,
Adquisicion = DateTime.Now,
Vencimiento = DateTime.MaxValue
};
candidatoParaCrear.Personas.Usuarios.CuentaActiva = 0;
candidatoParaCrear.Personas.Usuarios.PlanesUsuarios = planUsuarioDefault;
candidatoParaCrear.Personas.Usuarios.TipoPerfil = candidatoParaCrear.Personas.TipoPerfil;
bool soyMenorDeEdad = DateTimeHelper.DiferenciaEntreDosFechasAños(DateTime.Now, candidatoParaCrear.FechaNacimiento) < AppConstants.MayoriaEdad;
// Si soy menor de edad y no tengo tutor o el tutor no tiene email, explota
if (soyMenorDeEdad && (candidatoParaCrear.CandidatosResponsables == null || string.IsNullOrWhiteSpace(candidatoParaCrear.CandidatosResponsables.Email)))
{
throw new InvalidOperationException("Falta informacion para el tutor, esta persona es menor de edad!.");
}
// Si no requiero tutor no lo guardo
if (soyMenorDeEdad)
{
candidatoParaCrear.CandidatosResponsables.Candidatos = null;
}
else
{
candidatoParaCrear.CandidatosResponsables = null;
}
candidatoParaCrear.Personas.Candidatos = null;
candidatoParaCrear.Personas.Paises = null;
candidatoParaCrear.Personas.Idiomas = null;
candidatoParaCrear.Generos = null;
candidatoParaCrear.Personas.Anunciantes = null;
candidatoParaCrear.Personas.Grupos = null;
candidatoParaCrear.Personas.Representantes = null;
candidatoParaCrear.Personas.Usuarios.Personas = null;
foreach (var categoriaCandidato in candidatoParaCrear.CategoriasCandidatos)
{
categoriaCandidato.Categorias = null;
categoriaCandidato.Candidatos = null;
foreach (var habilidadCandidato in categoriaCandidato.HabilidadesCandidatos)
{
habilidadCandidato.Habilidades = null;
}
}
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
candidatosRepo.CrearCandidato(candidatoParaCrear);
WrapperSimpleTypesDTO wrapperCrearCandidato = new WrapperSimpleTypesDTO();
wrapperCrearCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearCandidato.NumeroRegistrosAfectados > 0)
{
wrapperCrearCandidato.ConsecutivoCreado = candidatoParaCrear.Consecutivo;
wrapperCrearCandidato.ConsecutivoPersonaCreado = candidatoParaCrear.Personas.Consecutivo;
wrapperCrearCandidato.ConsecutivoUsuarioCreado = candidatoParaCrear.Personas.Usuarios.Consecutivo;
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string formatoEmail = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(candidatoParaCrear.Personas.CodigoIdioma, TipoFormatosEnum.ConfirmacionCuenta);
if (!string.IsNullOrWhiteSpace(formatoEmail))
{
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderNombre, candidatoParaCrear.Personas.Nombres);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenLogo, urlLogo);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenBanner, urlBanner);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlWeb, URL.UrlWeb);
string urlConfirmacionFormated = string.Format(URL.UrlWeb + @"Authenticate/ConfirmationOfRegistration?ID={0}&Language={1}", candidatoParaCrear.Personas.Usuarios.Consecutivo, candidatoParaCrear.Personas.CodigoIdioma);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlPaginaConfirmacion, urlConfirmacionFormated);
string tema = string.Empty;
switch (candidatoParaCrear.Personas.IdiomaDeLaPersona)
{
case Idioma.Español:
tema = "Confirmacion de registro";
break;
case Idioma.Ingles:
tema = "Confirmation of registration";
break;
case Idioma.Portugues:
tema = "Confirmação da inscrição";
break;
}
string emailParaEnviarConfirmacion = string.Empty;
// Si soy menor de edad el correo de confirmacion va hacia el tutor, si no va normal como siempre
if (soyMenorDeEdad)
{
emailParaEnviarConfirmacion = candidatoParaCrear.CandidatosResponsables.Email.Trim();
}
else
{
emailParaEnviarConfirmacion = candidatoParaCrear.Personas.Usuarios.Email.Trim();
}
// Recordar configurar la cuenta Gmail en este caso para que permita el logeo de manera insegura y poder mandar correos
// https://myaccount.google.com/lesssecureapps?pli=1
CorreoHelper correoHelper = new CorreoHelper(emailParaEnviarConfirmacion, AppConstants.CorreoAplicacion, AppConstants.ClaveCorreoAplicacion);
wrapperCrearCandidato.Exitoso = correoHelper.EnviarCorreoConHTML(formatoEmail, Correo.Gmail, tema, "SportsGo");
}
else
{
throw new InvalidOperationException("No hay formatos parametrizados para la confirmacion de la clave");
}
}
return(wrapperCrearCandidato);
}
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > ModificarEstadoPagoPersona(HistorialPagosPersonas historialPagoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
Notificaciones notificacion = null;
// Modifico el estado y la fecha de pago de este historial
HistorialPagosPersonas historialPagoExistente = await pagosRepo.ModificarEstadoPagoPersona(historialPagoParaModificar);
// Si el pago fue aprobado
if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.Aprobado)
{
PlanesRepository planRepo = new PlanesRepository(context);
// Busco el codigo de plan de la persona asignado cuando se registro
// Tabla PlanUsuarios, no es el plan en si, es el registro que lleva el control del plan para ese usuario
int?codigoPlanUsuario = await planRepo.BuscarCodigoPlanUsuarioPorCodigoPersona(historialPagoExistente.CodigoPersona);
PlanesBusiness planBusiness = new PlanesBusiness();
// Armo la entidad del nuevo plan
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = codigoPlanUsuario.Value,
CodigoPlanDeseado = historialPagoExistente.CodigoPlan
};
// Cambio el plan para esa persona
await planBusiness.CambiarDePlanUsuario(planUsuario);
// Si el pago que me es mandando esta marcado como PayU
// Actualizo las observaciones y la referencia del pago ya que es todo en uno
if (historialPagoParaModificar.EsPagoPorPayU)
{
historialPagoExistente.ReferenciaPago = historialPagoParaModificar.ReferenciaPago;
historialPagoExistente.ObservacionesCliente = historialPagoParaModificar.ObservacionesCliente;
}
// Armamos una notificacion para el nuevo plan
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanAprobado,
CodigoPlanNuevo = historialPagoExistente.CodigoPlan,
CodigoPersonaDestinoAccion = historialPagoExistente.CodigoPersona,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
else if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.Rechazado)
{
historialPagoExistente.ObservacionesAdministrador = historialPagoParaModificar.ObservacionesAdministrador;
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanRechazado,
CodigoPlanNuevo = historialPagoParaModificar.CodigoPlan,
CodigoPersonaDestinoAccion = historialPagoParaModificar.CodigoPersona,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
else if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.PendientePorAprobar)
{
if (string.IsNullOrWhiteSpace(historialPagoParaModificar.ReferenciaPago) || historialPagoParaModificar.CodigoArchivo <= 0)
{
throw new InvalidOperationException("No puedes reportar el pago de un plan si no ofreces la referencia del pago y/o el archivo");
}
historialPagoExistente.ReferenciaPago = historialPagoParaModificar.ReferenciaPago;
historialPagoExistente.CodigoArchivo = historialPagoParaModificar.CodigoArchivo;
historialPagoExistente.ObservacionesCliente = historialPagoParaModificar.ObservacionesCliente;
}
WrapperSimpleTypesDTO wrapperModificarEstadoPagoPersona = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperModificarEstadoPagoPersona.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarEstadoPagoPersona.NumeroRegistrosAfectados > 0)
{
wrapperModificarEstadoPagoPersona.Exitoso = true;
if (notificacion != null && notificacion.Consecutivo > 0)
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
if (notificacion.CodigoPersonaDestinoAccion.HasValue && notificacion.CodigoPersonaDestinoAccion > 0)
{
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacion.CodigoPersonaDestinoAccion.Value);
notificacion.CodigoIdiomaUsuarioBase = codigoIdioma;
}
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperModificarEstadoPagoPersona, timeLineNotificacion));
}
}
public PlaneRepositoryTest()
{
context = factory.GetUAAContext();
planesRepository = new PlanesRepository(context);
}
public async Task <WrapperSimpleTypesDTO> ModificarPlan(Planes planParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
planParaModificar.CodigoTipoPerfil = (int)planParaModificar.TipoPerfil;
Planes planExistente = await planRepository.ModificarPlan(planParaModificar);
if (planParaModificar.PlanesContenidos != null && planParaModificar.PlanesContenidos.Count > 0)
{
foreach (var planContenido in planParaModificar.PlanesContenidos)
{
if (planContenido.Consecutivo > 0)
{
await planRepository.ModificarPlanContenido(planContenido);
}
else
{
planRepository.CrearPlanContenido(planContenido);
}
}
}
// Si lo voy a desasignar como default valido que no me quede sin defaults
if (planExistente.PlanDefault == 1 && planParaModificar.PlanDefault == 0)
{
TipoPerfil tipoPerfil = planParaModificar.CodigoTipoPerfil.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
planExistente.PlanDefault = 0;
}
else
{
// Si lo voy a asignar entonces mando a desasignar todos los default de este perfil y procedo a asignar el que estoy modificando
if (planExistente.PlanDefault == 0 && planParaModificar.PlanDefault == 1)
{
await planRepository.DesasignarPlanDefaultDeUnPerfilMenosActual(planExistente.Consecutivo, planExistente.CodigoTipoPerfil);
}
planExistente.PlanDefault = planParaModificar.PlanDefault;
}
WrapperSimpleTypesDTO wrapperModificarPlan = new WrapperSimpleTypesDTO();
wrapperModificarPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarPlan.NumeroRegistrosAfectados > 0)
{
wrapperModificarPlan.Exitoso = true;
}
return(wrapperModificarPlan);
}
}
public async Task <WrapperSimpleTypesDTO> CrearGrupo(Grupos grupoParaCrear, string urlLogo, string urlBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanDefault = await planRepo.BuscarCodigoPlanDefault(TipoPerfil.Representante);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No existe un plan default para los grupo!.");
}
PlanesUsuarios planUsuarioDefault = new PlanesUsuarios
{
CodigoPlan = codigoPlanDefault.Value,
Adquisicion = DateTime.Now,
Vencimiento = DateTime.MaxValue
};
grupoParaCrear.Personas.Usuarios.CuentaActiva = 0;
grupoParaCrear.Personas.Usuarios.PlanesUsuarios = planUsuarioDefault;
grupoParaCrear.Personas.Usuarios.TipoPerfil = grupoParaCrear.Personas.TipoPerfil;
grupoParaCrear.Personas.Candidatos = null;
grupoParaCrear.Personas.Paises = null;
grupoParaCrear.Personas.Idiomas = null;
grupoParaCrear.Personas.Anunciantes = null;
grupoParaCrear.Personas.Grupos = null;
grupoParaCrear.Personas.Representantes = null;
grupoParaCrear.Personas.Usuarios.Personas = null;
grupoParaCrear.Personas.Paises = null;
grupoParaCrear.Personas.Idiomas = null;
foreach (var categoriaGrupo in grupoParaCrear.CategoriasGrupos)
{
categoriaGrupo.Categorias = null;
}
GruposRepository grupoRepository = new GruposRepository(context);
grupoRepository.CrearGrupo(grupoParaCrear);
WrapperSimpleTypesDTO wrapperCrearGrupo = new WrapperSimpleTypesDTO();
wrapperCrearGrupo.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearGrupo.NumeroRegistrosAfectados > 0)
{
wrapperCrearGrupo.Exitoso = true;
wrapperCrearGrupo.ConsecutivoCreado = grupoParaCrear.Consecutivo;
wrapperCrearGrupo.ConsecutivoPersonaCreado = grupoParaCrear.Personas.Consecutivo;
wrapperCrearGrupo.ConsecutivoUsuarioCreado = grupoParaCrear.Personas.Usuarios.Consecutivo;
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string formatoEmail = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(grupoParaCrear.Personas.CodigoIdioma, TipoFormatosEnum.ConfirmacionCuenta);
if (!string.IsNullOrWhiteSpace(formatoEmail))
{
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderNombre, grupoParaCrear.Personas.Nombres);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenLogo, urlLogo);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenBanner, urlBanner);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlWeb, URL.UrlWeb);
string urlConfirmacionFormated = string.Format(URL.UrlWeb + @"Authenticate/ConfirmationOfRegistration?ID={0}&Language={1}", grupoParaCrear.Personas.Usuarios.Consecutivo, grupoParaCrear.Personas.CodigoIdioma);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlPaginaConfirmacion, urlConfirmacionFormated);
string tema = string.Empty;
switch (grupoParaCrear.Personas.IdiomaDeLaPersona)
{
case Idioma.Español:
tema = "Confirmacion de registro";
break;
case Idioma.Ingles:
tema = "Confirmation of registration";
break;
case Idioma.Portugues:
tema = "Confirmação da inscrição";
break;
}
// Recordar configurar la cuenta Gmail en este caso para que permita el logeo de manera insegura y poder mandar correos
// https://myaccount.google.com/lesssecureapps?pli=1
CorreoHelper correoHelper = new CorreoHelper(grupoParaCrear.Personas.Usuarios.Email.Trim(), AppConstants.CorreoAplicacion, AppConstants.ClaveCorreoAplicacion);
wrapperCrearGrupo.Exitoso = correoHelper.EnviarCorreoConHTML(formatoEmail, Correo.Gmail, tema, "SportsGo");
}
else
{
throw new InvalidOperationException("No hay formatos parametrizados para la confirmacion de la clave");
}
}
return(wrapperCrearGrupo);
}
}
public async Task <List <TimeLineNotificaciones> > ListaTimeLineNotificaciones(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaFiltroBase != DateTime.MinValue)
{
buscador.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaFiltroBase);
}
List <NoticiasDTO> listaNoticias = await noticiaRepo.ListarNoticiasNotificaciones(buscador);
List <NotificacionesDTO> listarNotificaciones = await noticiaRepo.ListarNotificaciones(buscador);
List <TimeLineNotificaciones> listaTimeLineNotificacion = TimeLineNotificaciones.CrearListaTimeLineNotificaciones(listaNoticias, listarNotificaciones);
// Si no es minValue significa que estoy refrescando y no busco feed
if (buscador.FechaFiltroBase == DateTime.MinValue)
{
RssFeeds rssBuscado = await noticiaRepo.BuscarRssFeedPorCodigoIdioma(buscador.CodigoIdiomaUsuarioBase);
if (rssBuscado != null && !string.IsNullOrWhiteSpace(rssBuscado.UrlFeed))
{
FeedReader reader = new FeedReader();
IEnumerable <FeedItem> items = reader.RetrieveFeed(rssBuscado.UrlFeed);
if (items != null && items.Count() > 0)
{
IEnumerable <FeedItem> itemsFiltrados = items.Skip(buscador.SkipIndexBase).Take(buscador.TakeIndexBase);
if (itemsFiltrados != null && itemsFiltrados.Count() > 0)
{
foreach (FeedItem item in itemsFiltrados)
{
string url = item.Uri != null ? item.Uri.AbsoluteUri : string.Empty;
TimeLineNotificaciones timeLineRss = new TimeLineNotificaciones(item.Title, item.Summary, url, string.Empty, TipoNotificacionEnum.RssFeed);
listaTimeLineNotificacion.Insert(0, timeLineRss);
}
}
}
}
}
// Cuando Skip este en 0 significa que es la primera consulta, asi no repito su cosa de validar el plan
// si "FechaFiltroBase" tiene un valor significa que es pull to refresh y no debo agregar las validaciones del plan
if (buscador.SkipIndexBase == 0 && buscador.FechaFiltroBase == DateTime.MinValue)
{
PlanesRepository planRepo = new PlanesRepository(context);
AdministracionRepository adminRepo = new AdministracionRepository(context);
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = buscador.CodigoPlanUsuario,
IdiomaBase = buscador.IdiomaBase
};
PlanesUsuariosDTO planDelUsuarioValidado = await planRepo.BuscarPlanUsuario(planUsuario);
ImagenesPerfilAdministradores imagenperfil = await adminRepo.BuscarPrimeraImagenPerfilAdministrador();
long mesesFaltantesParaQueSeVenza = DateTimeHelper.DiferenciaEntreDosFechas(planDelUsuarioValidado.Vencimiento, DateTime.Now);
if (mesesFaltantesParaQueSeVenza == 1 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineCasiVence = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.EstaPorVencersePlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineCasiVence);
}
else if (mesesFaltantesParaQueSeVenza < 0 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineVencio = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.SeVencioPlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineVencio);
}
}
if (listaTimeLineNotificacion != null && listaTimeLineNotificacion.Count > 0)
{
foreach (var notificacion in listaTimeLineNotificacion)
{
notificacion.CreacionNotificacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.CreacionNotificacion);
notificacion.FechaInicioEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaInicioEvento);
notificacion.FechaTerminacionEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaTerminacionEvento);
notificacion.FechaVencimientoPlan = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaVencimientoPlan);
}
}
return(listaTimeLineNotificacion);
}
}
