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); } }