sábado, 18 de julho de 2015

AccountController

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Security;
using Lapuinka.PCP.Data.Model;
using Lapuinka.PCP.Domain;
using Lapuinka.PCP.Domain.Enums;
using Lapuinka.PCP.Domain.Enums.ClienteEnum;
using Lapuinka.PCP.Helper.Generics;
using Lapuinka.PCP.Helper.Security;
using Lapuinka.PCP.Helper.Web;
using Lapuinka.PCP.Resources;
using Lapuinka.PCP.Service;
using Lapuinka.PCP.Web.Core;
using Lapuinka.PCP.Web.Models;

namespace Lapuinka.PCP.Web.Controllers
{
    public class AccountController : ControladorPadrao
    {
        #region [ Propriedades e Variaveis ]

        private const string _senhaAtual = "senhaAtual";
        private readonly LapuinkaMembershipService customMemberShip;
        private readonly LapuinkaRoleService customRoles;

        #endregion [ Propriedades e Variaveis ]

        #region [ Construtores ]

        ///
        /// Construtor Padrão deste Controller
        ///
        public AccountController()
        {
            customMemberShip = new LapuinkaMembershipService();
            customRoles = new LapuinkaRoleService();
        }

        #endregion [ Construtores ]

        #region [ Ações ]

        #region [ Login ]

        ///
        /// Logs the on.
        ///
        ///
        public ActionResult Login()
        {
            ViewBag.PrimeiroAcesso = MvcApplication.PrimeiroAcesso;

            ViewBag.regioes = ObterRegioes();
            return View();
        }

        ///
        /// POST: /Account/Login
        ///
        /// The model.
        /// The return URL.
        /// The regiao.
        ///
        [HttpPost]
        public JsonResult Login(LogOnModel model, String returnUrl, String regiao)
        {
            DefinirCulture(regiao);
            customRoles.ConfigRoles(regiao);
            customMemberShip.ConfigMembership(regiao);

            // Verifica se o Usuário que está tentando acessar o sistema não está bloqueado ou não
            var usuario = customMemberShip.GetUser(model.Usuario, false);

            if (usuario == null)
            {
                return Json(new MensagemRetorno
                {
                    Sucesso = false,
                    Descricao = Resource.Msg_Geral_SenhaIncorreta
                }, JsonRequestBehavior.AllowGet);
            }
            // Se o Usuário não estiver Aprovado - Subscreve as outra Regras
            if (usuario.IsApproved.Equals(false))
            {
                return Json(new MensagemRetorno
                {
                    Sucesso = false,
                    Descricao = Resource.Msg_Geral_UsuarioDesativado
                }, JsonRequestBehavior.AllowGet);
            }
            // Verifica se o Usuário está BLoqueado no sistema
            if (usuario.IsLockedOut.Equals(false))
            {
                if (customMemberShip.ValidateUser(model.Usuario, model.Senha))
                {
                    var LapuinkaUser = AutenticarUsuario(model, customMemberShip);

                    if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
                        && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
                    {
                        //returnUrl = Constantes._viewHomeIndex;
                    }
                    else
                    {
                        returnUrl = Url.Content(Constantes._urlHomeIndex);
                        if (LapuinkaUser.CreationDate == LapuinkaUser.LastPasswordChangedDate)
                        {
                            returnUrl = DefinirUrlPorConstante(Constantes._viewAlterarSenha);
                        }
                        else
                        {
                            if (LapuinkaUser.ClienteId != null)
                            {
                                // Verifica se o cliente ainda não atualizou os dados após o 1º acesso
                                var cliente = new ClienteService().ObterPorId(LapuinkaUser.ClienteId.Value);
                               
                                if (cliente.dtAtualizacao.Date < LapuinkaUser.CreationDate.Date)
                                {
                                    returnUrl = Url.Content(Constantes._urlConsultorEditarMeusDados);
                                }

                                var pServico = new ParametroService();
                                var parametro = Convert.ToInt32(pServico.ObterValorPorId(ParametroEnum.PrazoAtualizarDados));
                                DateTime limiteAtualizacao = DateTime.Now;
                                limiteAtualizacao = limiteAtualizacao.AddMonths(-parametro);

                                //Verifica se o Consultor/Dirigente realizou a atualização dos dados dentro do tempo estipulado na tabela de parametros.
                                if (cliente.dtAtualizacao < limiteAtualizacao)
                                {
                                    returnUrl = Url.Content(Constantes._urlConsultorEditarMeusDados);
                                }
                            }
                        }
                    }
                    //LogService.Log("AccountController.Login()", Resource.Msg_Log_Autenticacao, LogService.LogType.Security);

                    return Json(new MensagemRetorno { Sucesso = true, PaginaParaNavegar = returnUrl }, JsonRequestBehavior.AllowGet);
                }
                return Json(new MensagemRetorno
                {
                    Sucesso = false,
                    Descricao = Resource.Msg_Geral_SenhaIncorreta
                }, JsonRequestBehavior.AllowGet);
            }
            return Json(new MensagemRetorno
            {
                Sucesso = false,
                Descricao = Resource.Msg_Geral_UsuarioBloqueado
            }, JsonRequestBehavior.AllowGet);

        }

        ///
        /// GET: /Account/LogOff
        ///
        ///
        public ActionResult LogOff()
        {
            // Remove da Sessão o LapuinkaUserService
            if (System.Web.HttpContext.Current.Session[ConstantHelper._sesUsuario] != null)
            {
                System.Web.HttpContext.Current.Session.Remove(ConstantHelper._sesUsuario);
                System.Web.HttpContext.Current.Session.Abandon();
                System.Web.HttpContext.Current.Session.Clear();
                System.Web.HttpContext.Current.Session.RemoveAll();
            }
            FormsAuthentication.SignOut();

            return RedirectToAction("Index", "Home");
        }

        #endregion [ Login ]

        #region [ Esqueci a Senha ]

        ///
        /// Esqueci a senha.
        ///
        /// The txtEmail.
        /// The regiao esqueci senha.
        ///
        [HttpPost]
        public JsonResult EsqueciSenha(String txtEmail, String regiaoEsqueciSenha)
        {
            var ret = new EmailService().EnviarConfirmacaoEsqueciSenha(txtEmail, regiaoEsqueciSenha);
            return Json(ret, JsonRequestBehavior.AllowGet);
        }

        #endregion [ Esqueci a Senha ]

        #region [ Recuperar a Senha ]

        ///
        /// Alterar a senha.
        ///
        /// The token.
        ///
        public ActionResult RecuperarSenha(String Token)
        {
            var mensagemDescriptografada = WebHelpers.DecryptString(MvcApplication.ChaveEsqueciSenhaKey, WebHelpers.DecryptASCII(Token));

            var valores = HttpUtility.ParseQueryString(mensagemDescriptografada);

            DefinirCulture(valores["pais"]);
            customRoles.ConfigRoles(valores["pais"]);
            customMemberShip.ConfigMembership(valores["pais"]);
            var userShip = customMemberShip.GetUser(valores["usuario"], false);
            var model = new UserShip();

            if (Convert.ToDateTime(valores["expira"]) > DateTime.Now)
            {
                if (userShip != null)
                {
                    model = new UserShip
                    {
                        nome = userShip.UserName,
                        pais = valores["pais"],
                        resposta = "",
                        eMail = userShip.Email,
                        senha = null
                    };
                }
                Session[_senhaAtual] = valores["senha"];
            }
            else
            {
                return RedirectToAction("Index", "Home");
            }

            return View(model);
        }

        ///
        /// Alterar a senha.
        ///
        /// The model.
        /// The txtnewpassword.
        /// The txtconfpassword.
        /// The identificador pais.
        ///
        [HttpPost]
        public ActionResult RecuperarSenha(UserShip model, String txtnewpassword, String txtconfpassword, String identificadorPais/*, String resposta*/)
        {
            try
            {
                customMemberShip.ConfigMembership(model.pais);
                customRoles.ConfigRoles(model.pais);
                if (txtnewpassword == txtconfpassword)
                {
                    var senhaAtual = Session[_senhaAtual] != null ? Session[_senhaAtual].ToString() : string.Empty;

                    // Além de trocar a Senha efetua o Desbloqueio caso exista
                    if (customMemberShip.ChangePassword(model.nome, senhaAtual, txtnewpassword))
                    {
                        Session.Remove(_senhaAtual);
                        var usuario = customMemberShip.ObterUsuario(model.eMail, true);
                        if (usuario != null && !String.IsNullOrWhiteSpace(usuario.NomeCompleto))
                        {
                            model.nome = usuario.NomeCompleto;
                        }
                        new EmailService().EnviarConfirmacaoAlteracaoSenha(model.nome, model.eMail, model.pais);
                        var ret = new MensagemRetorno
                        {
                            Sucesso = true,
                            Descricao = Resource.Msg_Geral_SenhaAlterada,
                            PaginaParaNavegar = DefinirUrlPorConstante(Constantes._viewAccountLogOn)
                        };

                        LogService.Log("AccountController.RecuperarSenha()",
                                    Resource.Msg_Log_SenhaAlterada,
                                    LogService.LogTipo.Seguranca);

                        return Json(ret, JsonRequestBehavior.AllowGet);
                    }
                    return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_SenhaNaoAlterado }, JsonRequestBehavior.AllowGet);
                }
                return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_ConfirmarSenhaInvalida }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                LogService.Log("AccountController.RecuperarSenha()", ex);
                return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_SenhaNaoAlterado }, JsonRequestBehavior.AllowGet);
            }
        }

        #endregion [ Recuperar a Senha ]

        #region [ Alterar a Senha ]

        ///
        /// Alterar a Senha.
        ///
        ///
        [LapuinkaAuthorize]
        public ActionResult AlterarSenha()
        {
            return View();
        }

        ///
        /// Changes the password. POST: /Account/AlterarSenha
        ///
        /// The model.
        ///
        [LapuinkaAuthorize]
        [HttpPost]
        public ActionResult AlterarSenha(ChangePasswordModel model)
        {
            try
            {
                customMemberShip.ConfigMembership(ObterIdentificadorPais());
                customRoles.ConfigRoles(ObterIdentificadorPais());
                if (model.NewPassword == model.ConfirmPassword)
                {
                    var currentUser = customMemberShip.GetUser(ObterNomeUsuarioLogado(), true /* userIsOnline */);
                    if (currentUser != null)
                    {
                        if (customMemberShip.ChangePassword(currentUser.UserName, customMemberShip.EncodePassword(model.OldPassword), model.NewPassword))
                        {
                            LogService.Log("AccountController.AlterarSenha()",
                                   Resource.Msg_Log_SenhaAlterada,
                                   LogService.LogTipo.Seguranca);

                            return Json(new MensagemRetorno { Sucesso = true, Descricao = Resource.Msg_Geral_SenhaAlterada, PaginaParaNavegar = Url.Content(Constantes._urlHomeIndex) },JsonRequestBehavior.AllowGet);
                        }
                    }
                    return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_SenhaNaoAlterado }, JsonRequestBehavior.AllowGet);
                }
                return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_ConfirmarSenhaInvalida }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                LogService.Log("AccountController.AlterarSenha()", ex);

                return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_SenhaNaoAlterado }, JsonRequestBehavior.AllowGet);
            }
        }

        #endregion [ Alterar a Senha ]

        #region [ Criar Senha Após Primeiro Acesso ]

        ///
        /// View para Criar uma Senha para o Usuário em seu Primeiro Acesso
        ///
        ///
        [LapuinkaAuthorize]
        public ActionResult CriarSenha()
        {
            return View();
        }

        [LapuinkaAuthorize]
        [HttpPost]
        public JsonResult CriarSenha(CriarSenhaModel model)
        {
            try
            {
                customMemberShip.ConfigMembership(ObterIdentificadorPais());
                if (model.NovaSenha == model.ConfirmacaoSenha)
                {
                    // Pegar Dados do Usuário logado
                    var currentUser = ObterUsuarioLogado();// customMemberShip.ObterUsuario(User.Identity.Name, true /* userIsOnline */);
                    if (currentUser != null)
                    {
                        var senhaAntiga = customMemberShip.GetPassword(currentUser.UserName, String.Empty);

                        // Alterar a Senha Gerada para a Senha Informada pelo Usuário
                        if (customMemberShip.ChangePassword(currentUser.UserName, senhaAntiga, model.NovaSenha))
                        {
                            var returnUrl = Url.Content(Constantes._urlConsultorEditarMeusDados);

                            //Verifica a documentação
                            if (UsuarioPossuiRegra(LapuinkaRoles.Consultor.ToString()) || UsuarioPossuiRegra(LapuinkaRoles.Dirigente.ToString()))
                            {
                                var cServico = new ClienteService();
                                if (currentUser.ClienteId != null)
                                {
                                    if (cServico.ConsultorAprovado(currentUser.ClienteId.Value) == false)
                                    {
                                        returnUrl = Url.Content(Constantes._urlConsultorFichaInscricao);
                                    }
                                }
                            }

                            LogService.Log("AccountController.CriarSenha()",
                                   Resource.Msg_Log_SenhaAlterada,
                                   LogService.LogTipo.Seguranca);

                            return Json(new MensagemRetorno
                            {
                                Sucesso = true,
                                Descricao = Resource.Msg_Geral_SenhaAlterada,
                                PaginaParaNavegar = returnUrl
                            },
                                JsonRequestBehavior.AllowGet);
                        }
                        return Json(new MensagemRetorno
                        {
                            Sucesso = false,
                            Descricao = Resource.Msg_Geral_SenhaNaoAlterado
                        }, JsonRequestBehavior.AllowGet);
                    }
                    return Json(new MensagemRetorno
                    {
                        Sucesso = false,
                        Descricao = Resource.Msg_Geral_SenhaNaoAlterado,
                        PaginaParaNavegar = DefinirUrlPorConstante(Constantes._viewAccountLogOn)
                    }, JsonRequestBehavior.AllowGet);
                }
                return Json(
                    new MensagemRetorno
                    {
                        Sucesso = false,
                        Descricao = Resource.Msg_Geral_ConfirmarSenhaInvalida
                    },
                    JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                LogService.Log("AccountController.CriarSenha()", ex);

                return Json(new MensagemRetorno { Sucesso = false, Descricao = Resource.Msg_Geral_SenhaNaoAlterado }, JsonRequestBehavior.AllowGet);
            }
        }

        #endregion [ Criar Senha Após Primeiro Acesso ]

        #region [ Primeiro Acesso ]

        ///
        /// View Responsável pelo Primeiro Acesso do usuário
        ///
        ///
        public ActionResult PrimeiroAcesso(String id)
        {
            if (!String.IsNullOrEmpty(id) && id != "0")
            {
                DefinirCulture(id);
            }
            return View();
        }

        ///
        /// Retorno da View Responsável pelo Primeiro Acesso do usuário
        ///
        /// The model.
        ///
        [HttpPost]
        public JsonResult PrimeiroAcesso(tb_Cliente model)
        {
            var servCliente = new ClienteService();
            model.nrCPF = model.nrCPF.Replace(".", String.Empty).Replace("-", String.Empty);

            var idAtivoAtivo = idAtivo.A.ToString();
            var idAtivoInativo = idAtivo.I.ToString();
            var idStatusAtivo = idStatus.A.ToString();
            var idStatusDocPendente = idStatus.D.ToString();

            // Validar os dados Informados no Formulário (cdLapuinka, nrCPF, dtNascimento, dsEmail)
            var cliente = servCliente.ObterRegistros(c =>
                c.cdLapuinka == model.cdLapuinka &&
                c.nrCPF == model.nrCPF &&
                c.dtNascimento == model.dtNascimento &&
                (c.idAtivo == idAtivoAtivo || c.idAtivo == idAtivoInativo) &&
                (c.idStatus == idStatusAtivo || c.idStatus == idStatusDocPendente)).FirstOrDefault();

            // Valida se o cliente existe, mas não vinculado ao MembershipProvider
            if (cliente != null)
            {
                // Validar se o Cliente já possui um Usuário AspNet na tb_UsuarioAspNet
                if (!servCliente.ExisteVinculoAspNet(cliente))
                {
                    customMemberShip.ConfigMembership(ObterIdentificadorPais());
                    customRoles.ConfigRoles(ObterIdentificadorPais());
                    // Validar se já existe um usuário na [aspnet_Users] com o email informado.
                    if (String.IsNullOrEmpty(customMemberShip.GetUserNameByEmail(model.dsEmail)))
                    {
                        var senhaGerada = Membership.GeneratePassword(6, 2);
                        // Caso não exista grava um novo Registro na [aspnet_Users]
                        try
                        {
                            MembershipCreateStatus status;
                            if (model.dtNascimento != null)
                                customMemberShip.CreateUser(model.dsEmail,
                                                            senhaGerada,
                                                            model.dsEmail,
                                                            String.Empty,
                                                            model.dtNascimento.Value.ToShortDateString(),
                                                            true,
                                                            null,
                                                            out status);

                            // -> Associa o UserId da [aspnet_Users] -> com o cdCliente da [tb_Cliente]
                            var LapuinkaUser = customMemberShip.ObterMembershipUser(model.dsEmail);
                            new ClienteService().VincularUsuarioCliente(cliente.cdCliente, LapuinkaUser.UserId);

                            // -> Definir as Roles conforme o idNivel da [tb_Cliente]
                            var usernames = new[] { model.dsEmail };
                            var roles = cliente.idNivel.Equals("C", StringComparison.OrdinalIgnoreCase)
                                            ? new[] { LapuinkaRoles.Consultor.ToString() }
                                            : new[] { LapuinkaRoles.Dirigente.ToString() };
                            customRoles.AddUsersToRoles(usernames, roles);

                            try
                            {
                                //Atualizar Email na Base de Dados (passando o Email que a Pessoa Digitou para a Base)
                                cliente.dsEmail = model.dsEmail;
                                //cliente.dtAtualizacao = DateTime.Now;
                                cliente.dtAtualizacaoEmail = DateTime.Now;
                                servCliente.AtualizarObjeto(cliente);

                                // Verifica a Existência de tb_EnderecoCliente - Caso não exista, o sistema fará tal inserção
                                new EnderecoService().CriaEnderecoClienteSenaoExistir(cliente);
                            }
                            catch (Exception ex)
                            {
                                LogService.Log("AccountController.PrimeiroAcesso()", ex);
                            }

                            // -> Enviar email de Confirmação avisando que o usuário(email) foi criado com sucesso.. bla bla bla...
                            new EmailService().EnviarConfirmacaoPrimeiroAcesso(cliente);

                            LogService.Log("PrimeiroAcesso", String.Format(Resource.Msg_Log_Cadastro_Criado, LapuinkaUser.UserName));

                            // -> Autenticar o novo Usuário.
                            if (customMemberShip.ValidateUser(model.dsEmail, senhaGerada))
                            {
                                AutenticarUsuario(new LogOnModel
                                {
                                    MeLembre = false,
                                    Usuario = model.dsEmail,
                                    Senha = senhaGerada
                                }, customMemberShip);

                                return Json(new MensagemRetorno { Descricao = Resource.Msg_Geral_CadastroConfirmado, PaginaParaNavegar = Url.Content(Constantes._urlCriarSenha), Sucesso = true }, JsonRequestBehavior.AllowGet);
                            }
                            return Json(new MensagemRetorno { Descricao = Resource.Msg_Geral_CadastroConfirmado, PaginaParaNavegar = DefinirUrlPorConstante(Constantes._viewAccountLogOn), Sucesso = false }, JsonRequestBehavior.AllowGet);
                        }
                        catch (Exception ex)
                        {
                            LogService.Log("AccountController.PrimeiroAcesso()", ex);
                        }
                    }
                    // Caso exista deverá ser exibida uma mensagem na tela informando (Já existe um usuário(email) cadastrado no sistema! Tente outro usuário(email).)
                    return Json(new MensagemRetorno { Descricao = String.Format(Resource.Msg_PrimeiroAcesso_UsuarioExistente, model.dsEmail), Sucesso = false }, JsonRequestBehavior.AllowGet);

                }
                // Caso o cliente já possua um usuario AspNet, informar que: Seu Primeiro acesso já foi concedido, você pode solicitar alteração de senha através do link "Esqueci minha senha"!, redirecionando para a tela de Login
                return Json(new MensagemRetorno { Descricao = Resource.Msg_PrimeiroAcesso_ClienteVinculado, Sucesso = false }, JsonRequestBehavior.AllowGet);
            }
            // Provavelmente os dados estão incorretos Ou o Usuário não possue Cadastro no sistema
            return Json(new MensagemRetorno { Descricao = Resource.Msg_Geral_DadosIncorretos, Sucesso = false }, JsonRequestBehavior.AllowGet);
        }

        #endregion [ Primeiro Acesso ]

        #endregion [ Ações ]

        #region [ Métodos ]

        public static List ObterRegioes()
        {
            var list = ObterRegioes(SecurityHelper.ObtemFirstConnectionString());
            if (list.Count > 1)
                list.Insert(0, new SelectListItem { Value = "-1", Text = Resource.Msg_Geral_Selecione, Selected = true });

            return list;
        }

        ///
        /// Obtem as regioes
        ///
        ///
        public static List ObterRegioes(String connectionString)
        {
            var paises = new List();
            var conexoes = new RegiaoService(connectionString).ObterRegioes();

            foreach (var item in conexoes)
            {
                var select = new SelectListItem();
                select.Text = item.nmRegiao;
                select.Value = item.cdRegiao.ToString();
                paises.Add(select);
            }

            return paises;
        }

        #endregion [ Métodos ]
    }
}


Postar um comentário