public async Task <WrapperSimpleTypesDTO> CrearAnuncio(Anuncios anuncioParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
PlanesDTO configuracionPlan = await anuncianteRepo.BuscarConfiguracionAnuncioPorPlanAnunciante(anuncioParaCrear.CodigoAnunciante);
anuncioParaCrear.Vencimiento = DateTimeHelper.SumarDiasSegunTipoCalendario(anuncioParaCrear.FechaInicio, configuracionPlan.NumeroDiasVigenciaAnuncio);
anuncioParaCrear.NumeroApariciones = configuracionPlan.NumeroAparicionesAnuncio;
anuncianteRepo.CrearAnuncio(anuncioParaCrear);
WrapperSimpleTypesDTO wrapperCrearAnuncio = new WrapperSimpleTypesDTO();
wrapperCrearAnuncio.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperCrearAnuncio.Exitoso = true;
wrapperCrearAnuncio.ConsecutivoCreado = anuncioParaCrear.Consecutivo;
}
return(wrapperCrearAnuncio);
}
}
public async Task <WrapperSimpleTypesDTO> CrearPlan(PlanesDTO planParaCrear)
{
if (planParaCrear == null || planParaCrear.Archivos == null)
{
throw new ArgumentNullException("No puedes crear un plan si planParaCrear es nulo!.");
}
if (planParaCrear.Precio < 0 || planParaCrear.CodigoPeriodicidad <= 0 ||
(planParaCrear.VideosPerfil < 0 || planParaCrear.VideosPerfil > 1) ||
(planParaCrear.ServiciosChat < 0 | planParaCrear.ServiciosChat > 1) ||
(planParaCrear.ConsultaCandidatos < 0 || planParaCrear.ConsultaCandidatos > 1) ||
(planParaCrear.DetalleCandidatos < 0 || planParaCrear.DetalleCandidatos > 1) ||
(planParaCrear.ConsultaGrupos < 0 || planParaCrear.ConsultaGrupos > 1) ||
(planParaCrear.DetalleGrupos < 0 || planParaCrear.DetalleGrupos > 1) ||
(planParaCrear.ConsultaEventos < 0 || planParaCrear.ConsultaEventos > 1) ||
(planParaCrear.CreacionAnuncios < 0 || planParaCrear.CreacionAnuncios > 1) ||
(planParaCrear.EstadisticasAnuncios < 0 || planParaCrear.EstadisticasAnuncios > 1) ||
(planParaCrear.TiempoPermitidoVideo < AppConstants.MinimoSegundos || planParaCrear.TiempoPermitidoVideo > AppConstants.MaximoSegundos) ||
planParaCrear.NumeroCategoriasPermisibles <= 0 || planParaCrear.Archivos.ArchivoContenido == null ||
planParaCrear.TipoPerfil == TipoPerfil.SinTipoPerfil)
{
throw new ArgumentException("planParaCrear vacio y/o invalido!.");
}
else if (planParaCrear.TipoPerfil == TipoPerfil.Anunciante && (planParaCrear.NumeroDiasVigenciaAnuncio <= 0 && planParaCrear.NumeroAparicionesAnuncio <= 0))
{
throw new ArgumentException("planParaCrear vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperCrearPlan = await client.PostAsync <PlanesDTO, WrapperSimpleTypesDTO>("Planes/CrearPlan", planParaCrear);
return(wrapperCrearPlan);
}
public async Task <PlanesDTO> BuscarConfiguracionAnuncioPorPlanAnunciante(int codigoAnunciante)
{
PlanesDTO configuracionPlan = await _context.Anunciantes.Where(x => x.Consecutivo == codigoAnunciante)
.Select(x => new PlanesDTO
{
NumeroDiasVigenciaAnuncio = x.Personas.Usuarios.PlanesUsuarios.Planes.NumeroDiasVigenciaAnuncio,
NumeroAparicionesAnuncio = x.Personas.Usuarios.PlanesUsuarios.Planes.NumeroAparicionesAnuncio
}).FirstOrDefaultAsync();
return(configuracionPlan);
}
public override async void Init(object initData)
{
base.Init(initData);
Pago = initData as HistorialPagosModel;
// Significa que es un nuevo pago
if (Pago == null)
{
PlanesDTO planParaComprar = initData as PlanesDTO;
try
{
FacturaFormatoDTO facturaFormatoParaBuscar = new FacturaFormatoDTO
{
IdiomaDeLaFacturaFormato = App.IdiomaPersona,
CodigoPais = App.Persona.CodigoPais
};
FacturaFormatoDTO facturaFormato = await _pagosService.BuscarFacturaFormato(facturaFormatoParaBuscar);
if (facturaFormato != null)
{
HistorialPagosPersonasDTO historialPago = new HistorialPagosPersonasDTO();
historialPago.TextoFacturaFormato = facturaFormato.Texto;
historialPago.CodigoPais = App.Persona.CodigoPais;
historialPago.CodigoMoneda = App.Persona.Paises.CodigoMoneda;
historialPago.Paises = App.Persona.Paises;
historialPago.Monedas = App.Persona.Paises.Monedas;
historialPago.CodigoPersona = App.Persona.Consecutivo;
historialPago.Planes = planParaComprar;
historialPago.CodigoPlan = planParaComprar.Consecutivo;
historialPago.Precio = planParaComprar.Precio;
Pago = new HistorialPagosModel(historialPago);
RaisePropertyChanged(nameof(Pago));
}
else
{
await CoreMethods.DisplayAlert(SportsGoResources.Error, SportsGoResources.ErrorAlConsultarInfoPagos, "OK");
}
}
catch (Exception)
{
await CoreMethods.DisplayAlert(SportsGoResources.Error, SportsGoResources.ErrorAlConsultarInfoPagos, "OK");
}
}
}
public async Task <List <PlanesDTO> > ListarPlanesAdministrador(PlanesDTO planParaListar)
{
if (planParaListar == null)
{
throw new ArgumentNullException("No puedes listar los planes si planParaListar es nulo!.");
}
if (planParaListar.IdiomaBase == Idioma.SinIdioma || planParaListar.SkipIndexBase < 0 || planParaListar.TakeIndexBase <= 0)
{
throw new ArgumentException("planParaListar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
List <PlanesDTO> planBuscado = await client.PostAsync <PlanesDTO, List <PlanesDTO> >("Planes/ListarPlanesAdministrador", planParaListar);
return(planBuscado);
}
public async Task <PlanesDTO> BuscarPlanDefaultDeUnPerfil(PlanesDTO planParaBuscar)
{
if (planParaBuscar == null)
{
throw new ArgumentNullException("No puedes buscar un plan si planParaBuscar es nulo!.");
}
if (planParaBuscar.TipoPerfil == TipoPerfil.SinTipoPerfil)
{
throw new ArgumentException("planParaBuscar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
PlanesDTO planBuscado = await client.PostAsync("Planes/BuscarPlanDefaultDeUnPerfil", planParaBuscar);
return(planBuscado);
}
public async Task <PlanesDTO> BuscarPlan(PlanesDTO planParaBuscar)
{
if (planParaBuscar == null)
{
throw new ArgumentNullException("No puedes buscar un plan si planParaBuscar es nulo!.");
}
if (planParaBuscar.Consecutivo <= 0)
{
throw new ArgumentException("planParaBuscar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
PlanesDTO planBuscado = await client.PostAsync("Planes/BuscarPlan", planParaBuscar);
return(planBuscado);
}
public async Task <WrapperSimpleTypesDTO> EliminarPlan(PlanesDTO planParaEliminar)
{
if (planParaEliminar == null)
{
throw new ArgumentNullException("No puedes eliminar un plan si planParaEliminar es nulo!.");
}
if (planParaEliminar.Consecutivo <= 0 || planParaEliminar.CodigoArchivo <= 0)
{
throw new ArgumentException("planParaEliminar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperPlanParaEliminar = await client.PostAsync <PlanesDTO, WrapperSimpleTypesDTO>("Planes/EliminarPlan", planParaEliminar);
return(wrapperPlanParaEliminar);
}
public async Task <WrapperSimpleTypesDTO> DesasignarPlanDefault(PlanesDTO planParaDesasignar)
{
if (planParaDesasignar == null)
{
throw new ArgumentNullException("No puedes desasignar un plan default si planParaDesasignar es nulo!.");
}
if (planParaDesasignar.Consecutivo <= 0)
{
throw new ArgumentException("planParaDesasignar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperDesasignarPlanDefault = await client.PostAsync <PlanesDTO, WrapperSimpleTypesDTO>("Planes/DesasignarPlanDefault", planParaDesasignar);
return(wrapperDesasignarPlanDefault);
}
public async Task <WrapperSimpleTypesDTO> ModificarArchivoPlan(PlanesDTO planArchivoParaModificar)
{
if (planArchivoParaModificar == null)
{
throw new ArgumentNullException("No puedes modificar el archivo del plan si planArchivoParaModificar es nulo!.");
}
if (planArchivoParaModificar.CodigoArchivo <= 0 || planArchivoParaModificar.ArchivoContenido == null)
{
throw new ArgumentException("planArchivoParaModificar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperModificarArchivoPlan = await client.PostAsync <PlanesDTO, WrapperSimpleTypesDTO>("Planes/ModificarArchivoPlan", planArchivoParaModificar);
return(wrapperModificarArchivoPlan);
}
async Task CargarPlanes(int skipIndex, int takeIndex)
{
if (!NoHayNadaMasParaCargar)
{
PlanesDTO plan = new PlanesDTO
{
CodigoPaisParaBuscarMoneda = App.Persona.CodigoPais,
CodigoIdiomaUsuarioBase = App.Persona.CodigoIdioma,
TipoPerfil = App.Persona.TipoPerfil,
SkipIndexBase = skipIndex,
TakeIndexBase = takeIndex
};
if (IsNotConnected)
{
return;
}
List <PlanesDTO> listaPlanes = await _planesService.ListarPlanesPorIdioma(plan);
if (listaPlanes != null)
{
if (listaPlanes.Count > 0)
{
if (_planes == null)
{
_planes = new ObservableRangeCollection <PlanesDTO>(listaPlanes);
}
else
{
_planes.AddRange(listaPlanes);
}
RaisePropertyChanged(nameof(Planes));
}
else
{
NoHayNadaMasParaCargar = listaPlanes.Count <= 0;
}
}
}
}
async Task IniciarSesionUsuarioParaRegistrar(UsuariosDTO usuario)
{
if (IsNotConnected)
{
return;
}
WrapperSimpleTypesDTO wrapperUsuario = await _authService.VerificarSiUsuarioYaExiste(usuario);
if (!wrapperUsuario.Existe)
{
usuario.TipoPerfil = _tipoCuentaPerfil.TipoPerfil;
PersonasDTO personaParaCrear = new PersonasDTO
{
Usuarios = usuario,
TipoPerfil = _tipoCuentaPerfil.TipoPerfil,
IdiomaDeLaPersona = App.IdiomaPersona,
PersonaRecordandose = Recuerdame
};
PlanesDTO planParaBuscar = new PlanesDTO
{
TipoPerfil = _tipoCuentaPerfil.TipoPerfil
};
PlanesDTO planDefaultParaElPerfil = await _planesServices.BuscarPlanDefaultDeUnPerfil(planParaBuscar);
personaParaCrear.Usuarios.PlanesUsuarios = new PlanesUsuariosDTO
{
Planes = planDefaultParaElPerfil
};
App.Usuario = null;
App.Persona = null;
await CoreMethods.PushPageModel <InformacionPerfilPageModel>(personaParaCrear);
}
else
{
await CoreMethods.DisplayAlert(SportsGoResources.TituloAlerta, SportsGoResources.UsuarioRepetido, "OK");
}
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
PlanesDTO item = BindingContext as PlanesDTO;
if (item == null)
{
return;
}
UrlArchivo.Source = null;
if (!string.IsNullOrWhiteSpace(item.UrlArchivo))
{
UrlArchivo.Source = item.UrlArchivo;
}
else
{
UrlArchivo.Source = App.Current.Resources["RutaDefaultImagen"] as string;
}
AbreviaturaMoneda.Text = "(" + App.Persona.Paises.Monedas.AbreviaturaMoneda + "): ";
}
public async Task <JsonResult> GetListPlansByProfile(PlanesDTO plansToSearch)
{
Result <PlanesDTO> result = new Result <PlanesDTO>();
try
{
PlanesServices planService = new PlanesServices();
plansToSearch.IdiomaBase = plansToSearch.IdiomaBase == 0 ? UserLoggedIn().PersonaDelUsuario.IdiomaDeLaPersona : plansToSearch.IdiomaBase;
plansToSearch.CodigoTipoPerfil = plansToSearch.CodigoTipoPerfil == 0 ? UserLoggedIn().CodigoTipoPerfil : plansToSearch.CodigoTipoPerfil;
plansToSearch.CodigoPaisParaBuscarMoneda = plansToSearch.CodigoPaisParaBuscarMoneda == 0 ? UserLoggedIn().PersonaDelUsuario.CodigoPais : plansToSearch.CodigoPaisParaBuscarMoneda;
result.list = await planService.ListarPlanesPorIdioma(plansToSearch);
if (result.list == null)
{
return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(Json(Helper.returnErrorList(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
}
public async Task <Response <bool> > UpdateAsync(PlanesDTO modelDto)
{
var response = new Response <bool>();
try
{
var resp = _mapper.Map <Planes>(modelDto);
response.Data = await _Domain.UpdateAsync(resp);
if (response.Data)
{
response.IsSuccess = true;
response.Message = "Registro Exitoso!";
}
}
catch (Exception ex)
{
response.Data = false;
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
