public void Create(UsuarioVM usuarioVM)
{
var usuario = Mapper.Map<UsuarioVM, Usuario>(usuarioVM);
BeginTransaction();
usuarioService.Create(usuario);
Commit();
}
public ResultadoProcedimientoVM CrearUsuario(UsuarioVM usuario)
{
ResultadoProcedimientoVM resultado = new ResultadoProcedimientoVM();
try
{
using (var bdConn = new OracleConnection(cadenaConexion))
{
using (var bdCmd = new OracleCommand("PKG_USUARIO.SP_REGISTRAR_USUARIO", bdConn))
{
bdCmd.CommandType = CommandType.StoredProcedure;
bdCmd.Parameters.AddRange(ParametrosUsuario(usuario));
bdConn.Open();
bdCmd.ExecuteNonQuery();
resultado.CodResultado = 1;
resultado.NomResultado = "Registro Correctamente";
}
}
}
catch (Exception ex)
{
resultado.CodResultado = 0;
resultado.NomResultado = ex.Message;
}
return(resultado);
}
private void InitializeApplication()
{
if (usuarioVM == null)
{
usuarioVM = new UsuarioVM();
}
}
public ActionResult RegistrarCuenta()
{
UsuarioVM usuario = new UsuarioVM();
var combotipoPersona = new ParametroBLL().ConsultaParametro(EnumParametroTipo.TipoPersona.ValorEntero());
var comboTipoDocumento = new ParametroBLL().ConsultaParametro(EnumParametroTipo.TipoDocumento.ValorEntero());
comboTipoDocumento.Add(new ParametroModelo()
{
PARCOD = 0, PARNOM = ".:Tipo de Documento:."
});
combotipoPersona.Add(new ParametroModelo()
{
PARCOD = 0, PARNOM = ".:Tipo de Persona:."
});
usuario.SelectTipoDocumento = comboTipoDocumento.OrderBy(x => x.PARCOD)
.Select(j => new SelectListItem
{
Value = j.PARSEC.ToString(),
Text = j.PARNOM,
}).ToList();
usuario.SelectTipoPersona = combotipoPersona.OrderBy(x => x.PARCOD)
.Select(j => new SelectListItem
{
Value = j.PARSEC.ToString(),
Text = j.PARNOM,
}).ToList();
return(PartialView(usuario));
}
public ActionResult Salvar(Usuario usuario)
{
var model = new UsuarioVM();
try
{
if (usuario.Id != 0)
{
UsuarioServer.Atualizar(usuario);
model.Usuario = usuario;
model.Consistencia.Add("Alterado com sucesso!", ConsisteUtils.Tipo.Sucesso);
}
else
{
UsuarioServer.Novo(usuario);
model.Usuario = usuario;
model.Consistencia.Add("Incluido com sucesso!", ConsisteUtils.Tipo.Sucesso);
}
}
catch (Exception e)
{
model.Usuario = usuario;
var consistencia = new ConsisteUtils();
consistencia.Add(e.Message, ConsisteUtils.Tipo.Inconsistencia);
model.Consistencia = consistencia;
}
return(View("Form", model));
}
public bool gravar(UsuarioVM usu)
{
Endereco end = new Endereco()
{
bairro = usu.bairro,
cep = usu.cep,
cidade = new Cidade().getCidade(usu.cidade),
complemento = usu.complemento,
id = usu.idEndereco,
numero = usu.num,
referencia = usu.referencia,
rua = usu.rua
};
Usuario u = new Usuario()
{
id = usu.id,
celular = usu.celular,
cpf = usu.cpf,
dataNascimento = usu.dtNasc,
email = usu.email,
endereco = end,
nivelAcesso = usu.nivelAcesso,
nome = usu.nome,
rg = usu.rg,
senha = usu.senha,
telefoneFixo = usu.fixo
};
return(u.gravar());
}
public ActionResult Edit(UsuarioVM UsuarioVM)
{
if (ModelState.IsValid)
{
var to = UsuarioService.Obter(UsuarioVM.Identificador);
var UsuarioTO = Mapper.Map <UsuarioVM, UsuarioTO>(UsuarioVM);
if (to.Senha != UsuarioTO.Senha)
{
UsuarioTO.Senha = UtilitarioService.GerarHashMD5(UsuarioTO.Senha);
}
UsuarioService.Atualizar(UsuarioTO);
if (!UsuarioTO.Valido)
{
Session["Mensagem"] = UsuarioTO.Valido;
return(RedirectToAction("Index"));
}
UsuarioVM = Mapper.Map <UsuarioTO, UsuarioVM>(UsuarioTO);
}
return(RedirectToAction("Index"));
}
public bool SaveChanges(UsuarioVM usuario)
{
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
var u = db.usuario.Single(x => x.ID == usuario.ID);
u.Email = this.Email;
u.Nascimento = this.Nascimento;
u.Nome = this.Nome;
u.Telefone = this.Telefone;
u.Username = this.Username;
this.SetJsonAmbientes(u);
this.SetJsonGeneros(u);
db.ObjectStateManager.ChangeObjectState(u, System.Data.EntityState.Modified);
db.SaveChanges();
return(true);
}
}
catch { }
return(false);
}
public ActionResult Editar(UsuarioVM vm)
{
using (IVIADbContext contexto = new IVIADbContext())
{
GerenteUsuarios gerente = new GerenteUsuarios(contexto);
Usuario usuario = new Usuario();
usuario.Id = vm.Id;
usuario.Nome = vm.Nome;
usuario.Email = vm.Email;
usuario.Senha = vm.Senha;
try
{
gerente.ValidarAlterarUsuario(usuario);
contexto.Entry <Usuario>(usuario).State = System.Data.EntityState.Modified;
contexto.SaveChanges();
RedirectToAction("Index");
}
catch (RegrasDeNegocioException ex)
{
ex.CopiarPara(ModelState);
vm.Mensagem = "Erro";
}
return(View(vm));
}
}
//----------------------------------------------------------------------
public async Task <UsuarioVM> GetVM(int id)
{
var traer = await _context.Usuarios
.Include(a => a.pais)
.Include(b => b.soporte)
.Include(c => c.rol)
.FirstOrDefaultAsync(f => f.usuario_id == id);
if (traer == null)
{
throw new Exception("Usuario no encontrado");
}
UsuarioVM modelo = new UsuarioVM
{
usuario_id = traer.usuario_id,
rol_id = traer.rol_id,
rol = traer.rol.nombre,
pais_id = traer.pais_id,
pais = traer.pais.nombre,
soporte_id = traer.soporte_id,
soporte = traer.soporte.nombre,
nombre = traer.nombre,
email = traer.email,
activo = traer.activo,
programador = traer.programador,
tlf_movil = traer.tlf_movil,
tlf_oficina = traer.tlf_oficina,
f_login = traer.f_login
};
return(modelo);
}
public async Task <IActionResult> Criar(UsuarioVM viewModel)
{
var EmailJaExiste = await db.Usuarios.AnyAsync(a => a.Email == viewModel.Email);
if (EmailJaExiste)
{
ModelState.AddModelError("Email", "Email já foi cadastrado!");
}
if (ModelState.IsValid)
{
var usuario = new Usuario(viewModel.Nome, viewModel.Email, viewModel.Perfil);
//TODO: Retirar esse método para utilizar em produção
usuario.AlterarSenha("123456");
await db.AddAsync(usuario);
await db.SaveChangesAsync();
//TODO: Descomentar se for utilizar
// await email.EnviarEmailParaCriacaoDeSenha(usuario.Email, usuario.Hash);
return(RedirectToAction(nameof(Index)));
}
CarregarPerfis();
return(View(viewModel));
}
public void InsUsuario(UsuarioVM usu)
{
// TODO: Add insert logic here
List <UsuarioVM> us = new List <UsuarioVM>();
XmlSerializer xs = new XmlSerializer(typeof(List <UsuarioVM>));
StreamReader s = new StreamReader(@"C:\Users\y7bi\source\repos\MVC_Angular_Bootstrap\Dados\Usuarios.xml");
us = (List <UsuarioVM>)xs.Deserialize(s);
s.Close();
UsuarioVM uAux = us.Where(u => (u.Cpf == usu.Cpf || u.Email == usu.Email) && u.Matricula != usu.Matricula).FirstOrDefault();
if (uAux == null)
{
usu.Matricula = DateTime.Now.ToString("yyyyMMddHms");
us.Add(usu);
StreamWriter sw = new StreamWriter(@"C:\Users\y7bi\source\repos\MVC_Angular_Bootstrap\Dados\Usuarios.xml");
xs.Serialize(sw, us);
sw.Close();
}
}
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 IActionResult Login(UsuarioVM user)
{
if (user != null)
{
var v = _usuarioBO.GetUsuario(user.UserName);
if (v.UserName == user.UserName.ToLower() && v.Senha == user.Senha)
{
HttpContext.Session.SetString("usuarioLogadoID", v.Id.ToString());
HttpContext.Session.SetString("nomeUsuarioLogado", v.Nome);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
else
{
ViewBag.Mensagem = new RetornoMensagem(
mensagem: "Usuario e Senha em branco!",
tipo: Domain.Models.Enuns.Tipos.Senha
);
return(RedirectToAction("Index", "Login"));
}
}
public ActionResult Evento(string id)
{
if (this.BaseUsuario != null)
{
this.Usuario = new UsuarioVM(this.BaseUsuario);
}
else
{
this.Usuario = null;
}
ViewBag.Usuario = this.Usuario;
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
int idEvento = int.MinValue;
int.TryParse(id, out idEvento);
var e = new EventoVM(db.evento.First(x => x.ID == idEvento && x.Ativo && x.Publicado));
e.ContarVisualizacao();
return(View(e));
}
}
catch { return(Redirect("/inicio/")); }
}
public async Task <IActionResult> Editar(UsuarioVM model)
{
var EmailJaExisteEmOutroUsuario = await db.Usuarios.AnyAsync(a =>
a.Id != model.Id &&
a.Email == model.Email);
if (EmailJaExisteEmOutroUsuario)
{
ModelState.AddModelError("Email", "Email já foi cadastrado!");
}
if (ModelState.IsValid)
{
var usuario = await db.Usuarios.FindAsync(model.Id);
usuario.Atualizar(model.Nome, model.Email, model.Perfil);
db.Update(usuario);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
CarregarPerfis();
return(View(model));
}
public ActionResult Seguindo(string tab = "musicos")
{
ViewBag.Tab = tab;
this.Usuario = new UsuarioVM(this.BaseUsuario);
return(View(this.Usuario));
}
public ActionResult ChangeCoordinador(UsuarioVM usuarioVM)
{
UsuarioDomainModel usuarioDomainModel = new UsuarioDomainModel();
AutoMapper.Mapper.Map(usuarioVM, usuarioDomainModel);
movilizadoBusiness.MigrarMovilizados(usuarioDomainModel);
return(RedirectToAction("Administrar", "Usuario"));
}
public ActionResult Endereco()
{
this.Usuario = new UsuarioVM(this.BaseUsuario);
var endereco = this.Usuario.Endereco;
return(View(endereco));
}
public ActionResult UploadProfile(HttpPostedFileBase Arquivo, string Href)
{
this.Usuario = new UsuarioVM(this.BaseUsuario);
new ImagemVM(Arquivo, this.Usuario.ID, int.MinValue, 1).Upload();
return(Redirect(Href));
}
private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
{
if (_usuarioVM == null)
{
_usuarioVM = new UsuarioVM();
}
this.DataContext = _usuarioVM;
}
public ActionResult registrarAdministrado(UsuarioVM modelo)
{
modelo.NRO_DOCUMENTO = (modelo.ID_TIPO_DOCUMENTO == EnumParametro.DNI.ValorEntero() ? modelo.DNI : modelo.NRO_DOCUMENTO);
UsuarioVM usuario = new UsuarioVM();
usuario.NOMBRE_USUARIO = modelo.NRO_DOCUMENTO;
usuario.CLAVE = RandomString(6);
usuario.ID_TIPO_PERSONA = modelo.ID_TIPO_PERSONA;
usuario.ID_TIPO_DOCUMENTO = modelo.ID_TIPO_DOCUMENTO;
usuario.NRO_DOCUMENTO = modelo.NRO_DOCUMENTO;
usuario.RAZON_SOCIAL = modelo.RAZON_SOCIAL;
usuario.TELEFONO = modelo.TELEFONO;
usuario.CORREO = modelo.CORREO;
usuario.DIRECCION = modelo.DIRECCION;
usuario.NOMBRES = modelo.NOMBRES;
usuario.APEPAT = modelo.APEPAT;
usuario.APEMAT = modelo.APEMAT;
usuario.NRO_DOCUMENTO_REPRESENTANTE_LOCAL = modelo.NRO_DOCUMENTO_REPRESENTANTE_LOCAL;
usuario.ID_TIPO_DOCUMENTO_REPRESENTANTE_LEGAL = modelo.ID_TIPO_DOCUMENTO_REPRESENTANTE_LEGAL;
//verifica si el usuario ya fue creado
var resultadoBusqueda = new UsuarioBLL().BuscarUsuario(usuario.NRO_DOCUMENTO, "", 0, usuario.ID_TIPO_PERSONA);
if (resultadoBusqueda.ResultadoUsuarioVM.Validacion == 1)
{
return(Json(new { codresultado = 0, mensaje = "Ya existe un usuario para el nro documento " + usuario.NRO_DOCUMENTO }));
}
if (resultadoBusqueda.ResultadoUsuarioVM.Validacion == 3)
{
return(Json(new { codresultado = 0, mensaje = "La empresa " + usuario.NRO_DOCUMENTO + " no esta autorizada por el ATU." }));
}
var resultadoRegistra = new UsuarioBLL().CrearUsuario(usuario);
List <ComboModalidadServicioVM> resultaModalidadServicio = new List <ComboModalidadServicioVM>();
if (resultadoRegistra.CodResultado == 1)
{
if (modelo.ID_TIPO_PERSONA == EnumParametroTipoPersona.PersonaJuridica.ValorEntero())
{
resultaModalidadServicio = new UsuarioBLL().BuscarModalidad(usuario.NRO_DOCUMENTO);
foreach (var item in resultaModalidadServicio)
{
var resultadoModalidad = new UsuarioBLL().CrearModalidadServicio(usuario.NRO_DOCUMENTO, item.ID_MODALIDAD_SERVICIO);
}
}
enviarConfirmacion(usuario.CORREO, usuario.NRO_DOCUMENTO, usuario.CLAVE, resultaModalidadServicio);
return(Json(new { codresultado = 1, mensaje = "Registró correctamente" }));
}
else
{
return(Json(new { codresultado = 0, mensaje = resultadoRegistra.NomResultado }));
}
}
public List <UsuarioVM> getUsuario()
{
var dados = new Usuario().getUsuario();
List <UsuarioVM> list = new List <UsuarioVM>();
foreach (Usuario u in dados)
{
UsuarioVM usu = new UsuarioVM();
usu.bairro = u.endereco.bairro;
usu.celular = u.celular;
usu.cep = u.endereco.cep;
usu.cidade = u.endereco.cidade.id;
usu.id = u.id;
usu.idEndereco = u.endereco.id;
usu.nivelAcesso = u.nivelAcesso;
usu.nome = u.nome;
usu.rg = u.rg;
usu.rua = u.endereco.rua;
usu.senha = u.senha;
usu.fixo = u.telefoneFixo;
list.Add(usu);
}
if (list.Count > 0)
{
return(list);
}
/*
* if (dados != null && dados.Count > 0)
* {
* return (from Usuario u in dados
* select new UsuarioVM()
* {
* bairro = u.endereco.bairro,
* celular = u.celular,
* cep = u.endereco.cep,
* cidade = u.endereco.cidade.id,
* id = u.id,
* complemento = u.endereco.complemento,
* cpf = u.cpf,
* dtNasc = u.dataNascimento,
* email = u.email,
* estado = u.endereco.cidade.estado.id,
* fixo = u.telefoneFixo,
* idEndereco = u.endereco.id,
* nivelAcesso = u.nivelAcesso,
* nome = u.nome,
* num = u.endereco.numero,
* referencia = u.endereco.referencia,
* rg = u.rg,
* rua = u.endereco.rua,
* senha = u.senha
* }).ToList();
* }*/
return(null);
}
private Boolean add = true; // true añadir usuario, false modificar usuario
/// <summary>
/// Constructor para añadir un usuario
/// </summary>
/// <param name="uVM">Vista modelo del usuario</param>
public AddEditUsuario(UsuarioVM uVM)
{
UIGlobal.AddEditUsuario = this;
InitializeComponent();
usuarioVM = uVM;
usuario = new Usuario();
DataContext = usuario;
add = true;
}
public UsuarioView()
{
InitializeComponent();
BindingContext = new UsuarioVM();
listaUsuarios.ItemTapped += (sender, e) => {
Usuario usuario = (Usuario)e.Item;
BindingContext = new UsuarioVM(usuario);
};
}
public IActionResult GetUsuario(string usuarioId)
{
int casaId = Util.GetCasaUsuario(User);
Usuario u = _authService.GetUsuario(usuarioId, casaId);
UsuarioVM uVM = Mapper.Map <UsuarioVM>(u);
return(Ok(uVM));
}
public ActionResult Buscar()
{
if (this.BaseUsuario != null)
{
this.Usuario = new UsuarioVM(this.BaseUsuario);
ViewBag.Usuario = this.Usuario;
}
return(View());
}
public void AoRealizarUmPostParaAActionEdicaoDeveChamarOMetodoCreateDoUsuarioAppServiceSeModelIsValid()
{
var vm = new UsuarioVM
{
Nome = "Fulano",
Email = "*****@*****.**"
};
usuariosController.Edicao(vm);
usuarioAppService.Received().Update(vm);
}
public ActionResult Edicao(UsuarioVM model)
{
if (!ModelState.IsValid)
{
PreencherTodosOsViewBags(model.SetorId, model.PerfilId);
return View(model);
}
usuarioAppService.Update(model);
return RedirectToAction("Index", "Usuarios");
}
public bool ValidarNomeUsuario(UsuarioVM usuario)
{
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
return(!db.usuario.Any(x => x.Username.ToLower() == this.Username.ToLower() && x.ID != usuario.ID));
}
}
catch { return(true); }
}
public IActionResult Edit(long id)
{
Usuario usuario = this.db.Usuarios.Where(x => x.Id == id).FirstOrDefault();
UsuarioVM vm = new UsuarioVM();
vm.Nome = usuario.Nome;
vm.Email = usuario.Email;
vm.Password = usuario.Password;
return(View(vm));
}
public bool ValidarEmail(UsuarioVM usuario)
{
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
return(!db.usuario.Any(x => x.Email == this.Email && x.ID != usuario.ID));
}
}
catch { return(true); }
}
public ActionResult <UsuarioVM> Login(UsuarioVM model)
{
try
{
return(Ok(_usuarioService.Login(model)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void AoRealizarUmPostParaAActionNovoDeveChamarOMetodoCreateDoUsuarioAppServiceSeModelIsValid()
{
var vm = new UsuarioVM
{
Nome = "Fulano",
Email = "*****@*****.**",
Password = "******",
ConfirmacaoPassword = "******"
};
usuariosController.Novo(vm);
usuarioAppService.Received().Create(vm);
}
public void AoAlterarASenhaDeveChamarOMetodoAtualizarSenhaDoAppService()
{
var vm = new UsuarioVM
{
Nome = "Fulano",
Email = "*****@*****.**",
Password = "******",
ConfirmacaoPassword = "******"
};
usuariosController.AlterarSenha(vm);
usuarioAppService.Received().AtualizarSenha(vm);
}
private UsuarioVM ObterViewModelInvalido()
{
var badModel = new UsuarioVM();
var validationContext = new ValidationContext(badModel, null, null);
var validationResults = new List<ValidationResult>();
Validator.TryValidateObject(badModel, validationContext, validationResults, true);
foreach (var validationResult in validationResults)
{
usuariosController.ModelState.AddModelError(validationResult.MemberNames.First(), validationResult.ErrorMessage);
}
return badModel;
}
public void AoSolicitarAlteracaoDeSenhaDeveRetornarUmUsuarioVMParaAView()
{
var vm = new UsuarioVM
{
Nome = "Fulano",
Email = "*****@*****.**"
};
usuarioAppService.ObterParaEdicao(1).Returns(vm);
var result = (ViewResult)usuariosController.AlterarSenha(1);
Assert.AreEqual(typeof(UsuarioVM), result.Model.GetType());
}
public ActionResult AlterarSenha(UsuarioVM model)
{
usuarioAppService.AtualizarSenha(model);
return RedirectToAction("Index");
}
public ActionResult Novo(UsuarioVM model)
{
if (!ModelState.IsValid)
{
PreencherTodosOsViewBags();
return View(model);
}
usuarioAppService.Create(model);
sistemaHub.Comunicar(setorAppService.ObterNomeDoSetorPorId(model.SetorId), "Usuário adicionado ao sistema");
return RedirectToAction("Index", "Usuarios");
}
public void AtualizarSenha(UsuarioVM usuario)
{
BeginTransaction();
usuarioService.AtualizarSenha(Mapper.Map<UsuarioSenhaDTO>(usuario));
Commit();
}
