public ActionResult Login()
        {
            AcessoModel objAcessoUsuario = new AcessoModel();

            var _cookieLembraUsuario   = HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieLembrarUsuario")];
            var _cookieManterConectado = HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieManterConectado")];

            HttpCookie BrowserVerificaCriarCookie = new HttpCookie(objMD5.getMD5Hash("BrowserVerificaCriarCookie")); // C6D27B273F1B25456B7D9D05ECAFECA4

            HttpContext.Response.Cookies.Add(BrowserVerificaCriarCookie);

            if (_cookieManterConectado != null)
            {
                if (CryptographyRepository.Descriptografar(HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieManterConectado")][objMD5.getMD5Hash("USUMANTERLOG")].ToString()) == "true")
                {
                    objAcessoUsuario.manterConectado = true;
                }
            }

            if (_cookieLembraUsuario != null)
            {
                objAcessoUsuario.usuario        = CryptographyRepository.Descriptografar(HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieLembrarUsuario")][objMD5.getMD5Hash("USERNAME")]);
                objAcessoUsuario.lembrarUsuario = true;
            }
            return(View(objAcessoUsuario));
        }
Example #2
0
        static void Main(string[] args)
        {
            try
            {
                string password = "******";
                string salt     = "sample1234!@#*";

                var encryptedText = CryptographyRepository.Encrypt(password, salt, "sample0");
                Console.WriteLine("Encrypted text : " + encryptedText);
                var decryptedText = CryptographyRepository.Decrypt(password, salt, encryptedText);
                Console.WriteLine(decryptedText);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        public ActionResult DesfazerMoverPastaArquivoModal(MoverPastaArquivoDesfazerMover desfazerPastaArquivoMovidos)
        {
            UsuarioContext usuarioAcessoContext = new UsuarioContext();

            DiretoriosArquivosContext diretoriosArquivosContext = new DiretoriosArquivosContext();

            // string _arrayIdPastaArquivo = "";
            int i = 0;

            int?[] _arrayIdPastaArquivo = {};
            _arrayIdPastaArquivo = new int?[desfazerPastaArquivoMovidos.ListPasArqMov.Count];

            foreach (var dirArqMovidos in desfazerPastaArquivoMovidos.ListPasArqMov)
            {
                _arrayIdPastaArquivo[i] = Int32.Parse(CryptographyRepository.Descriptografar(dirArqMovidos.CodPasArq));
                i++;
            }

            var _retornoQueryUser = (from usuarioInfoAcesso in usuarioAcessoContext.CloudUsuariosAcesso
                                     where usuarioInfoAcesso.Uac_UserName == User.Identity.Name
                                     select usuarioInfoAcesso).SingleOrDefault();

            var _retornoQueryDiretorioArquivo = (from dirArquiInfo in diretoriosArquivosContext.CloudDiretoriosArquivos
                                                 where dirArquiInfo.Dia_Fk_Usu_id == _retornoQueryUser.Uac_Fk.Usu_Id &&
                                                 _arrayIdPastaArquivo.Contains(dirArquiInfo.Dia_Id)
                                                 select dirArquiInfo).ToList();

            //  _IdPastaArquivo = CryptographyRepository.Criptografar(_retornoQueryDiretorioArquivo.Dia_Id.ToString());
            List <MoverPastaArquivo> desfazerPastaArquivoMovidosLista = new List <MoverPastaArquivo>();

            foreach (var itemRetornoQuery in _retornoQueryDiretorioArquivo)
            {
                MoverPastaArquivo pastaArquivoMovidosQuery = new MoverPastaArquivo();

                pastaArquivoMovidosQuery.CodigoPastaArquivo = CryptographyRepository.Criptografar(itemRetornoQuery.Dia_Id.ToString());
                pastaArquivoMovidosQuery.NomePastaArquivo   = itemRetornoQuery.Dia_Nome;


                desfazerPastaArquivoMovidosLista.Add(pastaArquivoMovidosQuery);
            }
            return(PartialView(desfazerPastaArquivoMovidosLista));
        }
        public ActionResult Login(string returnUrl)
        {
            LoginViewModel objAcessoUsuario = new LoginViewModel();

            HttpCookie BrowserVerificaCriarCookie = new HttpCookie(ConverterMD5.getMD5Hash("BrowserVerificaCriarCookie")); // C6D27B273F1B25456B7D9D05ECAFECA4

            HttpContext.Response.Cookies.Add(BrowserVerificaCriarCookie);

            var _cookieLembraUsuario = HttpContext.Request.Cookies[ConverterMD5.getMD5Hash("UserCookieLembrarUsuario")];

            if (_cookieLembraUsuario != null)
            {
                objAcessoUsuario.UserName         = CryptographyRepository.Descriptografar(HttpContext.Request.Cookies[ConverterMD5.getMD5Hash("UserCookieLembrarUsuario")][ConverterMD5.getMD5Hash("USERNAME")]);
                objAcessoUsuario.RememberUserName = true;
            }


            ViewBag.ReturnUrl = returnUrl;
            return(View(objAcessoUsuario));
        }
        public ActionResult RenomearPasta(FormCollection PostFolder)
        {
            string _caminhoSolicitadoPasta = PostFolder["hidCaminhoComp"];
            string _novoNomePasta          = PostFolder["NomePasta"];
            string _diretorioBaseUsuario   = null;

            string _caminhoSemPasta     = null;
            string _antigoNomePasta     = null;
            string _nomePastaTemporaria = null;

            string _caminhoPastaOriginal     = null;
            string _caminhoMiniPastaOriginal = null;


            string _caminhoPastaAlterada         = null;
            string _caminhoPastaAlteradaTemp     = null;
            string _caminhoMiniPastaAlterada     = null;
            string _caminhoMiniPastaAlteradaTemp = null;

            string _caminhoPaiCompleto = null;


            UsuarioContext usuarioAcesso = new UsuarioContext();

            var _retornoQueryUser = (from usuarioInfoAcesso in usuarioAcesso.CloudUsuariosAcesso
                                     where usuarioInfoAcesso.Uac_UserName == User.Identity.Name
                                     select usuarioInfoAcesso).SingleOrDefault();

            _diretorioBaseUsuario = _retornoQueryUser.Uac_Fk.Usu_DiretorioBase;

            Encoding iso = Encoding.GetEncoding("ISO-8859-1");

            _caminhoSolicitadoPasta = HttpUtility.UrlDecode(_caminhoSolicitadoPasta, iso);

            _caminhoSemPasta = _caminhoSolicitadoPasta.Substring(0, _caminhoSolicitadoPasta.LastIndexOf("/"));

            _antigoNomePasta = Path.GetFileName(_caminhoSemPasta);

            _caminhoSemPasta = _caminhoSemPasta.Substring(0, _caminhoSemPasta.LastIndexOf("/"));

            //   DiretoriosArquivosContext diretoriosArquivosContext = new DiretoriosArquivosContext();

            diretoriosArquivosContex.Configuration.AutoDetectChangesEnabled = false;

            using (var trans = diretoriosArquivosContex.Database.BeginTransaction(IsolationLevel.ReadCommitted))
            {
                try
                {
                    var _retornoQueryDiretorioArquivo = (from dirArquiInfo in diretoriosArquivosContex.CloudDiretoriosArquivos
                                                         where dirArquiInfo.Dia_Nome == _antigoNomePasta &&
                                                         dirArquiInfo.Dia_CaminhoAtual == _caminhoSemPasta + "/" &&
                                                         dirArquiInfo.Dia_Fk_Usu_id == _retornoQueryUser.Uac_Fk.Usu_Id
                                                         select dirArquiInfo).AsNoTracking().SingleOrDefault();

                    var diretoriosArquivos = new NewPhotoCloudDiretoriosArquivos
                    {
                        Dia_Id              = _retornoQueryDiretorioArquivo.Dia_Id,
                        Dia_Fk_Usu_id       = _retornoQueryUser.Uac_Fk.Usu_Id,
                        Dia_Nome            = _novoNomePasta,
                        Dia_CaminhoOriginal = _retornoQueryDiretorioArquivo.Dia_CaminhoOriginal,
                        Dia_CaminhoAtual    = _retornoQueryDiretorioArquivo.Dia_CaminhoAtual,
                        Dia_Tipo            = _retornoQueryDiretorioArquivo.Dia_Tipo,
                        Dia_DataCriacao     = _retornoQueryDiretorioArquivo.Dia_DataCriacao,
                        Dia_DataExclusao    = _retornoQueryDiretorioArquivo.Dia_DataExclusao,
                        Dia_Status          = _retornoQueryDiretorioArquivo.Dia_Status
                    };

                    diretoriosArquivosContex.Entry(diretoriosArquivos).State = EntityState.Modified;
                    diretoriosArquivosContex.SaveChanges();


                    try
                    {
                        //      DiretoriosArquivosContext diretoriosArquivosFilhosContext = new DiretoriosArquivosContext();

                        var _retornoQueryDiretorioArquivoFilhos = (from dirArquiFilhoInfo in diretoriosArquivosContex.CloudDiretoriosArquivos
                                                                   where dirArquiFilhoInfo.Dia_CaminhoAtual.StartsWith(_caminhoSolicitadoPasta) &&
                                                                   dirArquiFilhoInfo.Dia_Fk_Usu_id == _retornoQueryUser.Uac_Fk.Usu_Id
                                                                   select dirArquiFilhoInfo).AsNoTracking();

                        //     List<NewPhotoCloudDiretoriosArquivos> _listArqDirUpdate = new List<NewPhotoCloudDiretoriosArquivos>();

                        foreach (var item in _retornoQueryDiretorioArquivoFilhos)
                        {
                            string _caminhoAlterado         = item.Dia_CaminhoAtual.Replace("/" + _antigoNomePasta + "/", "/" + _novoNomePasta + "/");
                            var    diretoriosArquivosFilhos = new NewPhotoCloudDiretoriosArquivos
                            {
                                Dia_Id              = item.Dia_Id,
                                Dia_Fk_Usu_id       = _retornoQueryUser.Uac_Fk.Usu_Id,
                                Dia_Nome            = item.Dia_Nome,
                                Dia_CaminhoOriginal = item.Dia_CaminhoOriginal,
                                Dia_CaminhoAtual    = _caminhoAlterado,
                                //    Dia_CaminhoAtual = _caminhoSemPasta + "/" + _novoNomePasta + "/",
                                Dia_Tipo         = item.Dia_Tipo,
                                Dia_DataCriacao  = item.Dia_DataCriacao,
                                Dia_DataExclusao = item.Dia_DataExclusao,
                                Dia_Status       = item.Dia_Status
                            };

                            diretoriosArquivosContex.Entry(diretoriosArquivosFilhos).State = EntityState.Modified;
                        }
                        diretoriosArquivosContex.ChangeTracker.DetectChanges();
                        diretoriosArquivosContex.SaveChanges();
                    }
                    catch (Exception e)
                    {
                        trans.Rollback();
                        ViewBag.Message        = "Falha ao registrar a alteração dos conteúdos da pasta: <strong>" + _novoNomePasta + "</strong>";
                        ViewBag.Status         = -1;
                        ViewBag.CaminhoRetorno = _caminhoSemPasta;
                        ViewBag.PastaRetorno   = _antigoNomePasta;
                        return(PartialView());
                    }
                }
                catch (Exception e)
                {
                    trans.Rollback();
                    ViewBag.Message        = "Falha ao registrar a alteração da pasta: <strong>" + _novoNomePasta + "</strong>";
                    ViewBag.Status         = -1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                try
                {
                    _caminhoMiniPastaOriginal = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + _caminhoSemPasta + "/" + _antigoNomePasta);
                    _caminhoPastaOriginal     = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + _caminhoSemPasta + "/" + _antigoNomePasta);

                    _caminhoMiniPastaAlterada = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + _caminhoSemPasta + "/" + _novoNomePasta);
                    _caminhoPastaAlterada     = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + _caminhoSemPasta + "/" + _novoNomePasta);
                }
                catch (Exception e)
                {
                    trans.Rollback();
                    ViewBag.Message        = "Falha ao renomear a pasta de  <strong>" + _antigoNomePasta + "</strong> para <strong>" + _novoNomePasta + "</strong>. <br /> Caminho muito extenso.";
                    ViewBag.Status         = -1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                if (_caminhoMiniPastaAlterada.Length >= 248)
                {
                    _caminhoPaiCompleto = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + _caminhoSemPasta);
                    _caminhoPaiCompleto = _caminhoPaiCompleto.Substring(1, _caminhoPaiCompleto.LastIndexOf("\\") - 1);

                    trans.Rollback();
                    ViewBag.Message        = "Não é possível renomear a pasta <strong>" + _antigoNomePasta + "</strong>  para <strong>" + _novoNomePasta + "</strong>. <br /> Caminho muito extenso.";
                    ViewBag.Status         = 1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                if (_caminhoMiniPastaOriginal.Equals(_caminhoMiniPastaAlterada, StringComparison.InvariantCultureIgnoreCase))
                {
                    ConvertMD5 ConverteMd5 = new ConvertMD5();
                    _nomePastaTemporaria          = Path.GetFileName(_caminhoMiniPastaAlterada);
                    _caminhoMiniPastaAlteradaTemp = _caminhoSemPasta + "/" + ConverteMd5.getMD5Hash(CryptographyRepository.Criptografar(_nomePastaTemporaria));


                    try
                    {
                        //System.IO.Directory.Move(Server.MapPath(@"\pasta"), Server.MapPath(@"\pasta renomeada"));
                        _caminhoMiniPastaAlteradaTemp = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + _caminhoMiniPastaAlteradaTemp);

                        System.IO.Directory.Move(@_caminhoMiniPastaOriginal, @_caminhoMiniPastaAlteradaTemp);
                    }
                    catch (Exception e)
                    {
                        trans.Rollback();
                        ViewBag.Message        = "Falha ao criar pasta temporária de miniaturas para configuração de diretórios.";
                        ViewBag.Status         = -1;
                        ViewBag.CaminhoRetorno = _caminhoSemPasta;
                        ViewBag.PastaRetorno   = _antigoNomePasta;
                        return(PartialView());
                    }
                }

                // Determine whether the directory exists.
                if (Directory.Exists(_caminhoMiniPastaAlterada))
                {
                    if (_caminhoMiniPastaAlteradaTemp != null)
                    {
                        System.IO.Directory.Move(@_caminhoMiniPastaAlteradaTemp, @_caminhoMiniPastaOriginal);
                    }

                    trans.Rollback();
                    ViewBag.Message        = "A pasta <strong>" + _novoNomePasta + "</strong> já existe.";
                    ViewBag.Status         = 1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                if (_caminhoMiniPastaAlteradaTemp != null)
                {
                    _caminhoMiniPastaOriginal = _caminhoMiniPastaAlteradaTemp;
                }

                try
                {
                    //System.IO.Directory.Move(Server.MapPath(@"\pasta"), Server.MapPath(@"\pasta renomeada"));

                    System.IO.Directory.Move(@_caminhoMiniPastaOriginal, @_caminhoMiniPastaAlterada);
                }
                catch (Exception e)
                {
                    trans.Rollback();
                    ViewBag.Message        = "Falha ao renomear a pasta de miniaturas, de <strong>" + _antigoNomePasta + "</strong> para <strong>" + _novoNomePasta + "</strong>.";
                    ViewBag.Status         = -1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                _nomePastaTemporaria = null;

                if (_caminhoPastaOriginal.Equals(_caminhoPastaAlterada, StringComparison.InvariantCultureIgnoreCase))
                {
                    ConvertMD5 ConverteMd5 = new ConvertMD5();
                    _nomePastaTemporaria      = Path.GetFileName(_caminhoPastaAlterada);
                    _caminhoPastaAlteradaTemp = _caminhoSemPasta + "/" + ConverteMd5.getMD5Hash(CryptographyRepository.Criptografar(_nomePastaTemporaria));


                    try
                    {
                        //System.IO.Directory.Move(Server.MapPath(@"\pasta"), Server.MapPath(@"\pasta renomeada"));
                        _caminhoPastaAlteradaTemp = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + _caminhoPastaAlteradaTemp);

                        System.IO.Directory.Move(@_caminhoPastaOriginal, @_caminhoPastaAlteradaTemp);
                    }
                    catch (Exception e)
                    {
                        trans.Rollback();
                        ViewBag.Message        = "Falha ao criar pasta temporária para configuração de diretórios.";
                        ViewBag.Status         = -1;
                        ViewBag.CaminhoRetorno = _caminhoSemPasta;
                        ViewBag.PastaRetorno   = _antigoNomePasta;
                        return(PartialView());
                    }
                }

                // Determine whether the directory exists.
                if (Directory.Exists(_caminhoPastaAlterada))
                {
                    if (_caminhoPastaAlteradaTemp != null)
                    {
                        System.IO.Directory.Move(@_caminhoPastaAlteradaTemp, @_caminhoPastaOriginal);
                        // ?????????????? RENOMEAR MINI ?????????????????
                    }

                    trans.Rollback();
                    ViewBag.Message        = "A pasta <strong>" + _novoNomePasta + "</strong> já existe.";
                    ViewBag.Status         = 1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                if (_caminhoPastaAlteradaTemp != null)
                {
                    _caminhoPastaOriginal = _caminhoPastaAlteradaTemp;
                }

                try
                {
                    //System.IO.Directory.Move(Server.MapPath(@"\pasta"), Server.MapPath(@"\pasta renomeada"));

                    System.IO.Directory.Move(_caminhoPastaOriginal, _caminhoPastaAlterada);
                }
                catch (Exception e)
                {
                    System.IO.Directory.Move(_caminhoMiniPastaAlterada, _caminhoMiniPastaOriginal);
                    trans.Rollback();
                    ViewBag.Message        = "Falha ao renomear a pasta de  <strong>" + _antigoNomePasta + "</strong> para <strong>" + _novoNomePasta + "</strong>.";
                    ViewBag.Status         = -1;
                    ViewBag.CaminhoRetorno = _caminhoSemPasta;
                    ViewBag.PastaRetorno   = _antigoNomePasta;
                    return(PartialView());
                }

                trans.Commit();
            }



            ViewBag.Message        = "A pasta <strong>" + _antigoNomePasta + "</strong> foi renomeada para <strong>" + _novoNomePasta + "</strong> com sucesso.";
            ViewBag.Status         = 0;
            ViewBag.CaminhoRetorno = _caminhoSemPasta;
            ViewBag.PastaRetorno   = _novoNomePasta;
            return(PartialView());
        }
        protected override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            ConvertMD5 objMD5 = new ConvertMD5();

            var CookieAuthentication = filterContext.HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieAuthentication")];

            if (CookieAuthentication == null)
            {
                filterContext.Result = new RedirectToRouteResult(
                    new RouteValueDictionary {
                    { "controller", "Acesso" },
                    { "action", "Login" }
                });
            }
            else
            {
                string _maqUsuarioCookie = CryptographyRepository.Descriptografar(filterContext.HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieAuthentication")][objMD5.getMD5Hash("USUMAQNOM")].ToString());
                string _IpUsuarioCookie  = CryptographyRepository.Descriptografar(filterContext.HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieAuthentication")][objMD5.getMD5Hash("USUMAQIP4")].ToString());

                string _IpMaquina;

                IPHostEntry hostInfo = Dns.GetHostEntry(Dns.GetHostName());
                _IpMaquina = hostInfo.AddressList.Where(i => i.AddressFamily.Equals(AddressFamily.InterNetwork)).First().ToString();

                if (_maqUsuarioCookie == Dns.GetHostName() && _IpUsuarioCookie == _IpMaquina)
                {
                    var _idUsuarioCookie = CryptographyRepository.Descriptografar(filterContext.HttpContext.Request.Cookies[objMD5.getMD5Hash("UserCookieAuthentication")][objMD5.getMD5Hash("USUIDLOGD")].ToString());

                    int IDUsuario;
                    if (int.TryParse(_idUsuarioCookie, out IDUsuario))
                    {
                        photocloudEntities ContextoUsuario = new photocloudEntities();

                        var Consulta = (from usuario in ContextoUsuario.pho_usuarios
                                        join usuario_acesso in ContextoUsuario.pho_usuario_acesso on usuario.usu_id equals usuario_acesso.usa_fk_usuario
                                        where usuario.usu_id == IDUsuario
                                        select new
                        {
                            usuario.usu_id,
                            usuario.usu_nome,
                            usuario.usu_sobrenome,
                            usuario.usu_diretoriobase,
                            usuario_acesso.usa_email,
                            usuario_acesso.usa_login
                        }).SingleOrDefault();
                        //  select usuario, usuario_acesso).SingleOrDefault();

                        int    _idUsuario        = Consulta.usu_id;
                        string _nomeUsuario      = Consulta.usu_nome;
                        string _sobrenomeUsuario = Consulta.usu_sobrenome;
                        string _emailUsuario     = Consulta.usa_email;
                        string _loginUsuario     = Consulta.usa_login;
                        string _diretorioUsuario = Consulta.usu_diretoriobase;

                        UsuarioLogadoModel objUsuarioLogado = new UsuarioLogadoModel();

                        objUsuarioLogado.idUsuario        = _idUsuario;
                        objUsuarioLogado.nomeUsuario      = _nomeUsuario;
                        objUsuarioLogado.sobrenomeUsuario = _sobrenomeUsuario;
                        objUsuarioLogado.loginUsuario     = _loginUsuario;
                        objUsuarioLogado.diretorioUsuario = _diretorioUsuario;

                        filterContext.Controller.ViewData.Add("vdtUsuarioLogado", objUsuarioLogado);
                    }
                    else
                    {
                        filterContext.Result = new RedirectToRouteResult(
                            new RouteValueDictionary
                        {
                            { "controller", "Acesso" },
                            { "action", "login" }
                        });
                    }
                }
                else
                {
                    filterContext.Result = new RedirectToRouteResult(
                        new RouteValueDictionary
                    {
                        { "controller", "Acesso" },
                        { "action", "login" }
                    });
                }
            }
            base.OnActionExecuting(filterContext);
        }
        public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            var _cookieHabilitadoBrowser = HttpContext.Request.Cookies[ConverterMD5.getMD5Hash("BrowserVerificaCriarCookie")];

            if (_cookieHabilitadoBrowser == null)
            {
                return(RedirectToAction("HabilitarCookie", "Restricao"));
            }
            else
            {
                if (!ModelState.IsValid)
                {
                    return(View(model));
                }

                UsuarioContext usuarioAcesso = new UsuarioContext();

                var _retornoQueryUser = (from login in usuarioAcesso.CloudUsuariosAcesso
                                         where login.Uac_Email == model.UserName || login.Uac_UserName == model.UserName
                                         select login).SingleOrDefault();

                if (_retornoQueryUser != null)
                {
                    model.UserName = _retornoQueryUser.Uac_UserName;
                }


                // 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.UserName, model.Password, model.RememberMe, shouldLockout : false);

                switch (result)
                {
                case SignInStatus.Success:

                    HttpCookie VerificaCookie = new HttpCookie(ConverterMD5.getMD5Hash("BrowserVerificaCriarCookie"));
                    VerificaCookie.Expires = DateTime.Now.AddDays(-1d);
                    Response.Cookies.Add(VerificaCookie);

                    bool _LembrarUsuario = model.RememberUserName;

                    if (_LembrarUsuario)
                    {
                        HttpCookie LembrarUsuarioCookie = new HttpCookie(ConverterMD5.getMD5Hash("UserCookieLembrarUsuario"));                                                // 77E9E65EE9901E30F3C233D965916A9C

                        LembrarUsuarioCookie.Values.Add(ConverterMD5.getMD5Hash("USERNAME"), CryptographyRepository.Criptografar(_retornoQueryUser.Uac_UserName.ToString())); // 27087B329DEEADE828EDD652D45461B2
                        LembrarUsuarioCookie.Expires = DateTime.Now.AddDays(30);
                        System.Web.HttpContext.Current.Response.Cookies.Add(LembrarUsuarioCookie);
                    }
                    else
                    {
                        if (System.Web.HttpContext.Current.Request.Cookies[ConverterMD5.getMD5Hash("UserCookieLembrarUsuario")] != null)
                        {
                            HttpCookie myCookie = new HttpCookie(ConverterMD5.getMD5Hash("UserCookieLembrarUsuario"));
                            myCookie.Expires = DateTime.Now.AddDays(-1d);
                            System.Web.HttpContext.Current.Response.Cookies.Add(myCookie);
                        }
                    }

                    return(RedirectToLocal(returnUrl));

                case SignInStatus.LockedOut:
                    return(View("Lockout"));

                case SignInStatus.RequiresVerification:
                    return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));

                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "Usuário ou senha inválidos.");

                    return(View(model));
                }
            }
        }
        public ActionResult MoverPastaArquivo(MoverPastaArquivoOrigem moverPastaArquivo)
        {
            string _diretorioBaseUsuario      = "";
            string _caminhoOrigem             = "";
            string _caminhoOrigemMiniatura    = "";
            string _nomePastaArquivoOrigem    = "";
            string _caminhoDestino            = "";
            string _caminhoDestinoMiniatura   = "";
            string _caminhoSemPasta           = "";
            string _codigoPastaArquivo        = "";
            string _caminhoDestinoSubPastas   = "";
            bool   _pastaArquivoExisteOrigem  = false;
            bool   _pastaArquivoExisteDestino = false;

            var _qtdPastaMovido   = 0;
            var _qtdArquivoMovido = 0;

            ViewBag.Status = 0;


            //    MoverPastaArquivoRetornoSucesso _jsonRecuperaListaPastasArquivosMovidos;

            //      List<MoverPastaArquivoRetornoSucesso> RetornoPastasArquivosMovidos = new List<MoverPastaArquivoRetornoSucesso>();
            MoverPastaArquivoDesfazerMover RetornoPastasArquivosMovidos = new MoverPastaArquivoDesfazerMover();


            //var arrJsJsonMoverPara = new {
            //        "caminhoRetorno": moverPastaArquivo.CaminhoRetorno,
            //        "caminhoPastaPai":moverPastaArquivo.CaminhoPastaPai,
            //        "estadoPasta": moverPastaArquivo.EstadoPasta,
            //        "caminhoAtualDestino": moverPastaArquivo.CaminhoAtualDestino,
            //        "listaMoverPastasArquivos": [
            //                        { "nomePastaArquivo": moverPastaArquivo.ListaMoverPastasArquivos., "caminhoOriginal": moverPastaArquivo.ListaMoverPastasArquivos., "tipoArquivoPasta": moverPastaArquivo.ListaMoverPastasArquivos. }
            //            ]
            //};
            ConvertMD5 ConverterMD5 = new ConvertMD5();

            UsuarioContext usuarioAcesso = new UsuarioContext();

            var _retornoQueryUser = (from usuarioInfoAcesso in usuarioAcesso.CloudUsuariosAcesso
                                     where usuarioInfoAcesso.Uac_UserName == User.Identity.Name
                                     select usuarioInfoAcesso).SingleOrDefault();

            _diretorioBaseUsuario = _retornoQueryUser.Uac_Fk.Usu_DiretorioBase;



            var _cookieItensMovidos = HttpContext.Request.Cookies[ConverterMD5.getMD5Hash("ListaPastasArquivosMovidos")];

            if (_cookieItensMovidos != null)
            {
                RetornoPastasArquivosMovidos = JsonConvert.DeserializeObject <MoverPastaArquivoDesfazerMover>(HttpContext.Request.Cookies[ConverterMD5.getMD5Hash("ListaPastasArquivosMovidos")]["PasArqMov"]);
            }


            ViewBag.DirBase = _diretorioBaseUsuario;
            try
            {
                _caminhoDestino          = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + "/" + moverPastaArquivo.CaminhoAtualDestino);
                _caminhoDestinoMiniatura = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + "/" + moverPastaArquivo.CaminhoAtualDestino);
            }
            catch (Exception e)
            {
                ViewBag.Message = "Falha ao configurar caminhos de destino. Nenhum item foi movido.";
                ViewBag.Status  = -1;
                return(PartialView(moverPastaArquivo));
            }

            ///  _caminhoInicialMiniatura = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario);
            //  _caminhoInicial = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario);

            List <MoverPastaArquivoDesfazerMoverLista> ListaPastaArquivoMovido     = new List <MoverPastaArquivoDesfazerMoverLista>();
            List <MoverPastaArquivoNomeMovidos>        ListaNomePastaArquivoMovido = new List <MoverPastaArquivoNomeMovidos>();

            foreach (var itemPastaArquivo in moverPastaArquivo.ListaMoverPastasArquivos)
            {
                using (var trans = diretoriosArquivosContex.Database.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    _caminhoSemPasta = itemPastaArquivo.CaminhoOriginal.Substring(0, itemPastaArquivo.CaminhoOriginal.LastIndexOf("/"));
                    if (itemPastaArquivo.TipoArquivoPasta == 'D')
                    {
                        _caminhoSemPasta = _caminhoSemPasta.Substring(0, _caminhoSemPasta.LastIndexOf("/"));
                    }


                    try
                    {
                        _caminhoOrigem          = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + itemPastaArquivo.CaminhoOriginal);
                        _caminhoOrigemMiniatura = Server.MapPath("~/pho_fotos_miniatura/" + _diretorioBaseUsuario + itemPastaArquivo.CaminhoOriginal);

                        if (itemPastaArquivo.TipoArquivoPasta == 'D')
                        {
                            _nomePastaArquivoOrigem = Path.GetFileName(itemPastaArquivo.CaminhoOriginal.Substring(0, itemPastaArquivo.CaminhoOriginal.LastIndexOf("/")));
                        }
                        else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                        {
                            _nomePastaArquivoOrigem = Path.GetFileName(itemPastaArquivo.CaminhoOriginal);
                        }

                        //throw new Exception();
                    }
                    catch (Exception e)
                    {
                        trans.Rollback();
                        if (itemPastaArquivo.TipoArquivoPasta == 'D')
                        {
                            itemPastaArquivo.MensagemsRetorno = "Falha ao configurar caminhos de origem da pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Pasta não movida.";
                        }
                        else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                        {
                            itemPastaArquivo.MensagemsRetorno = "Falha ao configurar caminhos de origem do arquivo: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Arquivo não movido.";
                        }
                        itemPastaArquivo.StatusRetorno = -1;
                        continue;
                    }
                    if (itemPastaArquivo.TipoArquivoPasta == 'D')
                    {
                        _pastaArquivoExisteOrigem  = Directory.Exists(_caminhoOrigem);
                        _pastaArquivoExisteDestino = Directory.Exists(_caminhoDestino + _nomePastaArquivoOrigem);
                    }
                    else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                    {
                        _pastaArquivoExisteOrigem  = System.IO.File.Exists(_caminhoOrigem);
                        _pastaArquivoExisteDestino = System.IO.File.Exists(_caminhoDestino + _nomePastaArquivoOrigem);
                    }
                    else
                    {
                        itemPastaArquivo.MensagemsRetorno = "Falha ao identificar o tipo do item: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>.";
                        itemPastaArquivo.StatusRetorno    = -1;
                        continue;
                    }

                    if (_pastaArquivoExisteOrigem)
                    {
                        if (_pastaArquivoExisteDestino)
                        {
                            trans.Rollback();
                            if (itemPastaArquivo.TipoArquivoPasta == 'D')
                            {
                                itemPastaArquivo.MensagemsRetorno = "Já existe uma pasta com o nome <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong> neste local.";
                                itemPastaArquivo.StatusRetorno    = 1;
                            }
                            else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                            {
                                itemPastaArquivo.MensagemsRetorno = "Já existe um arquivo com o nome <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong> neste local.";
                                itemPastaArquivo.StatusRetorno    = 1;
                            }
                            continue;
                        }
                        else
                        {
                            try
                            {
                                var _retornoQueryDiretorioArquivo = (from dirArquiInfo in diretoriosArquivosContex.CloudDiretoriosArquivos
                                                                     where dirArquiInfo.Dia_Nome == itemPastaArquivo.NomePastaArquivo &&
                                                                     dirArquiInfo.Dia_CaminhoAtual == _caminhoSemPasta + "/" &&
                                                                     dirArquiInfo.Dia_Fk_Usu_id == _retornoQueryUser.Uac_Fk.Usu_Id
                                                                     select dirArquiInfo).AsNoTracking().SingleOrDefault();

                                _codigoPastaArquivo = CryptographyRepository.Criptografar(_retornoQueryDiretorioArquivo.Dia_Id.ToString());
                                //  _codigoPastaArquivo = _retornoQueryDiretorioArquivo.Dia_Id.ToString();

                                var diretoriosArquivos = new NewPhotoCloudDiretoriosArquivos
                                {
                                    Dia_Id              = _retornoQueryDiretorioArquivo.Dia_Id,
                                    Dia_Fk_Usu_id       = _retornoQueryUser.Uac_Fk.Usu_Id,
                                    Dia_Nome            = _retornoQueryDiretorioArquivo.Dia_Nome,
                                    Dia_CaminhoOriginal = _retornoQueryDiretorioArquivo.Dia_CaminhoAtual,
                                    Dia_CaminhoAtual    = moverPastaArquivo.CaminhoAtualDestino,
                                    Dia_Tipo            = _retornoQueryDiretorioArquivo.Dia_Tipo,
                                    Dia_DataCriacao     = _retornoQueryDiretorioArquivo.Dia_DataCriacao,
                                    Dia_Status          = _retornoQueryDiretorioArquivo.Dia_Status
                                };

                                diretoriosArquivosContex.Entry(diretoriosArquivos).State = EntityState.Modified;
                                diretoriosArquivosContex.SaveChanges();

                                try
                                {
                                    var _retornoQueryDiretorioArquivoFilhos = (from dirArquiFilhoInfo in diretoriosArquivosContex.CloudDiretoriosArquivos
                                                                               where dirArquiFilhoInfo.Dia_CaminhoAtual.StartsWith(itemPastaArquivo.CaminhoOriginal) &&
                                                                               dirArquiFilhoInfo.Dia_Fk_Usu_id == _retornoQueryUser.Uac_Fk.Usu_Id
                                                                               select dirArquiFilhoInfo).AsNoTracking();

                                    foreach (var item in _retornoQueryDiretorioArquivoFilhos)
                                    {
                                        _caminhoDestinoSubPastas = item.Dia_CaminhoAtual;

                                        _caminhoDestinoSubPastas = _caminhoDestinoSubPastas.Replace(itemPastaArquivo.CaminhoOriginal, moverPastaArquivo.CaminhoAtualDestino + itemPastaArquivo.NomePastaArquivo + "/");

                                        var diretoriosArquivosFilhos = new NewPhotoCloudDiretoriosArquivos
                                        {
                                            Dia_Id              = item.Dia_Id,
                                            Dia_Fk_Usu_id       = _retornoQueryUser.Uac_Fk.Usu_Id,
                                            Dia_Nome            = item.Dia_Nome,
                                            Dia_CaminhoOriginal = item.Dia_CaminhoAtual,
                                            Dia_CaminhoAtual    = _caminhoDestinoSubPastas,
                                            Dia_Tipo            = item.Dia_Tipo,
                                            Dia_DataCriacao     = item.Dia_DataCriacao,
                                            Dia_Status          = item.Dia_Status
                                        };

                                        diretoriosArquivosContex.Entry(diretoriosArquivosFilhos).State = EntityState.Modified;
                                    }
                                    diretoriosArquivosContex.ChangeTracker.DetectChanges();
                                    diretoriosArquivosContex.SaveChanges();
                                }
                                catch (Exception e)
                                {
                                    trans.Rollback();
                                    if (itemPastaArquivo.TipoArquivoPasta == 'D')
                                    {
                                        itemPastaArquivo.MensagemsRetorno = "Falha ao registrar a alteração da pasta contida na pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Pasta não movida.";
                                    }
                                    else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                                    {
                                        itemPastaArquivo.MensagemsRetorno = "Falha ao registrar a alteração do arquivo contido na pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Arquivo não movido.";
                                    }
                                    itemPastaArquivo.StatusRetorno = -1;
                                    continue;
                                }
                            }
                            catch (Exception e)
                            {
                                trans.Rollback();
                                if (itemPastaArquivo.TipoArquivoPasta == 'D')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao registrar a alteração da pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Pasta não movida.";
                                }
                                else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao registrar a alteração do arquivo: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Arquivo não movido.";
                                }
                                itemPastaArquivo.StatusRetorno = -1;
                                continue;
                            }

                            try
                            {
                                System.IO.Directory.Move(_caminhoOrigemMiniatura, _caminhoDestinoMiniatura + _nomePastaArquivoOrigem);
                            }
                            catch (Exception e)
                            {
                                trans.Rollback();
                                if (itemPastaArquivo.TipoArquivoPasta == 'D')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao tentar mover a configuração de miniaturas da pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Pasta não movida.";
                                }
                                else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao tentar mover a configuração de miniaturas do arquivo: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Arquivo não movido.";
                                }
                                itemPastaArquivo.StatusRetorno = -1;
                                continue;
                            }
                            try
                            {
                                System.IO.Directory.Move(_caminhoOrigem, _caminhoDestino + _nomePastaArquivoOrigem);
                            }
                            catch (Exception e)
                            {
                                System.IO.Directory.Move(_caminhoDestinoMiniatura + _nomePastaArquivoOrigem, _caminhoOrigemMiniatura);
                                trans.Rollback();
                                if (itemPastaArquivo.TipoArquivoPasta == 'D')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao tentar mover a pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Pasta não movida.";
                                }
                                else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                                {
                                    itemPastaArquivo.MensagemsRetorno = "Falha ao tentar mover o arquivo: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>. Arquivo não movido.";
                                }
                                itemPastaArquivo.StatusRetorno = -1;
                                continue;
                            }

                            if (itemPastaArquivo.TipoArquivoPasta == 'D')
                            {
                                _qtdPastaMovido++;
                            }
                            else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                            {
                                _qtdArquivoMovido++;
                            }

                            //     itemPastaArquivo.CodigoPastaArquivo = _codigoPastaArquivo;

                            MoverPastaArquivoDesfazerMoverLista PastaArquivoMovido     = new MoverPastaArquivoDesfazerMoverLista();
                            MoverPastaArquivoNomeMovidos        NomePastaArquivoMovido = new MoverPastaArquivoNomeMovidos();
                            if (_cookieItensMovidos != null)
                            {
                                foreach (var itemJaMovido in RetornoPastasArquivosMovidos.ListPasArqMov)
                                {
                                    if (itemJaMovido.CodPasArq == _codigoPastaArquivo)
                                    {
                                        RetornoPastasArquivosMovidos.ListPasArqMov.Remove(itemJaMovido);
                                        break;
                                    }
                                    Console.Write(itemJaMovido.CodPasArq + " == ");
                                    Console.Write(_codigoPastaArquivo);
                                }
                            }
                            PastaArquivoMovido.CodPasArq            = _codigoPastaArquivo;
                            NomePastaArquivoMovido.NomePastaArquivo = itemPastaArquivo.NomePastaArquivo;
                            NomePastaArquivoMovido.CaminhoOriginal  = itemPastaArquivo.CaminhoOriginal;
                            NomePastaArquivoMovido.TipoArquivoPasta = itemPastaArquivo.TipoArquivoPasta;

                            //    PastaArquivoMovido.NomePastaArquivo = itemPastaArquivo.NomePastaArquivo;
                            //     PastaArquivoMovido.TipoArquivoPasta = itemPastaArquivo.TipoArquivoPasta;
                            //     PastaArquivoMovido.DataMoverArquivoPasta = DateTime.Now.ToUniversalTime();

                            //    RetornoPastasArquivosMovidos.ListaPastaArquivoMovidos.Add(PastaArquivoMovido);

                            ListaPastaArquivoMovido.Add(PastaArquivoMovido);
                            ListaNomePastaArquivoMovido.Add(NomePastaArquivoMovido);

                            trans.Commit();
                        }
                    }
                    else
                    {
                        if (itemPastaArquivo.TipoArquivoPasta == 'D')
                        {
                            itemPastaArquivo.MensagemsRetorno = "A pasta <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong> não foi localizada. Ela pode ter sido removida ou renomeada.";
                            itemPastaArquivo.StatusRetorno    = -1;
                        }
                        else if (itemPastaArquivo.TipoArquivoPasta == 'A')
                        {
                            itemPastaArquivo.MensagemsRetorno = "O arquivo <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong> não foi localizado. Ele pode ter sido removido ou renomeado.";
                            itemPastaArquivo.StatusRetorno    = -1;
                        }
                        continue;
                    }

                    //try
                    //{
                    //    var diretoriosArquivos = new NewPhotoCloudDiretoriosArquivos
                    //    {

                    //        Dia_Nome = _novaPasta,
                    //        Dia_CaminhoAtual = _caminhoNovaPasta,
                    //        Dia_DataCriacao = DateTime.Now.ToUniversalTime(),
                    //        Dia_Tipo = "D",
                    //        Dia_Status = "A",
                    //        Dia_Fk_Usu_id = _usu_id

                    //    };

                    //    diretoriosArquivosContex.CloudDiretoriosArquivos.Add(diretoriosArquivos);

                    //    //   s.Entry(diretoriosArquivos).State = EntityState.Modified;
                    //    diretoriosArquivosContex.SaveChanges();
                    //}
                    //catch (Exception e)
                    //{
                    //    trans.Rollback();
                    //    if (itemPastaArquivo.TipoArquivoPasta == 'D')
                    //    {
                    //        itemPastaArquivo.MensagemsRetorno = "Falha ao registrar a pasta: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>";
                    //    }
                    //    else if (itemPastaArquivo.TipoArquivoPasta == 'A') {
                    //        itemPastaArquivo.MensagemsRetorno = "Falha ao registrar o arquivo: <strong>" + itemPastaArquivo.NomePastaArquivo + "</strong>";
                    //    }

                    //    itemPastaArquivo.StatusRetorno = -1;

                    //}

                    //trans.Commit();
                }
            }

            moverPastaArquivo.QtdPastaMovida   = _qtdPastaMovido;
            moverPastaArquivo.QtdArquivoMovido = _qtdArquivoMovido;

            if (_qtdPastaMovido == 0 && _qtdArquivoMovido == 0)
            {
                ViewBag.Message = "Nenhum item selecionado  foi movido.";
                ViewBag.Status  = 1;
            }
            //    string teste = moverPastaArquivo.CaminhoPastaPai;


            if (moverPastaArquivo.EstadoPasta == "aberta")
            {
                //string _caminhoRetornoAberta = moverPastaArquivo.CaminhoRetorno.Substring(0, moverPastaArquivo.CaminhoRetorno.LastIndexOf("/"));
                //_caminhoRetornoAberta = _caminhoRetornoAberta.Substring(0, _caminhoRetornoAberta.LastIndexOf("/"));
                //ViewBag.CaminhoRetorno = _caminhoRetornoAberta +"/";
                ViewBag.CaminhoRetorno = moverPastaArquivo.CaminhoPastaPai;
            }
            else
            {
                ViewBag.CaminhoRetorno = moverPastaArquivo.CaminhoRetorno;
            }

            if (_cookieItensMovidos != null)
            {
                foreach (var itemMovido in RetornoPastasArquivosMovidos.ListPasArqMov)
                {
                    MoverPastaArquivoDesfazerMoverLista PastaArquivoMovido = new MoverPastaArquivoDesfazerMoverLista();

                    PastaArquivoMovido.CodPasArq = itemMovido.CodPasArq;
                    ListaPastaArquivoMovido.Add(PastaArquivoMovido);
                }
            }

            RetornoPastasArquivosMovidos.DtMovArqPas   = DateTime.Now.ToUniversalTime();
            RetornoPastasArquivosMovidos.ListPasArqMov = ListaPastaArquivoMovido;

            //  string _jsonListaPastasArquivosMovidos = new JavaScriptSerializer().Serialize(Json.Encode(RetornoPastasArquivosMovidos));

            string _jsonListaPastasArquivosMovidos     = JsonConvert.SerializeObject(RetornoPastasArquivosMovidos);
            string _jsonListaNomePastasArquivosMovidos = "{\"ListPasArqMov\":" + JsonConvert.SerializeObject(ListaNomePastaArquivoMovido) + "}";

            HttpCookie CookieListaPastaArquivoMovidos = new HttpCookie(ConverterMD5.getMD5Hash("ListaPastasArquivosMovidos"));  //6DCF4293C1633A918B283205FB5A67E5

            CookieListaPastaArquivoMovidos.Values.Add("PasArqMov", _jsonListaPastasArquivosMovidos);
            CookieListaPastaArquivoMovidos.Expires = DateTime.Now.AddMinutes(5);
            System.Web.HttpContext.Current.Response.Cookies.Add(CookieListaPastaArquivoMovidos);

            //     Console.WriteLine(moverPastaArquivo);

            ViewBag.JsonMovidos = _jsonListaNomePastasArquivosMovidos;

            return(PartialView(moverPastaArquivo));
        }
        public ActionResult ListaArquivos(FormCollection Postpath)
        {
            string _caminhoSolicitado      = Postpath["pasta"];
            string _pastaAtual             = "";
            string _diretorioPai           = "";
            string _caminhoCompleto        = "";
            string _diretorioBaseUsuario   = "";
            int?   _idUsuario              = null;
            string _cookieViewGridListHash = "";

            ConvertMD5 ConverterMD5 = new ConvertMD5();

            UsuarioContext usuarioAcesso = new UsuarioContext();

            var _retornoQueryUser = (from usuarioInfoAcesso in usuarioAcesso.CloudUsuariosAcesso
                                     where usuarioInfoAcesso.Uac_UserName == User.Identity.Name
                                     select usuarioInfoAcesso).SingleOrDefault();

            _diretorioBaseUsuario = _retornoQueryUser.Uac_Fk.Usu_DiretorioBase;
            _idUsuario            = _retornoQueryUser.Uac_Fk.Usu_Id;

            _cookieViewGridListHash = "0000000000" + _idUsuario.ToString();
            _cookieViewGridListHash = _cookieViewGridListHash.Substring(_cookieViewGridListHash.Length - 10);

            _cookieViewGridListHash = ConverterMD5.getMD5Hash(CryptographyRepository.Criptografar("viewgridlist" + _cookieViewGridListHash));

            ViewData["cookieViewGridListHash"] = _cookieViewGridListHash;

            var _viewgridlist = HttpContext.Request.Cookies[_cookieViewGridListHash];

            if (_viewgridlist == null)
            {
                ViewData["viewgridlist"] = "grid";
            }
            else
            {
                ViewData["viewgridlist"] = _viewgridlist.Value.ToString();
            }


            if ((_caminhoSolicitado.LastIndexOf("/") - 1) > 1)
            {
                string   _formataBreadcrumb = _caminhoSolicitado.Substring(1, _caminhoSolicitado.LastIndexOf("/") - 1);
                string[] _breadcrumb        = _formataBreadcrumb.Split('/');
                ViewData["breadcrumb"]        = _breadcrumb;
                ViewData["formataBreadcrumb"] = _formataBreadcrumb;
                ViewData["tamanhoBreadcrumb"] = _formataBreadcrumb.Length;
            }

            _pastaAtual = _caminhoSolicitado.Substring(0, _caminhoSolicitado.LastIndexOf("/"));

            if (_caminhoSolicitado == "/")
            {
                _diretorioPai = "/";
            }
            else
            {
                _diretorioPai = _pastaAtual.Substring(0, _pastaAtual.LastIndexOf("/")) + "/";
            }


            _pastaAtual = _pastaAtual.Substring(_pastaAtual.LastIndexOf("/") + 1);

            if (_diretorioPai == "" || _diretorioPai == null)
            {
                _diretorioPai = "/";
            }

            if (_pastaAtual == "" || _pastaAtual == null)
            {
                _pastaAtual = "[photoCloud:]";
            }

            ViewData["diretorioPai"]   = _diretorioPai;
            ViewData["pastaAtual"]     = _pastaAtual;
            ViewData["diretorioAtual"] = _caminhoSolicitado;



            _caminhoCompleto = Server.MapPath("~/pho_fotos/" + _diretorioBaseUsuario + "/" + _caminhoSolicitado);

            if (System.IO.File.Exists(_caminhoCompleto))
            {
                //http://stackoverflow.com/questions/1176022/unknown-file-type-mime
                return(base.File(_caminhoCompleto, "application/octet-stream"));
            }
            else if (System.IO.Directory.Exists(_caminhoCompleto))
            {
                List <ListaDiretorios> list_listaDiretorios = new List <ListaDiretorios>();

                IEnumerable <string> diretorioLista = Directory.EnumerateDirectories(_caminhoCompleto);
                foreach (string dir in diretorioLista)
                {
                    //if (Path.GetFileName(dir) != _diretorioBaseUsuario + "_RECICLE")
                    //{
                    DirectoryInfo d = new DirectoryInfo(dir);

                    ListaDiretorios dirModel = new ListaDiretorios();

                    dirModel.DiretorioBase       = _diretorioBaseUsuario;
                    dirModel.Diretorio           = "/" + _caminhoSolicitado + Path.GetFileName(dir) + "/";
                    dirModel.DiretorioNome       = Path.GetFileName(dir);
                    dirModel.DiretorioDataAcesso = d.LastAccessTime;

                    list_listaDiretorios.Add(dirModel);
                    //}
                }

                int quant = list_listaDiretorios.Count;

                List <ListaArquivos> list_listaArquivos = new List <ListaArquivos>();

                IEnumerable <string> arquivoLista = Directory.EnumerateFiles(_caminhoCompleto);
                foreach (string fil in arquivoLista)
                {
                    FileInfo f = new FileInfo(fil);

                    ListaArquivos fileModel = new ListaArquivos();

                    if (f.Extension.ToLower() != "php" && f.Extension.ToLower() != "aspx" && f.Extension.ToLower() != "asp")
                    {
                        fileModel.ArquivoNome       = Path.GetFileName(fil);
                        fileModel.ArquivoDiretorio  = "pho_fotos/" + _diretorioBaseUsuario + _caminhoSolicitado + Path.GetFileName(fil);
                        fileModel.ArquivoCaminho    = _caminhoSolicitado + Path.GetFileName(fil);
                        fileModel.ArquivoDataAcesso = f.LastAccessTime;
                        fileModel.ArquivoTamanho    = (f.Length < 1024) ? f.Length.ToString() + " B" : f.Length / 1024 + " KB";
                        fileModel.ArquivoExtensao   = f.Extension.Replace(@".", @"").ToLower();

                        list_listaArquivos.Add(fileModel);
                    }
                }

                ListaDiretoriosArquivos explorerModel = new ListaDiretoriosArquivos(list_listaDiretorios, list_listaArquivos);

                return(PartialView(explorerModel));
            }
            else
            {
                return(Content("<div class='alert alert-danger' role='alert'>" + _caminhoSolicitado + " não é um arquivo ou diretório válido.</div>"));
            }
        }