public byte AtribuirPrestadorOrcamento(string orc, string prestador)
        {
            try
              {
            //busca o objeto orcamento
            var orcamento = _orcamentoApp.GetById(Convert.ToInt32(orc));
            //busca o objeto prestador
            var prestadorRecuperado = _prestadorApp.GetPorGuid(Guid.Parse(prestador));
            //atribui o prestador ao orçamento
            orcamento.PrestadorFk.Add(prestadorRecuperado);
            //salva no banco
            _orcamentoApp.Update(orcamento);
            return 1;
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "AtribuirPrestadorOrcamento";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return 0;
              }
        }
 public async Task<byte> AtivaStatusPrestador(string email)
 {
     try
     {
         Prestador prestador = _prestadorApp.GetPorEmail(email);
         prestador.status = EnumClass.EnumStatus.Ativo;
         _prestadorApp.Update(prestador);
         var user = _userManager.FindByName(email);
            var code = _userManager.GeneratePasswordResetToken(user.Id);
             var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
             await _userManager.SendEmailAsync(user.Id, "Esqueci minha senha", "Por favor altere sua senha clicando aqui: <a href='" + callbackUrl + "'></a>");
         //retorna 1 para procedimento realizado com sucesso
         return 1;
     }
     catch (Exception e)
     {
         var logVm = new LogViewModel();
         logVm.Mensagem = e.Message;
         logVm.Controller = "Prestador";
         logVm.View = "Ativar status prestador";
         var log = Mapper.Map<LogViewModel, Log>(logVm);
         _logAppService.SaveOrUpdate(log);
         //retorna 0 senao deu certo efetuar o update
         return 0;
     }
 }
        public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
        {
            try
            {
                var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
                if (loginInfo == null)
                {
                    return RedirectToAction("Login");
                }

                // Sign in the user with this external login provider if the user already has a login
                var result = await _signInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
                switch (result)
                {
                    case SignInStatus.Success:
                        return RedirectToLocal(returnUrl);
                    case SignInStatus.LockedOut:
                        return View("Lockout");
                    case SignInStatus.RequiresVerification:
                        return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = false });
                    case SignInStatus.Failure:
                    default:
                        // Se ele nao tem uma conta solicite que crie uma
                        ViewBag.ReturnUrl = returnUrl;
                        ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
                        return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
                }
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "ExternalLoginCallback";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public async Task<ActionResult> SendCode(string returnUrl, bool rememberMe)
        {
            try
            {
                var userId = await _signInManager.GetVerifiedUserIdAsync();
                if (userId == null)
                {
                    return View("Error");
                }
                var userFactors = await _userManager.GetValidTwoFactorProvidersAsync(userId);
                var factorOptions = userFactors.Select(purpose => new SelectListItem { Text = purpose, Value = purpose }).ToList();
                // return View(new SendCodeViewModel { Providers = factorOptions, ReturnUrl = returnUrl, RememberMe = rememberMe });

                return View("Error");

            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "SendCode";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public async Task<ActionResult> ForgotPassword(ForgotPasswordViewModel model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                  var user = _userManager.FindByName(model.Email);
                    if (user == null)
                    {
                        // Não revelar se o usuario nao existe ou nao esta confirmado
                        return View("ForgotPasswordConfirmation");
                    }

                    //var code = _userManager.GeneratePasswordResetToken(user.Id);
                    var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id }, protocol: Request.Url.Scheme);
                    //await _userManager.SendEmailAsync(user.Id, "Esqueci minha senha", "Por favor altere sua senha clicando aqui: <a href='" + callbackUrl + "'></a>");
                    //ViewBag.Link = callbackUrl;
                    //ViewBag.Status = "DEMO: Caso o link não chegue: ";
                    //ViewBag.LinkAcesso = callbackUrl;
                    

                    var saudacao = "";
                    var date = DateTime.Now;
                    if (date.Hour > 12 && date.Hour < 18)
                    {
                        saudacao = "boa tarde";
                    }
                    else if (date.Hour > 0 && date.Hour < 12)
                    {
                        saudacao = "bom dia";
                    }
                    else
                    {
                        saudacao = "boa noite";
                    }


                    var corpoNotificacao = "Olá, " + saudacao + "!" + " <br /><br /> Troque agora sua senha." +
                                "<br /> <a href=" + '\u0022' + callbackUrl + '\u0022' + "><strong>Clique aqui</strong></a> para alterar sua senha. " +
                                "<br /><br /> Att, <br />" +
                                " Equipe Agiliza.";

                    var assuntoNotificacao = "Solicitação de nova senha";
                   var _enviaEmail = new EnviaEmail();
                    var enviouNotificacao = _enviaEmail.EnviaEmailConfirmacao(model.Email, corpoNotificacao, assuntoNotificacao);
                    if (!enviouNotificacao.Key)
                    {
                        var logVm = new LogViewModel();
                        logVm.Mensagem = enviouNotificacao.Value;
                        logVm.Controller = "Enviar Email Nova Senha";
                        logVm.View = "Enviar email notificação de nova senha.";
                        var log = Mapper.Map<LogViewModel, Log>(logVm);
                        _logAppService.SaveOrUpdate(log);
                    }
                    return View("ForgotPasswordConfirmation");
                }

                // No caso de falha, reexibir a view. 
                return View(model);
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "ForgotPassword";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }
        public async Task<ActionResult> Register(RegisterViewModel model)
        {
            try
            {

                if (ModelState.IsValid)
                {
                    var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                    var result = await _userManager.CreateAsync(user, model.Password);
                    if (result.Succeeded)
                    {
                        await _signInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);

                        var code = await _userManager.GenerateEmailConfirmationTokenAsync(user.Id);
                        var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                        await _userManager.SendEmailAsync(user.Id, "Confirme sua Conta", "Por favor confirme sua conta clicando neste link: <a href='" + callbackUrl + "'></a>");
                        ViewBag.Link = callbackUrl;
                        return View("DisplayEmail");
                    }
                    AddErrors(result);
                }

                // If we got this far, something failed, redisplay form
                return View(model);
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "Register";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }
        public async Task<ActionResult> VerifyCode(string provider, string returnUrl, bool rememberMe)
        {
            try
            {
                // Require that the user has already logged in via username/password or external login
                if (!await _signInManager.HasBeenVerifiedAsync())
                {
                    return View("Error");
                }
                var user = await _userManager.FindByIdAsync(await _signInManager.GetVerifiedUserIdAsync());
                if (user != null)
                {
                    ViewBag.Status = "DEMO: Caso o código não chegue via " + provider + " o código é: ";
                    ViewBag.CodigoAcesso = await _userManager.GenerateTwoFactorTokenAsync(user.Id, provider);
                }
                return View(new VerifyCodeViewModel { Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe });
            }
            catch (Exception e)
            {

                var logVm = new LogViewModel {Mensagem = e.Message, Controller = "Account", View = "VerifyCode"};
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public ActionResult Deletar(int id)
        {
            try
            {
                var servico = _iServicoApp.GetById(id);
                var servicoVm = Mapper.Map<Servico, ServicoViewModel>(servico);
                return View(servicoVm);

                //var servico = _iServicoApp.GetById(id);
                //var servicoPrestador = _servicoPrestadorAppService.GetById(id);
                //if (servicoPrestador != null)
                //    msgRetorno =
                //        "Este serviço não pode ser excluido pois está vinculado aos serviços oferecidos por algum prestador";
                //else
                //{
                //    msgRetorno = "Serviço deletado com sucesso";
                //    _iServicoApp.Remove(servico);
                //}
                //return RedirectToAction("ListarTodos");

            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Servico";
                logVm.View = "Deletar";

                var log = Mapper.Map<LogViewModel, Log>(logVm);

                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

            //var servicoViewModel = Mapper.Map<Servico, ServicoViewModel>(servico);
            //return View(servicoViewModel);
        }
        //
        // GET: /Orcamento/Cadastrar
        public ActionResult Cadastrar()
        {
            try
              {
            ViewBag.ListaCat = new SelectList(_categoriaApp.GetAll(), "cat_Id", "cat_Nome");
            return View();
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Cadastrar GET";
            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public PartialViewResult BuscaTrabalhosPartial(string servico, string cidade, string estado)
        {
            try
              {
            var cidades = _cidadeApp.GetById(int.Parse(cidade));
            var nomeCidade = _utils.PrimeiraLetraMaiuscula(cidades.NomeCidade);
            var estados = (EnumClass.EnumEstados)Enum.Parse(typeof(EnumClass.EnumEstados), estado);
            var retorno = _orcamentoApp.RetornaOrcamentos(Convert.ToInt32(servico), cidades.NomeCidade, estados);

            var usuario = _prestadorApp.GetPorGuid(new Guid(_userId));
            var servicos = _prestadorApp.GetPrestadoresComServicos().Where(s => s.pres_Id == usuario.pres_Id)
            .Select(y => y.ServicoPrestador).Select(j => j.Select(u => u.serv_Id)).ToList();

            retorno = _orcamentoApp.VerificaSeOrcamentoPertenceAoUsuario(retorno, usuario.pres_Raio_Recebimento, usuario.pres_latitude, usuario.pres_longitude);

            var lstOrc = new List<Orcamento>();
            var lst = new List<int>();
            foreach (var s in servicos)
            {
              foreach (var sv in s)
              {
            lst.Add(sv);
              }
            }

            foreach (var orc in retorno)
            {
              if (lst.Any(s => s.Equals(orc.serv_Id)) && _orcamentoApp.PegarQuantidadeOrcamentosPorPrestador(orc.orc_Id))
              {
            lstOrc.Add(orc);
              }
            }

            var frase = "";
            if (lstOrc.Count() == 1)
              frase = "Foi encontrado " + lstOrc.Count().ToString() + " orçamento para " + cidades.NomeCidade +
                  "-" + estados;
            else
              frase = "Foram encontrados " + lstOrc.Count().ToString() + " orçamentos para " + cidades.NomeCidade +
                  "-" + estados;
            ViewBag.FraseQtd = frase;

            return PartialView(Mapper.Map<IEnumerable<Orcamento>, IEnumerable<OrcamentoViewModel>>(lstOrc));
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "BuscaTraballhos";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return PartialView();
              }
        }
        private void EnviaEmailConfirmacao (ApplicationUser user)
        {

            var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id }, protocol: Request.Url.Scheme);
            _enviarEmail = new EnviaEmail();
            var corpo = "Por favor confirme sua conta clicando neste link:  <a href=" + '\u0022' + callbackUrl +
                        '\u0022' + ">Clique aqui</a>";
            var assunto = "Confirme seu email";

            var send = _enviarEmail.EnviaEmailConfirmacao(user.Email, corpo, assunto);

            if (!send.Key)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = send.Value;
                logVm.Controller = "Prestador";
                logVm.View = "EnviaEmailConfirmacao";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
            }
        }
        public ActionResult Editar(PrestadorEditarViewModel prestador)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    DateTime weekDay = DateTime.Now;
                    string data = weekDay.ToString("dd-MM-yyyy-HH-mm-ss");

                    var file = this.Request.Files[0];
                    if (!string.IsNullOrEmpty(file.FileName))
                    {
                        string savedFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Images/ImagemPerfil");
                        savedFileName = Path.Combine(savedFileName, Path.GetFileName(data + "_" + file.FileName));
                        file.SaveAs(savedFileName);
                        prestador.caminho_foto = Path.GetFileName(data + "_" + file.FileName);
                    }
                    else
                    {
                        var prestadorOld = _prestadorApp.GetPorGuid(Guid.Parse(prestador.pres_Id));
                        prestador.caminho_foto = prestadorOld.caminho_foto;
                    }
                    //inicia a distribuição das propriedades do prestador
                    var prestadordomain = _prestadorApp.GetPorGuid(Guid.Parse(prestador.pres_Id));
                    prestadordomain.pres_Nome = prestador.pres_nome;
                    prestadordomain.pres_Email = prestador.pres_email;
                    prestadordomain.nome_Empresa = prestador.nome_Empresa;
                    prestadordomain.apresentacao_Empresa = prestador.apresentacao_Empresa;
                    prestadordomain.apresentacao_Pesssoal = prestador.apresentacao_Pesssoal;
                    prestadordomain.pres_Cpf_Cnpj = prestador.pres_cpf_cnpj;
                    prestadordomain.pres_Telefone_Celular = prestador.pres_telefone_celular;
                    prestadordomain.pres_Telefone_Residencial = prestador.pres_telefone_residencial;
                    //atualiza o email do usuario no aspnetuser tambem
                    prestadordomain.Usuario.Email = prestador.pres_email;
                    prestadordomain.Usuario.PasswordHash = prestador.pres_email;
                    //grava os dados
                    _prestadorApp.Update(prestadordomain);
                    //redireciona o cara para continuar o processo de cadastro dos serviços
                    return RedirectToAction("ServicosCategorias", "Servico",
                        new
                        {
                            cpf = prestador.pres_cpf_cnpj,
                            nome = prestador.pres_nome,
                            email = prestador.pres_email,
                            celular = prestador.pres_telefone_celular,
                            editarPerfil = true
                        });
                    //return RedirectToAction("MeuPerfil", new { usuarioId = prestador.pres_Id });
                }
                catch (Exception e)
                {
                    var logVm = new LogViewModel();
                    logVm.Mensagem = e.Message;
                    logVm.Controller = "Prestador";
                    logVm.View = "Post Editar Perfil";

                    var log = Mapper.Map<LogViewModel, Log>(logVm);

                    _logAppService.SaveOrUpdate(log);
                    return RedirectToAction("ErroAoCadastrar");
                }
            }
            else
            {
                return View(prestador);
            }
        }
        public ActionResult Editar(string id)
        {
            try
            {
                var prestador = _prestadorApp.GetPorGuid(Guid.Parse(id));
                ViewBag.Nome = prestador.pres_Nome;
                ViewBag.CaminhoFoto = prestador.caminho_foto;
                var prestadorViewModel = Mapper.Map<Prestador, PrestadorEditarViewModel>(prestador);
                return View(prestadorViewModel);
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Prestador";
                logVm.View = "Get Editar Perfil";

                var log = Mapper.Map<LogViewModel, Log>(logVm);

                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }
        public ActionResult EditarPerfil(PrestadorUsuarioViewModel prestadorViewModel)
        {
            try
            {
                DateTime weekDay = DateTime.Now;
                string data = weekDay.ToString("dd-MM-yyyy-HH-mm-ss");

                var file = this.Request.Files[0];
                if (!string.IsNullOrEmpty(file.FileName))
                {
                    string savedFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Images/ImagemPerfil");
                    savedFileName = Path.Combine(savedFileName, Path.GetFileName(data + "_" + file.FileName));
                    file.SaveAs(savedFileName);
                    prestadorViewModel.caminho_foto = Path.GetFileName(data + "_" + file.FileName);
                }
                else
                {
                    var prestadorOld = _prestadorApp.GetPorGuid(Guid.Parse(prestadorViewModel.pres_Id));
                    prestadorViewModel.caminho_foto = prestadorOld.caminho_foto;
                }
                ModelState["Senha"].Errors.Clear();
                ModelState["ConfirmaSenha"].Errors.Clear();

                if (ModelState.IsValid)
                {

                    var prestador = Mapper.Map<PrestadorUsuarioViewModel, Prestador>(prestadorViewModel);
                    var endereco = prestador.pres_Endereco;
                    var partes = endereco.Split(',');
                    foreach (var parte in partes.Where(s => s.Contains("-")))
                    {
                        var separar = parte.Split('-');
                        var ufs = " AC, AL, AP, AM, BA, CE, DF, ES, GO, MA, MT, MS, MG, PA,PB, PR, PE, PI, RJ, RN, RS, RO, RR, SC, SP, SE, TO";
                        if (ufs.Contains(separar[1]))
                        {
                            prestador.Estado =
                                (EnumClass.EnumEstados)Enum.Parse(typeof(EnumClass.EnumEstados), separar[1]);
                            prestador.Cidade = separar[0];
                        }
                        else
                            continue;

                    }

                    _prestadorApp.Update(prestador);
                    //redireciona o cara para continuar o processo de cadastro dos serviços
                    return RedirectToAction("ServicosCategorias", "Servico",
                        new
                        {
                            cpf = prestador.pres_Cpf_Cnpj,
                            nome = prestador.pres_Nome,
                            email = prestador.pres_Email,
                            celular = prestador.pres_Telefone_Celular,
                            editarPerfil = true
                        });

                    //return RedirectToAction("MeuPerfil", new { usuarioId = prestador.pres_Id });
                }
                else
                {
                    return View(prestadorViewModel);
                }
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Prestador";
                logVm.View = "Post Editar Perfil";

                var log = Mapper.Map<LogViewModel, Log>(logVm);

                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }
 public byte VerificaSeEstaLigado(string orc, string prestador)
 {
     try
       {
     Orcamento retorno = _orcamentoApp.RetornaOrcamentoPorId(Convert.ToInt32(orc));
     //percorre a lista de orçamento para ver se o prestador ja esta ligado
     foreach (var item in retorno.PrestadorFk)
     {
       if (item.pres_Id == prestador)
       {
     //retorna um se econtrar o prestador na lista
     return 1;
       }
     }
     //senao encontrar o prestador na lista retorna 0 nao esta ligado
     return 0;
       }
       catch (Exception e)
       {
     var logVm = new LogViewModel();
     logVm.Mensagem = e.Message;
     logVm.Controller = "Orçamento";
     logVm.View = "AtribuirPrestadorOrcamento";
     var log = Mapper.Map<LogViewModel, Log>(logVm);
     _logAppService.SaveOrUpdate(log);
     return 2;
       }
 }
        public ActionResult BuscaTrabalhos(string usuarioId)
        {
            try
              {
            _userId = usuarioId;
            var prestador = _prestadorApp.GetPorGuid(Guid.Parse(usuarioId));
            ViewBag.Nome = prestador.pres_Nome;
            ViewBag.CaminhoFoto = prestador.caminho_foto;
            ViewBag.UsuarioId = prestador.pres_Id;

            ViewBag.ListaCat = new SelectList(_categoriaApp.GetAll(), "cat_Id", "cat_Nome");
            var orcamentoVm = Mapper.Map<IEnumerable<Orcamento>, IEnumerable<OrcamentoViewModel>>
            (_orcamentoApp.RetornarOrcamentosComDistanciaCalculada(prestador.pres_latitude,
                prestador.pres_longitude, prestador.pres_Raio_Recebimento, prestador.pres_Id));
            string frase;
            var orcamentoViewModels = orcamentoVm as OrcamentoViewModel[] ?? orcamentoVm.ToArray();
            if (orcamentoViewModels.Count() == 1)
              frase = "Foi encontrado " + orcamentoViewModels.Count().ToString() + " orçamento.";
            else
              frase = "Foram encontrados " + orcamentoViewModels.Count().ToString() + " orçamentos";
            ViewBag.FraseQtd = frase;

            return View(orcamentoVm);
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "BuscaTraballhos";
            var log = Mapper.Map<LogViewModel, Log>(logVm);
            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public ActionResult Cadastrar(OrcamentoViewModel orcamento, int servico_id)
        {
            try
              {

            if (ModelState.IsValid)
            {
              var orcamentoEntity = Mapper.Map<OrcamentoViewModel, Orcamento>(orcamento);

              var endereco = orcamento.orc_Endereco;
              var partes = endereco.Split(',');
              foreach (var parte in partes.Where(s => s.Contains("-")))
              {

            var separar = parte.Split('-');
            var ufs =
                " AC, AL, AP, AM, BA, CE, DF, ES, GO, MA, MT, MS, MG, PA,PB, PR, PE, PI, RJ, RN, RS, RO, RR, SC, SP, SE, TO";
            if (ufs.Contains(separar[1]))
            {
              orcamentoEntity.orc_estado =
                  (EnumClass.EnumEstados)Enum.Parse(typeof(EnumClass.EnumEstados), separar[1]);
              orcamentoEntity.orc_cidade = separar[0];
            }
            else
              continue;

              }
              orcamentoEntity.serv_Id = servico_id;
              _orcamentoApp.Add(orcamentoEntity);

              var corpo = @"Olá " + orcamento.orc_nome_solicitante + " seu orçamento já está cadastrado em nosso sistema, fique atento que logo o prestador entrará em contato com você. Obrigado por nos escolher!" +
            "<br /><br /> Att, <br />";

              var assunto = "Orçamento Enviado";
              _enviaEmail = new EnviaEmail();
              var enviou = _enviaEmail.EnviaEmailConfirmacao(orcamentoEntity.orc_email_solicitante, corpo, assunto);
              if (!enviou.Key)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = enviou.Value;
            logVm.Controller = "Enviar Email";
            logVm.View = "Cadastrar Orçamento";
            var log = Mapper.Map<LogViewModel, Log>(logVm);
            _logAppService.SaveOrUpdate(log);
              }

              _enviaEmail.EnviaEmailConfirmacao(orcamentoEntity.orc_email_solicitante, corpo, assunto);

              var prestadores = _orcamentoApp.EnviaEmailParaPrestadoresQueOferecemOServico(orcamentoEntity.serv_Id);
              foreach (var prestadorID in prestadores)
              {
            var prestador = _prestadorApp.GetPorGuid(prestadorID);
            var envia = _orcamentoApp.EnviaEmailNotificacao(prestador, orcamentoEntity);
            if (envia.Key)
            {
              var corpoNotificacao = "Olá, " + _utils.PrimeiraLetraMaiuscula(prestador.pres_Nome.Trim()) + ", " + _utils.DefineSaudacao() + "!" + " <br /><br /> Chegou mais um orçamento para você." +
                  " <br /> Este orçamento está à uma distância de " + envia.Value.Trim() + ". <br />" +
                  "<br /> <a href=" + '\u0022' + "www.agilizaorcamentos.com.br/Orcamento/BuscaTrabalhos?usuarioId=" + prestador.pres_Id + '\u0022' + "><strong>Clique aqui</strong></a> para visualizar os orçamentos disponíveis para você. " +
                  "<br /><br /> Att, <br />" +
                  "Equipe Agiliza";

              var assuntoNotificacao = "Novo orçamento encontrado";
              _enviaEmail = new EnviaEmail();
              var enviouNotificacao = _enviaEmail.EnviaEmailConfirmacao(prestador.pres_Email, corpoNotificacao, assuntoNotificacao);
              if (!enviou.Key)
              {
                var logVm = new LogViewModel();
                logVm.Mensagem = enviou.Value;
                logVm.Controller = "Enviar Email Notificação";
                logVm.View = "Enviar email notificação de novo orçamento.";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
              }
            }
              }

              //Enviar email para administradores de novo orçamento

              var servico = _servicoApp.GetById(servico_id);

              var admins = _prestadorApp.GetAdministradores();

              foreach (var admin in admins)
              {
            var corpoNovoUsuario = "Olá, " + _utils.PrimeiraLetraMaiuscula(admin.pres_Nome.Trim()) + ", " + _utils.DefineSaudacao() + "!" + " <br /><br /> Chegou mais um novo orçamento para Agiliza." +
            " <br /><strong>Solicitante:</strong>  " + orcamento.orc_nome_solicitante +
            " <br /><strong>Email:</strong>  " + orcamento.orc_email_solicitante +
            " <br /><strong>Telefone:</strong>  " + orcamento.orc_telefone_solicitante +
            " <br /><strong>Tipo de serviço:</strong>  " + servico.serv_Nome +
            " <br /><strong>Descrição:</strong>  " + orcamento.orc_descricao +
            " <br /><strong>Local para realizar o trabalho:</strong>  " + orcamento.orc_Endereco +
            " <br /><strong>Prazo previsto:</strong>  " + orcamento.orc_prazo +

            " <br /><strong>Descrição:</strong>  " + orcamento.orc_descricao +
            "<br /> <a href=" + '\u0022' + "www.agilizaorcamentos.com.br/Orcamento/ListarTodos" + '\u0022' + "><strong>Clique aqui</strong></a> para visualizar os orçamentos. " +
            "<br /><br /> Att, <br />" +
            "Equipe Agiliza";

            var assuntoNotificacao = "Novo orçamento Cadastrado";
            _enviaEmail = new EnviaEmail();
            var enviouNotificacao = _enviaEmail.EnviaEmailConfirmacao(admin.pres_Email, corpoNovoUsuario, assuntoNotificacao);
            if (!enviou.Key)
            {
              var logVm = new LogViewModel();
              logVm.Mensagem = enviou.Value;
              logVm.Controller = "Enviar Email Notificação para admin de novo orçamento";
              logVm.View = "Enviar email notificação para admin de novo orçamento.";
              var log = Mapper.Map<LogViewModel, Log>(logVm);
              _logAppService.SaveOrUpdate(log);
            }
              }

              return RedirectToAction("OrcamentoEnviadoSucesso");
            }
            else
            {
              ViewBag.ListaCat = new SelectList(_categoriaApp.GetAll(), "cat_Id", "cat_Nome");
              return View(orcamento);
            }

              }
              catch (Exception e)
              {

            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Cadastrar Post";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public ActionResult ServicosCategorias(FormCollection collection, string cpf,
            string nome, string celular, string email, bool editarPerfil)
        {
            try
            {
                var sbEmail = new StringBuilder();
                var servicos = new List<Servico>();
                foreach (var col in collection)
                {
                    int servId;
                    Int32.TryParse(col.ToString(), out servId);
                    var servico = _iServicoApp.GetById(servId);

                    sbEmail.Append(servico.serv_Nome);
                    sbEmail.Append(", ");

                    servicos.Add(servico);
                }
                //inserir por email, assim nao tem como duplicar
                var prestador = _iPrestadorApp.GetPorEmail(email);
                _iServicoPrestadorApp.SalvarServicosPrestador(servicos, prestador);
                if (editarPerfil)
                {
                    return RedirectToAction("MeuPerfil", "Prestador", new { usuarioId = prestador.pres_Id });
                }
                else
                {
                    //Enviar email para admins de novo usuario
                    var admins = _iPrestadorApp.GetAdministradores();

                    foreach (var admin in admins)
                    {
                        var corpoNovoUsuario = "Olá, " + _utils.PrimeiraLetraMaiuscula(admin.pres_Nome.Trim()) + ", " + _utils.DefineSaudacao() + "!" + " <br /><br /> Chegou mais um prestador para Agiliza." +
                        " <br /><strong>Nome:</strong>  " + prestador.pres_Nome +
                        " <br /><strong>Email:</strong>  " + prestador.pres_Email +
                        " <br /><strong>Telefone:</strong>  " + prestador.pres_Telefone_Residencial +
                        " <br /><strong>Celular:</strong>  " + prestador.pres_Telefone_Celular +
                        " <br /><strong>Endereço:</strong>  " + prestador.pres_Endereco +
                        " <br /><strong>Serviços:</strong><br />  " + sbEmail.ToString().Substring(0, sbEmail.ToString().Length - 2) + "." +

                        "<br /><br /> <a href=" + '\u0022' + "www.agilizaorcamentos.com.br/Prestador/Index" + '\u0022' + "><strong>Clique aqui</strong></a> para visualizar os prestadores cadastrados. " +
                        "<br /><br /> Att, <br />" +
                        " Equipe Agiliza.";

                        var assuntoNotificacao = "Novo orçamento Cadastrado";
                        var _enviaEmail = new EnviaEmail();
                        var enviouNotificacao = _enviaEmail.EnviaEmailConfirmacao(admin.pres_Email, corpoNovoUsuario, assuntoNotificacao);
                        if (!enviouNotificacao.Key)
                        {
                            var logVm = new LogViewModel();
                            logVm.Mensagem = enviouNotificacao.Value;
                            logVm.Controller = "Enviar Email Notificação para admin de novo prestador";
                            logVm.View = "Enviar email notificação para admin de novo prestador.";
                            var log = Mapper.Map<LogViewModel, Log>(logVm);
                            _logAppService.SaveOrUpdate(log);
                        }
                    }

                    return RedirectToAction("PrestadorCadastroSucesso", "Prestador");
                }
            }
            catch
            {
                return RedirectToAction("ErroAoCadastrar");
            }
        }
 public ActionResult ConfirmarDeletar(int id)
 {
     try
       {
     var orcamento = _orcamentoApp.GetById(id);
     _orcamentoApp.Remove(orcamento);
     return RedirectToAction("ListarTodos");
       }
       catch (Exception e)
       {
     var logVm = new LogViewModel();
     logVm.Mensagem = e.Message;
     logVm.Controller = "Orçamento";
     logVm.View = "Deletar Orcamento";
     var log = Mapper.Map<LogViewModel, Log>(logVm);
     _logAppService.SaveOrUpdate(log);
     return RedirectToAction("ErroAoDeletar");
       }
 }
        public async Task<ActionResult> VerifyCode(VerifyCodeViewModel model)
        {

            try
            {
                if (ModelState.IsValid)
                {
                    var result = await _signInManager.TwoFactorSignInAsync(model.Provider, model.Code, isPersistent: model.RememberMe, rememberBrowser: model.RememberBrowser);
                    switch (result)
                    {
                        case SignInStatus.Success:
                            return RedirectToLocal(model.ReturnUrl);
                        case SignInStatus.LockedOut:
                            return View("Lockout");
                        case SignInStatus.Failure:
                        default:
                            ModelState.AddModelError("", "Código Inválido.");
                            return View(model);
                    }
                }
                else
                    return View(model);

            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "VerifyCode";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        //
        // GET: /Orcamento/Details/5
        public ActionResult Detalhes(int id, string usuarioId)
        {
            try
              {
            _userId = usuarioId;
            var orcamentoEntity = Mapper.Map<Orcamento, OrcamentoViewModel>(_orcamentoApp.GetById(id));
            var servico = _servicoApp.GetById(orcamentoEntity.serv_Id);
            ViewBag.Servico = servico.serv_Nome;
            ViewBag.UsuarioId = usuarioId;

            return View(orcamentoEntity);
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Detalhes Get";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public ActionResult ConfirmEmail(string userId)
        {
            try
            {
                bool emailConfirmed = false;
                if (userId == null)
                {
                    return View("Error");
                }

                var user = _userManager.FindById(userId);
                if (user != null)
                {
                    user.EmailConfirmed = true;
                    _userManager.Update(user);
                    emailConfirmed = true;
                }

                
                //var result = await _userManager.ConfirmEmailAsync(userId, code);
                return View(emailConfirmed ? "EmailConfirmadoOk" : "Error");
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "Register";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }
        public ActionResult Detalhes(OrcamentoViewModel orcamentoVm, string usuarioId)
        {
            try
              {
            var orcamentoEntity = Mapper.Map<OrcamentoViewModel, Orcamento>(orcamentoVm);
            orcamentoEntity.Status = EnumClass.EnumStatusOrcamento.Fechado;
            _orcamentoApp.Update(orcamentoEntity);

            return RedirectToAction("BuscaTrabalhos", new { usuarioId });
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Detalhes Post";
            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return View(model);
                }

                var user = await _userManager.FindByNameAsync(model.Email);
                if (user == null)
                {
                    // Não revelar se o usuario nao existe ou nao esta confirmado
                    return RedirectToAction("Login", "Account");
                }

                user.PasswordHash = HashPassword(model.Password);
                var update =_userManager.Update(user);
                return RedirectToAction("Login", "Account");


                //if (result.Succeeded)
                //{
                //    return RedirectToAction("Login", "Account");
                //}
                //AddErrors(result);
                return View();
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "ResetPassword";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public ActionResult Editar(OrcamentoViewModel orcamentoVm)
        {
            try
              {
            //var orcamentodomain = Mapper.Map<OrcamentoViewModel, Orcamento>(orcamento);
            var orcamento = _orcamentoApp.GetById(orcamentoVm.orc_Id);
            // orcamentodomain.orc_descricao = orcamento.orc_descricao;
            orcamento.orc_descricao = orcamentoVm.orc_descricao;

            _orcamentoApp.Update(orcamento);
            return RedirectToAction("ListarTodos");
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Editar Post";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return View(model);
                }

                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, change to shouldLockout: true
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: true);
                var prestador = _prestadorAppService.GetPorEmail(model.Email);
                var userId = prestador.pres_Id;
                var rolesPrestador = _userManager.GetRoles(userId);
                var role = "";

                role = rolesPrestador != null ? rolesPrestador[0] : null;



                switch (result)
                {
                    case SignInStatus.Success:
                        //joga o usuario para a tela inicial 
                        //@Html.ActionLink("[ Disponíveis ]", "BuscaTrabalhos", "Orcamento", new { usuarioId = @Model.UsuarioId }, null)
                        if (role == "Prestador")
                            return RedirectToAction("BuscaTrabalhos", "Orcamento", new { usuarioId = userId });
                        else
                            return RedirectToAction("Index", "Prestador", new { usuarioId = userId });
                    case SignInStatus.LockedOut:
                        return View("Lockout");
                    case SignInStatus.RequiresVerification:
                        return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                    case SignInStatus.Failure:
                    default:
                        ModelState.AddModelError("", "Login ou Senha incorretos.");
                        return View(model);
                }
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel {Mensagem = e.Message, Controller = "Account", View = "Login"};
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public ActionResult Pagamento(string token, string amt, string cc, string item_name, string st, string tx)
        {
            try
              {
            if (st.Equals("Completed"))
            {
              var separarId = item_name.Split('-');

              var id = separarId[1];

              var orcamento = _orcamentoApp.GetById(int.Parse(id));
              var prestador = _prestadorApp.GetPorGuid(Guid.Parse(_userId));

              orcamento.PrestadorFk = new List<Prestador>();
              orcamento.PrestadorFk.Add(prestador);

              prestador.OrcamentoFk = new List<Orcamento>();
              prestador.OrcamentoFk.Add(orcamento);

              _prestadorApp.Update(prestador);
              _orcamentoApp.Update(orcamento);

              return RedirectToAction("Detalhes", new { id = id, usuarioId = _userId });
            }
            return View();
              }
              catch (Exception e)
              {
            var logVm = new LogViewModel();
            logVm.Mensagem = e.Message;
            logVm.Controller = "Orçamento";
            logVm.View = "Pagamento";

            var log = Mapper.Map<LogViewModel, Log>(logVm);

            _logAppService.SaveOrUpdate(log);
            return RedirectToAction("ErroAoCadastrar");
              }
        }
        public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
        {
            try
            {
                if (User.Identity.IsAuthenticated)
                {
                    return RedirectToAction("Index", "Manage");
                }

                if (ModelState.IsValid)
                {
                    // Pegar a informação do login externo.
                    var info = await AuthenticationManager.GetExternalLoginInfoAsync();
                    if (info == null)
                    {
                        return View("ExternalLoginFailure");
                    }
                    var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                    var result = await _userManager.CreateAsync(user);
                    if (result.Succeeded)
                    {
                        result = await _userManager.AddLoginAsync(user.Id, info.Login);
                        if (result.Succeeded)
                        {
                            await _signInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                            return RedirectToLocal(returnUrl);
                        }
                    }
                    AddErrors(result);
                }

                ViewBag.ReturnUrl = returnUrl;
                return View(model);
            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Account";
                logVm.View = "ExternalLoginConfirmation";
                var log = Mapper.Map<LogViewModel, Log>(logVm);
                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }

        }
        public ActionResult Create(PrestadorUsuarioViewModel prestadorUsuario, string cpf, string cnpj)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var retorno = _userManager.FindByEmail(prestadorUsuario.pres_email);
                    if (retorno != null)
                    {
                        ModelState.AddModelError("pres_email", "Email já cadastrado");
                        return View(prestadorUsuario);
                    }
                    else
                    {
                        var prestador = new Prestador();

                        //primeiro efetua o cadastro do usuario
                        var user = new ApplicationUser
                        {
                            UserName = prestadorUsuario.pres_email,
                            Email = prestadorUsuario.pres_email
                        };
                        //adicionar a role para este usuario
                        IdentityUserRole role = new IdentityUserRole();
                        role.RoleId = "2"; //role 2 e role prestador
                        role.UserId = user.Id;
                        user.Roles.Add(role);
                        //cria o usuario
                        var result = _userManager.Create(user, prestadorUsuario.Senha);

                        EnviaEmailConfirmacao(user);

                        
                        if (result.Succeeded)
                        {
                            prestadorUsuario.pres_cpf_cnpj = cpf.Replace("-", "").Replace("/", "").Replace(".", "");
                            //pega o usuario cadastrado e adiciona ele no objeto prestador
                            Usuario usuarioCadastrado = new Usuario();
                            usuarioCadastrado = _usuarioApp.ObterPorEmail(prestadorUsuario.pres_email);
                            prestador.Usuario = usuarioCadastrado;
                            prestador.pres_Nome = prestadorUsuario.pres_nome;
                            prestador.pres_Email = prestadorUsuario.pres_email;
                            prestador.pres_Cpf_Cnpj = prestadorUsuario.pres_cpf_cnpj;
                            prestador.pres_Endereco = prestadorUsuario.pres_Endereco;
                            prestador.pres_Telefone_Celular = prestadorUsuario.pres_telefone_celular;
                            prestador.pres_Telefone_Residencial = prestadorUsuario.pres_telefone_residencial;
                            prestador.status = EnumClass.EnumStatus.Ativo;
                            prestador.pres_Raio_Recebimento = prestadorUsuario.pres_Raio_Recebimento;
                            prestador.pres_latitude = prestadorUsuario.pres_Latitude;
                            prestador.pres_longitude = prestadorUsuario.pres_Longitude;


                            var endereco = prestador.pres_Endereco;
                            var partes = endereco.Split(',');
                            foreach (var parte in partes.Where(s => s.Contains("-")))
                            {

                                var separar = parte.Split('-');
                                var ufs = " AC, AL, AP, AM, BA, CE, DF, ES, GO, MA, MT, MS, MG, PA,PB, PR, PE, PI, RJ, RN, RS, RO, RR, SC, SP, SE, TO";
                                if (ufs.Contains(separar[1]))
                                {
                                    prestador.Estado =
                                        (EnumClass.EnumEstados)Enum.Parse(typeof(EnumClass.EnumEstados), separar[1]);
                                    prestador.Cidade = separar[0];
                                }
                                else
                                    continue;

                            }

                            _prestadorApp.SaveOrUpdate(prestador);
                            //redireciona o cara para continuar o processo de cadastro dos serviços
                            return RedirectToAction("ServicosCategorias", "Servico",
                                new
                                {
                                    cpf = prestador.pres_Cpf_Cnpj,
                                    nome = prestador.pres_Nome,
                                    email = prestador.pres_Email,
                                    celular = prestador.pres_Telefone_Celular,
                                    editarPerfil = false
                                });
                            


                        }
                        else
                        {
                            return View(prestadorUsuario);
                        }

                    }
                }
                else
                {
                    return View(prestadorUsuario);
                }

            }
            catch (Exception e)
            {
                var logVm = new LogViewModel();
                logVm.Mensagem = e.Message;
                logVm.Controller = "Prestador";
                logVm.View = "Create";

                var log = Mapper.Map<LogViewModel, Log>(logVm);

                _logAppService.SaveOrUpdate(log);
                return RedirectToAction("ErroAoCadastrar");
            }
        }