public async Task <IActionResult> PutUser([FromBody] UserRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UsuarioEntity userEntity = await _userHelper.GetUserAsync(request.Email);
if (userEntity == null)
{
return(BadRequest("No se encontro el usuario"));
}
IdentityResult respose = await _userHelper.UpdateUserAsync(userEntity);
if (!respose.Succeeded)
{
return(BadRequest(respose.Errors.FirstOrDefault().Description));
}
UsuarioEntity updatedUser = await _userHelper.GetUserAsync(request.Email);
return(Ok(updatedUser));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new UsuarioEntity {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> GetUserByEmail([FromBody] EmailRequest emailRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
UsuarioEntity userEntity = await _userHelper.GetUserAsync(emailRequest.Email);
if (userEntity == null)
{
return(NotFound("no se encontro el usuario"));
}
if (userEntity.UserType == UserType.Distribuidor)
{
DistribuidorEntity dist = _dataContext.Distribuidor
.Where(d => d.Email == emailRequest.Email)
.FirstOrDefault();
return(Ok(_converterHelper.ToDistUserResponse(userEntity, dist)));
}
else
{
ClienteEntity clie = _dataContext.Cliente
.Where(c => c.Email == emailRequest.Email)
.FirstOrDefault();
return(Ok(_converterHelper.ToClieUserResponse(userEntity, clie)));
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new UsuarioEntity {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public IHttpActionResult AddUsers(UsuarioEntity model)
{
try
{
using (var ts = new TransactionScope())
{
Usuario usuario = new Usuario();
if (!model.UsuarioId.HasValue)
{
context.Usuario.Add(usuario);
usuario.Estado = ConstantHelpers.ESTADO.ACTIVO;
usuario.FechaRegistro = DateTime.Now;
}
usuario.Nombres = model.Nombres;
usuario.Apellidos = model.Apellidos;
usuario.Credenciales = model.Credenciales;
usuario.Contrasenia = CipherLogic.Cipher(CipherAction.Encrypt, CipherType.UserPassword, model.Contrasenia);
usuario.Correo = model.Correo;
context.SaveChanges();
ts.Complete();
}
response.Data = "Usuario Agregado con éxito";
response.Error = false;
response.Message = "Success";
return(Ok(response));
}
catch (Exception ex)
{
return(Unauthorized());
}
}
public bool Atualizar(UsuarioEntity usuario)
{
try
{
connection.Open();
SqlCommand command = new SqlCommand("UPDATE Usuario SET codGra = @codGra, nomUsu = @nomUsu, sexUsu = @sexUsu, endUsu = @endUsu, cidUsu = @cidUsu, ufUsu = @ufUsu, telUsu = @telUsu, emaUsu = @emaUsu, senUsu = @senUsu WHERE cpfUsu = @cpfUsu", connection);
command.Parameters.AddWithValue("@cpfUsu", usuario.cpfUsu);
command.Parameters.AddWithValue("@codGra", usuario.codGra);
command.Parameters.AddWithValue("@nomUsu", usuario.nomUsu);
command.Parameters.AddWithValue("@sexUsu", usuario.sexUsu);
command.Parameters.AddWithValue("@endUsu", usuario.endUsu);
command.Parameters.AddWithValue("@cidUsu", usuario.cidUsu);
command.Parameters.AddWithValue("@ufUsu", usuario.ufUsu);
command.Parameters.AddWithValue("@telUsu", usuario.telUsu);
command.Parameters.AddWithValue("@emaUsu", usuario.emaUsu);
command.Parameters.AddWithValue("@senUsu", usuario.senUsu);
command.ExecuteNonQuery();
}
catch
{
return(false);
}
finally
{
if (connection != null)
{
connection.Close();
}
}
return(true);
}
protected void btnRegistro_Click(object sender, EventArgs e)
{
try
{
UsuarioEntity usuario = new UsuarioEntity();
usuario.nombre = tbNombre.Text;
usuario.apellido = tbApellido.Text;
usuario.mail = tbMail.Text;
usuario.password = tbPassword.Text;
usuario.domicilio = tbDomicilio.Text;
usuario.telefono = tbTelefono.Text;
if (Convert.ToBoolean(ViewState["Nuevo"]))
{
boUsuario.Registrar(usuario, tbMail.Text);
}
else
{
boUsuario.Actualizar(usuario);
Context.Items.Add("MostrarTodos", "S");
Server.Transfer("Usuarios.aspx");
}
SessionHelper.AlmacenarUsuarioAutenticado(boUsuario.Autenticar(tbMail.Text, tbPassword.Text));
/*System.Web.Security.FormsAuthentication.RedirectFromLoginPage(SessionHelper.UsuarioAutenticado.mail, false);*/
Context.Items.Add("e_mail", SessionHelper.UsuarioAutenticado.mail);
Context.Items.Add("idpermiso", SessionHelper.UsuarioAutenticado.idPermiso);
Server.Transfer("Default.aspx");
}
catch (ValidacionExcepcionAbstract ex)
{
WebHelper.MostrarMensaje(Page, ex.Message);
}
}
public async Task <ActionResult> Post([FromBody] UsuarioEntity usuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.Post(usuario);
if (result != null)
{
return(Created(new Uri(Url.Link("GetWithId", new { id = result.Id })), result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
private UsuarioEntity CrearUsuario(SqlDataReader cursor)
{
UsuarioEntity usuario = new UsuarioEntity();
usuario.Id = cursor.GetInt32(cursor.GetOrdinal("ID"));
usuario.Nombre = cursor.GetString(cursor.GetOrdinal("Nombre"));
usuario.Apellido = cursor.GetString(cursor.GetOrdinal("Apellido"));
usuario.Email = cursor.GetString(cursor.GetOrdinal("Email"));
usuario.Password = cursor.GetString(cursor.GetOrdinal("Password"));
usuario.FechaNacimiento = cursor.GetDateTime(cursor.GetOrdinal("FechaNacimiento"));
usuario.Sexo = cursor.GetString(cursor.GetOrdinal("Sexo"))[0];
if (!cursor.IsDBNull(cursor.GetOrdinal("Foto")))
{
usuario.Foto = cursor.GetString(cursor.GetOrdinal("Foto"));
}
usuario.FechaRegistracion = cursor.GetDateTime(cursor.GetOrdinal("FechaRegistracion"));
if (!cursor.IsDBNull(cursor.GetOrdinal("FechaActualizacion")))
{
usuario.FechaActualizacion = cursor.GetDateTime(cursor.GetOrdinal("FechaActualizacion"));
}
return(usuario);
}
public void Initialize()
{
_solicitacaoRepository =
new SolicitacaoRepositoryMock();
_usuarioRepositoryMock =
new Mock<IUsuarioRepository>();
_solicitacaoDomainService =
new SolicitacaoDomainService(
_solicitacaoRepository, _usuarioRepositoryMock.Object);
_usuario =
new UsuarioEntity("Nome1", "login@1");
typeof(UsuarioEntity)
.GetProperty("Codigo")
.SetValue(_usuario, 10);
_solicitacao
= new SolicitacaoEntity(
"Nome",
SolicitacaoObjetivoValueObject.AumentoVendas,
"Descricao",
_usuario,
"Área");
}
public async Task <UsuarioEntityResponse> Create(UsuarioEntity usuarioEntity)
{
var entityReponse = mapper.Map <UsuarioEntityResponse>(usuarioEntity);
entityReponse.Status = "Cadastrado com Sucesso";
return(await Task.FromResult(entityReponse));
}
public void RemoveLivroCarrinho(UsuarioEntity usuario, LivroEntity livro)
{
CarrinhoEntity carrinho = _carrinhoRepository.GetByUser(usuario.Id);
if (carrinho != null)
{
if (carrinho.Livros.Any(i => i.Id == livro.Id))
{
carrinho.RemoverLivro(livro.Id);
}
if (carrinho.Livros.Count > 0)
{
_carrinhoRepository.Update(carrinho);
}
else
{
_carrinhoRepository.Delete(carrinho);
}
}
else
{
throw new System.Exception("Usuário não tem carrinho!");
}
}
private void AgregarChats(string userName)
{
UsuarioEntity usuarioOrigen = CachingManager.Instance.GetUsuarioByUsername(UserName);
List <UsuarioEntity> usuarios = CachingManager.Instance.GetAllUsuarios();
foreach (UsuarioEntity u in usuarios)
{
ChatEntity chat = new ChatEntity()
{
Nombre = "Chat",
EsGrupo = false,
Fecha = DateTime.Now
};
ChatUsuarioEntity chatUsuario = new ChatUsuarioEntity()
{
IdUsuario = u.IdUsuario,
EsOwner = false,
Fecha = DateTime.Now
};
ChatUsuarioEntity chatUsuarioDestino = new ChatUsuarioEntity()
{
IdUsuario = usuarioOrigen.IdUsuario,
EsOwner = false,
Fecha = DateTime.Now
};
chat.ChatUsuarioItems.Add(chatUsuario);
chat.ChatUsuarioItems.Add(chatUsuarioDestino);
context.Add(chat);
context.SaveChanges();
}
}
/// <summary>
/// Registra beneficiario en condonacion
/// </summary>
/// <param name="usuarioEntity">UsuarioEntity de entrada</param>
/// <returns>Retorna RespuestaAjax</returns>
public RespuestaAjax RegistrarBeneficiarioCondonacion(UsuarioEntity usuarioEntity)
{
RespuestaAjax Respuesta = new RespuestaAjax();
//UsuarioDao objUsuario = new UsuarioDao();
DataTable vobjResultado = this.usuarioDao.RegistrarBeneficiarioCondonacion(usuarioEntity.IdSolicitante,
usuarioEntity.IdEstado, usuarioEntity.IdNivel, usuarioEntity.Observacion, usuarioEntity.IdConvocatoria,
usuarioEntity.CertifPermEstado, usuarioEntity.CertifPromNotas, usuarioEntity.CertifProgCursado,
usuarioEntity.CertifDiploma, usuarioEntity.CertifSoporte, usuarioEntity.VideoYoutube,
usuarioEntity.CertifVideo, usuarioEntity.CertifFinMateria,
usuarioEntity.CertifDocsRequeridos, usuarioEntity.CertifDocSubsanacion);
if (vobjResultado != null)
{
List <UsuarioEntity> lstUsuario = Utilitario.ConvertTo <UsuarioEntity>(vobjResultado);
Respuesta.Mensage = string.Format("La solicitud fue radicada exitosamente con el radicado # {0}",
lstUsuario.FirstOrDefault().IdRadicado);
Respuesta.Estado = EstadoRespuesta.OK;
}
else
{
Respuesta.Mensage = "Error al insertar información en el Formulario de Condonación";
Respuesta.Estado = EstadoRespuesta.ERROR;
}
return(Respuesta);
}
//[EnableCorsAttribute("http://localhost:44522", "*", "*")]//para permitir CORS
public HttpResponseMessage TraerFrecuencia(int id_Amenaza)
{
UsuarioEntity usuarioComprobado = new UsuarioEntity();
Msg respuesta = new Msg();
try
{
var frecuencia = EscalaFrecuenciaDatos.ObtenerFrecuencia(id_Amenaza);
if (frecuencia == null)
{
respuesta.Datos = frecuencia;
respuesta.Estado = "OK";
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, respuesta));
}
else
{
respuesta.Datos = frecuencia;
respuesta.Estado = "False";
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, respuesta));
}
}
catch (Exception e)
{
respuesta.Mensajes = e.Message.ToString();
return(Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, respuesta));
}
}
public void Insertar(UsuarioEntity usuario)
{
try
{
using (SqlConnection conexion = ConexionDA.ObtenerConexion())
{
using (SqlCommand comando = new SqlCommand("UsuarioInsert", conexion))
{
comando.CommandType = CommandType.StoredProcedure;
SqlCommandBuilder.DeriveParameters(comando);
comando.Parameters["@UsuarioNombre"].Value = usuario.Nombre.Trim();
comando.Parameters["@UsuarioApellido"].Value = usuario.Apellido.Trim();
comando.Parameters["@UsuarioEmail"].Value = usuario.Email.Trim();
comando.Parameters["@UsuarioPassword"].Value = usuario.Password.Trim();
comando.Parameters["@UsuarioFechaNacimiento"].Value = usuario.FechaNacimiento;
comando.Parameters["@UsuarioSexo"].Value = usuario.Sexo;
comando.Parameters["@UsuarioFechaRegistracion"].Value = usuario.FechaRegistracion;
comando.ExecuteNonQuery();
usuario.Id = Convert.ToInt32(comando.Parameters["@RETURN_VALUE"].Value);
}
conexion.Close();
}
}
catch (Exception ex)
{
throw new ExcepcionDA("Se produjo un error al insertar el usuario.", ex);
}
}
public static void Update(UsuarioEntity entity)
{
try
{
string query;
query = $@"
UPDATE usuario
SET
contrasenia = @Contrasenia,
perfil_id = @PerfilId,
nombre = @Nombre,
nombre_de_usuario = @NombreDeUsuario
WHERE id = @Id;
";
using (var db = new MySqlConnection(Conexion.CadenaDeConexion))
{
db.Query(query, new
{
Contrasenia = entity.Contrasenia,
PerfilId = entity.PerfilId,
Nombre = entity.Nombre,
NombreDeUsuario = entity.NombreDeUsuario,
Id = entity.Id
});
}
}
catch (Exception)
{
throw;
}
}
protected void btnGravar_Click(object sender, EventArgs e)
{
UsuarioEntity usuario = new UsuarioEntity();
UsuarioController usuarioController = new UsuarioController();
if (txtNome.Text == "" || txtCpf.Text == "" || txtSexo.SelectedValue == "0" || txtEmail.Text == "" || txtGraduacao.SelectedValue == "0" || txtSenha.Text == "")
{
this.ClientScript.RegisterClientScriptBlock(typeof(string), "alert", "<script>alert('Preencha todos os campos!');</script>");
}
else
{
usuario.cpfUsu = txtCpf.Text;
usuario.nomUsu = txtNome.Text;
usuario.endUsu = txtEndereco.Text;
usuario.cidUsu = txtCidade.Text;
usuario.ufUsu = txtUf.Text;
usuario.sexUsu = txtSexo.SelectedValue;
usuario.telUsu = txtTelefone.Text;
usuario.emaUsu = txtEmail.Text;
usuario.senUsu = txtSenha.Text;
usuario.codGra = Convert.ToInt32(txtGraduacao.SelectedValue);
if (usuarioController.Atualizar(usuario))
{
this.ClientScript.RegisterClientScriptBlock(typeof(string), "alert", "<script>alert('Usuário atualizado com sucesso!'); window.location.href='Home.aspx';</script>");
}
else
{
this.ClientScript.RegisterClientScriptBlock(typeof(string), "alert", "<script>alert('Erro na alteração do registro!');</script>");
}
}
}
public void CETBajaNegocio(TramiteEntity tramite, int idEstadoACambiar, UsuarioEntity us)
{
using (SitcomEntities db = new SitcomEntities())
{
var result = db.Tramite.Include("Negocio").Where(t => t.idTramite == tramite.idTramite).FirstOrDefault();
if (result != null)
{
switch (idEstadoACambiar)
{
case 2: result.idUsuarioResponsable = us.idUsuario;
result.idEstadoTramite = 2;//2: En revisión
db.SaveChanges();
break;
case 3: result.fechaFin = DateTime.Now; //3: Aprobado
result.idEstadoTramite = 3;
result.comentario = tramite.comentario;
db.SaveChanges();
break;
default:
break;
}
}
}
}
public async Task <ActionResult> Put([FromBody] UsuarioEntity usuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.Put(usuario);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public ActionResult Update(EncuestaEntity encuesta, List <PreguntaEntity1> Preguntas, List <ResOpcMultsEntity1> respuestas, string usuario, int activa)
{
UsuarioEntity user = proxyUsuario.GetUsuarioList().Where(o => o.Usuario.ToLower() == usuario.ToLower()).FirstOrDefault();
encuesta.FechaCreacion = DateTime.Now.ToShortDateString();
encuesta.IdUsuario = user.IdUsuario.Value;
if (activa == 1)
{
encuesta.Activa = true;
}
else
{
encuesta.Activa = false;
}
XElement xe = XElement.Parse(Globals.SerializeTool.Serialize <EncuestaEntity>(encuesta));
XElement xmll = XElement.Parse(Globals.SerializeTool.SerializeList <PreguntaEntity1>(Preguntas));
XElement fg = XElement.Parse(Globals.SerializeTool.SerializeList <ResOpcMultsEntity1>(respuestas));
xe.Add(xmll, fg);
int result = proxy.UpdateEncuesta(xe.ToString());
return(null);
}
public IHttpActionResult PutUsuarioEntity(int id, UsuarioEntity usuarioEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != usuarioEntity.Id)
{
return(BadRequest());
}
db.Entry(usuarioEntity).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioEntityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
protected void btnOk_Click(object sender, EventArgs e)
{
if (txtUsuario.Text == "" || txtSenha.Text == "")
{
this.ClientScript.RegisterClientScriptBlock(typeof(string), "alert", "<script>alert('Preencha todos os campos!');</script>");
}
else
{
UsuarioController usuarioController = new UsuarioController();
UsuarioEntity usuario = usuarioController.Validar(txtUsuario.Text, txtSenha.Text);
if (usuario.nomUsu != null)
{
Session["cpfUsu"] = usuario.cpfUsu;
Session["nomUsu"] = usuario.nomUsu;
Session["codCar"] = usuario.codCar;
Session["nomCar"] = usuario.nomCar;
Session["cnpjEmp"] = usuario.cnpjEmp;
Session["nomEmp"] = usuario.nomEmp;
Response.Write(Session["cpfUsu"]);
Response.Write(Session["nomUsu"]);
Response.Write(Session["codCar"]);
Response.Write(Session["nomCar"]);
Response.Write(Session["cnpjEmp"]);
Response.Write(Session["nomEmp"]);
Response.Redirect("~/Home.aspx");
}
else
{
this.ClientScript.RegisterClientScriptBlock(typeof(string), "alert", "<script>alert('Usuário ou senha inválidos!');</script>");
}
}
}
public static UsuarioEntity GetById(string id)
{
UsuarioEntity user = null;
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
{
conn.Open();
string sql = @"SELECT USUARIO , SUSCRIPCION , PWD , NOMBRE , APELLIDO , EMAIL , ESTADO , producto
FROM USUARIOS_TMP_GLOBAL
WHERE USUARIO = @usuario";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("usuario", NonBlankValueOf(id));
SqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
user = LoadUser(reader);
}
conn.Close();
}
return(user);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
for (int i = 1; i < 32; i++)
{
ddlDia.Items.Add(new ListItem(i.ToString(), i.ToString()));
}
for (int i = DateTime.Now.Year; i > 1904; i--)
{
ddlAnio.Items.Add(new ListItem(i.ToString(), i.ToString()));
}
if (SessionHelper.UsuarioAutenticado != null)
{
UsuarioEntity usuario = SessionHelper.UsuarioAutenticado;
txtNombre.Text = usuario.Nombre;
txtApellido.Text = usuario.Apellido;
txtPassword.Text = usuario.Password;
ddlAnio.SelectedValue = usuario.FechaNacimiento.Year.ToString();
ddlMes.SelectedValue = usuario.FechaNacimiento.Month.ToString();
ddlDia.SelectedValue = usuario.FechaNacimiento.Day.ToString();
if (usuario.Sexo == 'F')
{
radMujer.Checked = true;
}
else
{
radHombre.Checked = true;
}
}
}
txtPassword.Attributes["type"] = "password";
}
private static void ValidaPassword(UsuarioEntity usuario, string vieja, string nueva, string validacion, TipoValidacionPassword Tipo)
{
string vieja_md5 = string.Empty;
// Descifro solo en el casos de un changeclave (sino nunca llega como parametro)
if (Tipo == TipoValidacionPassword.Change)
{
if (string.IsNullOrEmpty(vieja))
{
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_PASSWORD_INCORRECTA, false);
}
vieja_md5 = MAETools.HashMD5(vieja);
}
if ((Tipo == TipoValidacionPassword.Change) && (vieja_md5 != usuario.Pass))
{
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_PASSWORD_INCORRECTA, false);
}
if ((Tipo == TipoValidacionPassword.Change) && (vieja == nueva))
{
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_CLAVESINCAMBIOS, false);
}
ValidaConfiguracionPassword(nueva, validacion, usuario, Tipo);
}
protected void btnRegistrate_Click(object sender, EventArgs e)
{
try
{
UsuarioEntity usuario = new UsuarioEntity();
usuario.Nombre = txtNombre.Text;
usuario.Apellido = txtApellido.Text;
usuario.Email = txtEmail.Text;
usuario.Password = txtPassword.Text;
usuario.FechaNacimiento = Util.ObtenerFecha(
int.Parse(ddlAnio.SelectedValue),
int.Parse(ddlMes.SelectedValue),
int.Parse(ddlDia.SelectedValue));
usuario.Sexo = (ControlsHelper.RadioSeleccionado("Debe seleccionar el sexo.", radMujer, radHombre) == radMujer ? 'F' : 'M');
boUsuario.Registrar(usuario, txtEmailVerificacion.Text);
SessionHelper.AlmacenarUsuarioAutenticado(boUsuario.Autenticar(txtEmail.Text, txtPassword.Text));
System.Web.Security.FormsAuthentication.RedirectFromLoginPage(SessionHelper.UsuarioAutenticado.Email, false);
}
catch (ValidacionExcepcionAbstract ex)
{
WebHelper.MostrarMensaje(Page, ex.Message);
}
}
public void Eliminar(int id)
{
UsuarioEntity entidad = new UsuarioEntity();
entidad.IdUsuario = id;
EjecutarComando(TipoComando.Eliminar, entidad);
}
private void CrearParametros(OdbcCommand command, UsuarioEntity entidad)
{
OdbcParameter parameter = null;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
parameter.Value = entidad.Usuario;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
parameter.Value = entidad.Clave;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
parameter.Value = entidad.Apellido;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
parameter.Value = entidad.Nombre;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
if (entidad.TieneEmail())
{
parameter.Value = entidad.Mail;
}
else
{
parameter.Value = DBNull.Value;
}
}
public void Actualizar(UsuarioEntity usuario)
{
try
{
using (SqlConnection conexion = ConexionDA.ObtenerConexion())
{
using (SqlCommand comando = new SqlCommand("ActualizarUsuario", conexion))
{
comando.CommandType = CommandType.StoredProcedure;
SqlCommandBuilder.DeriveParameters(comando);
comando.Parameters["@UsuarioNombre"].Value = usuario.nombre.Trim();
comando.Parameters["@UsuarioApellido"].Value = usuario.apellido.Trim();
comando.Parameters["@UsuarioEmail"].Value = usuario.mail.Trim();
comando.Parameters["@UsuarioPassword"].Value = usuario.password.Trim();
comando.Parameters["@UsuarioTelefono"].Value = usuario.telefono.Trim();
comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;
comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();
comando.ExecuteNonQuery();
}
conexion.Close();
}
}
catch (Exception ex)
{
throw new ExcepcionDA("Se produjo un error al actualizar el usuario.", ex);
}
}
public void Actualizar(UsuarioEntity usuario)
{
try
{
using (SqlConnection conexion = ConexionDA.ObtenerConexion())
{
using (SqlCommand comando = new SqlCommand("ActualizarUsuario", conexion))
{
comando.CommandType = CommandType.StoredProcedure;
SqlCommandBuilder.DeriveParameters(comando);
comando.Parameters["@UsuarioNombre"].Value = usuario.nombre.Trim();
comando.Parameters["@UsuarioApellido"].Value = usuario.apellido.Trim();
comando.Parameters["@UsuarioEmail"].Value = usuario.mail.Trim();
comando.Parameters["@UsuarioPassword"].Value = usuario.password.Trim();
comando.Parameters["@UsuarioTelefono"].Value = usuario.telefono.Trim();
comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;
comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();
comando.ExecuteNonQuery();
}
conexion.Close();
}
}
catch (Exception ex)
{
throw new ExcepcionDA("Se produjo un error al actualizar el usuario.", ex);
}
}
public void Insertar(UsuarioEntity usuario)
{
try
{
using (SqlConnection conexion = ConexionDA.ObtenerConexion())
{
using (SqlCommand comando = new SqlCommand("CrearUsuario", conexion))
{
comando.CommandType = CommandType.StoredProcedure;
SqlCommandBuilder.DeriveParameters(comando);
comando.Parameters["@UsuarioNombre"].Value = usuario.nombre.Trim();
comando.Parameters["@UsuarioApellido"].Value = usuario.apellido.Trim();
comando.Parameters["@UsuarioEmail"].Value = usuario.mail.Trim();
comando.Parameters["@UsuarioPassword"].Value = usuario.password.Trim();
comando.Parameters["@UsuarioTelefono"].Value = usuario.telefono.Trim();
/*comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;*/
comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();
//comando.Parameters["@UsuarioFechaRegistracion"].Value = usuario.FechaRegistracion;
comando.ExecuteNonQuery();
/*usuario.idUsuario = Convert.ToInt32(comando.Parameters["@RETURN_VALUE"].Value);*/
}
conexion.Close();
}
}
catch (Exception ex)
{
throw new ExcepcionDA("Se produjo un error al insertar el usuario.", ex);
}
}
public void IniciarSesion(UsuarioDto usuarioDto)
{
UsuarioEntity usuario = _usuarioRepository.ObtenerUsuarioPorUsername(usuarioDto.Username);
if (usuario == null)
{
throw new Exception("No se encontró un usuario válido");
}
else
{
string password = _encriptacion.Encriptar(usuarioDto.Password);
bool passwordCorrecto = _usuarioRepository.VerificarPassword(usuarioDto.Username, password);
if (passwordCorrecto)
{
if (usuario.IndicadorHabilitado == EstadoEntidad.No)
{
throw new Exception("El usuario no se encuentra habilitado en el sistema");
}
}
else
{
throw new Exception("La contraseña proporcionada no es la correcta");
}
}
}
public void Initialize()
{
_usuarioRepositoryMock =
new Mock<IUsuarioRepository>();
_usuarioDomainService
= new UsuarioDomainService(_usuarioRepositoryMock.Object);
_usuario = Fakes.UsuarioFake.MakeSingle();
}
public void QuandoEuAtualizarUmUsuarioGerarExceptionSeUsuarioForNulo()
{
//arrange
_usuario = null;
//act
_usuarioDomainService.Atualizar(_usuario);
//assert
}
public void QuandoEuCriarUmUsuarioONomeDeveTer3CaracteresNoMinimo()
{
//arrange
_nome = "AB";
UsuarioEntity usuario;
//act
usuario = new UsuarioEntity(_nome, _login);
//assert
}
public void QuandoEuCriarUmUsuarioOLoginDeveSerObrigatorio()
{
//arrange
_login = string.Empty;
UsuarioEntity usuario;
//act
usuario = new UsuarioEntity(_nome, _login);
//assert
}
public void QuandoEuCriarUmUsuario()
{
//arrange
UsuarioEntity usuario;
//act
usuario = new UsuarioEntity(_nome, _login);
//assert
Assert.IsNotNull(usuario);
Assert.AreEqual(_nome, usuario.Nome);
Assert.AreEqual(_login, usuario.Login);
Assert.IsNotNull(usuario.Senha);
Assert.IsNotNull(usuario.Codigo);
Assert.IsNull(usuario.DataNascimento);
Assert.IsNull(usuario.EnderecoCompleto);
Assert.IsFalse(string.IsNullOrWhiteSpace(usuario.Senha));
}
public void Actualizar(UsuarioEntity entidad)
{
try
{
// Valida los datos cargados por el Usuario.
//Validar(entidad);
// Si el empleado no existe en la base de datos...
/*
if (daUsuario.BuscarPorClavePrimaria(entidad.mail) == null)
{
// ...se lanza la excepción correspondiente.
//throw new UsuarioNoExisteException(entidad.Legajo);
}
*/
// Si existe, se actualizan los datos.
daUsuario.Actualizar(entidad);
}
catch (ExcepcionDA ex)
{
}
}
public void Cadastrar(UsuarioEntity usuario)
{
ValidarUsuario(usuario);
_usuarioRepository.Add(usuario);
}
private void ValidarUsuario(UsuarioEntity usuario)
{
ValidatorHelper.GarantirNaoNulo(usuario, Messages.UsuarioNulo);
}
public void Atualizar(UsuarioEntity usuario)
{
ValidarUsuario(usuario);
_usuarioRepository.Update(usuario);
}
private UsuarioEntity CrearUsuario(SqlDataReader cursor)
{
UsuarioEntity usuario = new UsuarioEntity();
usuario.idUsuario = cursor.GetInt32(cursor.GetOrdinal("id_user"));
// completar los getordinal ( con los nombres de los campos de tabla m_usuario
usuario.idPermiso = cursor.GetInt32(cursor.GetOrdinal("idpermiso"));
usuario.nombre = cursor.GetString(cursor.GetOrdinal("nombre"));
usuario.apellido = cursor.GetString(cursor.GetOrdinal("apellido"));
usuario.mail = cursor.GetString(cursor.GetOrdinal("mail"));
usuario.password = cursor.GetString(cursor.GetOrdinal("contraseña"));
usuario.telefono = cursor.GetString(cursor.GetOrdinal("telefono"));
usuario.domicilio = cursor.GetString(cursor.GetOrdinal("domicilio"));
return usuario;
}
public void Insertar(UsuarioEntity usuario)
{
try
{
using (SqlConnection conexion = ConexionDA.ObtenerConexion())
{
using (SqlCommand comando = new SqlCommand("CrearUsuario", conexion))
{
comando.CommandType = CommandType.StoredProcedure;
SqlCommandBuilder.DeriveParameters(comando);
comando.Parameters["@UsuarioNombre"].Value = usuario.nombre.Trim();
comando.Parameters["@UsuarioApellido"].Value = usuario.apellido.Trim();
comando.Parameters["@UsuarioEmail"].Value = usuario.mail.Trim();
comando.Parameters["@UsuarioPassword"].Value = usuario.password.Trim();
comando.Parameters["@UsuarioTelefono"].Value = usuario.telefono.Trim();
/*comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;*/
comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();
//comando.Parameters["@UsuarioFechaRegistracion"].Value = usuario.FechaRegistracion;
comando.ExecuteNonQuery();
/*usuario.idUsuario = Convert.ToInt32(comando.Parameters["@RETURN_VALUE"].Value);*/
}
conexion.Close();
}
}
catch (Exception ex)
{
throw new ExcepcionDA("Se produjo un error al insertar el usuario.", ex);
}
}
private void CriarUsuario()
{
_usuario = new UsuarioEntity(_nome, _login, _senha, _grupos);
}
public void Registrar(UsuarioEntity Usuario, string emailVerificacion)
{
try
{
Usuario.ValidarDatos();
if (daUsuario.ExisteEmail(Usuario.mail))
throw new EmailExisteExcepcionBO();
if (Usuario.mail != emailVerificacion.Trim())
throw new VerificacionEmailExcepcionBO();
daUsuario.Insertar(Usuario);
}
catch (ExcepcionDA ex)
{
throw new ExcepcionBO("No se pudo realizar la registración del Usuario.", ex);
}
}
