コード例 #1
0
 public void FacebookGetImagem(Historia historia)
 {
     try
     {
         FacebookClient facebookClient = new FacebookClient();
         facebookClient.AppId       = ConfiguracaoAppUtil.Get(enumConfiguracaoGeral.facebookAppID);
         facebookClient.AppSecret   = ConfiguracaoAppUtil.Get(enumConfiguracaoGeral.facebookAppSecret);
         facebookClient.AccessToken = historia.IndicadorFacebookToken;
         dynamic picture = facebookClient.Get("me/picture?redirect=false&width=800");
         if ((picture != null) && (picture.data != null) && (picture.data.url != null))
         {
             using (WebClient webClient = new WebClient())
             {
                 webClient.DownloadFile(picture.data.url, ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.indicadorFotoDiretorio, historia.IndicadorFotoArquivoNome));
             }
         }
     }
     catch (Exception ex)
     {
         LogUtil.Error(ex);
         try
         {
             dal.RemoverIndicadorFoto(historia.ID);
         }
         catch (Exception e)
         {
             LogUtil.Error(e);
         }
     }
 }
コード例 #2
0
        public void EnviarEmailRecusaIndicado(IndicadoModel model) //quando o indicado nega
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadorRecusa.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model.Historia));

            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação recusada", email);
        }
コード例 #3
0
        private void EnviarEmailIndicado(Historia entidade)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadoIndicacao.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.IndicadoEmail, "Bradesco | Tocha Olímpica | Sua indicação", email);
        }
コード例 #4
0
        public RetornoModel Enviar(FaleConosco model)
        {
            if (string.IsNullOrEmpty(model.Nome))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Nome é obrigatório"
                });
            }
            if (string.IsNullOrEmpty(model.Email))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Email é obrigatório"
                });
            }
            if (string.IsNullOrEmpty(model.Mensagem))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Mensagem  é obrigatório"
                });
            }
            if (model.FaleConoscoAssuntoID == 0)
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Assunto  é obrigatório"
                });
            }
            if (!model.Email.IsValidMail())
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Email inválido"
                });
            }

            Salvar(model);
            FaleConoscoAssuntoService assuntoService = new FaleConoscoAssuntoService();

            model.FaleConoscoAssunto = assuntoService.Carregar(model.FaleConoscoAssuntoID);

            if (model.FaleConoscoAssunto.Destinos.Count > 0)
            {
                string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "FaleConosco.cshtml");
                string email = RazorUtil.Render(path, EmailModel.GetModel(model));

                foreach (FaleConoscoDestino destino in model.FaleConoscoAssunto.Destinos)
                {
                    EmailUtil.Send(model.Nome, model.Email, destino.Nome, destino.Email, "Bradesco | Tocha Olímpica | Fale Conosco | " + model.FaleConoscoAssunto.Nome, email);
                }
            }
            return(new RetornoModel()
            {
                Sucesso = true, Mensagem = "Ok!"
            });
        }
コード例 #5
0
        public RetornoModel EnviarEmail(Compartilhe entidade)
        {
            if (string.IsNullOrEmpty(entidade.DeNome))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Seu Nome é obrigatório"
                });
            }
            if (string.IsNullOrEmpty(entidade.DeEmail))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Seu Email é obrigatório"
                });
            }
            if (string.IsNullOrEmpty(entidade.ParaNome))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Nome do Amigo é obrigatório"
                });
            }
            if (string.IsNullOrEmpty(entidade.ParaEmail))
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Email do Amigo é obrigatório"
                });
            }
            if (!entidade.DeEmail.IsValidMail())
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Seu Email inválido"
                });
            }
            if (!entidade.ParaEmail.IsValidMail())
            {
                return(new RetornoModel()
                {
                    Sucesso = false, Mensagem = "Email do Amigo inválido"
                });
            }


            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "Compartilhe.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.DeNome, entidade.DeEmail, entidade.ParaNome, entidade.ParaEmail, "Bradesco | Tocha Olímpica | Compartilharam com você", email);

            return(new RetornoModel()
            {
                Sucesso = true, Mensagem = "Ok!"
            });
        }
コード例 #6
0
        private void RenomearImagemPerfil(string NomeOriginal, string NomeNovo)
        {
            string caminhoArquivo     = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.indicadoFotoDiretorio, NomeOriginal);
            string caminhoArquivoNovo = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.indicadoFotoDiretorio, NomeNovo);

            if ((!File.Exists(caminhoArquivoNovo)) && (File.Exists(caminhoArquivo)))
            {
                File.Copy(caminhoArquivo, caminhoArquivoNovo);
            }
        }
コード例 #7
0
        public void EnviarEmailsAdicionadoNaGaleria(IndicadoModel entidade)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoAdicionadoGaleriaParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Adicionado a galeria", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoAdicionadoGaleriaParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(entidade.Indicado));
            EmailUtil.Send(entidade.Indicado.Email, "Bradesco | Tocha Olímpica | Adicionado a galeria", email);
        }
コード例 #8
0
        private void EnviarEmailsConfirmacaoResponsavel(IndicadoModel model)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "ConfirmacaoResponsavelParaIndicado.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model));

            EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Indicação autorizada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "ConfirmacaoResponsavelParaIndicador.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(model));
            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação autorizada", email);
        }
コード例 #9
0
        public void EnviarEmailRecusaResponsavel(IndicadoModel model) //quando o responsavel nega
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "RecusaResponsavelParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(model));

            EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Autorização recusada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "RecusaResponsavelParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(model));
            EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Autorização recusada", email);
        }
コード例 #10
0
        public void EnviarEmailsRecusaHistoria(IndicadoModel entidade)
        {
            string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoRecusaTriagemParaIndicador.cshtml");
            string email = RazorUtil.Render(path, EmailModel.GetModel(entidade));

            EmailUtil.Send(entidade.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | História recusada", email);

            path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "AvisoRecusaTriagemParaIndicado.cshtml");
            email = RazorUtil.Render(path, EmailModel.GetModel(entidade));
            EmailUtil.Send(entidade.Indicado.Email, "Bradesco | Tocha Olímpica | História recusada", email);
        }
コード例 #11
0
        public void ConverterVideo(string caminhoArquivo, string nomeArq)
        {
            var ffMpeg = new FFMpegConverter();

            ffMpeg.ConvertMedia(caminhoArquivo, ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.mp4"), Format.mp4);
            ffMpeg.ConvertMedia(caminhoArquivo, ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.webm"), Format.webm);
            ffMpeg.ConvertMedia(caminhoArquivo, ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.ogv"), Format.ogg);

            File.Move(ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.webm"), ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + ".webm"));
            File.Move(ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.ogv"), ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + ".ogv"));
            File.Move(ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + "Temp.mp4"), ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + ".mp4"));
        }
コード例 #12
0
        public RetornoModel AtualizarCache(Editorial editorial)
        {
            RetornoModel   retorno = null;
            EditorialModel model   = new EditorialModel();

            model.Editorial = editorial;
            model.Conteudo  = new EditorialBlocoService().ListarPorEditorialID(editorial.ID, true);

            string path = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.editorialTemplateConteudo, "ConteudoTemplate.cshtml");

            editorial.ConteudoHTML = RazorUtil.Render(path, EditorialModel.GetModel(model));

            editorial.DataModificacao = DateTime.Now;

            dal.AtualizarCache(editorial);

            return(retorno);
        }
コード例 #13
0
        private void EnviarEmailsConfirmacaoIndicado(IndicadoModel model)
        {
            if (!MenorIdade(model.Indicado))
            {
                string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadorConfirmacao.cshtml");
                string email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Indicação aceita", email);
            }
            else
            {
                string path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "Autorizacao.cshtml");
                string email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Indicado.ResponsavelEmail, "Bradesco | Tocha Olímpica | Autorização", email);

                path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadoAguardandoResponsavelParaIndicado.cshtml");
                email = RazorUtil.Render(path, EmailModel.GetModel(model.Indicado));
                EmailUtil.Send(model.Historia.IndicadoEmail, "Bradesco | Tocha Olímpica | Aguardando autorização", email);

                path  = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.emailTemplateDiretorio, "IndicadoMenorConfirmacaoParaIndicador.cshtml");
                email = RazorUtil.Render(path, EmailModel.GetModel(model));
                EmailUtil.Send(model.Historia.IndicadorEmail, "Bradesco | Tocha Olímpica | Aguardando autorização", email);
            }
        }
コード例 #14
0
        public RetornoModel <string> Upload(HttpPostedFileBase arquivo)
        {
            string nomeArq = null;

            try
            {
                if ((arquivo != null) && (arquivo.ContentLength > 0))
                {
                    string content = arquivo.ContentType.Split('/')[0];

                    if (content == "image" || content == "video" || content == "audio")
                    {
                        //Salva o arquivo
                        nomeArq = Guid.NewGuid().ToString();
                        string nomeArqSalvar = nomeArq;
                        if (content == "image")
                        {
                            nomeArqSalvar += Path.GetExtension(arquivo.FileName);
                            nomeArq        = nomeArqSalvar;
                        }
                        else if (content == "audio")
                        {
                            nomeArqSalvar += Path.GetExtension(arquivo.FileName);
                            nomeArq        = nomeArqSalvar;
                        }
                        else
                        {
                            nomeArqSalvar += ".orig" + Path.GetExtension(arquivo.FileName);
                        }
                        string caminhoArquivo = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.editorialMidiaDiretorio, nomeArqSalvar);
                        arquivo.SaveAs(caminhoArquivo);

                        if (!AntivirusUtil.Verificar(caminhoArquivo))
                        {
                            return(new RetornoModel <string> {
                                Mensagem = "Este arquivo contém vírus, favor tentar outro arquivo.", Sucesso = false
                            });
                        }
                        else
                        {
                            if (content == "video")
                            {
                                Task.Run(() => ConverterVideo(caminhoArquivo, nomeArq));
                            }
                        }
                    }
                    else
                    {
                        return(new RetornoModel <string> {
                            Mensagem = "Tipo de arquivo inválido.", Sucesso = false
                        });
                    }
                }
                else
                {
                    return(new RetornoModel <string> {
                        Mensagem = "Nenhum arquivo enviado.", Sucesso = false
                    });
                }
            }
            catch (Exception e)
            {
                LogUtil.Error(e);
                return(new RetornoModel <string> {
                    Mensagem = "Falha no upload, tente novamente!", Sucesso = false
                });
            }
            return(new RetornoModel <string> {
                Retorno = nomeArq, Mensagem = "Upload realizado com sucesso", Sucesso = true
            });
        }
コード例 #15
0
        public static UploadFotoModel CarregarFotoInfo(string arquivoNome, int widthCustom = 0, int heightCustom = 0)
        {
            if (string.IsNullOrEmpty(arquivoNome))
            {
                return(null);
            }
            UploadFotoModel model = new UploadFotoModel();

            model.file = arquivoNome;

            var auxNomeExt = arquivoNome.Split('.');

            if (auxNomeExt.Length > 1)
            {
                string nomeNovo   = auxNomeExt[0];
                var    auxNomePos = auxNomeExt[0].Split(new string[] { "__" }, StringSplitOptions.None);
                if (auxNomePos.Length > 2)
                {
                    var auxTam = auxNomePos[1].Split('x');
                    var auxPos = auxNomePos[2].Split('x');
                    model.width  = Convert.ToInt32(auxTam[0]);
                    model.height = Convert.ToInt32(auxTam[1]);
                    model.x      = Convert.ToInt32(auxPos[0]);
                    model.y      = Convert.ToInt32(auxPos[1]);

                    double percentual = 1.00;
                    if (model.height > indicadoMaxHeightImage)
                    {
                        percentual = Convert.ToDouble(indicadoMaxHeightImage) / Convert.ToDouble(model.height);

                        model.height = indicadoMaxHeightImage;
                        model.width  = Convert.ToInt32(model.width * percentual);
                    }
                    else if (model.width > indicadoMaxWidthImage)
                    {
                        percentual   = Convert.ToDouble(indicadoMaxWidthImage) / Convert.ToDouble(model.width);
                        model.width  = indicadoMaxWidthImage;
                        model.height = Convert.ToInt32(model.height * percentual);
                    }
                }
                else
                {
                    var arquivo = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.indicadoFotoDiretorio, model.file);
                    if (File.Exists(arquivo))
                    {
                        var aux = Image.FromFile(arquivo);
                        model.width  = aux.Width;
                        model.height = aux.Height;
                        if (Convert.ToDouble(model.width) / Convert.ToDouble(model.height) < Convert.ToDouble(indicadoMaxWidth) / Convert.ToDouble(indicadoMaxHeight))
                        {
                            model.height = Convert.ToInt32(Convert.ToDouble(indicadoMaxWidth) * Convert.ToDouble(model.height) / Convert.ToDouble(model.width));
                            model.width  = indicadoMaxWidth;
                            model.x      = 0;
                            model.y      = Convert.ToInt32((indicadoMaxHeight - model.height) / 2);
                        }
                        else
                        {
                            model.width  = Convert.ToInt32(Convert.ToDouble(indicadoMaxHeight) * Convert.ToDouble(model.width) / Convert.ToDouble(model.height));
                            model.height = indicadoMaxHeight;
                            model.x      = Convert.ToInt32((indicadoMaxWidth - model.width) / 2);
                            model.y      = 0;
                        }
                    }
                    else
                    {
                        return(null);
                    }
                }

                if ((widthCustom > 0) && (heightCustom > 0))
                {
                    double percentual = 1.00;
                    if (Convert.ToDouble(widthCustom) / Convert.ToDouble(heightCustom) < Convert.ToDouble(indicadoMaxWidth) / Convert.ToDouble(indicadoMaxHeight))
                    {
                        percentual = Convert.ToDouble(widthCustom) / Convert.ToDouble(indicadoMaxWidth);
                    }
                    else
                    {
                        percentual = Convert.ToDouble(heightCustom) / Convert.ToDouble(indicadoMaxHeight);
                    }
                    model.width  = Convert.ToInt32(model.width * percentual);
                    model.height = Convert.ToInt32(model.height * percentual);
                    model.y      = Convert.ToInt32(model.y * percentual);
                    model.x      = Convert.ToInt32(model.x * percentual);
                }
            }
            return(model);
        }
コード例 #16
0
 public static bool VerificaVideoConvertido(string nomeArq)
 {
     return(File.Exists(ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArq + ".mp4")));
 }
コード例 #17
0
        public RetornoModel <string> Upload(HttpPostedFileBase arquivo)
        {
            string nomeArq = null;

            try
            {
                if ((arquivo != null) && (arquivo.ContentLength > 0))
                {
                    string content = arquivo.ContentType.Split('/')[0];
                    if (content == "image" || content == "video")
                    {
                        //Salva o arquivo
                        nomeArq = Guid.NewGuid().ToString();
                        string nomeArqSalvar = nomeArq;
                        if (content == "image")
                        {
                            if (arquivo.ContentLength > ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadImagemMaxSize))
                            {
                                int maxKb = Convert.ToInt32(ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadImagemMaxSize) / 1024);
                                return(new RetornoModel <string> {
                                    Mensagem = "O tamanho máximo para upload de imagem é de " + ((maxKb > 1024) ? Convert.ToInt32(maxKb / 1024) + "Mb" : maxKb + "Kb") + ".", Sucesso = false
                                });
                            }
                            nomeArqSalvar += Path.GetExtension(arquivo.FileName);
                            nomeArq        = nomeArqSalvar;
                        }
                        else
                        {
                            if (arquivo.ContentLength > ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadVideoMaxSize))
                            {
                                int maxKb = Convert.ToInt32(ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadVideoMaxSize) / 1024);
                                return(new RetornoModel <string> {
                                    Mensagem = "O tamanho máximo para upload de vídeo é de " + ((maxKb > 1024) ? Convert.ToInt32(maxKb / 1024) + "Mb" : maxKb + "Kb") + ".", Sucesso = false
                                });
                            }
                            nomeArqSalvar += ".orig" + Path.GetExtension(arquivo.FileName);
                        }
                        string caminhoArquivo = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.historiaMidiaDiretorio, nomeArqSalvar);
                        arquivo.SaveAs(caminhoArquivo);

                        if (!AntivirusUtil.Verificar(caminhoArquivo))
                        {
                            return(new RetornoModel <string> {
                                Mensagem = "Este arquivo contém vírus, favor tentar outro arquivo.", Sucesso = false
                            });
                        }
                        else
                        {
                            if (content == "video")
                            {
                                Task.Run(() => ConverterVideo(caminhoArquivo, nomeArq));
                            }
                        }
                    }
                    else
                    {
                        return(new RetornoModel <string> {
                            Mensagem = "Tipo de arquivo inválido.", Sucesso = false
                        });
                    }
                }
                else
                {
                    return(new RetornoModel <string> {
                        Mensagem = "Nenhum arquivo enviado.", Sucesso = false
                    });
                }
            }
            catch (Exception e)
            {
                LogUtil.Error(e);
                return(new RetornoModel <string> {
                    Mensagem = "Falha no upload, tente novamente!", Sucesso = false
                });
            }
            return(new RetornoModel <string> {
                Retorno = nomeArq, Mensagem = "Upload realizado com sucesso", Sucesso = true
            });
        }
コード例 #18
0
        public RetornoModel <UploadFotoModel> Upload(HttpPostedFileBase arquivo)
        {
            string          nomeArq = null;
            UploadFotoModel retorno = null;

            try
            {
                if ((arquivo != null) && (arquivo.ContentLength > 0))
                {
                    string content = arquivo.ContentType.Split('/')[0];
                    if (content == "image")
                    {
                        if (arquivo.ContentLength > ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadImagemMaxSize))
                        {
                            int maxKb = Convert.ToInt32(ConfiguracaoAppUtil.GetAsInt(enumConfiguracaoLib.uploadImagemMaxSize) / 1024);
                            return(new RetornoModel <UploadFotoModel> {
                                Mensagem = "O tamanho máximo para upload de imagem é de " + ((maxKb > 1024) ? Convert.ToInt32(maxKb / 1024) + "Mb" : maxKb + "Kb") + ".", Sucesso = false
                            });
                        }
                        //Salva o arquivo
                        nomeArq = Guid.NewGuid().ToString() + Path.GetExtension(arquivo.FileName);
                        string caminhoArquivo = ConfiguracaoAppUtil.GetPath(enumConfiguracaoLib.indicadoFotoDiretorio, nomeArq);
                        arquivo.SaveAs(caminhoArquivo);

                        if (!AntivirusUtil.Verificar(caminhoArquivo))
                        {
                            return(new RetornoModel <UploadFotoModel> {
                                Mensagem = "Este arquivo contém vírus, favor tentar outro arquivo.", Sucesso = false
                            });
                        }
                        Image img = Image.FromFile(caminhoArquivo);
                        retorno = new UploadFotoModel
                        {
                            file   = nomeArq,
                            width  = img.Width,
                            height = img.Height,
                            x      = Convert.ToInt32((indicadoMaxWidth - img.Width) / 2),
                            y      = Convert.ToInt32((indicadoMaxHeight - img.Height) / 2)
                        };
                    }
                    else
                    {
                        return(new RetornoModel <UploadFotoModel> {
                            Mensagem = "Tipo de arquivo inválido.", Sucesso = false
                        });
                    }
                }
                else
                {
                    return(new RetornoModel <UploadFotoModel> {
                        Mensagem = "Nenhum arquivo enviado.", Sucesso = false
                    });
                }
            }
            catch (Exception e)
            {
                LogUtil.Error(e);
                return(new RetornoModel <UploadFotoModel> {
                    Mensagem = "Falha no upload, tente novamente!", Sucesso = false
                });
            }
            return(new RetornoModel <UploadFotoModel> {
                Retorno = retorno, Mensagem = "Upload realizado com sucesso.", Sucesso = true
            });
        }