Ejemplo n.º 1
0
        /// <summary>
        /// Baixa arquivo
        /// </summary>
        /// <param name="doc"></param>
        /// <returns>retorna o arquivo pra download</returns>
        ///
        public ActionResult Download(string nomeDoc)
        {
            Usuario user = GetSessionUser();

            Documento doc = documentoRepository.GetDocumentoByNome(nomeDoc);

            if (user.Permissao == EnumPermissaoUsuario.professor)
            {
                return(RedirectToAction("Unauthorized", "Error"));
            }

            if (user.Permissao == EnumPermissaoUsuario.coordenador)
            {
                List <Documento> retorno = documentoRepository.GetDocsByCoordenador(user.IdUsuario);
                if (!retorno.Any(x => x.IdDocumento == doc.IdDocumento))
                {
                    return(RedirectToAction("Unauthorized", "Error"));
                }
            }

            string nomeArquivo = doc.NomeDocumento;
            string extensao    = Path.GetExtension(nomeArquivo);

            string contentType = "application/" + extensao.Substring(1);

            byte[] bytes = DirDoc.BaixaArquivo(doc, user);

            if (bytes == null)
            {
                return(RedirectToAction("Unauthorized", "Error"));
            }

            return(File(bytes, contentType, nomeArquivo));
        }
Ejemplo n.º 2
0
        public string AlteraDocumento(SolicitacaoDocumento sol)
        {
            SolicitacaoDocumento solic = db.SolicitacaoDocumento.Find(sol.IdSolicitacao);

            try
            {
                if (solic.Documento != null)
                {
                    DocumentoRepository docRep = new DocumentoRepository();
                    docRep.DeletaArquivo(solic.Documento, false);
                }
            }
            catch
            {
            }
            solic.DataAbertura = DateTime.Now;
            solic.DataLimite   = solic.DataAbertura.AddDays(7);

            solic.Documento               = solic.Documento == null ? new Documento() : solic.Documento;
            solic.Documento.arquivo       = sol.Documento.arquivo;
            solic.Documento.NomeDocumento = sol.Documento.NomeDocumento;
            solic.Documento.IdAlunoCurso  = solic.IdAlunoCurso;
            solic.Documento.IdTipoDoc     = sol.Documento.IdTipoDoc;

            string msgDoc = DirDoc.SalvaArquivo(solic.Documento);

            if (db.SaveChanges() > 0)
            {
                return("Alterado");
            }
            return("Erro");
        }
Ejemplo n.º 3
0
        public bool DeletaArquivo(Documento doc, bool deletaDoc)
        {
            SolicitacaoDocumento sol = new SolicitacaoDocumento();

            try
            {
                doc = db.Documento.Find(doc.IdDocumento);
                if (string.IsNullOrEmpty(doc.CaminhoDocumento) || DirDoc.DeletaArquivo(doc.CaminhoDocumento))
                {
                    doc.NomeDocumento    = "";
                    doc.CaminhoDocumento = null;

                    if (deletaDoc)
                    {
                        if (doc.SolicitacaoDocumento.Count() > 0)
                        {
                            sol        = db.SolicitacaoDocumento.Find(doc.SolicitacaoDocumento.FirstOrDefault().IdSolicitacao);
                            sol.Status = EnumStatusSolicitacao.excluido;

                            doc.SolicitacaoDocumento.Clear();
                        }
                        db.Documento.Remove(doc);
                    }


                    return(db.SaveChanges() > 0);
                }
            }
            catch (Exception ex)
            {
                return(false);
            }

            return(false);
        }
Ejemplo n.º 4
0
        public object GeraCertificados(int idEvento)
        {
            bool flag = DirDoc.GeraCertificado(idEvento);

            if (flag)
            {
                try
                {
                    var    evento      = eventoRepository.GetEventoById(idEvento);
                    var    url         = System.Web.Hosting.HostingEnvironment.MapPath("~/Views/Email/CertificadoGerado.cshtml");
                    string viewCode    = System.IO.File.ReadAllText(url);
                    var    eventoEmail = eventoRepository.ConverToEmailModel(evento, Url.Action("Login", "Account", null, Request.Url.Scheme));

                    var          html            = RazorEngine.Razor.Parse(viewCode, eventoEmail);
                    List <Aluno> alunosPresentes = eventoRepository.GetAlunosPresentes(evento);

                    eventoRepository.AlteraStatusEvento(idEvento, EnumStatusEvento.certificados);

                    try
                    {
                        if (alunosPresentes != null && alunosPresentes.Count > 0 && alunosPresentes.Any(x => x.Usuario.E_mail != ""))
                        {
                            var to   = alunosPresentes.Where(x => !string.IsNullOrEmpty(x.Usuario.E_mail)).Select(x => x.Usuario.E_mail).ToArray();
                            var from = System.Configuration.ConfigurationManager.AppSettings["MailFrom"].ToString();
                            Email.EnviarEmail(from, to, string.Format("Certificado do evento {0} gerado", evento.NomeEvento), html);
                        }
                    }
                    catch (Exception ex)
                    {
                    }

                    return(Json(new { Status = true, Type = "success", Message = "Certificados gerados com sucesso!", ReturnUrl = Url.Action("Index") }, JsonRequestBehavior.AllowGet));
                }
                catch (Exception ex)
                {
                    return(Json(new { Status = false, Type = "error", Message = "Houve um erro, tente novamente mais tarde!" }, JsonRequestBehavior.AllowGet));
                }
            }
            return(Json(new { Status = false, Type = "error", Message = "Houve um erro, tente novamente mais tarde!" }, JsonRequestBehavior.AllowGet));
        }
Ejemplo n.º 5
0
        public object SalvarDocumento(Documento doc, HttpPostedFileBase uploadFile)
        {
            Usuario user = GetSessionUser();

            if (ModelState.IsValid)
            {
                try
                {
                    // valida se o aluno está matriculado no curso que coordena
                    if (user.Permissao == EnumPermissaoUsuario.coordenador)
                    {
                        var cursos = cursoRepository.GetCursoByCoordenador(user.IdUsuario);
                        if (!cursos.Any(x => x.AlunoCurso.Any(y => y.IdAluno == doc.AlunoCurso.IdAluno)))
                        {
                            return(Json(new { Status = false, Type = "error", Message = "Não autorizado!" }, JsonRequestBehavior.AllowGet));
                        }
                    }

                    if (uploadFile == null)
                    {
                        return(Json(new { Status = false, Type = "error", Message = "Selecione um documento" }, JsonRequestBehavior.AllowGet));
                    }

                    if (!ValidaArquivo(uploadFile.FileName))
                    {
                        return(Json(new { Status = false, Type = "error", Message = "Formato inválido" }, JsonRequestBehavior.AllowGet));
                    }

                    doc.arquivo       = DirDoc.converterFileToArray(uploadFile);
                    doc.NomeDocumento = uploadFile.FileName;
                    string mensagem = DirDoc.SalvaArquivo(doc);

                    switch (mensagem)
                    {
                    case "Arquivo existente":
                        return(Json(new { Status = true, Type = "success", Message = "Documento salvo com sucesso", ReturnUrl = Url.Action("Index") }, JsonRequestBehavior.AllowGet));

                    case "Sucesso":
                        doc.arquivo = null;
                        Utilidades.SalvaLog(user, EnumAcao.Persistir, doc, (doc.IdDocumento > 0 ? (int?)doc.IdDocumento : null));
                        return(Json(new { Status = true, Type = "success", Message = "Documento salvo com sucesso", ReturnUrl = Url.Action("Index") }, JsonRequestBehavior.AllowGet));

                    case "Falha ao persistir":
                        return(Json(new { Status = false, Type = "error", Message = mensagem }, JsonRequestBehavior.AllowGet));

                    case "Falha ao criptografar":
                        return(Json(new { Status = false, Type = "error", Message = mensagem }, JsonRequestBehavior.AllowGet));

                    default:
                        return(null);
                    }
                }
                catch (Exception e)
                {
                    return(Json(new { Status = false, Type = "error", Message = "Ocorreu um erro ao realizar esta operação" }, JsonRequestBehavior.AllowGet));
                }
            }
            else
            {
                return(Json(new { Status = false, Type = "error", Message = "Campos inválidos" }, JsonRequestBehavior.AllowGet));
            }
        }
        public object SalvarSolicitacao(SolicitacaoDocumento sol, HttpPostedFileBase uploadFile)
        {
            Usuario user = GetSessionUser();

            string msg = "Erro";

            if (uploadFile == null)
            {
                return(Json(new { Status = false, Type = "error", Message = "Selecione um documento" }, JsonRequestBehavior.AllowGet));
            }

            try
            {
                var edit = true;
                sol.Status       = sol.IdSolicitacao > 0 ? sol.Status : EnumStatusSolicitacao.pendente;
                sol.DataAbertura = DateTime.Now;
                AlunoCurso al = new AlunoCurso();

                if (sol.IdSolicitacao == 0)
                {
                    al = cursoRepository.GetAlunoCurso(User.Identity.Name);

                    sol.IdAlunoCurso    = al.IdAlunoCurso;
                    sol.TipoSolicitacao = EnumTipoSolicitacao.aluno;

                    edit = false;

                    sol.Documento               = new Documento();
                    sol.Documento.arquivo       = DirDoc.converterFileToArray(uploadFile);
                    sol.Documento.NomeDocumento = uploadFile.FileName;
                    sol.Documento.IdAlunoCurso  = sol.IdAlunoCurso;

                    sol.Documento.IdTipoDoc = tipoDocumentoRepository.GetTipoDoc("certificado").IdTipoDoc;

                    string msgDoc = DirDoc.SalvaArquivo(sol.Documento);

                    sol.DataLimite = sol.DataAbertura.AddDays(7);
                    msg            = solicitacaoRepository.PersisteSolicitacao(sol);
                }
                else
                {
                    sol.Documento               = new Documento();
                    sol.Documento.arquivo       = DirDoc.converterFileToArray(uploadFile);
                    sol.Documento.NomeDocumento = uploadFile.FileName;
                    sol.Documento.IdAlunoCurso  = sol.IdAlunoCurso;

                    sol.Documento.IdTipoDoc = tipoDocumentoRepository.GetTipoDoc("certificado").IdTipoDoc;

                    msg = solicitacaoRepository.AlteraDocumento(sol);
                }

                if (msg != "Erro")
                {
                    if (!edit)
                    {
                        try
                        {
                            sol.AlunoCurso = al;
                            var solicitacaoEmail = solicitacaoRepository.ConverToEmailModel(sol, Url.Action("Login", "Account", null, Request.Url.Scheme));

                            var    url      = System.Web.Hosting.HostingEnvironment.MapPath("~/Views/Email/NovaSolicitacaoHoras.cshtml");
                            string viewCode = System.IO.File.ReadAllText(url);

                            var html = RazorEngine.Razor.Parse(viewCode, solicitacaoEmail);

                            var toEmail = new List <Usuario>();
                            var coord   = cursoRepository.GetCoordenadorByCurso(al.IdCurso);
                            toEmail = usuarioRepository.GetUsuariosSecretaria();
                            if (coord != null && coord.Usuario != null)
                            {
                                toEmail.Add(coord.Usuario);
                            }
                            if (toEmail.Any(x => !string.IsNullOrEmpty(x.E_mail)))
                            {
                                var to   = toEmail.Where(x => !string.IsNullOrEmpty(x.E_mail)).Select(x => x.E_mail).ToArray();
                                var from = System.Configuration.ConfigurationManager.AppSettings["MailFrom"].ToString();
                                Email.EnviarEmail(from, to, "Nova solicitação de horas complementares", html);
                            }
                        }
                        catch (Exception e)
                        {
                        }
                    }
                    Utilidades.SalvaLog(user, EnumAcao.Persistir, sol, (sol.IdSolicitacao > 0 ? (int?)sol.IdSolicitacao : null));
                    return(Json(new { Status = true, Type = "success", Message = "Solicitação salva com sucesso", ReturnUrl = Url.Action("Index") }, JsonRequestBehavior.AllowGet));
                }
                else
                {
                    return(Json(new { Status = false, Type = "error", Message = "Ocorreu um erro ao realizar esta operação." }, JsonRequestBehavior.AllowGet));
                }
            }
            catch (Exception e)
            {
                return(Json(new { Status = false, Type = "error", Message = "Ocorreu um erro ao realizar esta operação." }, JsonRequestBehavior.AllowGet));
            }
        }
        public object EnviarDocumento(SolicitacaoDocumento sol, HttpPostedFileBase uploadFile)
        {
            Usuario user = GetSessionUser();

            try
            {
                if (uploadFile == null)
                {
                    return(Json(new { Status = false, Type = "error", Message = "Selecione um documento" }, JsonRequestBehavior.AllowGet));
                }


                var solicitacao = solicitacaoRepository.GetSolicitacaoById(sol.IdSolicitacao);

                if (solicitacao.AlunoCurso.Aluno.Usuario.IdUsuario == User.Identity.Name)
                {
                    solicitacao.Status          = EnumStatusSolicitacao.processando;
                    solicitacao.DataAtendimento = DateTime.Now;

                    solicitacao.Documento.arquivo       = DirDoc.converterFileToArray(uploadFile);
                    solicitacao.Documento.NomeDocumento = uploadFile.FileName;

                    string msgDoc = DirDoc.SalvaArquivo(solicitacao.Documento);
                    switch (msgDoc)
                    {
                    case "Falha ao persistir":
                        return(Json(new { Status = false, Type = "error", Message = msgDoc }, JsonRequestBehavior.AllowGet));

                    case "Falha ao criptografar":
                        return(Json(new { Status = false, Type = "error", Message = msgDoc }, JsonRequestBehavior.AllowGet));

                    default:
                        string msg = solicitacaoRepository.PersisteSolicitacao(solicitacao);

                        if (msg != "Erro")
                        {
                            try
                            {
                                var    url      = System.Web.Hosting.HostingEnvironment.MapPath("~/Views/Email/SolicitacaoDocumentoAtendida.cshtml");
                                string viewCode = System.IO.File.ReadAllText(url);

                                var solicitacaoEmail = solicitacaoRepository.ConverToEmailModel(sol, Url.Action("Login", "Account", null, Request.Url.Scheme));
                                var html             = RazorEngine.Razor.Parse(viewCode, solicitacaoEmail);

                                if (!string.IsNullOrEmpty(solicitacaoEmail.EmailFuncionario))
                                {
                                    var to   = new[] { solicitacaoEmail.EmailFuncionario };
                                    var from = System.Configuration.ConfigurationManager.AppSettings["MailFrom"].ToString();

                                    Email.EnviarEmail(from, to, string.Format("Solicitação de documento atendida - {0} - {1}", solicitacaoEmail.NomeTipoDocumento, solicitacaoEmail.NomeAluno), html);
                                }
                            }
                            catch (Exception)
                            {
                            }
                            Utilidades.SalvaLog(user, EnumAcao.Persistir, solicitacao, solicitacao.IdSolicitacao);
                            return(Json(new { Status = true, Type = "success", Message = "Solicitação salva com sucesso", ReturnUrl = Url.Action("Index") }, JsonRequestBehavior.AllowGet));
                        }
                        else
                        {
                            return(Json(new { Status = false, Type = "error", Message = "Ocorreu um erro ao realizar esta operação." }, JsonRequestBehavior.AllowGet));
                        }
                    }
                }
                else
                {
                    return(Json(new { Status = false, Type = "error", Message = "Não autorizado!" }, JsonRequestBehavior.AllowGet));
                }
            }
            catch (Exception e)
            {
                return(Json(new { Status = false, Type = "error", Message = "Ocorreu um erro ao realizar esta operação." }, JsonRequestBehavior.AllowGet));
            }
        }