public async Task <WrapperSimpleTypesDTO> CrearGrupo(GruposDTO grupoParaCrear)
{
if (grupoParaCrear == null || grupoParaCrear.Personas == null || grupoParaCrear.Personas.Usuarios == null || grupoParaCrear.CategoriasGrupos == null)
{
throw new ArgumentNullException("No puedes crear un grupo si grupoParaCrear, la persona, las categorias o el usuario del grupo es nulo!.");
}
else if (string.IsNullOrWhiteSpace(grupoParaCrear.Personas.Nombres) || grupoParaCrear.Personas.CodigoPais <= 0 || grupoParaCrear.Personas.TipoPerfil == TipoPerfil.SinTipoPerfil ||
grupoParaCrear.Personas.CodigoIdioma <= 0 || string.IsNullOrWhiteSpace(grupoParaCrear.Personas.Telefono) || string.IsNullOrWhiteSpace(grupoParaCrear.Personas.CiudadResidencia))
{
throw new ArgumentException("Persona de grupoParaCrear vacio y/o invalido!.");
}
else if (string.IsNullOrWhiteSpace(grupoParaCrear.Personas.Usuarios.Usuario) || string.IsNullOrWhiteSpace(grupoParaCrear.Personas.Usuarios.Clave) ||
string.IsNullOrWhiteSpace(grupoParaCrear.Personas.Usuarios.Email))
{
throw new ArgumentException("Usuario de grupoParaCrear vacio y/o invalido!.");
}
else if (grupoParaCrear.CategoriasGrupos.Count <= 0 || !grupoParaCrear.CategoriasGrupos.All(x => x.CodigoCategoria > 0))
{
throw new ArgumentException("Categorias de grupoParaCrear vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperCrearGrupo = await client.PostAsync <GruposDTO, WrapperSimpleTypesDTO>("Grupos/CrearGrupo", grupoParaCrear);
return(wrapperCrearGrupo);
}
public async Task <List <int> > ListarCodigoCategoriasDeUnGrupo(int codigoPersona)
{
GruposDTO grupo = await _context.Grupos.Where(x => x.CodigoPersona == codigoPersona)
.Select(x => new GruposDTO
{
CategoriasGrupos = x.CategoriasGrupos.Where(z => z.CodigoGrupo == x.Consecutivo)
.Select(z => new CategoriasGruposDTO
{
CodigoCategoria = z.CodigoCategoria,
}).ToList(),
})
.FirstOrDefaultAsync();
return(grupo.CategoriasGrupos.Select(x => x.CodigoCategoria).ToList());
}
async Task <WrapperSimpleTypesDTO> CrearGrupo()
{
GruposDTO grupoParaCrear = Persona.GrupoDeLaPersona;
grupoParaCrear.Personas = Persona;
GruposServices gruposServices = new GruposServices();
if (IsNotConnected)
{
return(null);
}
WrapperSimpleTypesDTO wrapper = await gruposServices.CrearGrupo(grupoParaCrear);
return(wrapper);
}
public async Task <WrapperSimpleTypesDTO> ModificarInformacionGrupo(GruposDTO grupoParaModificar)
{
if (grupoParaModificar == null)
{
throw new ArgumentNullException("No puedes modificar un grupo si grupoParaModificar es nulo!.");
}
if (grupoParaModificar.Consecutivo <= 0)
{
throw new ArgumentException("grupoParaModificar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperModificarGrupo = await client.PostAsync <GruposDTO, WrapperSimpleTypesDTO>("Grupos/ModificarInformacionGrupo", grupoParaModificar);
return(wrapperModificarGrupo);
}
public async Task <GruposDTO> BuscarGrupoPorCodigoGrupo(GruposDTO grupoParaBuscar)
{
if (grupoParaBuscar == null)
{
throw new ArgumentNullException("No puedes buscar un grupo si grupoParaBuscar es nulo!.");
}
if (grupoParaBuscar.Consecutivo <= 0)
{
throw new ArgumentException("grupoParaBuscar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
GruposDTO grupoBuscado = await client.PostAsync("Grupos/BuscarGrupoPorCodigoGrupo", grupoParaBuscar);
return(grupoBuscado);
}
public IActionResult Post([FromBody] GruposDTO grupo)
{
var nuevoGrupo = _grupos.CrearGrupo(grupo);
if (!ModelState.IsValid || grupo.usuarios.Length == 0)
{
return(BadRequest(ModelState));
}
else if (nuevoGrupo.Succes)
{
return(Created("api/grupos/", nuevoGrupo));
}
else
{
return(NotFound(nuevoGrupo));
}
}
/*CUANDO CREO UN GRUPO, TENGO QUE INSERTAR EN LA TABLA estado_de_preferencias el id_grupo y
* cantidad_usuarios_por_grupo(contar la cantidad de usuarios que agrego)
*/
public CrearGrupoResponseApi CrearGrupo(GruposDTO grupo)
{
var fechaString = DateTime.Today.ToString();
//Guardo dentro de fechaSinHora la fec1ha con formato Dia-Mes-Año
var fechaSinHora = fechaString.Split(' ').FirstOrDefault().Replace("/", "-");
try
{
Grupos grupos = new Grupos()
{
Nombre = grupo.NombreDelGrupo,
Imagen = grupo.Imagen,
FechaCreacion = fechaSinHora
};
context.Grupos.Add(grupos);
var usuarios = grupo.usuarios.Select(x => new GruposUsuarios()
{
IdUsuarios = x.IdUsuario,
IdGrupo = grupos.IdGrupo,
});
context.GruposUsuarios.AddRange(usuarios);
var cantidadDeUsuarios = grupo.usuarios.Count();
EstadoDePreferencias estadoDePreferencias = new EstadoDePreferencias
{
CantidadUsuariosPorGrupo = cantidadDeUsuarios,
IdGrupo = grupos.IdGrupo,
ContadorPreferenciasElegidas = 0,
ContadorDeVotos = 0
};
context.Add(estadoDePreferencias);
context.SaveChanges();
return(new CrearGrupoResponseApi(true, "Se guardo el grupo exitosamente"));
}
catch (Exception ex)
{
return(new CrearGrupoResponseApi(false, "Fallo al guardar los datos del grupo"));
}
}
public async Task <JsonResult> UpdatePerson(PersonasDTO person)
{
Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();
try
{
switch (person.TipoPerfil)
{
case TipoPerfil.Candidato:
CandidatosDTO candidateToUpdate = new CandidatosDTO();
candidateToUpdate = person.CandidatoDeLaPersona;
person.CandidatoDeLaPersona = null;
candidateToUpdate.Personas = person;
return(await CreateCandidate(candidateToUpdate));
case TipoPerfil.Grupo:
GruposDTO groupToUpdate = new GruposDTO();
groupToUpdate = person.GrupoDeLaPersona;
person.GrupoDeLaPersona = null;
groupToUpdate.Personas = person;
return(await CreateGroup(groupToUpdate));
case TipoPerfil.Representante:
RepresentantesDTO agentToUpdate = new RepresentantesDTO();
agentToUpdate = person.RepresentanteDeLaPersona;
person.RepresentanteDeLaPersona = null;
agentToUpdate.Personas = person;
return(await CreateAgent(agentToUpdate));
default:
result.Success = false;
result.Message = "No es un perfíl válido";
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
}
public BuscadorModel(GruposDTO grupo) : this(grupo.Personas, TipoBusqueda.Grupo)
{
}
public async Task <JsonResult> CreateGroup(GruposDTO group)
{
Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();
try
{
string newEmail = group.Personas.Usuarios.Email;
group.Personas.CodigoUsuario = UserLoggedIn().Consecutivo;
group.Personas.Usuarios = UserLoggedIn();
group.Personas.Usuarios.Email = newEmail;
GruposServices groupService = new GruposServices();
PersonasServices personService = new PersonasServices();
AuthenticateServices usuarioService = new AuthenticateServices();
if (group.Consecutivo != 0)
{
group.CategoriasGrupos = null;
result.obj = await personService.ModificarPersona(group.Personas); // Update person
if (result.obj != null)
{
result.obj = await groupService.ModificarInformacionGrupo(group); // Update group
}
if (result.obj != null)
{
result.obj = await usuarioService.ModificarEmailUsuario(group.Personas.Usuarios); // Update email user
}
if (result.obj != null)
{
UserLoggedIn().PersonaDelUsuario.IdiomaDeLaPersona = group.Personas.IdiomaDeLaPersona;
}
}
else
{
group.CategoriasGrupos.ToList().ForEach(c => c.Categorias = null);
result.obj = await groupService.CrearGrupo(group); // Create a new group
if (result.obj != null)
{
AuthenticateServices service = new AuthenticateServices();
UsuariosDTO userToValidate = UserLoggedIn();
userToValidate.Personas = null;
userToValidate.TiposPerfiles = null;
userToValidate.PlanesUsuarios = null;
var userAgent = await service.VerificarUsuario(userToValidate);
if (userAgent != null)
{
setUserLogin(userAgent);
}
}
}
if (result.obj == null)
{
return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
result.Message = "La información se ha guardado con éxito";
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
}