示例#1
0
        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));
        }
示例#2
0
        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));
        }
示例#4
0
        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);
            }
        }
示例#5
0
        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));
        }
示例#6
0
        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);
            }
        }
示例#8
0
        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"));
        }
示例#11
0
        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));
        }
示例#13
0
        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"));
            }
        }
示例#15
0
        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));
        }
示例#16
0
        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);
            }
        }
示例#17
0
        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);
            }
        }
示例#18
0
 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"));
     }
 }
示例#19
0
        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);
        }
示例#20
0
        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);
        }
示例#21
0
        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));
        }
示例#23
0
        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);
            }
        }
示例#24
0
        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");
        }
示例#25
0
        //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"));
            }
        }
示例#26
0
        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);
            }
        }
示例#27
0
        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);
        }
示例#28
0
        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);
            }
        }
示例#29
0
        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);
            }
        }
示例#30
0
        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"));
        }
示例#32
0
        // 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;
        }
示例#33
0
        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;
 }