public List <UsuarioDomainModel> GetUsuarios()
{
List <Usuario> usuarios = usuarioRepository.GetAll(p => p.idStatus == 1).ToList();
List <UsuarioDomainModel> usuarioDomainModels = new List <UsuarioDomainModel>();
foreach (Usuario item in usuarios)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
usuarioDomainModel.Nombres = item.Nombres;
usuarioDomainModel.Apellidos = item.Apellidos;
usuarioDomainModel.Email = item.Email;
foreach (var rol in item.Usuario_Rol)
{
UsuarioRolDomainModel usuarioRolDomainModel = new UsuarioRolDomainModel();
usuarioRolDomainModel.Rol = new RolDomainModel
{
Nombre = rol.Rol.Nombre
};
usuarioDomainModel.UsuarioRoles = new List <UsuarioRolDomainModel>();
usuarioDomainModel.UsuarioRoles.Add(usuarioRolDomainModel);
}
usuarioDomainModels.Add(usuarioDomainModel);
}
return(usuarioDomainModels);
}
/// <summary>
/// este metodo se encarga de validar el correo del usuario dentro de la plataforma para recuperar una contraseña
/// </summary>
/// <param name="email">el email el usuario a buscar dentro de la plataforma</param>
/// <returns>una entidad del tipo usuarioDomainModel</returns>
public UsuarioDomainModel ValidarEmailPasswordrecovery(string email)
{
UsuarioDomainModel usuarioDM = null;
try
{
if (!string.IsNullOrEmpty(email))
{
Usuario usuario = usuarioRepository.SingleOrDefault(p => p.Email == email && p.Status.strValor == Recursos.RecursosBusiness.USUARIO_ACTIVO);
if (usuario != null)
{
usuarioDM = new UsuarioDomainModel();
usuarioDM.Id = usuario.Id;
usuarioDM.Nombres = usuario.Nombres;
usuarioDM.Apellidos = usuario.Apellidos;
usuarioDM.Clave = usuario.Clave;
usuarioDM.Email = usuario.Email;
}
return(usuarioDM);
}
return(usuarioDM);
}
catch (Exception ex)
{
string mensajeErr = ex.Message;
usuarioDM = new UsuarioDomainModel();
usuarioDM.Id = 0;
return(usuarioDM);
}
}
public List <UsuarioDomainModel> GetUsuariosByCoordinador(int idCoordinador)
{
List <Usuario> usuarios = usuarioRepository.GetAll(p => p.idStatus == 1 && p.idUsuario == idCoordinador).ToList();
List <UsuarioDomainModel> usuarioDomainModels = new List <UsuarioDomainModel>();
foreach (Usuario item in usuarios)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
usuarioDomainModel.Id = item.Id;
usuarioDomainModel.Nombres = item.Nombres;
usuarioDomainModel.Apellidos = item.Apellidos;
usuarioDomainModel.Email = item.Email;
usuarioDomainModel.NombreCompleto = item.Nombres + item.Apellidos;
foreach (var rol in item.Usuario_Rol)
{
UsuarioRolDomainModel usuarioRolDomainModel = new UsuarioRolDomainModel();
usuarioRolDomainModel.Rol = new RolDomainModel
{
Nombre = rol.Rol.Nombre
};
usuarioDomainModel.UsuarioRoles = new List <UsuarioRolDomainModel>();
usuarioDomainModel.UsuarioRoles.Add(usuarioRolDomainModel);
}
usuarioDomainModels.Add(usuarioDomainModel);
}
return(usuarioDomainModels);
}
//Método para administrador y superadministrador
public List<UsuarioDomainModel> GetUsuarios()
{
List<Usuario> usuarios = usuarioRepository.GetAll(p => p.idStatus == 1 && p.idPerfil == 3).ToList();
List<UsuarioDomainModel> usuarioDomainModels = new List<UsuarioDomainModel>();
foreach (Usuario item in usuarios)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
usuarioDomainModel.Id = item.Id;
usuarioDomainModel.Nombres = item.Nombres;
usuarioDomainModel.Apellidos = item.Apellidos;
usuarioDomainModel.Email = item.Email;
usuarioDomainModel.NombreCompleto = item.Nombres + item.Apellidos;
usuarioDomainModel.area_movilizador = item.area_movilizador;
foreach (var rol in item.Usuario_Rol)
{
UsuarioRolDomainModel usuarioRolDomainModel = new UsuarioRolDomainModel();
usuarioRolDomainModel.Rol = new RolDomainModel
{
Nombre = rol.Rol.Nombre
};
usuarioDomainModel.UsuarioRoles = new List<UsuarioRolDomainModel>();
usuarioDomainModel.UsuarioRoles.Add(usuarioRolDomainModel);
}
usuarioDomainModels.Add(usuarioDomainModel);
}
return usuarioDomainModels;
}
public ActionResult GetUsuario(int id, int type)
{
UsuarioVM usuarioVM = null;
switch (type)
{
case 1:
UsuarioDomainModel usuarioDomainModel = usuarioBusiness.GetUsuario(id);
usuarioVM = new UsuarioVM();
AutoMapper.Mapper.Map(usuarioDomainModel, usuarioVM);
ViewBag.idCambio = new SelectList(usuarioBusiness.GetUsuarios(), "Id", "NombreCompleto");
return(PartialView("_Change", usuarioVM));
case 2:
UsuarioDomainModel usuarioDomain = usuarioBusiness.GetUsuario(id);
usuarioVM = new UsuarioVM();
AutoMapper.Mapper.Map(usuarioDomain, usuarioVM);
return(PartialView("_Update", usuarioVM));
case 3:
usuarioDomainModel = usuarioBusiness.GetUsuario(id);
usuarioVM = new UsuarioVM();
AutoMapper.Mapper.Map(usuarioDomainModel, usuarioVM);
return(PartialView("_Drop", usuarioVM));
case 4:
break;
default:
break;
}
return(PartialView(""));
}
public ActionResult ChangeCoordinador(UsuarioVM usuarioVM)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
AutoMapper.Mapper.Map(usuarioVM, usuarioDomainModel);
movilizadoBusiness.MigrarMovilizados(usuarioDomainModel);
return(RedirectToAction("Administrar", "Usuario"));
}
/// <summary>
/// Este metodo se encarga de traer a todos los movilizados de cada uno de los movilizadores existentes
/// se utiliza un stroreprocedure para la llamada a la consulta compleja
/// </summary>
/// <param name="idCoordinador">el identificador del coordinador</param>
/// <returns>una lista de usuarios domain model</returns>
public List <UsuarioDomainModel> GetMovilizadoresByCoordinador(int idCoordinador)
{
List <UsuarioDomainModel> usersDM = new List <UsuarioDomainModel>(); //lista vacia
try
{
List <Usuario> usuarios = usuarioRepository.GetAll().Where(p => p.idUsuario == idCoordinador).ToList();
foreach (Usuario user in usuarios)
{
List <MovilizadoDomainModel> movilizados = new List <MovilizadoDomainModel>();//lista vacia
UsuarioDomainModel usuarioDM = new UsuarioDomainModel();
usuarioDM.Id = user.Id;
usuarioDM.IdPerfil = user.idPerfil.Value;
usuarioDM.IdStatus = user.idStatus.Value;
usuarioDM.Nombres = user.Nombres;
usuarioDM.Apellidos = user.Apellidos;
int IdUsuarioMovilizador = user.Id;
var movilizadores = movilizadoRepository.GetAll().Where(p => p.Usuario.idPerfil == 2 && p.idStatus == 1 && p.idUsuario == IdUsuarioMovilizador).ToList();
foreach (var m in movilizadores)
{
if (m.Usuario.idUsuario == idCoordinador)
{
MovilizadoDomainModel movilizado = new MovilizadoDomainModel(); ///creo un objeto movilizado vacio
//movilizado.id = m.id;
movilizado.StrNombre = m.strNombre;
movilizado.StrApellidoPaterno = m.strApellidoPaterno;
movilizado.StrApellidoMaterno = m.strApellidoMaterno;
movilizado.IdUsuario = m.idUsuario.Value;
//movilizado.I = m.idDireccion;
movilizado.DireccionDomainModel = new DireccionDomainModel();//creamos la direccion de forma vacia para ser llenada
movilizado.DireccionDomainModel.StrCalle = m.Direccion.strCalle;
movilizado.DireccionDomainModel.StrNumeroInterior = m.Direccion.strNumeroInterior;
movilizado.DireccionDomainModel.IdColonia = m.Direccion.idColonia.Value;
movilizado.DireccionDomainModel.ColoniaDomainModel = new ColoniaDomainModel();
movilizado.DireccionDomainModel.ColoniaDomainModel.StrCodigoPostal = m.Direccion.Colonia.strCodigoPostal.Value.ToString();
movilizado.DireccionDomainModel.ColoniaDomainModel.StrTipoDeAsentamiento = m.Direccion.Colonia.strTipoDeAsentamiento;
movilizado.DireccionDomainModel.ColoniaDomainModel.StrAsentamiento = m.Direccion.Colonia.strAsentamiento;
movilizado.TelefonoDomainModel = new TelefonoDomainModel();
movilizado.TelefonoDomainModel.StrNumeroCelular = m.Telefono.strNumeroCelular;
movilizados.Add(movilizado);//agregamos el movilizado a la lista
}
}
usuarioDM.Movilizados = movilizados;
usersDM.Add(usuarioDM);///agrego a la lista de usuarios un usuario con su movilizador
}
return(usersDM);
}
catch (Exception ex)
{
string mensajeErr = ex.Message;
return(usersDM);
}
}
public ActionResult UpdateUsuario(UsuarioVM usuarioVM)
{
if (usuarioVM != null)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
AutoMapper.Mapper.Map(usuarioVM, usuarioDomainModel);
usuarioBusiness.UpdateUsuario(usuarioDomainModel);
}
return(RedirectToAction("Administrar", "Usuario"));
}
public ActionResult Create(UsuarioRolVM usuarioVM)
{
if (usuarioVM != null)
{
var identity = (ClaimsPrincipal)Thread.CurrentPrincipal;
usuarioVM.Usuario.idStatus = (int)EnumStatus.ALTA;
usuarioVM.Usuario.Clave = Funciones.Encrypt(usuarioVM.Usuario.Clave);
var properties = ClaimsPrincipal.Current.Identities.First();
usuarioVM.Usuario.Id = int.Parse(properties.Claims.First(i => i.Type == ClaimTypes.NameIdentifier).Value);
if (identity.IsInRole("Administrador") || identity.IsInRole("Super Administrador"))
{
UsuarioRolDomainModel usuarioDM = new UsuarioRolDomainModel();
AutoMapper.Mapper.Map(usuarioVM, usuarioDM);
usuarioBusiness.AddUpdateUsuarios(usuarioDM);
}
else
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
if (identity.IsInRole("MultiNivel"))
{
usuarioVM.Usuario.area_movilizador = "MultiNivel";
}
else if (identity.IsInRole("Planilla Ganadora"))
{
usuarioVM.Usuario.area_movilizador = "Planilla Ganadora";
}
else if (identity.IsInRole("Campaña"))
{
usuarioVM.Usuario.area_movilizador = "Campaña";
}
else if (identity.IsInRole("En Campaña"))
{
usuarioVM.Usuario.area_movilizador = "En Campaña";
}
else if (identity.IsInRole("Redes Sociales"))
{
usuarioVM.Usuario.area_movilizador = "Redes Sociales";
}
AutoMapper.Mapper.Map(usuarioVM.Usuario, usuarioDomainModel);
usuarioBusiness.AddUser(usuarioDomainModel);
}
}
return(RedirectToAction("Create", "Usuario"));
}
public bool BajaUsuario(UsuarioDomainModel usuarioDM)
{
bool resultado = false;
if (usuarioDM != null)
{
Usuario usuario = usuarioRepository.SingleOrDefault(p => p.Id == usuarioDM.Id);
if (usuarioDM.Id > 0)
{
usuario.idStatus = usuarioDM.IdStatus;
usuarioRepository.Update(usuario);
resultado = true;
}
}
return resultado;
}
public ActionResult Login(LoginVM loginView, string returnUrl)
{
ActionResult result; //esto se debe inicializar
string clave = Funciones.Encrypt(loginView.Password); //encryptamos el password
UsuarioDomainModel usuarioDM = usuarioBusiness.ValidarLogin(loginView.Email, clave);
if (usuarioDM != null)
{
result = SigInUser(usuarioDM, loginView.RememberMe, returnUrl);
}
else
{
return(View(loginView));
}
return(result);
}
/// <summary>
/// Este metodo se encarga de almacenar un movilizador dentro del sistema
/// </summary>
/// <param name="usuarioDM">el movilizador del sistema</param>
/// <param name="perfilDM">el perfil del movilizador</param>
/// <returns>una respuesta true/false</returns>
public bool AddUpdateUsuarioMovilizador(UsuarioDomainModel usuarioDM, PerfilDomainModel perfilDM)
{
bool respuesta = false;
Usuario_Rol user = null;
try
{
if (usuarioDM != null)
{
Usuario_Rol usuarioRol = usuarioRolRepository.SingleOrDefault(p => p.Id == usuarioDM.Id);
if (usuarioDM.Id > 0)
{
}
else
{
///este metodo se encarga de buscar el rol del coordiandor que agrega al movilizador
user = usuarioRolRepository.SingleOrDefault(p => p.Id_Usuario == usuarioDM.IdUsuario);
usuarioRol = new Usuario_Rol();
usuarioRol.Usuario = new Usuario
{
Nombres = usuarioDM.Nombres,
Apellidos = usuarioDM.Apellidos,
Email = usuarioDM.Email,
Clave = usuarioDM.Clave,
ProviderKey = usuarioDM.ProviderKey,
ProviderName = usuarioDM.ProviderName,
idPerfil = perfilDM.Id,
idStatus = usuarioDM.IdStatus,
idUsuario = usuarioDM.IdUsuario
};
usuarioRol.Id_rol = user.Id_rol;
usuarioRol.dteFecha = DateTime.Now;
usuarioRolRepository.Insert(usuarioRol);
respuesta = true;
}
}
}
catch (Exception ex)
{
string mensajeErr = ex.Message;
}
return(respuesta);
}
public ActionResult Eliminar(UsuarioVM usuarioVM)
{
try
{
if (usuarioVM != null)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
usuarioDomainModel = usuarioBusiness.GetUsuario(usuarioVM.Id);
usuarioDomainModel.IdStatus = (int)EnumStatus.BAJA;
usuarioBusiness.BajaUsuario(usuarioDomainModel);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(RedirectToAction("Administrar", "Usuario"));
}
public bool MigrarMovilizados(UsuarioDomainModel usuarioDomainModel)
{
bool respuesta = false;
if (usuarioDomainModel != null)
{
List <Movilizado> movilizado = movilizadoRepository.GetAll().Where(p => p.idUsuario == usuarioDomainModel.Id).ToList();
if (movilizado != null)
{
foreach (var item in movilizado)
{
item.idUsuario = usuarioDomainModel.idCambio;
}
movilizadoRepository.UpdateAll(movilizado);
}
}
return(respuesta);
}
public List <UsuarioDomainModel> GetAllCoordinadores(int idRol)
{
List <UsuarioDomainModel> coordinadores = new List <UsuarioDomainModel>();
try
{
List <Usuario> usuarios = usuarioRepository.GetAll().Where(p => p.idStatus == 1 && p.idPerfil == 1).ToList <Usuario>();
List <UsuarioRolDomainModel> usuariosRoles = new List <UsuarioRolDomainModel>();
foreach (Usuario usuario in usuarios)
{
UsuarioDomainModel usuarioDM = new UsuarioDomainModel();
usuarioDM.Nombres = usuario.Nombres;
usuarioDM.Apellidos = usuario.Apellidos;
usuarioDM.Email = usuario.Email;
usuarioDM.Id = usuario.Id;
foreach (Usuario_Rol item in usuario.Usuario_Rol)
{
usuarioDM.IdRol = item.Id_rol;
UsuarioRolDomainModel usuarioRolDM = new UsuarioRolDomainModel();
//usuarioRolDM.Id = item.Id;
//usuarioRolDM.IdRol = item.Id_rol;
//usuarioRolDM.IdUsuario = item.Id_Usuario;
RolDomainModel rolDM = new RolDomainModel();
rolDM.Id = item.Rol.Id;
rolDM.Nombre = item.Rol.Nombre;
usuarioRolDM.Rol = rolDM;
usuariosRoles.Add(usuarioRolDM);
}
usuarioDM.UsuarioRoles = usuariosRoles;
coordinadores.Add(usuarioDM);
}
return(coordinadores.Where(p => p.IdRol == idRol).ToList());
}
catch (Exception ex)
{
string mensajeErr = ex.Message;
return(coordinadores);
}
}
public UsuarioDomainModel ValidarLogin(string email, string password)
{
UsuarioDomainModel usuarioDM = null;
try
{
Usuario usuario = usuarioRepository.SingleOrDefault(p => p.Email == email && p.Clave == password);
if (usuario != null)
{
usuarioDM = new UsuarioDomainModel();
usuarioDM.Id = usuario.Id;
usuarioDM.Nombres = usuario.Nombres;
usuarioDM.Apellidos = usuario.Apellidos;
usuarioDM.Clave = usuario.Clave;
usuarioDM.Email = usuario.Email;
usuarioDM.ProviderKey = usuario.ProviderKey;
usuarioDM.ProviderName = usuario.ProviderName;
List<UsuarioRolDomainModel> rolesDM = new List<UsuarioRolDomainModel>();
foreach (Usuario_Rol user in usuario.Usuario_Rol)
{
UsuarioRolDomainModel usuarioRolDM = new UsuarioRolDomainModel();
RolDomainModel rolDM = new RolDomainModel();
usuarioRolDM.IdUsuario = user.Id_Usuario;
usuarioRolDM.IdRol = user.Id_rol;
rolDM.Id = user.Rol.Id;
rolDM.Nombre = user.Rol.Nombre;
usuarioRolDM.Rol = rolDM;
rolesDM.Add(usuarioRolDM);
}
usuarioDM.UsuarioRoles = rolesDM;
}
return usuarioDM;
}
catch (Exception ex)
{
return usuarioDM;
}
}
public UsuarioDomainModel GetUsuario(int id)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
Usuario usuario = usuarioRepository.SingleOrDefault(p => p.Id == id);
usuarioDomainModel.Id = usuario.Id;
usuarioDomainModel.Nombres = usuario.Nombres;
usuarioDomainModel.Apellidos = usuario.Apellidos;
usuarioDomainModel.Email = usuario.Email;
foreach (var item in usuario.Usuario_Rol)
{
UsuarioRolDomainModel usuarioRolDomainModel = new UsuarioRolDomainModel();
usuarioRolDomainModel.Rol = new RolDomainModel
{
Nombre = item.Rol.Nombre
};
usuarioDomainModel.UsuarioRoles.Add(usuarioRolDomainModel);
}
return(usuarioDomainModel);
}
private ActionResult SigInUser(UsuarioDomainModel userDM, bool rememberMe, string returnUrl)
{
ActionResult Result;
//un claims puede almacenar cualquier tipo de informacion del usuario, nombre, mail, password, lo que sea
List <Claim> Claims = new List <Claim>(); //listado de claims
Claims.Add(new Claim(ClaimTypes.NameIdentifier, userDM.Id.ToString())); //primer claims
Claims.Add(new Claim(ClaimTypes.Email, userDM.Email));
Claims.Add(new Claim(ClaimTypes.Name, userDM.Nombres));
///podemos crear un tipo de claims personalizado
Claims.Add(new Claim("FullName", $"{userDM.Nombres} {userDM.Apellidos}"));
///estos claims se almacenan en la cookie para identificar al usuario y sus atributos o permisos
//Claims.Add(new Claim(ClaimTypes.Actor, userDM.Perfil.StrValor));
//ahora establñecemos los claims con los roles del usuario
if (userDM.UsuarioRoles != null && userDM.UsuarioRoles.Any())
{
Claims.AddRange(userDM.UsuarioRoles.Select(p => new Claim(ClaimTypes.Role, p.Rol.Nombre)));
}
var Identity = new ClaimsIdentity(Claims, DefaultAuthenticationTypes.ApplicationCookie); //entonces ahora creamos una identidad basada en claims con sus roles permisos y nombre del usuario
///cuando el usuario se logea se crea una cookie de autenticacion
///
//este AutenticationManager se encarga de administrarla cookie y da el seguimiento a todo el sitio con todo y los permisos del usuario
IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = rememberMe
}, Identity); //el rememberMe es para recordarlo true/false
if (string.IsNullOrWhiteSpace(returnUrl))
{
returnUrl = Url.Action("Registros", "Movilizado");
}
Result = Redirect(returnUrl);
return(Result);
}
public bool UpdateUsuario(UsuarioDomainModel usuarioDomainModel)
{
bool respuesta = false;
if (usuarioDomainModel != null)
{
Usuario usuario = usuarioRepository.SingleOrDefault(p => p.Id == usuarioDomainModel.Id);
if (usuario != null)
{
if (usuario.Id > 0)
{
usuario.Nombres = usuarioDomainModel.Nombres;
usuario.Apellidos = usuarioDomainModel.Apellidos;
usuario.Email = usuarioDomainModel.Email;
usuarioRepository.Update(usuario);
respuesta = true;
}
}
}
return(respuesta);
}
public bool AddUser(UsuarioDomainModel usuarioDomainModel)
{
bool respuesta = false;
if (usuarioDomainModel != null)
{
Usuario usuario = new Usuario();
usuario.Nombres = usuarioDomainModel.Nombres;
usuario.Apellidos = usuarioDomainModel.Apellidos;
usuario.Email = usuarioDomainModel.Email;
usuario.Clave = usuarioDomainModel.Clave;
usuario.idPerfil = usuarioDomainModel.IdPerfil;
usuario.idStatus = usuarioDomainModel.IdStatus;
usuario.idUsuario = usuarioDomainModel.Id;
usuario.area_movilizador = usuarioDomainModel.area_movilizador;
usuarioRepository.Insert(usuario);
respuesta = true;
}
return(respuesta);
}
///este metodo se encarga de recuperar la contraseña de una cuenta via email
public ActionResult RecoveryPassword([Bind(Include = "FromEmail")] EmailVM emailVM)
{
if (!string.IsNullOrEmpty(emailVM.FromEmail))
{
UsuarioDomainModel usuarioDM = usuarioBusiness.ValidarEmailPasswordrecovery(emailVM.FromEmail.ToLower());
if (usuarioDM != null)
{
emailVM.FromNombre = usuarioDM.Nombres + " " + usuarioDM.Apellidos;
emailVM.Asunto = Recursos.RecursosAdmin.RECUPERACION_PASSWORD_MAIL;
emailVM.Mensaje = Recursos.RecursosAdmin.MENSAJE_PASSWORD_RECOVERY + " Tu Password es: " + Funciones.Decrypt(usuarioDM.Clave);
emailVM.FromEmail = usuarioDM.Email.ToLower();
EmailDomainModel emailDM = new EmailDomainModel();
RecoveryPassword recovery = new RecoveryPassword();
AutoMapper.Mapper.Map(emailVM, emailDM);
if (recovery.RecuperarPasswordAccount(emailDM))
{
return(RedirectToAction("SuccessRecoveryPassword", "Account"));//vista a donde se envia el mensaje de exito
}
}
}
///regresa a un page de error
return(RedirectToAction("NoEmailRecovery", "Error"));
}