public async Task <IActionResult> Create(Cozinha c, IFormFile fupImagem)
{
if (fupImagem != null)
{
string arquivo = Guid.NewGuid().ToString() + Path.GetExtension(fupImagem.FileName);
string caminho = Path.Combine(hosting.WebRootPath, "deliveryimagens", arquivo);
fupImagem.CopyTo(new FileStream(caminho, FileMode.Create));
c.Imagem = arquivo;
}
else
{
c.Imagem = "semimagem.jfif";
}
UsuarioLogado uLogado = new UsuarioLogado
{
UserName = c.Nome,
Email = c.Email,
nivelAcesso = 0,
idNormal = c.idCozinha
};
IdentityResult result = await userManager.CreateAsync(uLogado, c.Senha);
if (result.Succeeded)
{
if (cozinhaDAO.Cadastrar(c))
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Essa cozinha já existe!");
}
AdicionarErros(result);
return(View(c));
}
protected override void Configure()
{
Mapper.CreateMap <Usuario, UsuarioViewModel>()
.BeforeMap((d, vm) =>
{
vm.CategoriasInteresse = new List <int>();
foreach (var categoria in d.UsuarioCategoria)
{
vm.CategoriasInteresse.Add(categoria.Categoria.Id);
}
});
Mapper.CreateMap <Categoria, CategoriaViewModel>();
Mapper.CreateMap <Empresa, EmpresaViewModel>();
Mapper.CreateMap <Enquete, EnqueteViewModel>()
.BeforeMap((d, vm) =>
{
vm.EmpresaId = (int)UsuarioLogado.UsuarioAutenticado().EmpresaId;
vm.UsuarioId = UsuarioLogado.UsuarioAutenticado().Id;
vm.Tipo = UsuarioLogado.UsuarioAutenticado().Perfil == Domain.Enumeradores.EnumPerfil.AdministradorEmpresa
? Domain.Enumeradores.EnumTipoEnquete.Interesse
: Domain.Enumeradores.EnumTipoEnquete.Publica;
});
Mapper.CreateMap <Pergunta, PerguntaViewModel>();
Mapper.CreateMap <Resposta, RespostaViewModel>();
Mapper.CreateMap <Documento, DocumentoViewModel>();
Mapper.CreateMap <Plataforma, PlataformaViewModel>();
Mapper.CreateMap <Voucher, VoucherViewModel>();
Mapper.CreateMap <Banner, BannerViewModel>();
Mapper.CreateMap <Filial, FilialViewModel>();
}
public async Task <IActionResult> Cadastrar(Usuario u)
{
// Criar um objeto UsuarioLogado e passar obrigatoriamente o Email e UserName
UsuarioLogado usuarioLogado = new UsuarioLogado
{
Email = u.Email,
UserName = u.Email
};
//Cadastra o resultado do cadastro
IdentityResult result = await _userManager.CreateAsync(usuarioLogado, u.Senha);
//Testar o resultado do cadastro
if (result.Succeeded)
{
//Logar o usuário no sistema
await _signManager.SignInAsync(usuarioLogado, isPersistent : false);
if (_usuarioDAO.Cadastrar(u))
{
return(RedirectToAction(nameof(Index)));
}
ModelState.AddModelError("", "Usuário já está cadastrado!");
}
else
{
AdicionarErros(result);
}
return(View(u));
}
public string EditarMeusDados(ModeloDeEdicaoDeUsuario modelo, UsuarioLogado usuario)
{
try
{
var usuarioParaAlterar = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
if (usuarioParaAlterar.Login.Valor != modelo.Email)
{
var usuarioComMesmoLogin = this._servicoExternoDePersistencia.RepositorioDeUsuarios.PegarAtivoPorLogin(modelo.Email);
if (usuarioComMesmoLogin != null)
{
throw new ExcecaoDeAplicacao("Já existe um usuário com o mesmo login");
}
}
var batalhao = this._servicoExternoDePersistencia.RepositorioDeBatalhoes.PegarPorId(modelo.Batalhao);
usuarioParaAlterar.AlterarMeusDados(modelo.Nome, modelo.Email, modelo.Ddd, modelo.Telefone, batalhao, modelo.Matricula);
this._servicoExternoDePersistencia.Persistir();
return("Meus dados alterado com sucesso.");
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao(ex.Message);
}
}
public HttpCookie AuthenticateUser(string email, string senha)
{
Usuario result;
string senhaHash = GetHash(senha);
result = usuarioRepository.SimpleWhere(u => u.Email == email && u.Senha == senhaHash).FirstOrDefault();
if (result == null)
{
throw new InternalException("Usuário inexistente ou senha inválida");
}
UsuarioLogado usuarioLogado = new UsuarioLogado(result);
UsuarioLogadoSerializable serializable = new UsuarioLogadoSerializable(result);
string userData = new JavaScriptSerializer().Serialize(serializable);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1, result.Email, DateTime.Now, DateTime.Now.AddHours(2), false, userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpContext.Current.User = usuarioLogado;
return(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
}
public async Task <string> AtivarUsuario(int id, UsuarioLogado usuario)
{
try
{
var usuarioParaAlterar = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(id);
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
if (usuarioParaAlterar != null)
{
if (usuarioParaAlterar.Ativo)
{
usuarioParaAlterar.InativarUsuario();
}
else
{
var modeloDeEmail = this._servicoDeMontagemDeEmails.MontarEmailCadastroAtivo(usuarioParaAlterar);
await this._servicoDeEnvioDeEmails.EnvioDeEmail(usuarioParaAlterar, modeloDeEmail.Titulo, modeloDeEmail.Mensagem);
usuarioParaAlterar.AtivarUsuario();
}
}
this._servicoExternoDePersistencia.Persistir();
return("Usuário alterado com sucesso.");
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Não foi possível alterar o usuário: " + ex.InnerException);
}
}
public string AtivarCamera(int id, UsuarioLogado usuario)
{
try
{
var camera = this._servicoExternoDePersistencia.RepositorioDeCameras.PegarPorId(id);
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
if (camera != null)
{
if (camera.Ativo)
{
camera.Inativar(usuarioBanco);
}
else
{
camera.Ativar(usuarioBanco);
}
}
this._servicoExternoDePersistencia.Persistir();
return("Câmera alterada com sucesso.");
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Não foi possível alterar a Câmera: " + ex.InnerException);
}
}
public async Task <IActionResult> Create([Bind("Email,Senha,Id,CriadoEm,ConfirmacaoSenha,Cep,Logradouro,Uf,Bairro,Localidade")] UsuarioLogado usuarioLogado)
{
if (ModelState.IsValid)
{
Usuario usuario = new Usuario
{
UserName = usuarioLogado.Email,
Email = usuarioLogado.Email,
Cep = usuarioLogado.Cep,
Localidade = usuarioLogado.Localidade,
Logradouro = usuarioLogado.Logradouro,
Uf = usuarioLogado.Uf,
Bairro = usuarioLogado.Bairro,
};
IdentityResult result = await _userManager.CreateAsync(usuario, usuarioLogado.Senha);
var token = _userManager.GenerateEmailConfirmationTokenAsync(usuario);
if (result.Succeeded)
{
_context.Add(usuarioLogado);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
AdicionarErros(result);
}
return(View(usuarioLogado));
}
public async Task <IActionResult> CadastroColunistaPost(Pessoa pessoa)
{
if (pessoa.Tipo == "Colunista")
{
//Criar um objeto do usuario logado e passar obrigatoriamente email e username
UsuarioLogado userLogado = new UsuarioLogado()
{
Email = pessoa.Password,
UserName = pessoa.Password
};
//Cadastra o usuario na tabela do Identity
//IdentityResult result = await userManager.CreateAsync(userLogado, pessoa.Password);
//Testa o resultado do cadastro
// if (result.Succeeded)
Colunista c1 = new Colunista
{
Nome = pessoa.Nome,
Endereco = pessoa.Endereco,
CPf = pessoa.CPf,
Password = pessoa.Password,
Tipo = pessoa.Tipo
};
if (_pessoaDAO.CadastrarPessoa(c1))
{
//Logar usuario no sistema
//await signInManager.SignInAsync(userLogado, isPersistent: false);
return(RedirectToAction("HomeColunista"));
}
else
{
ModelState.AddModelError("", "Cpf já Cadastrado");
}
}
else
{
Cliente p1 = new Cliente
{
Nome = pessoa.Nome,
Endereco = pessoa.Endereco,
CPf = pessoa.CPf,
Password = pessoa.Password,
Tipo = pessoa.Tipo
};
if (_pessoaDAO.CadastrarPessoa(p1))
{
//Logar usuario no sistema
//wait signInManager.SignInAsync(userLogado, isPersistent: false);
return(RedirectToAction("HomeCliente"));
}
else
{
ModelState.AddModelError("", "Cpf já Cadastrado");
}
}
return(View());
}
public async Task <IActionResult> NovaConta(Usuario model)
{
UsuarioLogado usuario = new UsuarioLogado();
var json = JsonConvert.SerializeObject(model);
var postRequest = new StringContent(json, Encoding.UTF8, "application/json");
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.PostAsync(apiUrl + "nova-conta", postRequest).ConfigureAwait(false))
{
string apiResponse = await response.Content.ReadAsStringAsync();
usuario = JsonConvert.DeserializeObject <UsuarioLogado>(apiResponse);
if (usuario.sucess == false)
{
ViewData["Error"] = usuario.errors[0].ToString();
return(View());
}
}
}
this.Autenticar();
HttpContext.Session.Set <Guid>("Id", usuario.data.userToken.id);
HttpContext.Session.Set <String>("AcessToken", usuario.data.acessToken);
HttpContext.Session.Set <String>("Email", usuario.data.userToken.email);
return(RedirectToAction("ListarPorUsuario", "Produtos"));
}
public bool Deletar(int?id)
{
if (!UsuarioLogado.IsInRole(Funcionalidade.FormaRecebimentoDeletar))
{
messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
return(false);
}
if (id == null)
{
messageQueue.Add(Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
return(false);
}
var formaRecebimento = formaRecebimentoRepository.ObterPeloId(id);
if (formaRecebimento.Automatico == true)
{
messageQueue.Add(Resource.Sigim.ErrorMessages.RegistroProtegido, TypeMessage.Error);
return(false);
}
try
{
formaRecebimentoRepository.Remover(formaRecebimento);
formaRecebimentoRepository.UnitOfWork.Commit();
messageQueue.Add(Resource.Sigim.SuccessMessages.ExcluidoComSucesso, TypeMessage.Success);
return(true);
}
catch (Exception)
{
messageQueue.Add(string.Format(Resource.Sigim.ErrorMessages.RegistroEmUso, formaRecebimento.Descricao), TypeMessage.Error);
return(false);
}
}
public async Task <IActionResult> Cadastrar(Usuario u)
{
if (ModelState.IsValid)
{
UsuarioLogado uLogado = new UsuarioLogado
{
UserName = u.Email,
Email = u.Email
};
//Cadastrar o user na tabela do Identity
IdentityResult result = await _userManager.CreateAsync(uLogado, u.Senha);
if (result.Succeeded)
{
//Token confirmação email
string token = await _userManager.GenerateEmailConfirmationTokenAsync(uLogado);
//Autenticação do usuário
await _signInManager.SignInAsync(uLogado, false);
if (_usuarioDAO.Cadastrar(u))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Esse e-mail já está sendo usado!");
}
AdicionarErros(result);
}
return(View(u));
}
public ActionResult Login(LoginModel login)
{
ViewBag.Admin = true;
ViewBag.User = CurrentUser == null ? "Logar" : "Bem Vindo";
ViewBag.ExibeFooter = true;
if (ModelState.IsValid)
{
try
{
var usuario = db.UsuariosDB.Find(p => p.Email.ToLower() == login.Usuario.ToLower() && p.Senha == login.Senha).FirstOrDefault();
if (usuario != null)
{
var user = new UsuarioLogado
{
Id = usuario.Id,
Nome = usuario.NomeCompleto,
Perfil = usuario.Perfil
};
Session.RemoveAll();
HttpContext.Session["Usuario"] = user;
ViewBag.Admin = user.Perfil == PerfilUsuario.Cliente ? false : true;
ViewBag.User = CurrentUser == null ? "Logar" : "Bem Vindo";
return(Redirect("~/Home/Index"));
}
}
catch (Exception ex)
{
return(View("Index"));
}
}
return(View("Index"));
}
public ActionResult Index(string usuario, string senha)
{
UsuarioLogado.ExpiraCookie();
Usuario usu = Login.ValidaLogin(usuario, senha);
FormsAuthentication.SetAuthCookie(usuario, false);
UsuarioLogado.EmpresaId = usu.EmpresaId;
UsuarioLogado.PerfilId = usu.PerfilId;
Perfil prf = new RepositorioPerfil().BuscarPorId(usu.PerfilId);
UsuarioLogado.UsuarioId = usu.Id;
UsuarioLogado.Nome = usu.Nome;
UsuarioLogado.NomePerfil = prf.Descricao;
string returnUrl = Request.Form["returnUrl"];
if (this.Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> Cadastrar(Cliente c)
{
if (ModelState.IsValid)
{
UsuarioLogado usuarioLogado = new UsuarioLogado
{
Email = c.Email,
UserName = c.Email
};
IdentityResult result = await _userManager.
CreateAsync(usuarioLogado, c.Senha);
if (result.Succeeded)
{
await _signManager.SignInAsync(usuarioLogado,
isPersistent : false);
if (_clienteDAO.Cadastrar(c))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Este e-mail já está sendo utilizado!");
}
AdicionarErros(result);
}
return(View(c));
}
public static UsuarioLogado GetDadosUsuarioLogado(string UsuarioLogado)
{
DataContext db = new DataContext();
Usuario usuario = db.Usuarios.Where(a => a.email == UsuarioLogado).FirstOrDefault();
if (usuario == null)
{
return(null);
}
else
{
UsuarioLogado retorno = new UsuarioLogado();
retorno.Email = usuario.email;
retorno.admin = usuario.admin;
retorno.empresaId = usuario.empresaId;
retorno.admin = usuario.admin;
retorno.RuleCadastro = usuario.RuleCadastro;
retorno.RuleFinanceiro = usuario.RuleFinanceiro;
retorno.RuleMovimentacao = usuario.RuleMovimentacao;
var modulos = db.Empresas.Where(x => x.ID == usuario.empresaId).FirstOrDefault();
if (modulos != null)
{
retorno.moduloFinanceiro = modulos.ModuloFinanceiro;
}
else
{
retorno.moduloFinanceiro = 0;
}
return(retorno);
}
}
public bool Deletar(int?id)
{
if (!UsuarioLogado.IsInRole(Funcionalidade.ImpostoFinanceiroDeletar))
{
messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
return(false);
}
if (id == null)
{
messageQueue.Add(Resource.Sigim.ErrorMessages.NenhumRegistroEncontrado, TypeMessage.Error);
return(false);
}
var impostoFinanceiro = impostoFinanceiroRepository.ObterPeloId(id);
try
{
impostoFinanceiroRepository.Remover(impostoFinanceiro);
impostoFinanceiroRepository.UnitOfWork.Commit();
messageQueue.Add(Resource.Sigim.SuccessMessages.ExcluidoComSucesso, TypeMessage.Success);
return(true);
}
catch (Exception)
{
messageQueue.Add(string.Format(Resource.Sigim.ErrorMessages.RegistroEmUso, impostoFinanceiro.Descricao), TypeMessage.Error);
return(false);
}
}
public ActionResult EfetuarAvaliacao(UsuarioModel model, UsuarioLogado usuarioLogado, Usuario usuario)
{
try
{
model.Avaliacao.UsuarioAvaliador = usuarioLogado.usuarioLogado.IdUsuario;
model.Avaliacao.UsuarioAvaliado = model.UsuarioAvaliacao.IdUsuario;
bool avaliado = avaliacaoBusiness.InserirAvaliacao(model.Avaliacao);
if (avaliado == true)
{
TempData["Sucesso"] = "A";
return(RedirectToAction("Index", "Home"));
}
else
{
mensagem = Resources.Mensagens.mensagemErroAvaliacao;
TempData["Erro"] = mensagem;
return(RedirectToAction("Index", "Home"));
}
}
catch (Exception)
{
mensagem = Resources.Mensagens.mensagemErroBase;
TempData["Erro"] = mensagem;
return(RedirectToAction("Index", "Home"));
}
}
public FileDownloadDTO ExportarRelStatusVenda(RelStatusVendaFiltro filtro,
int?usuarioId,
FormatoExportacaoArquivo formato)
{
if (!UsuarioLogado.IsInRole(Funcionalidade.RelStatusVendaImprimir))
{
messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
return(null);
}
var specification = MontarSpecificationRelStatusVenda(filtro);
var lista = vendaRepository.ListarPeloFiltro(
specification,
l => l.Contrato,
l => l.Contrato.ListaVendaParticipante.Select(c => c.Cliente),
l => l.Contrato.Unidade,
l => l.Contrato.Unidade.Bloco,
l => l.Contrato.Unidade.Empreendimento,
l => l.Contrato.Unidade.Empreendimento.Incorporador,
l => l.TabelaVenda,
l => l.IndiceFinanceiro
).To <List <Venda> >();
relStatusVenda objRel = new relStatusVenda();
objRel.SetDataSource(RelStatusVendaToDataTable(lista));
var parametros = parametrosRepository.Obter();
Moeda moedaPadrao = new Moeda();
Moeda moedaConversao = new Moeda();
if (parametros.MoedaPadraoId.HasValue && parametros.MoedaPadraoId.Value > 0)
{
moedaPadrao = moedaRepository.ObterPeloId(parametros.MoedaPadraoId.Value);
}
if (filtro.MoedaConversao != 0)
{
moedaConversao = moedaRepository.ObterPeloId(filtro.MoedaConversao);
}
var caminhoImagem = PrepararIconeRelatorio(null, parametros);
var descricaoMoeda = ObterDescricaoMoeda(moedaPadrao, moedaConversao);
objRel.SetParameterValue("descricaoMoeda", descricaoMoeda);
objRel.SetParameterValue("caminhoImagem", caminhoImagem);
FileDownloadDTO arquivo = new FileDownloadDTO(
"Rel. Status da Venda",
objRel.ExportToStream((ExportFormatType)formato),
formato);
if (System.IO.File.Exists(caminhoImagem))
{
System.IO.File.Delete(caminhoImagem);
}
return(arquivo);
}
public void Autenticar(UsuarioLogado usuario)
{
DateTime today = DateTime.Now;
// obtém o timeout configurado no web.config <forms timeout="30" ></forms>
DateTime expires = today.Add(FormsAuthentication.Timeout);
// serializa os dados do usuario para gravar em cookie
string userData = Serializer.Serialize(usuario);
// gera o ticket de autenticação
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1, usuario.Nome, today, expires, false, userData, FormsAuthentication.FormsCookiePath);
// realiza a criptografia do ticket que será persistido no cookie
string encryptedTicket = FormsAuthentication.Encrypt(ticket);
// cria o cookie com os dados do ticket
HttpCookie cookie = new HttpCookie(this.NomeCookie, encryptedTicket);
// informa se o cookie pode ser manipulado via client-side
cookie.HttpOnly = true;
// obtém os dados configurado no web.config <forms path="teste" requireSSL="false" domain="seusite.com.br" ></forms>
cookie.Secure = FormsAuthentication.RequireSSL;
cookie.Path = FormsAuthentication.FormsCookiePath;
if (FormsAuthentication.CookieDomain != null)
{
cookie.Domain = FormsAuthentication.CookieDomain;
}
// adiciona o cookie na saída
HttpContext.Response.Cookies.Add(cookie);
}
public ActionResult AlterarSenha(AlterarSenhaModel senhaModel)
{
WorkLifetimeManager.Value.BeginTransaction(IsolationLevel.Serializable);
try
{
var usuarioId = new UsuarioLogado().UsuarioId;
var usuario = UsuarioRepositorio.Obter(WorkLifetimeManager.Value, usuarioId);
if (usuario == null)
{
throw new InvalidOperationException(string.Format("Não foi possível encontrar usuário com id: {0}.", usuarioId));
}
var senhaCodificada = Convert.ToBase64String(new SHA512Managed().ComputeHash(Encoding.ASCII.GetBytes(senhaModel.NovaSenha)));
usuario.Senha = senhaCodificada;
usuario.DeveDefinirNovaSenha = false;
UsuarioRepositorio.Salvar(WorkLifetimeManager.Value, usuario);
WorkLifetimeManager.Value.Commit();
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
WorkLifetimeManager.Value.Rollback();
return(View("RedefinirSenha", new AlterarSenhaModel {
MensagemErro = ex.Message
}));
}
}
public async Task <IActionResult> CadastroMedico(Medico m, int Categoria)
{
ViewBag.Categorias = new SelectList(_categoriaDao.ListarCategoria(), "CategoriaId", "Nome");
m.Categoria = _categoriaDao.BuscarCategoriaPorId(Categoria);
//if (ModelState.IsValid)
// {
UsuarioLogado usuarioLogado = new UsuarioLogado
{
UserName = m.Login,
PhoneNumber = m.Senha
};
IdentityResult result = await _userManager.CreateAsync(usuarioLogado, m.Senha);
if (result.Succeeded)
{
await _signInManager.SignInAsync(usuarioLogado, isPersistent : false);
if (_medicoDao.CadastrarMedico(m))
{
return(RedirectToAction("MenuPrincipalMedico"));
}
await _signInManager.SignOutAsync();
ModelState.AddModelError("", "Este e-mail já está sendo utilizado");
}
AdicionarErros(result);
//}
return(View(m));
}
public string AtivarComando(int id, UsuarioLogado usuario)
{
try
{
var comandoRegional = this._servicoExternoDePersistencia.RepositorioDeComandosRegionais.BuscarPorId(id);
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
if (comandoRegional != null)
{
if (comandoRegional.Ativo)
{
comandoRegional.Inativar(usuarioBanco);
}
else
{
comandoRegional.Ativar(usuarioBanco);
}
}
this._servicoExternoDePersistencia.Persistir();
return("Comando Regional alterado com sucesso.");
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Não foi possível alterar o Comando Regional: " + ex.InnerException);
}
}
public ActionResult Login(UsuarioLoginModel usuario)
{
if (ModelState.IsValid)
{
var repositorio = FabricaDeModulos.CriarUsuarioRepositorio();
var criptografia = FabricaDeModulos.CriarServicoCriptografia();
var usuarioAutenticado = repositorio.BuscarPorEmail(usuario.Email);
var senha = criptografia.CriptografarSenha(usuario.Senha);
if (usuarioAutenticado != null && usuarioAutenticado.Senha == senha)
{
var usuarioLogadoModel = new UsuarioLogado(usuarioAutenticado.Nome, usuarioAutenticado.Email, usuarioAutenticado.Permissoes.Select(x => x.Nome).ToArray());
FormsAuthentication.SetAuthCookie(usuario.Email, true);
Session["USUARIO_LOGADO"] = usuarioLogadoModel;
}
else
{
TempData["MensagemErro"] = "Email ou senha incorretos.";
}
return RedirectToAction("Index", "Login");
}
return View("Index");
}
//TODO - SALVAR NA BASE QUE USUARIO FOI DESLIGADO, RETORNANDO AVISO DE SUCESSO PRA VIEW ANTERIOR
public ActionResult SalvarDesligamento(UsuarioModel model, UsuarioLogado usuarioLogado)
{
try
{
model.Usuario.Racf = model.UsuarioDesligamento.Racf;
model.Usuario.IdDesligamento = usuarioLogado.usuarioLogado.IdUsuario;
if (_usrBusiness.DeletarUsuario(model.Usuario) == false)
{
mensagem = Resources.Mensagens.mensagemErroDesligamento;
TempData["Erro"] = mensagem;
return(RedirectToAction("Index", "Home"));
}
else
{
Email email = new Email();
email.EnviarEmail(model.UsuarioDesligamento.Email, model.Usuario.Motivo, model.ComentarioDesligamento);
TempData["Sucesso"] = "D";
return(RedirectToAction("Index", "Home"));
}
}
catch (Exception)
{
mensagem = Resources.Mensagens.mensagemErroBase;
TempData["Erro"] = mensagem;
return(RedirectToAction("Index", "Home"));
}
}
public string RealizarBaixaAlertaUsuario(UsuarioLogado usuario)
{
try
{
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
var alertas = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarNovosAlertas();
if (alertas != null)
{
foreach (var alerta in alertas)
{
usuarioBanco.InserirAlertaUsuario(alerta);
}
this._servicoExternoDePersistencia.Persistir();
}
else
{
return("Não foi possível realizar baixa de alerta.");
}
return("Alerta baixado com sucesso.");
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Não foi possível realizar baixa: " + ex.InnerException);
}
}
public FileDownloadDTO Exportar(int?id, FormatoExportacaoArquivo formato)
{
if (!UsuarioLogado.IsInRole(Funcionalidade.PreRequisicaoMaterialImprimir))
{
messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
return(null);
}
var preRequisicao = ObterPeloIdEUsuario(id, UsuarioLogado.Id);
relPreRequisicaoMaterial objRel = new relPreRequisicaoMaterial();
objRel.Database.Tables["OrdemCompra_preRequisicaoMaterialRelatorio"].SetDataSource(PreRequisicaoToDataTable(preRequisicao));
objRel.Database.Tables["OrdemCompra_preRequisicaoMaterialItemRelatorio"].SetDataSource(PreRequisicaoItemToDataTable(preRequisicao.ListaItens.ToList()));
var parametros = parametrosOrdemCompraRepository.Obter();
var caminhoImagem = PrepararIconeRelatorio(null, parametros);
objRel.SetParameterValue("caminhoImagem", caminhoImagem);
var nomeEmpresa = ObterNomeEmpresa(null, parametros);
objRel.SetParameterValue("nomeEmpresa", nomeEmpresa);
FileDownloadDTO arquivo = new FileDownloadDTO(
"PreRequisicaoMaterial_" + id.ToString(),
objRel.ExportToStream((ExportFormatType)formato),
formato);
RemoverIconeRelatorio(caminhoImagem);
return(arquivo);
}
public List <ModeloDeAlertaDaLista> BuscarAlertas(UsuarioLogado usuario)
{
try
{
var modelo = new List <ModeloDeAlertaDaLista>();
var alertas = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarNovosAlertas();
if (alertas != null)
{
foreach (var alerta in alertas)
{
var alertasUsuario = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarAlertasUsuarios(usuario.Id, alerta.Id);
var alertaUsuario = alertasUsuario.FirstOrDefault(a => a.Alerta.Id == alerta.Id);
if (alertaUsuario == null)
{
modelo.Add(new ModeloDeAlertaDaLista(alerta));
}
}
}
return(modelo);
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Não foi possível buscar os alertas: " + ex.InnerException);
}
}
public string ExcluirFoto(int id, UsuarioLogado usuario)
{
try
{
var foto = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarFotoPorId(id);
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
if (foto == null)
{
throw new ExcecaoDeAplicacao("Não foi encontrada a foto para a exclusão");
}
foto.InativarFoto();
foto.Carater.AdicionarHistorico(new HistoricoDeCarater("Excluir uma foto do caráter", foto.Descricao, TipoDeHistoricoDeCarater.Foto, usuarioBanco, foto.Id));
this._servicoExternoDePersistencia.Persistir();
return("Foto excluída com sucesso.");
}
catch (ExcecaoDeAplicacao ex)
{
throw new ExcecaoDeAplicacao(ex.Message);
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao(ex.Message);
}
}
public ModeloDeEdicaoDeCarater BuscarCaraterPorId(int id, UsuarioLogado usuario, bool EhCelular = false)
{
try
{
var carater = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarPorId(id);
if (carater != null)
{
var alertas = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarTodosAlertaPorCarater(carater.Id);
if (alertas != null)
{
var usuarioBanco = this._servicoExternoDePersistencia.RepositorioDeUsuarios.BuscarPorId(usuario.Id);
foreach (var alerta in alertas)
{
var alertasUsuarios = this._servicoExternoDePersistencia.RepositorioDeCaraters.PegarAlertasUsuarios(usuario.Id, alerta.Id);
if (alertasUsuarios.Count == 0)
{
usuarioBanco.InserirAlertaUsuario(alerta);
}
}
this._servicoExternoDePersistencia.Persistir();
}
}
var modelo = new ModeloDeEdicaoDeCarater(carater, EhCelular);
return(modelo);
}
catch (Exception ex)
{
throw new ExcecaoDeAplicacao("Erro ao consultar caráter");
}
}
public async Task <IActionResult> EmpresaRemoverParceria()
{
UsuarioLogado userLogado = await _userManager.GetUserAsync(User);
_empresaClienteDAO.RemoverClienteEmailEEmpresaId(userLogado.Email, Convert.ToInt32(TempData["id"].ToString()));
return(RedirectToAction("index"));
}
// neste método nós verificamos as permissões do usuário logado.
// vemos aqui se ele tem as mesmas que a declarada no atributo.
private bool TemAsPermissoesRequeridas(UsuarioLogado usuarioLogado)
{
// caso esta action precise de roles específicas, vamos pegar elas.
string[] permissoesRequeridas = String.IsNullOrWhiteSpace(this.Roles) ?
new string[0] : this.Roles.Split(';');
foreach (string permissao in permissoesRequeridas)
{
if (!usuarioLogado.Permissoes.Contains(permissao))
{
return false;
}
}
return true;
}
public void RegistrarLogin(string cpf, Laboris.Cosan.Service.Omnion.Login usuarioOmnion, string senha)
{
HttpCookie authCookie = FormsAuthentication.GetAuthCookie(cpf, false);
FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(authCookie.Value);
FormsAuthenticationTicket newTicket = new FormsAuthenticationTicket(ticket.Version, ticket.Name, ticket.IssueDate, ticket.Expiration, ticket.IsPersistent, usuarioOmnion.Nome);
authCookie.Value = FormsAuthentication.Encrypt(newTicket);
authCookie.Path = FormsAuthentication.FormsCookiePath;
Response.Cookies.Add(authCookie);
IPrincipal p = new GenericPrincipal(new FormsIdentity(newTicket), null);
// Attach the CustomPrincipal to HttpContext.User and Thread.CurrentPrincipal
UsuarioLogado usuarioLogado = new UsuarioLogado(usuarioOmnion, senha);
HttpContext.Current.Session["UsuarioOmnion"] = usuarioLogado;
HttpContext.Current.User = p;
Thread.CurrentPrincipal = p;
//string redirUrl = FormsAuthentication.GetRedirectUrl(txtCpf.Text, false);
/*
IPrincipal usr = HttpContext.Current.User;
FormsIdentity fIdent = usr.Identity as FormsIdentity;
*/
}
public static void CriarSessaoDeUsuario(Usuario usuarioAutenticado)
{
var usuarioLogado = new UsuarioLogado(usuarioAutenticado);
FormsAuthentication.SetAuthCookie(usuarioLogado.Email, true);
HttpContext.Current.Session[USUARIO_LOGADO] = usuarioLogado;
}