public List <UsuarioModelView> Listar()
{
StreamReader sr = new StreamReader("usuarios.csv", true);
UsuarioModelView usuario;
if (File.Exists("usuarios.csv"))
{
return(null);
}
string[] listaDeUsuario = File.ReadAllLines("usuarios.csv");
foreach (var item in listaDeUsuario)
{
if (item != null)
{
string[] dadosDeCadaUsuario = item.Split(";");
usuario = new UsuarioModelView();
usuario.Id = int.Parse(dadosDeCadaUsuario[0]);
usuario.Nome = dadosDeCadaUsuario[1];
usuario.Email = dadosDeCadaUsuario[2];
usuario.Senha = dadosDeCadaUsuario[3];
usuario.DataCriacao = DateTime.Parse(dadosDeCadaUsuario[4]);
listaDeUsuarios.Add(usuario);
}
}
return(listaDeUsuarios);
}
public static void UpdateUsuario(UsuarioModelView model)
{
User objretorno = new User();
//faz o de para: objModelView para objEntity
Mapper.CreateMap <UsuarioModelView, User>();
var objtpprod = Mapper.Map <User>(model);
////pega o nome da Produto
if (model.imagem != null)
{
objtpprod.imagem = model.imagem.FileName;
}
else
{
objtpprod.imagem = model.arquivoimagem;
}
//objtpprod.dataincl = DateTime.Now;
UserRepository tpprod = new UserRepository();
tpprod.Edit(objtpprod);
tpprod.Save();
}
public ActionResult Usuario(Int16 id = 0, Int16 id2 = 0, string id3 = "")
{
var model = new UsuarioModelView();
ViewBag.erro = id3;
if (id != 0)
{
//busca as informações para edição
model = ServiceUsuario.GetUsuarioId(id);
}
//busca os outros usuários daquele representante
//Int16 repreid = Domain.Util.valida.getRepresentanteID(User.Identity.Name);
//model.Representantes = ServiceRepresentante.getRepresentante(repreid);
//ViewBag.repreid = repreid;
//verifica se o usuário atual é admin
bool useradmin = GetUserAdmin(User.Identity.Name);
//model.Usuarios = ServiceUsuario.getUsuarioAll(repreid);
model.UsuariosTipos = ServiceUsuarioTipo.getUsuarioTipo(useradmin);
return(View(model));
}
public object Logar(
[FromBody] UsuarioModelView usuarioModelView,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfiguration tokenConfigurations)
{
bool credenciaisValidas = false;
if (usuarioModelView != null && !String.IsNullOrWhiteSpace(usuarioModelView.UserID))
{
var usuarioBase = _usuarioBll.ObterPorId(usuarioModelView.UserID);
credenciaisValidas = (usuarioBase != null &&
usuarioModelView.UserID == usuarioBase.UserID &&
usuarioModelView.AccessKey == usuarioBase.AccessKey);
}
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuarioModelView.UserID, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuarioModelView.UserID)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
});
}
else
{
_errorHandler.Mensagem = "Usuário não autorizado!";
_errorHandler.Error = true;
return(StatusCode(401, Json(_errorHandler)));
}
}
public ActionResult Inativar(UsuarioModelView user)
{
Usuario usuario = usuarioDAO.GetById(user.Id);
usuario.Ativo = !usuario.Ativo;
usuarioDAO.Alter(usuario);
return(RedirectToAction("Index"));
}
///<summary>Pede todas as informações para o usuário, recolhe e as insere no armazenamento. </summary>
public static void CadastrarUsuario()
{
string nome, email, senha, tipo = null, confirm;
//RECEBE E TESTA NOME DE USUÁRIO
do
{
System.Console.Write("Nome de usuário: ");
nome = Console.ReadLine();
if (!ValidacaoUtil.ValidarStringVazia(nome))
{
Mensagem.MostrarMensagem("O nome não pode ficar vazio.", TipoMensagemEnum.ALERTA);
}
} while (!ValidacaoUtil.ValidarStringVazia(nome));
//RECEBE E TESTA EMAIL
do
{
System.Console.Write("Email: ");
email = Console.ReadLine();
if (!ValidacaoUtil.ValidarEmail(email))
{
Mensagem.MostrarMensagem("O email não possui um formato válido.", TipoMensagemEnum.ALERTA);
}
} while (!ValidacaoUtil.ValidarEmail(email));
//RECEBE E TESTA SENHA
do
{
System.Console.Write("Senha: ");
senha = Console.ReadLine();
System.Console.Write("Confirme a senha: ");
confirm = Console.ReadLine();
if (!ValidacaoUtil.ValidarSenha(senha, confirm))
{
Mensagem.MostrarMensagem("A senha não pode ter menos de 8 caracteres nem mais do que 32.", TipoMensagemEnum.ALERTA);
}
} while (!ValidacaoUtil.ValidarSenha(senha, confirm));
//RECEBE O TIPO DE USUÁRIO
do
{
MenuUtil.MostrarMenuTipoUsuario();
MenuTipoUsuário opcaoTipoUsuario = (MenuTipoUsuário)Enum.Parse(typeof(MenuTipoUsuário), Console.ReadLine());
if (ValidacaoUtil.ValidarTipoUsuario(opcaoTipoUsuario) == null)
{
Mensagem.MostrarMensagem("Por favor, digite um número adequado.", TipoMensagemEnum.ALERTA);
continue;
}
else
{
tipo = ValidacaoUtil.ValidarTipoUsuario(opcaoTipoUsuario);
}
} while (tipo == null);
usuarioModelView = new UsuarioModelView(nome, email, senha, tipo);
repository.InserirUsuario(usuarioModelView);
Mensagem.MostrarMensagem("Usuário cadastrado com sucesso!", TipoMensagemEnum.SUCESSO);
}
public void Inserir(UsuarioModelView usuarioModelView)
{
var usuario = new Usuario();
usuario.UserID = usuarioModelView.UserID;
usuario.AccessKey = usuarioModelView.AccessKey;
_usuarioDAO.Inserir(usuario);
}
///<summary>Insere o usuário cadastrado na plataforma de armazenamento escolhida e também define seu ID com base na quantidade de usuários já existentes.</summary>
///<param name="usuarioModelView">Objeto usuário</param>
///<returns>Retorna um objeto do tipo UsuarioModelView.</returns>
public UsuarioModelView InserirUsuario(UsuarioModelView u)
{
//Gera um arquivo CSV
StreamWriter sw = new StreamWriter("usuarios.csv", true);
sw.WriteLine($"{u.Id};{u.Nome};{u.Email};{u.Senha};{u.Senha};{u.DataCriacao}");
sw.Close();
return(u);
}
public ActionResult Index(int pagina = 1, FiltroDefault filtro = null)
{
var _modelUsuario = new UsuarioModelView();
_modelUsuario.Usuarios = Filtrar(filtro);
_modelUsuario.Filtro = filtro;
_modelUsuario.Paginacao = new Paginacao();
_modelUsuario.Paginacao.PaginaAtual = pagina;
_modelUsuario.Usuarios = _modelUsuario.Paginacao.Paginar <Usuario>(_modelUsuario.Usuarios);
return(View("Index", _modelUsuario));
}
public IActionResult Adicionar([FromBody] UsuarioModelView usuarioModelView)
{
try
{
_usuarioBll.Inserir(usuarioModelView);
return(StatusCode(201));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(StatusCode(500));
}
}
//get produto ID
public static UsuarioModelView GetUsuarioId(Int16 id)
{
User objretorno = new User();
UserRepository tpprod = new UserRepository();
objretorno = tpprod.Find(id);
//faz o de para: objEntity para objModelView
UsuarioModelView model = GetUserModelDePara(objretorno);
return(model);
}
public ActionResult Adicionar(UsuarioModelView modelUser)
{
//Valida se há dados paracontinuar
if (modelUser == null)
{
return(new HttpStatusCodeResult(
HttpStatusCode.BadRequest));
}
CadastroDeUsuario usuario = UsuarioFactory.GeraUsuario(modelUser);
if (usuario == null)
{
return(new HttpStatusCodeResult(
HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
try
{
int?cc = null;
if (usuario.CentroDeCusto != null)
{
cc = usuario.CentroDeCusto.Id;
}
//Cria o usuário
WebSecurity.CreateUserAndAccount(usuario.Login, usuario.Senha, new
{
Nome = usuario.Nome,
Email = usuario.Email,
IsAdmin = usuario.IsAdmin,
Cpf = usuario.Cpf,
CentroDeCusto_id = cc
}
, false);
}
catch (MembershipCreateUserException ex)
{
return(View(usuario));
}
return(RedirectToAction("Index"));
}
else
{
return(View(modelUser));
}
}
///<summary>Valida se o email e a senha digitadas pelo usuário correspondem ao email e a senha de algum usuário já existente.</summary>
///<param name="email">Email do usuário</param>
///<param name="senha">Senha do usuário</param>
///<returns>Retorna 'true' caso a senha e o email tenham sido encontrados em algum usuário existente, e retorna 'false' no caso contrário.</returns>
public static bool ValidarLogin(string email, string senha)
{
UsuarioModelView usuario = UsuarioRepository.BuscarUsuarioPorEmail(email);
if (usuario == null)
{
return(false);
}
if (usuario.Senha == senha && usuario.Email == email)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Cria um usuário model view com base em uma model
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static UsuarioModelView BuildModelView(Usuario model)
{
UsuarioModelView modelView = new UsuarioModelView()
{
Ativo = model.Ativo,
DataCriacao = model.DataCriacao,
Email = model.Email,
Id = model.Id,
IsAdmin = model.IsAdmin,
LastAcess = model.LastAcess,
Login = model.Login,
Nome = model.Nome,
Password = model.Password
};
return(modelView);
}
/// <summary>
/// Cria um usuário com base em uma UsuárioModelView
/// </summary>
/// <param name="modelView">The model view.</param>
/// <returns></returns>
public static Usuario BuildModel(UsuarioModelView modelView)
{
Usuario user = new Usuario()
{
Ativo = modelView.Ativo,
DataCriacao = modelView.DataCriacao,
Email = modelView.Email,
Id = modelView.Id,
IsAdmin = modelView.IsAdmin,
LastAcess = modelView.LastAcess,
Login = modelView.Login,
Nome = modelView.Nome,
Password = modelView.Password
};
return(user);
}
/// <summary>
/// Cria uma usuário com base em UsuarioModelView
/// </summary>
/// <param name="model"></param>
/// <param name="ccDAO"></param>
/// <returns></returns>
public static CadastroDeUsuario GeraUsuario(UsuarioModelView model)
{
CadastroDeUsuario usuario = new CadastroDeUsuario()
{
CentroDeCusto = ccDAO.GetByCodigo(model.CentroDeCusto),
Cpf = model.Cpf,
Email = model.Email,
Id = model.Id,
IsAdmin = model.IsAdmin,
Login = model.Login,
Nome = model.Nome,
Senha = model.Senha,
Role = model.Role
};
return(usuario);
}
public ActionResult Incluir(UsuarioModelView user)
{
if (!ModelState.IsValid)
{
return(View(user));
}
user.Password = PasswordHash.Hash(user.Password);
user.DataCriacao = DateTime.Now;
Usuario usuario = UsuarioFactory.BuildModel(user);
usuario.Role = roleDAO.GetById(user.Role);
usuarioDAO.Add(usuario);
return(RedirectToAction("Index"));
}
public ActionResult Alterar(UsuarioModelView user)
{
if (!ModelState.IsValid)
{
ViewBag.Role = new SelectList(roleDAO.List(), "Id", "Description", user.Role);
return(View(user));
}
user.Password = PasswordHash.Hash(user.Password);
Usuario usuario = UsuarioFactory.BuildModel(user);
usuario.Role = roleDAO.GetById(user.Role);
usuarioDAO.Alter(usuario);
return(RedirectToAction("Index"));
}
public ActionResult Edit(UsuarioModelView usuario)
{
try
{
if (!ModelState.IsValid)
{
TempData["success"] = "Usuário editado com sucesso!!";
_usuarioService.Update(Mapper.Map <UsuarioModelView, Usuario>(usuario));
return(RedirectToAction("Index"));
}
throw new Exception("Não foi possivel editar este usuário, por favor contate o administrador do sistema.");
}
catch (Exception e)
{
TempData["warning"] = e.Message;
return(View(usuario));
}
}
public async Task <ActionResult> Post([FromServices] DataContext context, UsuarioModelView usuarioModel)
{
try
{
Usuario usuario = new Usuario();
usuario.EMAIL = usuarioModel.Email;
usuario.NOME = usuarioModel.NomeCompleto;
usuario.SENHA = usuarioModel.Senha;
context.Usuario.Add(usuario);
await context.SaveChangesAsync();
return(Ok(true));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private static UsuarioModelView GetUserModelDePara(User objprod)
{
UsuarioModelView model = new UsuarioModelView();
model.userid = objprod.UserId;
model.arquivoimagem = objprod.imagem;
model.apelido = objprod.Apelido;
model.dataalt = objprod.Dataalt;
model.dataincl = objprod.DataIncl;
model.email = objprod.Email;
model.nome = objprod.Nome;
model.senha = objprod.Senha;
model.status = objprod.Status;
model.usuariotipoid = objprod.usuariotipoid;
return(model);
}
public ActionResult Create(UsuarioModelView usuario)
{
try
{
if (ModelState.IsValid)
{
usuario.Removido = true;
__usuarioService.AddUsuario(Mapper.Map <UsuarioModelView, Usuario>(usuario));
TempData["success"] = "Novo usuário criado com sucesso!!";
return(PartialView("Partials/_UsuarioCreate"));
}
throw new Exception("Não foi possivel editar este usuário, por favor contate o administrador do sistema.");
}
catch (Exception e)
{
TempData["warning"] = e.Message;
return(RedirectToAction("Create", usuario));
}
}
public static void InsertUsuario(UsuarioModelView model)
{
User objretorno = new User();
//faz o de para: objModelView para objEntity
Mapper.CreateMap <UsuarioModelView, User>();
var objtpprod = Mapper.Map <User>(model);
objtpprod.DataIncl = DateTime.Now;
////pega o nome da Produto
if (model.imagem != null)
{
objtpprod.imagem = model.imagem.FileName;
}
UserRepository tpprod = new UserRepository();
tpprod.Add(objtpprod);
tpprod.Save();
}
public static UsuarioModelView GetModelView(CadastroDeUsuario model)
{
UsuarioModelView modelView = new UsuarioModelView()
{
Id = model.Id,
Cpf = model.Cpf,
Email = model.Email,
IsAdmin = model.IsAdmin,
Login = model.Login,
Nome = model.Nome,
Senha = model.Senha,
Role = model.Role
};
if (model.CentroDeCusto != null)
{
modelView.CentroDeCusto = model.CentroDeCusto.Codigo;
}
return(modelView);
}
public ActionResult Alterar(FormCollection form, UsuarioModelView modelUser)
{
//Valida se há dados para continuar
if (modelUser == null)
{
return(new HttpStatusCodeResult(
HttpStatusCode.BadRequest));
}
CadastroDeUsuario usuario = UsuarioFactory.GeraUsuario(modelUser);
MembershipUser user = Membership.GetUser(usuario.Login);
if (ModelState.IsValid)
{
try
{
//SecurityProvider securi = new SecurityProvider(usuarioDAO);
//securi.ChangePassword(usuario.Id, "", usuario.Senha);
user.ChangePassword(usuarioDAO.GetById(usuario.Id).Senha, usuario.Senha);
usuarioDAO.Altera(usuario);
}
catch (Exception ex)
{
ModelState.AddModelError("Alterar_Usuario", "Erro ao tentar mudar esse usuário " + ex.Message);
return(View("Alterar", usuario));
}
}
else
{
return(View("Alterar", usuario));
}
return(RedirectToAction("Index"));
}
public ActionResult Alterar(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(
HttpStatusCode.BadRequest));
}
ViewBag.CentroDeCusto = new SelectList(
ccDAO.ListAll(),
"Codigo",
"Descricao"
);
ViewBag.Role = new SelectList(
new RoleDAO().ListRole,
"Role",
"Descricao"
);
UsuarioModelView model = UsuarioFactory.GetModelView(usuarioDAO.GetById(id));
return(View(model));
}
public async Task <ActionResult <UsuarioModelView> > GetValidation([FromServices] DataContext context, [FromBody] UsuarioModelView usuarioModel)
{
try
{
var usuario = await context.Usuario
.AsNoTracking()
.FirstOrDefaultAsync(x => x.EMAIL == usuarioModel.Email);
if (usuario == null)
{
return(null);
}
else
{
if (usuario.SENHA == usuarioModel.Senha)
{
return(new UsuarioModelView()
{
NomeCompleto = usuario.NOME,
Email = usuario.EMAIL,
Senha = usuario.SENHA,
Admin = usuario.ADMIN
});
}
else
{
return(null);
}
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Usuario(UsuarioModelView model)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account", null));
}
if (ModelState.IsValid)
{
Domain.Util.Imagem ImgRet = new Domain.Util.Imagem();
//faz o upload da imagem
if (model.imagem != null)
{
ImgRet = Domain.Util.Upload.ImagemUpload(model.imagem, "usuario");
}
else
{
ImgRet.Ok = true;
}
String msg = string.Empty;
if (!ImgRet.Ok)
{
msg = ImgRet.Mensagem;
return(Redirect(Domain.Util.config.UrlSite + "User/Usuario/" + model.userid + "/0/" + HttpUtility.UrlEncode(msg)));
}
else
{
model.useralt = User.Identity.Name;
model.status = Convert.ToInt16(model.statusb);
//verifica se o email usuario já existe
ViewBag.msg = getUser(model.email, model.userid);
if (!string.IsNullOrEmpty(ViewBag.msg))
{
return(Redirect(Domain.Util.config.UrlSite + "User/Usuario/0/0/" + HttpUtility.UrlEncode(ViewBag.msg)));
}
else
{
if (model.userid != 0) //update
{
ServiceUsuario.UpdateUsuario(model);
}
else //insert
{
ServiceUsuario.InsertUsuario(model);
}
}
}
return(Redirect(Domain.Util.config.UrlSite + "User/Usuario"));
}
//Int16 repreid = Domain.Util.valida.getRepresentanteID(User.Identity.Name);
//model.Representantes = ServiceRepresentante.getRepresentante(repreid);
//ViewBag.repreid = repreid;
//model.Usuarios = ServiceUsuario.getUsuarioAll(repreid);
//verifica se o usuário atual é admin
bool useradmin = GetUserAdmin(User.Identity.Name);
model.UsuariosTipos = ServiceUsuarioTipo.getUsuarioTipo(useradmin);
return(View(model));
}
